siliconcompiler 0.33.2__py3-none-any.whl → 0.34.1__py3-none-any.whl

siliconcompiler/flowgraph.py

@@ -1,4 +1,5 @@
 import inspect
+import importlib
 
 from siliconcompiler import Schema
 from siliconcompiler.schema import BaseSchema, NamedSchema
@@ -10,7 +11,8 @@ from siliconcompiler import NodeStatus
 
 class FlowgraphSchema(NamedSchema):
     def __init__(self, name=None):
-        super().__init__(name=name)
+        super().__init__()
+        self.set_name(name)
 
         schema = EditableSchema(self)
         schema.insert("default", "default", FlowgraphNodeSchema())
@@ -30,6 +32,8 @@ class FlowgraphSchema(NamedSchema):
 
         self.__cache_node_outputs = None
 
+        self.__cache_tasks = None
+
     def node(self, step, task, index=0):
         '''
         Creates a flowgraph node.
@@ -79,6 +83,11 @@ class FlowgraphSchema(NamedSchema):
             raise ValueError(f"{task} is not a valid task, it must be associated with "
                              "a tool '<tool>.<task>'.")
 
+        if '/' in step:
+            raise ValueError(f"{step} is not a valid step, it cannot contain '/'")
+        if '/' in index:
+            raise ValueError(f"{index} is not a valid index, it cannot contain '/'")
+
         tool_name, task_name = task_parts[-2:]
 
         # bind tool to node
@@ -114,7 +123,7 @@ class FlowgraphSchema(NamedSchema):
 
         for step, index in [(head, head_index), (tail, tail_index)]:
             if not self.valid(step, index):
-                raise ValueError(f"{step}{index} is not a defined node in {self.name()}.")
+                raise ValueError(f"{step}/{index} is not a defined node in {self.name()}.")
 
         tail_node = (tail, tail_index)
         if tail_node in self.get(head, head_index, 'input'):
@@ -167,6 +176,37 @@ class FlowgraphSchema(NamedSchema):
 
         self.__clear_cache()
 
+    def insert_node(self, step, task, before_step, index=0, before_index=0):
+        '''
+        Insert a new node after the specified node
+
+        Args:
+            step (str): Step name
+            index (int/str): Step index
+            task (module/str): Task to associate with this node
+            before_step (str): name of step to insert task after
+            before_index (int/str): index of step to insert task after
+        '''
+
+        index = str(index)
+        before_index = str(before_index)
+
+        if (before_step, before_index) not in self.get_nodes():
+            raise ValueError(f'{before_step}/{before_index} is not a valid node in {self.name()}')
+
+        # add the node
+        self.node(step, task, index=index)
+
+        # rewire
+        for istep, iindex in self.get_node_outputs(before_step, before_index):
+            inputs = self.get(istep, iindex, "input")
+            inputs.remove((before_step, before_index))
+            self.set(istep, iindex, "input", inputs)
+            self.add(istep, iindex, "input", (step, index))
+        self.set(step, index, "input", [(before_step, before_index)])
+
+        self.__clear_cache()
+
     ###########################################################################
     def graph(self, subflow, name=None):
         '''
@@ -357,7 +397,7 @@ class FlowgraphSchema(NamedSchema):
         index = str(index)
 
         if (step, index) not in self.get_nodes():
-            raise ValueError(f"{step}{index} is not a valid node")
+            raise ValueError(f"{step}/{index} is not a valid node")
 
         if self.__cache_node_outputs is not None:
             return self.__cache_node_outputs[(step, index)]
@@ -433,15 +473,15 @@ class FlowgraphSchema(NamedSchema):
                 if input_nodes.count(node) > 1:
                     in_step, in_index = node
                     if logger:
-                        logger.error(f'Duplicate edge from {in_step}{in_index} to '
-                                     f'{step}{index} in the {self.name()} flowgraph')
+                        logger.error(f'Duplicate edge from {in_step}/{in_index} to '
+                                     f'{step}/{index} in the {self.name()} flowgraph')
                     error = True
 
         diff_nodes = check_nodes.difference(self.get_nodes())
         if diff_nodes:
             if logger:
                 for step, index in diff_nodes:
