siliconcompiler 0.36.2__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.2'
+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/project.py

@@ -4,7 +4,7 @@ import uuid
 
 import os.path
 
-from typing import Union, List, Tuple, TextIO, Optional, Dict, Set
+from typing import Type, Union, List, Tuple, TextIO, Optional, Dict, Set, TypeVar
 
 from siliconcompiler.schema import BaseSchema, NamedSchema, EditableSchema, Parameter, Scope, \
     __version__ as schema_version, \
@@ -33,6 +33,8 @@ from siliconcompiler.utils.multiprocessing import MPManager
 from siliconcompiler.utils.paths import jobdir, workdir
 from siliconcompiler.flows.showflow import ShowFlow
 
+TProject = TypeVar("TProject", bound="Project")
+
 
 class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
     """
@@ -236,7 +238,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         return self.get("option", field="schema")
 
     @classmethod
-    def convert(cls, obj: "Project") -> "Project":
+    def convert(cls: Type[TProject], obj: "Project") -> TProject:
         """
         Converts a project from one type to another (e.g., Project to Sim).
 
@@ -526,7 +528,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
                                  f"{', '.join([f'{step}/{index}' for step, index in breakpoints])}")
                 self.__dashboard.stop()
 
-    def run(self) -> "Project":
+    def run(self) -> TProject:
         '''
         Executes the compilation flow defined in the project's flowgraph.
 
@@ -1238,7 +1240,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
             return None
 
         # Create copy of project to avoid changing user project
-        proj: Project = self.copy()
+        proj = self.copy()
         proj.set_flow(ShowFlow(task))
 
         # Setup options:

siliconcompiler/schema/baseschema.py

@@ -8,6 +8,7 @@ import contextlib
 import copy
 import importlib
 import logging
+import pathlib
 
 try:
     import gzip
@@ -26,12 +27,15 @@ import os.path
 
 from enum import Enum, auto
 from functools import cache
-from typing import Dict, Type, Tuple, Union, Set, Callable, List, Optional, TextIO, Iterable, Any
+from typing import Dict, Type, Tuple, TypeVar, Union, Set, Callable, List, Optional, \
+    TextIO, Iterable, Any
 
 from .parameter import Parameter, NodeValue
 from .journal import Journal
 from ._metadata import version
 
+TSchema = TypeVar('TSchema', bound='BaseSchema')
+
 
 class LazyLoad(Enum):
     """
@@ -286,10 +290,10 @@ class BaseSchema:
 
     # Manifest methods
     @classmethod
-    def from_manifest(cls,
+    def from_manifest(cls: Type[TSchema],
                       filepath: Union[None, str] = None,
                       cfg: Union[None, Dict] = None,
-                      lazyload: bool = True) -> "BaseSchema":
+                      lazyload: bool = True) -> TSchema:
         '''
         Create a new schema based on the provided source files.
 
@@ -382,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()
@@ -849,7 +861,7 @@ class BaseSchema:
         return manifest
 
     # Utility functions
-    def copy(self, key: Optional[Tuple[str, ...]] = None) -> "BaseSchema":
+    def copy(self: TSchema, key: Optional[Tuple[str, ...]] = None) -> TSchema:
         """
         Returns a copy of this schema.
 

siliconcompiler/schema/docschema.py

@@ -1,6 +1,6 @@
-from typing import Union, List
+from typing import Type, Union, List
 
-from .baseschema import BaseSchema
+from .baseschema import BaseSchema, TSchema
 
 
 class DocsSchema(BaseSchema):
@@ -11,7 +11,7 @@ class DocsSchema(BaseSchema):
     """
 
     @classmethod
