siliconcompiler 0.36.3__tar.gz → 0.36.4__tar.gz

{siliconcompiler-0.36.3 → siliconcompiler-0.36.4}/.readthedocs.yaml

@@ -28,3 +28,4 @@ python:
         - lint
         - docs
         - optimizer
+        - cocotb

{siliconcompiler-0.36.3 → siliconcompiler-0.36.4}/Changes

@@ -8,6 +8,23 @@ The changes in each SiliconCompiler release version are described below. Commit
 version shown in (). Where applicable, the contributors that suggested a given
 feature are shown in [].
 
+SiliconCompiler 0.36.4 (2026-01-31)
+=========================================
+
+**Minor:**
+
+ * Fixed commandline handling of `sc-issue` when `-cfg` is missing.
+ * Added support for `-jobs` to `sc-install` to control number of build jobs.
+ * Updated detection of editable python installs.
+ * Fixed json serialization bug when journal is active.
+
+ * Tools:
+
+  * yosys: removed default use of kogge-stone techmap pass.
+  * openroad: correctly include lefs in floorplanning required keys.
+  * icarus, verilator: added support for cocotb plugins.
+
+
 SiliconCompiler 0.36.3 (2026-01-21)
 =========================================
 

{siliconcompiler-0.36.3 → siliconcompiler-0.36.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: siliconcompiler
-Version: 0.36.3
+Version: 0.36.4
 Summary: A compiler framework that automates translation from source code to silicon.
 Author: Zero ASIC
 License: Apache License 2.0
@@ -70,6 +70,8 @@ Requires-Dist: pydata-sphinx-theme==0.16.1; extra == "docs"
 Requires-Dist: sc-leflib>=0.2.0; extra == "docs"
 Provides-Extra: optimizer
 Requires-Dist: google-vizier[jax]==0.1.21; python_version >= "3.10" and extra == "optimizer"
+Provides-Extra: cocotb
+Requires-Dist: cocotb<2.1.0,>=2.0.1; (python_version >= "3.7" and python_version <= "3.13") and extra == "cocotb"
 Dynamic: license-file
 
 ![SiliconCompiler](https://raw.githubusercontent.com/siliconcompiler/siliconcompiler/main/docs/_static/sc_logo_with_text.png)

{siliconcompiler-0.36.3 → siliconcompiler-0.36.4}/pyproject.toml

@@ -124,6 +124,9 @@ docs = [
 optimizer = [
     "google-vizier[jax] == 0.1.21; python_version >= '3.10'"
 ]
+cocotb = [
+    "cocotb >= 2.0.1, < 2.1.0; python_version >= '3.7' and python_version <= '3.13'"
+]
 
 [tool.setuptools]
 include-package-data = true

{siliconcompiler-0.36.3 → siliconcompiler-0.36.4}/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-0.36.3 → siliconcompiler-0.36.4}/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-0.36.3 → siliconcompiler-0.36.4}/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-0.36.3 → siliconcompiler-0.36.4}/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-0.36.3 → siliconcompiler-0.36.4}/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-0.36.3 → siliconcompiler-0.36.4}/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-0.36.3 → siliconcompiler-0.36.4}/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-0.36.3 → siliconcompiler-0.36.4}/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-0.36.4/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)