-                    logger.error(f'{step}{index} is missing in the {self.name()} flowgraph')
+                    logger.error(f'{step}/{index} is missing in the {self.name()} flowgraph')
             error = True
 
         # Detect missing definitions
@@ -449,7 +489,7 @@ class FlowgraphSchema(NamedSchema):
             for item in ('tool', 'task', 'taskmodule'):
                 if not self.get(step, index, item):
                     if logger:
-                        logger.error(f'{step}{index} is missing a {item} definition in the '
+                        logger.error(f'{step}/{index} is missing a {item} definition in the '
                                      f'{self.name()} flowgraph')
                     error = True
 
@@ -459,11 +499,37 @@ class FlowgraphSchema(NamedSchema):
             if loop_path:
                 error = True
                 if logger:
-                    loop_path = [f"{step}{index}" for step, index in loop_path]
+                    loop_path = [f"{step}/{index}" for step, index in loop_path]
                     logger.error(f"{' -> '.join(loop_path)} forms a loop in {self.name()}")
 
         return not error
 
+    def get_task_module(self, step, index):
+        """
+        Returns the module for a given task
+
+        Args:
+            step (str): Step name
+            index (int/str): Step index
+        """
+
+        index = str(index)
+
+        if (step, index) not in self.get_nodes():
+            raise ValueError(f"{step}/{index} is not a valid node in {self.name()}.")
+
+        taskmodule = self.get(step, index, 'taskmodule')
+
+        # Create cache
+        if self.__cache_tasks is None:
+            self.__cache_tasks = {}
+
+        if taskmodule in self.__cache_tasks:
+            return self.__cache_tasks[taskmodule]
+
+        self.__cache_tasks[taskmodule] = importlib.import_module(taskmodule)
+        return self.__cache_tasks[taskmodule]
+
 
 class RuntimeFlowgraph:
     '''
@@ -618,13 +684,13 @@ class RuntimeFlowgraph:
         index = str(index)
 
         if (step, index) not in self.get_nodes():
-            raise ValueError(f"{step}{index} is not a valid node")
+            raise ValueError(f"{step}/{index} is not a valid node")
 
         return tuple(sorted(self.__walk_graph((step, str(index)), reverse=False)))
 
     def get_node_inputs(self, step, index, record=None):
         if (step, index) not in self.get_nodes():
-            raise ValueError(f"{step}{index} is not a valid node")
+            raise ValueError(f"{step}/{index} is not a valid node")
 
         if record is None:
             inputs = set()
@@ -691,7 +757,7 @@ class RuntimeFlowgraph:
         # Check for undefined prunes
         for step, index in sorted(prune_nodes.difference(flow.get_nodes())):
             if logger:
-                logger.error(f'{step}{index} is not defined in the {flow.name()} flowgraph')
+                logger.error(f'{step}/{index} is not defined in the {flow.name()} flowgraph')
             error = True
 
         if not error:
@@ -732,9 +798,9 @@ class RuntimeFlowgraph:
                         if entrynode in runtime.__walk_graph(exitnode):
                             found = True
                     if not found:
-                        exits = ",".join([f"{step}{index}"
+                        exits = ",".join([f"{step}/{index}"
                                           for step, index in runtime.get_exit_nodes()])
-                        missing.append(f'no path from {entrynode[0]}{entrynode[1]} to {exits} '
+                        missing.append(f'no path from {entrynode[0]}/{entrynode[1]} to {exits} '
                                        f'in the {flow.name()} flowgraph')
                     if found:
                         found_any = True

siliconcompiler/optimizer/vizier.py

@@ -157,7 +157,7 @@ class VizierOptimizier(Optimizer):
                 chip.graph(flow, org_flow, name=graph_name)
 
             # Complete nodes
-            nodes = chip.schema.get("flowgraph", org_flow, field="schema").get_nodes()
+            nodes = chip.get("flowgraph", org_flow, field="schema").get_nodes()
             for step, _ in list(nodes):
                 nodes.append((step, None))
             nodes = set(nodes)
@@ -167,7 +167,7 @@ class VizierOptimizier(Optimizer):
                 if key[0] == 'history':
                     continue
 
-                for value, step, index in chip.schema.get(*key, field=None).getvalues():
+                for value, step, index in chip.get(*key, field=None).getvalues():
                     node = (step, index)
 
                     if node in nodes: