siliconcompiler 0.36.3__py3-none-any.whl → 0.36.4__py3-none-any.whl

siliconcompiler/_metadata.py

@@ -1,5 +1,5 @@
 # Version number following semver standard.
-version = '0.36.3'
+version = '0.36.4'
 
 # Default server address for remote runs, if unspecified.
 default_server = 'https://server.siliconcompiler.com'

siliconcompiler/apps/sc_install.py

@@ -92,7 +92,8 @@ class ChoiceOptional(Container):
         return sorted(items)
 
 
-def install_tool(tool: str, script: str, build_dir: str, prefix: str) -> bool:
+def install_tool(tool: str, script: str, build_dir: str, prefix: str,
+                 jobs: Optional[int] = None) -> bool:
     """
     Prepare a build directory, configure the environment, and execute an install script for a tool.
 
@@ -102,6 +103,8 @@ def install_tool(tool: str, script: str, build_dir: str, prefix: str) -> bool:
         build_dir (str): Base directory where a per-tool build directory will be created.
         prefix (str): Installation prefix; added to PATH and used to determine whether
                       sudo is required.
+        jobs (Optional[int]): Maximum number of parallel jobs to use during build. If None,
+                             defaults to the number of CPU cores.
 
     Returns:
         bool: `True` if the install script exited with status 0, `False` otherwise.
@@ -117,6 +120,8 @@ def install_tool(tool: str, script: str, build_dir: str, prefix: str) -> bool:
     env["PATH"] = ":".join(path)
     env["PREFIX"] = prefix
     env["USE_SUDO_INSTALL"] = "no"
+    if jobs is not None:
+        env["NPROC"] = str(jobs)
     try:
         os.makedirs(prefix, exist_ok=True)
     except PermissionError:
@@ -312,6 +317,12 @@ To install tools in a different location:
 To build tools in a different location:
     sc-install -build_dir /tmp yosys
 
+To limit parallel build jobs (useful for memory-constrained systems):
+    sc-install yosys -jobs 4
+
+To combine options (custom location with limited parallelism):
+    sc-install -prefix /opt/tools -jobs 8 openroad yosys
+
 To show the install script:
     sc-install -show openroad
 
@@ -359,6 +370,13 @@ Tool groups:
         help="Directory to build the tool in",
         metavar="<path>")
 
+    parser.add_argument(
+        "-jobs",
+        type=int,
+        default=None,
+        help="Maximum number of parallel build jobs (default: number of CPU cores)",
+        metavar="<int>")
+
     parser.add_argument(
         "-show",
         action="store_true",
@@ -389,6 +407,9 @@ Tool groups:
 
     tools_handled = set()
     tools_completed = set()
+    if args.jobs is not None and args.jobs < 1:
+        print("Error: -jobs must be a positive integer", file=sys.stderr)
+        return 1
     for tool in args.tool:
         if tool in tools_handled:
             continue
@@ -396,7 +417,7 @@ Tool groups:
         if args.show:
             show_tool(tool, tools[tool])
         else:
-            if not install_tool(tool, tools[tool], args.build_dir, args.prefix):
+            if not install_tool(tool, tools[tool], args.build_dir, args.prefix, args.jobs):
                 notstarted = set(args.tool) - tools_completed - tools_handled
                 __print_summary(tools_completed, tool, notstarted)
                 return 1

siliconcompiler/apps/sc_issue.py

@@ -70,6 +70,10 @@ To run a testcase, use:
         switchlist=switchlist)
 
     if not issue.get("cmdarg", "run"):
+        if not issue.get("cmdarg", "cfg"):
+            issue.logger.error('-cfg must be provided')
+            return 1
+
         project: Project = Project.from_manifest(filepath=issue.get("cmdarg", "cfg"))
 
         # Determine abs path for build dir

siliconcompiler/flows/dvflow.py

@@ -1,5 +1,8 @@
 from siliconcompiler.tools.icarus import compile as icarus_compile
+from siliconcompiler.tools.icarus import cocotb_exec as icarus_cocotb
 from siliconcompiler.tools.verilator import compile as verilator_compile
+from siliconcompiler.tools.verilator import cocotb_compile as verilator_cocotb_compile
+from siliconcompiler.tools.verilator import cocotb_exec as verilator_cocotb
 from siliconcompiler.tools.execute import exec_input
 from siliconcompiler.tools.xyce import simulate as xyce_simulate
 from siliconcompiler.tools.xdm import convert as xdm_convert
@@ -24,7 +27,9 @@ class DVFlow(Flowgraph):
     Supported tools are:
 
         * 'icarus': Compiles and simulates with the Icarus Verilog simulator.
+        * 'icarus-cocotb': Compiles with Icarus and runs cocotb Python testbenches.
         * 'verilator': Compiles and simulates with Verilator.
+        * 'verilator-cocotb': Compiles with Verilator and runs cocotb Python testbenches.
         * 'xyce': Simulates a netlist with the Xyce circuit simulator.
         * 'xdm-xyce': Converts a design to a Xyce-compatible format and simulates.
     '''
@@ -50,10 +55,18 @@ class DVFlow(Flowgraph):
             self.node("compile", icarus_compile.CompileTask())
             sim_task = exec_input.ExecInputTask()
             com_name = "compile"
+        elif tool == "icarus-cocotb":
+            self.node("compile", icarus_compile.CompileTask())
+            sim_task = icarus_cocotb.CocotbExecTask()
+            com_name = "compile"
         elif tool == "verilator":
             self.node("compile", verilator_compile.CompileTask())
             sim_task = exec_input.ExecInputTask()
             com_name = "compile"
+        elif tool == "verilator-cocotb":
+            self.node("compile", verilator_cocotb_compile.CocotbCompileTask())
+            sim_task = verilator_cocotb.CocotbExecTask()
+            com_name = "compile"
         elif tool == "xyce":
             sim_task = xyce_simulate.SimulateTask()
             com_name = None

siliconcompiler/package/__init__.py

@@ -16,6 +16,7 @@ import logging
 import os
 import random
 import re
+import site
 import shutil
 import time
 import threading
@@ -27,7 +28,7 @@ from typing import Optional, List, Dict, Type, Union, TYPE_CHECKING, Final
 
 from fasteners import InterProcessLock
 from importlib.metadata import distributions, distribution
-from pathlib import Path
+from pathlib import Path, PureWindowsPath
 from urllib import parse as url_parse
 
 from siliconcompiler.utils import get_plugins, default_cache_dir
@@ -647,21 +648,25 @@ class PythonPathResolver(Resolver):
             return False
         dist_name = dist_map[module_name][0]
 
-        is_editable = False
         dist_obj = distribution(dist_name)
-        if not dist_obj or not dist_obj.files:
+        if not dist_obj:
             return False
 
-        for f in dist_obj.files:
-            if f.name == 'direct_url.json':
-                info = None
-                with open(f.locate(), 'r') as fp:
-                    info = json.load(fp)
-
-                if "dir_info" in info:
-                    is_editable = info["dir_info"].get("editable", False)
+        direct_url_content = dist_obj.read_text('direct_url.json')
+        if direct_url_content:
+            direct_url = json.loads(direct_url_content)
+            return direct_url.get('dir_info', {}).get('editable', False)
+
+        dist_loc = dist_obj.locate_file('')
+        site_paths = site.getsitepackages()
+        user_site_path = site.getusersitepackages()
+        if user_site_path:
+            site_paths.append(user_site_path)
+        if not dist_loc or not site_paths:
+            return False
 
-        return is_editable
+        dist_loc = PureWindowsPath(dist_loc).as_posix()
+        return dist_loc not in [PureWindowsPath(site_path).as_posix() for site_path in site_paths]
 
     @staticmethod
     def set_dataroot(root: "PathSchema",

siliconcompiler/package/git.py

@@ -151,7 +151,8 @@ class GitResolver(RemoteResolver):
             for submodule in repo.submodules:
                 submodule.update(recursive=True, init=True, force=True)
         except GitCommandError as e:
-            if 'Permission denied' in repr(e) or 'could not read Username' in repr(e):
+            error_msg = str(e)
+            if 'Permission denied' in error_msg or 'could not read Username' in error_msg:
                 if self.urlscheme in ('ssh', 'git+ssh'):
                     raise RuntimeError('Failed to authenticate with Git. Please ensure your SSH '
                                        'keys are set up correctly.')

siliconcompiler/schema/baseschema.py

@@ -8,6 +8,7 @@ import contextlib
 import copy
 import importlib
 import logging
+import pathlib
 
 try:
     import gzip
@@ -385,10 +386,18 @@ class BaseSchema:
         fout = BaseSchema.__open_file(filepath, is_read=False)
 
         try:
+            def default(obj: Any) -> Any:
+                if isinstance(obj, pathlib.PurePath):
+                    # Cast everything to a windows path and convert to posix.
+                    # https://stackoverflow.com/questions/73682260
+                    return pathlib.PureWindowsPath(obj).as_posix()
+                raise TypeError
+
             if _has_orjson:
-                manifest_str = json.dumps(self.getdict(), option=json.OPT_INDENT_2).decode()
+                manifest_str = json.dumps(self.getdict(), option=json.OPT_INDENT_2,
+                                          default=default).decode()
             else:
-                manifest_str = json.dumps(self.getdict(), indent=2)
+                manifest_str = json.dumps(self.getdict(), indent=2, default=default)
             fout.write(manifest_str)
         finally:
             fout.close()

siliconcompiler/schema_support/cmdlineschema.py

@@ -143,7 +143,7 @@ class CommandLineSchema(BaseSchema):
             # Grab config from argv
             try:
                 cfg_index = sys.argv.index("-cfg", 1)
-                if cfg_index < len(sys.argv):
+                if cfg_index + 1 < len(sys.argv):
                     cfg_file = sys.argv[cfg_index + 1]
             except ValueError:
                 pass
@@ -161,7 +161,8 @@ class CommandLineSchema(BaseSchema):
             # Add commandline key for input files
             if not isinstance(schema, CommandLineSchema):
                 raise TypeError("Schema is not a commandline class")
-            if "cmdarg" not in schema.getkeys() or "file" not in schema.getkeys("cmdarg"):
+
+            if not schema.valid("cmdarg", "input"):
                 schema._add_commandline_argument("input", "[file]", "input files", ...)
                 keyschema._add_commandline_argument("input", "[file]", "input files", ...)
 

siliconcompiler/tools/_common/cocotb/cocotb_task.py

@@ -0,0 +1,286 @@
+import os
+import sys
+from pathlib import Path
+from typing import Optional, Union, Dict
+import xml.etree.ElementTree as ET
+
+from siliconcompiler import Task
+
+try:
+    import cocotb_tools.config
+    from cocotb_tools.runner import Runner
+    _has_cocotb = True
+except ModuleNotFoundError:
+    _has_cocotb = False
+    Runner = object
+
+
+def get_cocotb_config(sim="icarus"):
+    if not _has_cocotb:
+        raise NotImplementedError("COCOTB must be installed to use get_cocotb_config")
+
+    libs_dir = cocotb_tools.config.libs_dir
+    lib_name = cocotb_tools.config.lib_name("vpi", sim)
+    share_dir = cocotb_tools.config.share_dir
+
+    return libs_dir, lib_name, share_dir
+
+
+class CocotbRunnerDummy(Runner):
+    """
+    A minimal Runner subclass used solely to retrieve the libpython path.
+
+    This class provides access to the libpython shared library location
+    without adding ``find_libpython`` as a direct dependency. It leverages
+    cocotb's existing Runner infrastructure, which handles libpython
+    discovery internally via the ``_set_env()`` method.
+
+    The abstract methods required by the Runner base class are implemented
+    as no-ops or raise NotImplementedError, as they are not intended to be
+    called. This class should only be instantiated to call
+    ``get_libpython_path()``.
+
+    Example:
+        >>> libpython = CocotbRunnerDummy().get_libpython_path()
+        >>> print(libpython)
+        /usr/lib/x86_64-linux-gnu/libpython3.10.so
+    """
+
+    def __init__(self):
+        if not _has_cocotb:
+            raise NotImplementedError("COCOTB must be installed to use get_cocotb_config")
+
+        super().__init__()
+        # These attributes are required by _set_env() which uses them to
+        # populate environment variables.
+        self.sim_hdl_toplevel = ""
+        self.test_module = ""
+        self.hdl_toplevel_lang = ""
+
+    def _simulator_in_path(self):
+        # No-op: This dummy class doesn't require any simulator executable.
+        pass
+
+    def _build_command(self):
+        raise NotImplementedError(
+            "CocotbRunnerDummy is not intended for building HDL sources")
+
+    def _test_command(self):
+        raise NotImplementedError(
+            "CocotbRunnerDummy is not intended for running tests")
+
+    def _get_define_options(self, defines):
+        raise NotImplementedError(
+            "CocotbRunnerDummy is not intended for HDL compilation")
+
+    def _get_include_options(self, includes):
+        raise NotImplementedError(
+            "CocotbRunnerDummy is not intended for HDL compilation")
+
+    def _get_parameter_options(self, parameters):
+        raise NotImplementedError(
+            "CocotbRunnerDummy is not intended for HDL compilation")
+
+    def get_libpython_path(self):
+        """
+        Retrieve the path to the libpython shared library.
+
+        This method uses cocotb's ``Runner._set_env()`` which internally
+        calls ``find_libpython.find_libpython()`` to locate the library.
+
+        Returns:
+            str: Absolute path to the libpython shared library.
+
+        Raises:
+            ValueError: If libpython cannot be found.
+        """
+        self._set_env()
+        return self.env["LIBPYTHON_LOC"]
+
+
+class CocotbTask(Task):
+
+    def __init__(self):
+        super().__init__()
+
+        self.add_parameter("cocotb_random_seed", "int",
+                           'Random seed for cocotb test reproducibility. '
+                           'If not set, cocotb will generate a random seed.')
+
+    def set_cocotb_randomseed(
+        self, seed: int,
+        step: Optional[str] = None,
+        index: Optional[Union[str, int]] = None
+    ):
+        """
+        Sets the random seed for cocotb tests.
+
+        Args:
+            seed (int): The random seed value.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "cocotb_random_seed", seed, step=step, index=index)
+
+    def task(self):
+        return "exec_cocotb"
+
+    def _get_test_modules(self):
+        """
+        Get cocotb test module names from Python files in filesets.
+
+        Returns:
+            tuple: (module_names, module_dirs) where module_names is a
+                   comma-separated string and module_dirs is a list of
+                   directories containing the modules.
+        """
+        module_names = []
+        module_dirs = []
+        seen_dirs = set()
+
+        for lib, fileset in self.project.get_filesets():
+            for pyfile in lib.get_file(fileset=fileset, filetype="python"):
+                path = Path(pyfile)
+                # Module name is the filename without .py extension
+                module_name = path.stem
+                module_names.append(module_name)
+                # Track the directory for PYTHONPATH
+                dir_path = str(path.parent.resolve())
+                if dir_path not in seen_dirs:
+                    seen_dirs.add(dir_path)
+                    module_dirs.append(dir_path)
+
+        return ",".join(module_names), module_dirs
+
+    def _get_toplevel_lang(self):
+        """
+        Determine the HDL toplevel language from the design schema.
+
+        For Icarus Verilog, this is always "verilog" since Icarus
+        doesn't support VHDL. SystemVerilog is treated as Verilog
+        for cocotb's TOPLEVEL_LANG.
+
+        Returns:
+            str: The toplevel language ("verilog").
+        """
+        # Icarus only supports Verilog/SystemVerilog, not VHDL
+        # cocotb uses "verilog" for both Verilog and SystemVerilog
+        return "verilog"
+
+    def __setup_cocotb_environment(self):
+        """
+        Set up all required environment variables for cocotb execution.
+        """
+
+        test_modules, _ = self._get_test_modules()
+        libpython_path = CocotbRunnerDummy().get_libpython_path()
+
+        # LIBPYTHON_LOC: path to libpython shared library
+        self.set_environmentalvariable("LIBPYTHON_LOC", libpython_path)
+        self.add_required_key("env", "LIBPYTHON_LOC")
+
+        # COCOTB_TOPLEVEL: the HDL toplevel module name
+        self.set_environmentalvariable("COCOTB_TOPLEVEL", self.design_topmodule)
+        self.add_required_key("env", "COCOTB_TOPLEVEL")
+
+        # COCOTB_TEST_MODULES: comma-separated list of Python test modules
+        self.set_environmentalvariable("COCOTB_TEST_MODULES", test_modules)
+        self.add_required_key("env", "COCOTB_TEST_MODULES")
+
+        # TOPLEVEL_LANG: HDL language of the toplevel
+        self.set_environmentalvariable("TOPLEVEL_LANG", self._get_toplevel_lang())
+        self.add_required_key("env", "TOPLEVEL_LANG")
+
+        # COCOTB_RESULTS_FILE: path to xUnit XML results
+        self.set_environmentalvariable("COCOTB_RESULTS_FILE", "outputs/results.xml")
+        self.add_required_key("env", "COCOTB_RESULTS_FILE")
+
+        # COCOTB_RANDOM_SEED: optional random seed for reproducibility
+        random_seed = self.get("var", "cocotb_random_seed")
+        if random_seed is not None:
+            self.set_environmentalvariable("COCOTB_RANDOM_SEED", str(random_seed))
+            self.add_required_key("env", "COCOTB_RANDOM_SEED")
+
+    def setup(self):
+        super().setup()
+
+        if not _has_cocotb:
+            raise RuntimeError("Cocotb is not installed; cannot run test.")
+
+        # Output: xUnit XML results file
+        self.add_output_file(file="results.xml")
+
+        self.add_required_key("option", "design")
+        self.add_required_key("option", "fileset")
+        if self.project.get("option", "alias"):
+            self.add_required_key("option", "alias")
+
+        # Require Python test modules
+        for lib, fileset in self.project.get_filesets():
+            if lib.has_file(fileset=fileset, filetype="python"):
+                self.add_required_key(lib, "fileset", fileset, "file", "python")
+
+        if self.get("var", "cocotb_random_seed") is not None:
+            self.add_required_key("var", "cocotb_random_seed")
+
+        # Set up cocotb environment variables
+        self.__setup_cocotb_environment()
+
+    def get_runtime_environmental_variables(self, include_path: bool = True) -> Dict[str, str]:
+        envs = super().get_runtime_environmental_variables(include_path)
+
+        _, module_dirs = self._get_test_modules()
+        libs_dir = cocotb_tools.config.libs_dir
+
+        # PATH: add cocotb libs directory
+        current_path = os.environ.get("PATH", "")
+        new_path = f"{libs_dir}{os.pathsep}{current_path}"
+        envs["PATH"] = new_path
+
+        # PYTHONPATH: add directories containing test modules
+        current_pythonpath = os.environ.get("PYTHONPATH", "")
+        pythonpath_parts = module_dirs + ([current_pythonpath] if current_pythonpath else [])
+        envs["PYTHONPATH"] = os.pathsep.join(pythonpath_parts)
+
+        # PYGPI_PYTHON_BIN: Python executable
+        envs["PYGPI_PYTHON_BIN"] = sys.executable
+
+        return envs
+
+    def _parse_cocotb_results(self, results_file: Path):
+        """
+        Parse the cocotb xUnit XML results file and extract metrics.
+
+        Args:
+            results_file: Path to the results.xml file.
+        """
+        try:
+            tree = ET.parse(results_file)
+            root = tree.getroot()
+
+            # Count testcases and failures/errors
+            testcases = root.findall(".//testcase")
+            tests = len(testcases)
+            failures = len(root.findall(".//failure"))
+            errors = len(root.findall(".//error"))
+
+            passed = tests - failures - errors
+
+            self.logger.info(f"Cocotb results: {passed}/{tests} tests passed")
+            if failures > 0:
+                self.logger.warning(f"Cocotb: {failures} test(s) failed")
+            if errors > 0:
+                self.logger.warning(f"Cocotb: {errors} test(s) had errors")
+
+            self.record_metric("errors", errors + failures, source_file=results_file)
+
+        except Exception as e:
+            self.logger.warning(f"Failed to parse cocotb results: {e}")
+
+    def post_process(self):
+        super().post_process()
+
+        # Parse cocotb results XML and report metrics
+        results_file = Path("outputs/results.xml")
+        if results_file.exists():
+            self._parse_cocotb_results(results_file)

