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

siliconcompiler/report/report.py

@@ -110,7 +110,7 @@ def make_manifest_helper(manifest_subsect, modified_manifest_subsect):
     def _is_leaf(cfg):
         # 'shorthelp' chosen arbitrarily: any mandatory field with a consistent
         # type would work.
-        return 'shorthelp' in cfg and isinstance(cfg['shorthelp'], str)
+        return 'type' in cfg and isinstance(cfg['type'], str)
 
     def build_leaf(manifest_subsect):
         if PerNode(manifest_subsect['pernode']) == PerNode.NEVER:
@@ -161,7 +161,10 @@ def make_manifest_helper(manifest_subsect, modified_manifest_subsect):
                         else:
                             modified_manifest_subsect[step + index] = value
 
-    for key, key_dict in manifest_subsect.items():
+    for key, key_dict in sorted(manifest_subsect.items(), key=lambda k: k[0]):
+        if key == "__meta__" or key == "__journal__":
+            continue
+
         if key != 'default':
             if _is_leaf(key_dict):
                 modified_manifest_subsect[key] = build_leaf(key_dict)

siliconcompiler/report/summary_image.py

@@ -1,7 +1,11 @@
 import os
 import string
+
+import os.path
+
 from PIL import Image, ImageFont, ImageDraw
 
+import siliconcompiler
 from siliconcompiler.utils import units
 from siliconcompiler.report.utils import _find_summary_image, _find_summary_metrics
 
