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

siliconcompiler/toolscripts/_tools.json

@@ -1,7 +1,7 @@
 {
   "openroad": {
     "git-url": "https://github.com/The-OpenROAD-Project/OpenROAD.git",
-    "git-commit": "cef8746bc887f3da67bd964ad9061ca7a8b8903a",
+    "git-commit": "be6d32d0c093e8e5f0545067f48509c60fbde1dc",
     "docker-cmds": [
       "# Remove OR-Tools files",
       "RUN rm -f $SC_PREFIX/Makefile $SC_PREFIX/README.md",
@@ -17,7 +17,7 @@
   },
   "opensta": {
     "git-url": "https://github.com/parallaxsw/OpenSTA.git",
-    "git-commit": "cda30445d652c6d41f68732675ddbf28b5efeeab",
+    "git-commit": "82fd625199d25dbe6ca25db9b62417caad358bb9",
     "auto-update": true
   },
   "netgen": {
@@ -60,7 +60,7 @@
   },
   "verilator": {
     "git-url": "https://github.com/verilator/verilator.git",
-    "git-commit": "v5.030",
+    "git-commit": "v5.038",
     "auto-update": true
   },
   "bambu": {
@@ -101,7 +101,7 @@
   },
   "yosys": {
     "git-url": "https://github.com/YosysHQ/yosys.git",
-    "git-commit": "v0.54",
+    "git-commit": "v0.56",
     "version-prefix": "",
     "auto-update": true
   },
@@ -139,11 +139,6 @@
     "git-url": "https://github.com/chipsalliance/verible.git",
     "auto-update": false
   },
-  "slang": {
-    "git-commit": "v8.1",
-    "git-url": "https://github.com/MikePopoloski/slang.git",
-    "auto-update": true
-  },
   "gtkwave": {
     "git-commit": "v3.3.116",
     "git-url": "https://github.com/gtkwave/gtkwave.git",
@@ -151,7 +146,7 @@
   },
   "yosys-slang": {
     "git-url": "https://github.com/povik/yosys-slang.git",
-    "git-commit": "9d9ce7b767d2ea776e2dee0ef636a84512e6b229",
+    "git-commit": "e0b5a4c2b8360479a408bc30f57871f3b0b814ff",
     "docker-depends": "yosys",
     "auto-update": true
   },

siliconcompiler/utils/__init__.py

@@ -1,12 +1,16 @@
 import contextlib
 import os
 import re
+import pathlib
 import psutil
 import shutil
+import stat
 import traceback
+
 from io import StringIO
 from pathlib import Path
 from jinja2 import Environment, FileSystemLoader
+
 from siliconcompiler.schema.parametervalue import PathNodeValue
 
 import sys
@@ -405,3 +409,65 @@ def print_traceback(logger, exception):
     logger.error("Backtrace:")
     for line in trace.getvalue().splitlines():
         logger.error(line)
+
+
+class FilterDirectories:
+    def __init__(self, project):
+        self.file_count = 0
+        self.directory_file_limit = None
+        self.abspath = None
+        self.project = project
+
+    @property
+    def logger(self):
+        return self.project.logger
+
+    @property
+    def builddir(self):
+        return self.project._getbuilddir()
+
+    def filter(self, path, files):
+        if pathlib.Path(path) == pathlib.Path.home():
+            # refuse to collect home directory
+            self.logger.error(f'Cannot collect user home directory: {path}')
+            return files
+
+        if pathlib.Path(path) == pathlib.Path(self.builddir):
+            # refuse to collect build directory
+            self.logger.error(f'Cannot collect build directory: {path}')
+            return files
+
+        # do not collect hidden files
+        hidden_files = []
+        # filter out hidden files (unix)
+        hidden_files.extend([f for f in files if f.startswith('.')])
+        # filter out hidden files (windows)
+        try:
+            if hasattr(os.stat_result, 'st_file_attributes'):
+                hidden_files.extend([
+                    f for f in files
+                    if bool(os.stat(os.path.join(path, f)).st_file_attributes &
+                            stat.FILE_ATTRIBUTE_HIDDEN)
+                ])
+        except:  # noqa 722
+            pass
+        # filter out hidden files (macos)
+        try:
+            if hasattr(os.stat_result, 'st_reparse_tag'):
+                hidden_files.extend([
+                    f for f in files
+                    if bool(os.stat(os.path.join(path, f)).st_reparse_tag &
+                            stat.UF_HIDDEN)
+                ])
+        except:  # noqa 722
+            pass
+
+        self.file_count += len(files) - len(hidden_files)
+
+        if self.directory_file_limit and \
+                self.file_count > self.directory_file_limit:
+            self.logger.error(f'File collection from {self.abspath} exceeds '
+                              f'{self.directory_file_limit} files')
+            return files
+
+        return hidden_files

siliconcompiler/utils/flowgraph.py

@@ -4,7 +4,7 @@ from siliconcompiler import NodeStatus
 from siliconcompiler.tools._common import input_file_node_name, get_tool_task
 
 from siliconcompiler.flowgraph import RuntimeFlowgraph
-from siliconcompiler.scheduler.schedulernode import SchedulerNode
+from siliconcompiler.scheduler import SchedulerNode
 
 
 ###########################################################################
@@ -65,7 +65,7 @@ def _check_flowgraph_io(chip, nodes=None):
                 in_tool, in_task = get_tool_task(chip, in_step, in_index, flow=flow)
                 task_class = chip.get("tool", in_tool, "task", in_task, field="schema")
 
-                with task_class.runtime(chip, step=in_step, index=in_index) as task:
+                with task_class.runtime(SchedulerNode(chip, in_step, in_index)) as task:
                     inputs = task.get_output_files()
 
             for inp in inputs:

siliconcompiler/utils/issue.py

@@ -10,6 +10,7 @@ from datetime import datetime
 from siliconcompiler.utils import get_file_template
 from siliconcompiler.tools._common import get_tool_task
 from siliconcompiler import RecordSchema
+from siliconcompiler.scheduler import SchedulerNode
 
 
 def generate_testcase(chip,
@@ -154,7 +155,7 @@ def generate_testcase(chip,
 
     task_class = chip.get("tool", tool, "task", task, field="schema")
 
-    with task_class.runtime(chip, step=step, index=index, relpath=new_work_dir) as task:
+    with task_class.runtime(SchedulerNode(chip, step, index), relpath=new_work_dir) as task:
         # Rewrite replay.sh
         prev_quiet = chip.get('option', 'quiet', step=step, index=index)
         chip.set('option', 'quiet', True, step=step, index=index)

siliconcompiler/utils/logging.py

@@ -1,5 +1,7 @@
 import logging
+import re
 import sys
+
 from siliconcompiler import utils
 
 
@@ -8,6 +10,18 @@ class SCBlankLoggerFormatter(logging.Formatter):
         super().__init__("%(message)s")
 
 
+class SCBlankColorlessLoggerFormatter(logging.Formatter):
+    def __init__(self):
+        super().__init__("%(message)s")
+
+        self.__rm = re.compile(u"\u001b\\[(\\d+)m")
+
+    def format(self, record):
+        msg = super().format(record)
+
+        return self.__rm.sub("", msg)
+
+
 class SCDebugLoggerFormatter(logging.Formatter):
     def __init__(self):
         super().__init__(

siliconcompiler/utils/multiprocessing.py

@@ -0,0 +1,256 @@
+import atexit
+import logging
+import multiprocessing
+import tempfile
+import os.path
+from datetime import datetime
+
+from siliconcompiler.report.dashboard.cli.board import Board
+
+
+class _ManagerSingleton(type):
+    """
+    A metaclass to enforce the singleton pattern on any class that uses it.
+
+    This ensures that only one instance of the target class is ever created
+    within the application's lifecycle. It uses a lock to make the
+    instantiation process thread-safe.
+
+    Attributes:
+        _instances (dict): A dictionary to store singleton instances, mapping
+            class objects to their single instance.
+        _lock (multiprocessing.Lock): A lock to prevent race conditions during
+            the first instantiation.
+    """
+    _instances = {}
+    _lock = multiprocessing.Lock()
+
+    @staticmethod
+    def has_cls(cls):
+        """
+        Checks if a singleton instance exists for the given class.
+
+        Args:
+            cls (type): The class to check.
+
+        Returns:
+            bool: True if an instance exists, False otherwise.
+        """
+        return cls in _ManagerSingleton._instances
+
+    @staticmethod
+    def remove_cls(cls):
+        """
+        Removes a class's singleton instance from the registry.
+
+        This is useful for cleanup, especially in testing scenarios where
+        a fresh instance is needed.
+
+        Args:
+            cls (type): The class whose instance should be removed.
+        """
+        if not _ManagerSingleton.has_cls(cls):
+            return
+
+        with _ManagerSingleton._lock:
+            if cls in _ManagerSingleton._instances:
+                del _ManagerSingleton._instances[cls]
+
+    def __call__(cls, *args, **kwargs):
+        """
+        Handles the instantiation of the class using a double-checked lock.
+
+        If an instance of the class does not already exist, it creates one
+        and stores it. Subsequent calls will return the existing instance.
+        A special '_init_singleton' method is called on the first creation.
+        """
+        if not _ManagerSingleton.has_cls(cls):
+            with _ManagerSingleton._lock:
+                if cls not in _ManagerSingleton._instances:
+                    instance = super(_ManagerSingleton, cls).__call__(*args, **kwargs)
+                    _ManagerSingleton._instances[cls] = instance
+                    # Custom initializer for the singleton instance
+                    instance._init_singleton()
+        return _ManagerSingleton._instances[cls]
+
+
+class MPManager(metaclass=_ManagerSingleton):
+    """
+    A singleton manager for handling multiprocessing resources in SiliconCompiler.
+
+    This class provides centralized, thread-safe access to shared resources
+    like a logger, a multiprocessing.Manager, and a dashboard Board instance.
+    It is designed to be instantiated once and accessed globally.
+    """
+    __ENABLE_LOGGER: bool = True
+
+    def __init__(self):
+        """
+        Initializes the MPManager.
+
+        Note: The actual setup logic is in _init_singleton, which is called
+        automatically by the _ManagerSingleton metaclass upon first instantiation.
+        """
+        pass
+
+    def _init_singleton(self):
+        """
+        Performs the one-time initialization of the singleton instance.
+
+        This method sets up the start time, error flag, logger,
+        multiprocessing manager, and registers the cleanup function (`stop`)
+        to be called on program exit.
+        """
+        self.__start = datetime.now()
+        self.__error = False
+
+        # Parent logger setup
+        now_file = self.__start.strftime("%Y-%m-%d-%H-%M-%S-%f")
+        self.__logfile = os.path.join(tempfile.gettempdir(),
+                                      "siliconcompiler",
+                                      f"{now_file}_{id(self)}.log")
+        self._init_logger()
+
+        # Manager to handle shared data between processes
+        self.__manager = multiprocessing.Manager()
+
+        # Dashboard singleton setup
+        self.__board_lock = self.__manager.Lock()
+        self.__board = None
+
+        # Register cleanup function to run at exit
+        atexit.register(MPManager.stop)
+
+    def _init_logger(self):
+        """
+        Initializes the logging configuration for SiliconCompiler.
+
+        It sets up a root logger named "siliconcompiler" and adds a file
+        handler to log messages to a temporary file. The log level is
+        initially set to INFO to capture the start time and then raised
+        to WARNING.
+        """
+        # Root logger for the application
+        self.__logger = logging.getLogger("siliconcompiler")
+        self.__logger.propagate = False
+
+        if self.__ENABLE_LOGGER:
+            self.__logger.setLevel(logging.INFO)
+            try:
+                os.makedirs(os.path.dirname(self.__logfile), exist_ok=True)
+
+                handler = logging.FileHandler(self.__logfile)
+                handler.setFormatter(logging.Formatter(
+                    '%(asctime)s | %(name)s | %(levelname)s | %(message)s'))
+                handler.setLevel(logging.INFO)
+
+                self.__logger.addHandler(handler)
+
+                now_print = self.__start.strftime("%Y-%m-%d %H:%M:%S.%f")
+                self.__logger.info(f"Log started at {now_print}")
+
+                # Reduce logging level after initial message
+                handler.setLevel(logging.WARNING)
+            except Exception:
+                # Fails silently if logging can't be set up
+                pass
+
+    @staticmethod
+    def stop():
+        """
+        Cleans up all managed resources as a static method.
+
+        This method is registered with atexit to run on script termination.
+        It closes logger handlers, deletes the log file if no errors occurred,
+        stops the dashboard service, shuts down the multiprocessing manager,
+        and finally removes the singleton instance from the registry.
+        """
+        if not _ManagerSingleton.has_cls(MPManager):
+            return
+
+        manager = MPManager()
+
+        # Remove all logger handlers to release file locks
+        for handler in list(manager.__logger.handlers):
+            manager.__logger.removeHandler(handler)
+            handler.close()
+
+        # Remove the log file if the run was successful
+        if not manager.__error:
+            try:
+                os.remove(manager.__logfile)
+            except:  # noqa E722
+                pass
+
+        # Stop the dashboard service if it's running
+        if manager.__board:
+            with manager.__board_lock:
+                if manager.__board:
+                    manager.__board.stop()
+                    manager.__board = None
+
+        # Shut down the multiprocessing manager
+        manager.__manager.shutdown()
+
+        # Unregister cleanup function to prevent it from being called again
+        atexit.unregister(MPManager.stop)
+
+        # Delete singleton instance to allow for re-initialization
+        _ManagerSingleton.remove_cls(MPManager)
+
+    @staticmethod
+    def error(msg: str = None):
+        """
+        Logs an error and flags the session as having an error.
+
+        This prevents the log file from being deleted upon exit, preserving it
+        for debugging.
+
+        Args:
+            msg (str, optional): The error message to log. Defaults to None.
+        """
+        manager = MPManager()
+        if msg:
+            manager.logger().error(f"Error: {msg}")
+        else:
+            manager.logger().error("Error occurred")
+        manager.__error = True
+
+    @staticmethod
+    def get_manager():
+        """
+        Provides access to the shared multiprocessing.Manager instance.
+
+        Returns:
+            multiprocessing.Manager: The singleton manager instance.
+        """
+        return MPManager().__manager
+
+    @staticmethod
+    def get_dashboard() -> Board:
+        """
+        Lazily initializes and returns the singleton dashboard Board instance.
+
+        This method ensures that the Board is only created when first requested
+        and that its initialization is thread-safe.
+
+        Returns:
+            Board: The singleton dashboard Board instance.
+        """
+        manager = MPManager()
+        if not manager.__board:
+            with manager.__board_lock:
+                # Double-check locking to ensure thread safety
+                if not manager.__board:
+                    manager.__board = Board(manager.__manager)
+        return manager.__board
+
+    @staticmethod
+    def logger() -> logging.Logger:
+        """
+        Provides access to the shared logger instance.
+
+        Returns:
+            logging.Logger: The singleton logger instance.
+        """
+        return MPManager().__logger

siliconcompiler/utils/showtools.py

@@ -44,3 +44,13 @@ def setup(chip):
     chip.register_showtool('dot', graphviz_screenshot)
     chip.register_showtool('xdot', graphviz_show)
     chip.register_showtool('xdot', graphviz_screenshot)
+
+
+def showtasks():
+    from siliconcompiler import ShowTaskSchema, ScreenshotTaskSchema
+
+    from siliconcompiler.tools.openroad.show import ShowTask as OpenROADShow
+    from siliconcompiler.tools.openroad.screenshot import ScreenshotTask as OpenROADScreenshot
+
+    ShowTaskSchema.register_task(OpenROADShow)
+    ScreenshotTaskSchema.register_task(OpenROADScreenshot)

{siliconcompiler-0.34.1.dist-info → siliconcompiler-0.34.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: siliconcompiler
-Version: 0.34.1
+Version: 0.34.3
 Summary: A compiler framework that automates translation from source code to silicon.
 Author-email: Andreas Olofsson <andreas.d.olofsson@gmail.com>
 License: Apache License 2.0
@@ -34,16 +34,16 @@ Requires-Dist: distro==1.9.0
 Requires-Dist: packaging<25,>=21.3
 Requires-Dist: psutil>=5.8.0
 Requires-Dist: Pillow==11.3.0
-Requires-Dist: GitPython==3.1.44
+Requires-Dist: GitPython<3.2,>=3.1.44
 Requires-Dist: lambdapdk>=0.1.47
-Requires-Dist: PyGithub==2.6.1
+Requires-Dist: PyGithub==2.7.0
 Requires-Dist: urllib3>=1.26.0
 Requires-Dist: fasteners==0.19
 Requires-Dist: fastjsonschema==2.21.1
 Requires-Dist: docker==7.1.0
 Requires-Dist: importlib_metadata; python_version < "3.10"
-Requires-Dist: orjson==3.10.18
-Requires-Dist: pyslang==8.1.0
+Requires-Dist: orjson<4,>=3.11.0
+Requires-Dist: pyslang==9.0.0
 Requires-Dist: streamlit==1.46.1; python_full_version != "3.9.7"
 Requires-Dist: streamlit_agraph==0.0.45; python_full_version != "3.9.7"
 Requires-Dist: streamlit-antd-components==0.3.2; python_full_version != "3.9.7"
@@ -54,7 +54,7 @@ Provides-Extra: test
 Requires-Dist: pytest==8.4.1; extra == "test"
 Requires-Dist: pytest-xdist==3.8.0; extra == "test"
 Requires-Dist: pytest-timeout==2.4.0; extra == "test"
-Requires-Dist: pytest-asyncio==1.0.0; extra == "test"
+Requires-Dist: pytest-asyncio==1.1.0; extra == "test"
 Requires-Dist: pytest-cov==6.2.1; extra == "test"
 Requires-Dist: responses==0.25.7; extra == "test"
 Requires-Dist: PyVirtualDisplay==3.0; extra == "test"