siliconcompiler/tools/builtin/wait.py

@@ -1,5 +1,10 @@
+from typing import TYPE_CHECKING
+
 from siliconcompiler.tools.builtin import BuiltinTask
 
+if TYPE_CHECKING:
+    from siliconcompiler import Flowgraph
+
 
 class Wait(BuiltinTask):
     '''
@@ -14,3 +19,134 @@ class Wait(BuiltinTask):
 
     def task(self):
         return "wait"
+
+    @staticmethod
+    def __has_path(flowgraph: "Flowgraph", source: tuple, target: tuple) -> bool:
+        '''
+        Helper method to check if there's any path from source to target node.
+
+        Args:
+            flowgraph: The flowgraph to search.
+            source: Tuple of (step, index) for the source node.
+            target: Tuple of (step, index) for the target node.
+
+        Returns:
+            bool: True if there's a path from source to target, False otherwise.
+        '''
+        if source == target:
+            return True
+
+        visited = set()
+        to_visit = [source]
+
+        while to_visit:
+            current = to_visit.pop(0)
+            if current == target:
+                return True
+            if current in visited:
+                continue
+            visited.add(current)
+
+            # Add all output nodes to the queue
+            outputs = flowgraph.get_node_outputs(current[0], current[1])
+            to_visit.extend(outputs)
+
+        return False
+
+    @staticmethod
+    def serialize_tool_tasks(flowgraph: "Flowgraph", tool_name: str) -> None:
+        '''
+        Adds wait tasks between nodes of the same tool that could execute in parallel.
+
+        This method inserts `Wait` task nodes between nodes that use the same
+        tool, but only when those nodes could execute in parallel (i.e., there's
+        no dependency path between them). This ensures that tool instances don't
+        execute in parallel, while avoiding unnecessary wait tasks for nodes
+        that already have a dependency relationship.
+
+        The method modifies the flowgraph in-place by:
+        1. Finding all nodes that use the specified tool
+        2. For each pair of tool nodes with no dependency path, inserting a wait task
+        3. Using naming convention: {target_step}.wait
+           (named after the node being delayed)
+
+        Args:
+            flowgraph: The flowgraph to modify.
+            tool_name (str): The name of the tool (e.g., 'openroad', 'yosys').
+                All nodes using this tool will be serialized.
+
+        Raises:
+            ValueError: If the flowgraph is invalid or tool_name is empty.
+
+        Example:
+            >>> flow = Flowgraph("myflow")
+            >>> flow.node("place1", openroad.Place, index=0)
+            >>> flow.node("syn", yosys.Syn, index=0)
+            >>> flow.node("place2", openroad.Place, index=1)
+            >>> flow.edge("place1", "syn")
+            >>> flow.edge("syn", "place2")
+            >>> Wait.serialize_tool_tasks(flow, "openroad")
+            >>> # No wait task added - place1 and place2 already have a dependency path
+        '''
+        if not tool_name or not isinstance(tool_name, str):
+            raise ValueError(f"tool_name must be a non-empty string, not {tool_name}")
+
+        if not flowgraph.validate():
+            raise ValueError(f"Flowgraph '{flowgraph.name}' is invalid before serialization")
+
+        # Find all nodes using the specified tool
+        tool_nodes = []
+        for step, index in flowgraph.get_nodes():
+            graph_node = flowgraph.get_graph_node(step, index)
+            if graph_node.get_tool() == tool_name:
+                tool_nodes.append((step, index))
+
+        if not tool_nodes or len(tool_nodes) < 2:
+            # Need at least 2 nodes to create wait tasks
+            return
+
+        # Sort nodes by execution order to establish a consistent serialization
+        execution_order = flowgraph.get_execution_order()
+        node_order_map = {}
+        for level_idx, level in enumerate(execution_order):
+            for node_idx, node in enumerate(level):
+                node_order_map[node] = (level_idx, node_idx)
+
+        sorted_tool_nodes = sorted(
+            tool_nodes, key=lambda n: node_order_map.get(n, (float('inf'), 0)))
+
+        # Check if there are pairs without dependency paths that need serialization
+        needs_serialization = False
+        for i in range(len(sorted_tool_nodes)):
+            for j in range(i + 1, len(sorted_tool_nodes)):
+                node1 = sorted_tool_nodes[i]
+                node2 = sorted_tool_nodes[j]
+                if not Wait.__has_path(flowgraph, node1, node2):
+                    needs_serialization = True
+                    break
+            if needs_serialization:
+                break
+
+        if not needs_serialization:
+            # All tool nodes already have dependency paths, no wait nodes needed
+            return
+
+        # Create wait nodes between each pair of consecutive tool nodes
+        # Chain: tool[0] -> wait_1 -> tool[1] -> wait_2 -> tool[2] -> ...
+        for i in range(len(sorted_tool_nodes) - 1):
+            curr_node = sorted_tool_nodes[i]
+            next_node = sorted_tool_nodes[i + 1]
+
+            # Check if there's already a dependency path between them
+            if Wait.__has_path(flowgraph, curr_node, next_node):
+                # Already serialized, skip
+                continue
+
+            # Create wait node named after the next node (the one being delayed)
+            wait_step = f"{next_node[0]}.wait"
+            wait_index = next_node[1]
+            flowgraph.node(wait_step, Wait(), index=wait_index)
+
+            # Connect: curr_node -> wait_node -> next_node
+            flowgraph.edge(curr_node[0], wait_step, tail_index=curr_node[1], head_index=wait_index)
+            flowgraph.edge(wait_step, next_node[0], tail_index=wait_index, head_index=next_node[1])