@@ -12,10 +16,6 @@ def _generate_summary_image(chip, output_path):
     featuring a layout thumbnail and several metrics.
     '''
 
-    img_path = _find_summary_image(chip)
-    if not img_path:
-        return
-
     # Extract metrics for display
     metrics = {
         'Chip': chip.design,
@@ -46,14 +46,31 @@ def _generate_summary_image(chip, output_path):
         'LUTs': ('luts', None),
         'Fmax': ('fmax', format_freq)}))
 
-    # Generate design
+    info = []
+    for metric, value in metrics.items():
+        info.append((metric, value))
+
+    generate_summary_image(chip, output_path, info)
 
+
+def generate_summary_image(project, output_path, info):
+    '''
+    Takes a layout screenshot and generates a design summary image
+    featuring a layout thumbnail and several metrics.
+    '''
+
+    img_path = _find_summary_image(project)
+    if not img_path:
+        return
+
+    # Generate design
     WIDTH = 1024
     BORDER = 32
     LINE_SPACING = 8
     TEXT_INDENT = 16
 
-    FONT_PATH = os.path.join(chip.scroot, 'data', 'RobotoMono', 'RobotoMono-Regular.ttf')
+    FONT_PATH = os.path.join(os.path.dirname(siliconcompiler.__file__),
+                             'data', 'RobotoMono', 'RobotoMono-Regular.ttf')
     FONT_SIZE = 40
 
     # matches dark gray background color configured in klayout_show.py
@@ -82,8 +99,9 @@ def _generate_summary_image(chip, output_path):
     text = []
     x = BORDER + TEXT_INDENT
     y = thumbnail_height + 2 * BORDER
-    for metric, value in metrics.items():
-        line = f'{metric}: {value}'
+    max_title_len = max([len(title) for title, _ in info])
+    for title, value in info:
+        line = f'{title:<{max_title_len}}: {value}'
 
         # shorten line till it fits
         cropped_line = line
@@ -94,8 +112,8 @@ def _generate_summary_image(chip, output_path):
             cropped_line = cropped_line[:-1]
 
         if cropped_line != line:
-            chip.logger.warning(f'Cropped {line} to {cropped_line} to fit in design summary '
-                                'image')
+            project.logger.warning(f'Cropped {line} to {cropped_line} to fit in design summary '
+                                   'image')
 
         # Stash line to write and coords to write it at
         text.append(((x, y), cropped_line))
@@ -110,7 +128,7 @@ def _generate_summary_image(chip, output_path):
         draw.text(coords, line, TEXT_COLOR, font=font)
 
     design_summary.save(output_path)
-    chip.logger.info(f'Generated summary image at {output_path}')
+    project.logger.info(f'Generated summary image at {output_path}')
 
 
 def _open_summary_image(image):

siliconcompiler/scheduler/__init__.py

@@ -1,5 +1,13 @@
+from siliconcompiler.scheduler.schedulernode import SchedulerNode
+from siliconcompiler.scheduler.slurm import SlurmSchedulerNode
+from siliconcompiler.scheduler.docker import DockerSchedulerNode
 from siliconcompiler.scheduler.taskscheduler import TaskScheduler
+from siliconcompiler.scheduler.scheduler import Scheduler
 
 __all__ = [
-    "TaskScheduler"
+    "Scheduler",
+    "SchedulerNode",
+    "TaskScheduler",
+    "DockerSchedulerNode",
+    "SlurmSchedulerNode"
 ]

siliconcompiler/scheduler/docker.py

@@ -7,10 +7,25 @@ from pathlib import Path
 
 from siliconcompiler.package import RemoteResolver
 from siliconcompiler.utils import default_email_credentials_file
-from siliconcompiler.scheduler.schedulernode import SchedulerNode
+from siliconcompiler.scheduler import SchedulerNode
 
 
 def get_image(chip, step, index):
+    """Determines the Docker image to use for a given node.
+
+    The image is selected based on the following priority:
+    1. The value of ['option', 'scheduler', 'queue'] specific to the step/index.
+    2. The value of the 'SC_DOCKER_IMAGE' environment variable.
+    3. A default image name constructed as 'ghcr.io/siliconcompiler/sc_runner:v<version>'.
+
+    Args:
+        chip (Chip): The Chip object.
+        step (str): The step name of the node.
+        index (str): The index of the node.
+
+    Returns:
+        str: The name of the Docker image to use.
+    """
     from siliconcompiler import __version__
 
     queue = chip.get('option', 'scheduler', 'queue', step=step, index=index)
@@ -23,6 +38,27 @@ def get_image(chip, step, index):
 
 
 def get_volumes_directories(chip, cache_dir, workdir, step, index):
+    """
+    Identifies and categorizes all host directories that need to be mounted
+    into the Docker container.
+
+    This function scans the chip schema for all file and directory paths,
+    collects them, and then prunes the list to a minimal set of parent
+    directories to mount. It then separates these directories into read-write
+    (RW) and read-only (RO) sets.
+
+    Args:
+        chip (Chip): The Chip object.
+        cache_dir (str): The path to the cache directory.
+        workdir (str): The path to the node's working directory.
+        step (str): The step name of the current node.
+        index (str): The index of the current node.
+
+    Returns:
+        tuple: A tuple containing two sets: (rw_volumes, ro_volumes).
+            `rw_volumes` is a set of Path objects for read-write directories.
+            `ro_volumes` is a set of Path objects for read-only directories.
+    """
     all_dirs = set()
     # Collect files
     for key in chip.allkeys():
@@ -89,17 +125,46 @@ def get_volumes_directories(chip, cache_dir, workdir, step, index):
 
 
 class DockerSchedulerNode(SchedulerNode):
+    """A SchedulerNode implementation for running tasks in a Docker container.
+
+    This class extends the base SchedulerNode to handle the specifics of
+    running a compilation step inside a Docker container. It uses the `docker-py`
+    library to manage the container lifecycle, including pulling the image,
+
+    mounting volumes, and executing the command.
+    """
+
     def __init__(self, chip, step, index, replay=False):
+        """Initializes a DockerSchedulerNode.
+
+        Args:
+            chip (Chip): The parent Chip object.
+            step (str): The step name in the flowgraph.
+            index (str): The index for the step.
+            replay (bool): If True, sets up the node to replay a previous run.
+        """
         super().__init__(chip, step, index, replay=replay)
 
         self.__queue = get_image(self.chip, self.step, self.index)
 
     @property
     def queue(self):
+        """str: The Docker image name to be used for the container."""
         return self.__queue
 
     @staticmethod
     def init(chip):
+        """
+        A static pre-processing hook for the Docker scheduler.
+
+        On Windows, this method forces all file/directory parameters to be
+        copied rather than linked, which avoids issues with differing
+        filesystem types between the host and the Linux-based container.
+        It then triggers `chip.collect()` to ensure all files are staged.
+
+        Args:
+            chip (Chip): The Chip object to perform pre-processing on.
+        """
         if sys.platform == 'win32':
             # this avoids the issue of different file system types
             chip.logger.error('Setting copy field to true for docker run on Windows')
@@ -112,6 +177,19 @@ class DockerSchedulerNode(SchedulerNode):
             chip.collect()
 
     def run(self):
+        """
+        Runs the node's task inside a Docker container.
+
+        This method orchestrates the entire process:
+        1. Connects to the Docker daemon.
+        2. Pulls the required Docker image if it's not present locally.
+        3. Determines and prepares all necessary volume mounts.
+        4. Creates and starts a detached Docker container.
+        5. Writes the current manifest to a file accessible by the container.
+        6. Executes the `sc-node` command inside the container.
+        7. Streams the container's log output to the console.
+        8. Halts on error and ensures the container is stopped upon completion.
+        """
         self._init_run_logger()
 
         try:

siliconcompiler/scheduler/run_node.py

@@ -1,4 +1,13 @@
 #!/usr/bin/env python3
+"""
+A command-line utility to execute a single node (step and index) from a
+SiliconCompiler flowgraph.
+
+This script is designed to be called by a scheduler (like Slurm, Docker, or
+a local process manager) to run a specific task in isolation. It takes all
+necessary configuration information via command-line arguments, sets up a
+Chip object, and executes the specified node's `run()` method.
+"""
 
 import argparse
 import os
@@ -8,19 +17,22 @@ import os.path
 
 from siliconcompiler import Chip, Schema
 from siliconcompiler.package import Resolver
-from siliconcompiler.scheduler.schedulernode import SchedulerNode
+from siliconcompiler.scheduler import SchedulerNode
 from siliconcompiler import __version__
 
 
 ##########################
 def main():
+    """The main entry point for the run_node script."""
     schema = Schema()
 
-    # Can't use chip.cmdline because we don't want a bunch of extra logger information
+    # Set up a minimal argument parser, as we don't need the full
+    # Chip.cmdline() functionality which includes extra logger setup.
     parser = argparse.ArgumentParser(prog='run_node',
                                      formatter_class=argparse.RawDescriptionHelpFormatter,
                                      description='Script to run a single node in an SC flowgraph')
 
+    # Define command-line arguments
     parser.add_argument('-version',
                         action='version',
                         version=__version__)
@@ -75,16 +87,17 @@ def main():
                         help='Running as replay')
     args = parser.parse_args()
 
-    # Change to working directory to allow rel path to be build dir
-    # this avoids needing to deal with the job hash on the client
-    # side
+    # Change to the specified working directory. This is crucial for remote
+    # runners (like Docker) where paths inside the environment are different
+    # from the host.
     os.chdir(os.path.abspath(args.cwd))
 
     # Create the Chip object.
     chip = Chip('<design>')
+    # Load the configuration from the manifest provided.
     chip.read_manifest(args.cfg)
 
-    # setup work directory
+    # Configure the chip object based on command-line arguments.
     chip.set('arg', 'step', args.step)
     chip.set('arg', 'index', args.index)
     chip.set('option', 'builddir', os.path.abspath(args.builddir))
@@ -95,40 +108,42 @@ def main():
     if args.remoteid:
         chip.set('record', 'remoteid', args.remoteid)
 
+    # If running in a container/remote machine, we unset the scheduler to
+    # prevent a recursive scheduling loop.
     if args.unset_scheduler:
         for _, step, index in chip.get('option', 'scheduler', 'name',
                                        field=None).getvalues():
             chip.unset('option', 'scheduler', 'name', step=step, index=index)
 
+    # Pre-populate the package cache if a map is provided.
     if args.cachemap:
         for cachepair in args.cachemap:
             package, path = cachepair.split(':')
             Resolver.set_cache(chip, package, path)
 
-    # Populate cache
+    # Ensure all package caches are populated before running the node.
     for resolver in chip.get('package', field='schema').get_resolvers().values():
         resolver()
 
-    # Run the task.
+    # Instantiate the SchedulerNode for the specified step and index.
     error = True
+    node = SchedulerNode(
+        chip,
+        args.step,
+        args.index,
+        replay=args.replay)
     try:
-        SchedulerNode(chip,
-                      args.step,
-                      args.index,
-                      replay=args.replay).run()
+        # Execute the node's run() method.
+        node.run()
         error = False
-
     finally:
+        # Archive results upon completion, regardless of success or failure.
         if args.archive:
-            # Archive the results.
             with tarfile.open(args.archive,
                               mode='w:gz') as tf:
-                chip._archive_node(tf,
-                                   step=args.step,
-                                   index=args.index,
-                                   include=args.include)
+                node.archive(tf, include=args.include)
 
-    # Return success/fail flag, in case the caller is interested.
+    # Return a non-zero exit code on error.
     if error:
         return 1
     return 0
@@ -136,4 +151,5 @@ def main():
 
 ##########################
 if __name__ == "__main__":
+    # This makes the script executable.
     sys.exit(main())