-    def make_docs(cls) -> Union[BaseSchema, List[BaseSchema]]:
+    def make_docs(cls: Type[TSchema]) -> Union[TSchema, List[TSchema]]:
         """Generate the documentation representation for this schema.
 
         By default, this method returns a standard instance of the class itself.

siliconcompiler/schema/editableschema.py

@@ -163,7 +163,7 @@ class EditableSchema:
             new_schema._BaseSchema__parent = None
         return new_schema
 
-    def rename(self, name: str):
+    def rename(self, name: str) -> None:
         '''
         Renames a named schema
         '''

siliconcompiler/schema/namedschema.py

@@ -4,9 +4,9 @@
 # SC dependencies outside of its directory, since it may be used by tool drivers
 # that have isolated Python environments.
 
-from typing import Dict, Tuple, Optional, Set, Union, List
+from typing import Dict, Tuple, Optional, Set, Type, Union, List
 
-from .baseschema import BaseSchema, LazyLoad
+from .baseschema import BaseSchema, LazyLoad, TSchema
 
 
 class NamedSchema(BaseSchema):
@@ -76,11 +76,11 @@ class NamedSchema(BaseSchema):
         return cfg.get("__meta__", {}).get("name", None)
 
     @classmethod
-    def from_manifest(cls,
+    def from_manifest(cls: Type[TSchema],
                       filepath: Union[None, str] = None,
                       cfg: Union[None, Dict] = None,
                       lazyload: bool = True,
-                      name: Optional[str] = None):
+                      name: Optional[str] = None) -> TSchema:
         '''
         Create a new schema based on the provided source files.
 
@@ -115,8 +115,8 @@ class NamedSchema(BaseSchema):
 
         return super()._from_dict(manifest, keypath, version=version, lazyload=lazyload)
 
-    def copy(self, key: Optional[Tuple[str, ...]] = None) -> "NamedSchema":
-        copy: NamedSchema = super().copy(key=key)
+    def copy(self: TSchema, key: Optional[Tuple[str, ...]] = None) -> TSchema:
+        copy = super().copy(key=key)
 
         if key and key[-1] != "default":
             copy.__name = key[-1]

siliconcompiler/schema_support/cmdlineschema.py

@@ -4,12 +4,14 @@ import sys
 
 import os.path
 
-from typing import Set, List, Optional, Union
+from typing import Set, List, Optional, Type, Union, TypeVar
 
 from siliconcompiler.schema import BaseSchema, EditableSchema, Parameter, Scope, PerNode
 from siliconcompiler.schema.utils import trim
 from siliconcompiler import _metadata
 
+TCmdSchema = TypeVar("TCmdSchema", bound="CommandLineSchema")
+
 
 class CommandLineSchema(BaseSchema):
     '''
@@ -68,14 +70,14 @@ class CommandLineSchema(BaseSchema):
         EditableSchema(self).insert("cmdarg", name, Parameter(type, **kwargs))
 
     @classmethod
-    def create_cmdline(cls,
+    def create_cmdline(cls: Type[TCmdSchema],
                        progname: Optional[str] = None,
                        description: Optional[str] = None,
                        switchlist: Optional[Union[List[str], Set[str]]] = None,
                        version: Optional[str] = None,
                        print_banner: bool = True,
                        use_cfg: bool = False,
-                       use_sources: bool = True) -> BaseSchema:
+                       use_sources: bool = True) -> TCmdSchema:
         """
         Creates an SC command line interface.
 
@@ -141,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
@@ -159,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/tool.py

@@ -53,7 +53,8 @@ if TYPE_CHECKING:
     from siliconcompiler.scheduler import SchedulerNode
     from siliconcompiler import Project
 
-TTask = TypeVar('TTask')
+TTask = TypeVar('TTask', bound='Task')
+TShowTask = TypeVar('TShowTask', bound='ShowTask')
 
 
 class TaskError(Exception):
@@ -2177,7 +2178,8 @@ class ShowTask(Task):
             cls.register_task(c)
 
     @classmethod
-    def get_task(cls, ext: Optional[str]) -> Union[Optional["ShowTask"], Set[Type["ShowTask"]]]:
+    def get_task(cls: Type[TShowTask], ext: Optional[str]) -> \
+            Union[Optional[TShowTask], Set[Type[TShowTask]]]:
         """
         Retrieves a suitable show task instance for a given file extension.