siliconcompiler 0.35.3__py3-none-any.whl → 0.36.0__py3-none-any.whl

siliconcompiler/constraints/fpga_timing.py

@@ -1,7 +1,9 @@
-from typing import Union
+from typing import List, Set, Tuple, Union, Optional, Dict
 
 from siliconcompiler.schema import BaseSchema, NamedSchema, EditableSchema, Parameter, \
     PerNode, Scope
+from siliconcompiler.constraints.timing_mode import TimingModeSchema
+from siliconcompiler.schema.baseschema import LazyLoad
 
 
 class FPGATimingScenarioSchema(NamedSchema):
@@ -12,7 +14,7 @@ class FPGATimingScenarioSchema(NamedSchema):
     scenario and operating mode.
     """
 
-    def __init__(self, name: str = None):
+    def __init__(self, name: Optional[str] = None):
         super().__init__()
         self.set_name(name)
 
@@ -31,7 +33,7 @@ class FPGATimingScenarioSchema(NamedSchema):
 
     def set_mode(self,
                  mode: str,
-                 step: str = None, index: Union[str, int] = None):
+                 step: Optional[str] = None, index: Optional[Union[str, int]] = None):
         """
         Sets the operational mode for the design.
 
@@ -42,8 +44,7 @@ class FPGATimingScenarioSchema(NamedSchema):
         """
         return self.set("mode", mode, step=step, index=index)
 
-    def get_mode(self,
-                 step: str = None, index: Union[str, int] = None) -> str:
+    def get_mode(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) -> str:
         """
         Gets the operational mode currently set for the design.
 
@@ -70,7 +71,8 @@ class FPGATimingConstraintSchema(BaseSchema):
     def __init__(self):
         super().__init__()
 
-        EditableSchema(self).insert("default", FPGATimingScenarioSchema())
+        EditableSchema(self).insert("scenario", "default", FPGATimingScenarioSchema())
+        EditableSchema(self).insert("mode", "default", TimingModeSchema())
 
     def add_scenario(self, scenario: FPGATimingScenarioSchema):
         """
@@ -96,9 +98,10 @@ class FPGATimingConstraintSchema(BaseSchema):
         if scenario.name is None:
             raise ValueError("scenario must have a name")
 
-        EditableSchema(self).insert(scenario.name, scenario, clobber=True)
+        EditableSchema(self).insert("scenario", scenario.name, scenario, clobber=True)
 
-    def get_scenario(self, scenario: str = None):
+    def get_scenario(self, scenario: Optional[str] = None) \
+            -> Union[FPGATimingScenarioSchema, Dict[str, FPGATimingScenarioSchema]]:
         """
         Retrieves one or all timing scenarios from the configuration.
 
@@ -107,8 +110,8 @@ class FPGATimingConstraintSchema(BaseSchema):
 
         Args:
             scenario (str, optional): The name (string) of the specific timing scenario to retrieve.
-                      If this argument is omitted or set to None, the method will return
-                      a dictionary containing all available timing scenarios.
+                                      If this argument is omitted or set to None, the method will
+                                      return a dictionary containing all available timing scenarios.
 
         Returns:
             If `scenario` is provided: The :class:`FPGATimingScenarioSchema` object corresponding
@@ -122,13 +125,13 @@ class FPGATimingConstraintSchema(BaseSchema):
         """
         if scenario is None:
             scenarios = {}
-            for scenario in self.getkeys():
-                scenarios[scenario] = self.get(scenario, field="schema")
+            for name in self.getkeys("scenario"):
+                scenarios[name] = self.get("scenario", name, field="schema")
             return scenarios
 
-        if not self.valid(scenario):
+        if not self.valid("scenario", scenario):
             raise LookupError(f"{scenario} is not defined")
-        return self.get(scenario, field="schema")
+        return self.get("scenario", scenario, field="schema")
 
     def make_scenario(self, scenario: str) -> FPGATimingScenarioSchema:
         """
@@ -144,7 +147,7 @@ class FPGATimingConstraintSchema(BaseSchema):
                             a non-empty string and unique within the current configuration.
 
         Returns:
-            :class:FPGATimingScenarioSchema: The newly created :class:`FPGATimingScenarioSchema`
+            :class:`FPGATimingScenarioSchema`: The newly created :class:`FPGATimingScenarioSchema`
                 object.
 
         Raises:
@@ -155,13 +158,42 @@ class FPGATimingConstraintSchema(BaseSchema):
         if not scenario:
             raise ValueError("scenario name is required")
 
-        if self.valid(scenario):
+        if self.valid("scenario", scenario):
             raise LookupError(f"{scenario} scenario already exists")
 
         scenarioobj = FPGATimingScenarioSchema(scenario)
         self.add_scenario(scenarioobj)
         return scenarioobj
 
+    def copy_scenario(self, scenario: str, name: str, insert: bool = True) \
+            -> FPGATimingScenarioSchema:
+        """
+        Copies an existing timing scenario, renames it, and optionally adds it to the design.
+
+        This method retrieves the scenario identified by ``scenario``, creates a
+        deep copy of it, and renames the copy to ``name``. If ``insert`` is True,
+        the new scenario is immediately added to the configuration.
+
+        Args:
+            scenario (str): The name of the existing scenario to be copied.
+            name (str): The name to assign to the new copied scenario.
+            insert (bool, optional): Whether to add the newly created scenario
+                to the configuration. Defaults to True.
+
+        Returns:
+            FPGATimingScenarioSchema: The newly created copy of the scenario.
+
+        Raises:
+            LookupError: If the source scenario specified by ``scenario`` does not exist.
+        """
+        constraint = EditableSchema(self.get_scenario(scenario)).copy()
+        EditableSchema(constraint).rename(name)
+        if insert:
+            if self.valid("scenario", name):
+                raise ValueError(f"{name} already exists")
+            self.add_scenario(constraint)
+        return constraint
+
     def remove_scenario(self, scenario: str) -> bool:
         """
         Removes a timing scenario from the design configuration.
@@ -183,8 +215,170 @@ class FPGATimingConstraintSchema(BaseSchema):
         if not scenario:
             raise ValueError("scenario name is required")
 
-        if not self.valid(scenario):
+        if not self.valid("scenario", scenario):
+            return False
+
+        EditableSchema(self).remove("scenario", scenario)
+        return True
+
+    def add_mode(self, mode: TimingModeSchema):
+        """
+        Adds a timing mode to the design configuration.
+
+        This method is responsible for incorporating a new or updated timing mode
+        into the system's configuration. If a mode with the same name already
+        exists, it will be overwritten (`clobber=True`).
+
+        Args:
+            mode: The :class:`TimingModeSchema` object representing the timing mode
+                  to add. This object must have a valid name defined via its `name()` method.
+
+        Raises:
+            TypeError: If the provided `mode` argument is not an instance of
+                       :class:`TimingModeSchema`.
+            ValueError: If the `mode` object's `name()` method returns None, indicating
+                        that the mode does not have a defined name.
+        """
+        if not isinstance(mode, TimingModeSchema):
+            raise TypeError("mode must be a timing mode object")
+
+        if mode.name is None:
+            raise ValueError("mode must have a name")
+
+        EditableSchema(self).insert("mode", mode.name, mode, clobber=True)
+
+    def get_mode(self, mode: Optional[str] = None) \
+            -> Union[TimingModeSchema, Dict[str, TimingModeSchema]]:
+        """
+        Retrieves one or all timing modes from the configuration.
+
+        This method provides flexibility to fetch either a specific timing mode
+        by its name or a collection of all currently defined modes.
+
+        Args:
+            mode (str, optional): The name (string) of the specific timing mode to retrieve.
+                                  If this argument is omitted or set to None, the method will
+                                  return a dictionary containing all available timing modes.
+
+        Returns:
+            If `mode` is provided: The :class:`TimingModeSchema` object corresponding
+                to the specified mode name.
+            If `mode` is None: A dictionary where keys are mode names (str) and
+                values are their respective :class:`TimingModeSchema` objects.
+
+        Raises:
+            LookupError: If a specific `mode` name is provided but no mode with
+                         that name is found in the configuration.
+        """
+        if mode is None:
+            modes = {}
+            for name in self.getkeys("mode"):
+                modes[name] = self.get("mode", name, field="schema")
+            return modes
+
+        if not self.valid("mode", mode):
+            raise LookupError(f"{mode} is not defined")
+        return self.get("mode", mode, field="schema")
+
+    def make_mode(self, mode: str) -> TimingModeSchema:
+        """
+        Creates and adds a new timing mode with the specified name.
+
+        This method initializes a new :class:`TimingModeSchema` object with the given
+        name and immediately adds it to the constraint configuration. It ensures that
+        a mode with the same name does not already exist, preventing accidental
+        overwrites.
+
+        Args:
+            mode (str): The name for the new timing mode. This name must be
+                        a non-empty string and unique within the current configuration.
+
+        Returns:
+            :class:`TimingModeSchema`: The newly created :class:`TimingModeSchema`
+                object.
+
+        Raises:
+            ValueError: If the provided `mode` name is empty or None.
+            LookupError: If a mode with the specified `mode` name already exists
+                         in the configuration.
+        """
+        if not mode:
+            raise ValueError("mode name is required")
+
+        if self.valid("mode", mode):
+            raise LookupError(f"{mode} mode already exists")
+
+        modeobj = TimingModeSchema(mode)
+        self.add_mode(modeobj)
+        return modeobj
+
+    def copy_mode(self, mode: str, name: str, insert: bool = True) \
+            -> TimingModeSchema:
+        """
+        Copies an existing timing mode, renames it, and optionally adds it to the design.
+
+        This method retrieves the mode identified by ``mode``, creates a
+        deep copy of it, and renames the copy to ``name``. If ``insert`` is True,
+        the new mode is immediately added to the configuration.
+
+        Args:
+            mode (str): The name of the existing mode to be copied.
+            name (str): The name to assign to the new copied mode.
+            insert (bool, optional): Whether to add the newly created mode
+                to the configuration. Defaults to True.
+
+        Returns:
+            TimingModeSchema: The newly created copy of the mode.
+
+        Raises:
+            LookupError: If the source mode specified by ``mode`` does not exist.
+        """
+        newmode = EditableSchema(self.get_mode(mode)).copy()
+        EditableSchema(newmode).rename(name)
+        if insert:
+            if self.valid("mode", name):
+                raise ValueError(f"{name} already exists")
+            self.add_mode(newmode)
+        return newmode
+
+    def remove_mode(self, mode: str) -> bool:
+        """
+        Removes a timing mode from the design configuration.
+
+        This method deletes the specified timing mode from the system's
+        configuration.
+
+        Args:
+            mode (str): The name of the timing mode to remove.
+                        This name must be a non-empty string.
+
+        Returns:
+            bool: True if the mode was successfully removed, False if no
+                  mode with the given name was found.
+
+        Raises:
+            ValueError: If the provided `mode` name is empty or None.
+        """
+        if not mode:
+            raise ValueError("mode name is required")
+
+        if not self.valid("mode", mode):
             return False
 
-        EditableSchema(self).remove(scenario)
+        EditableSchema(self).remove("mode", mode)
         return True
+
+    def _from_dict(self, manifest: Dict,
+                   keypath: Union[List[str], Tuple[str, ...]],
+                   version: Optional[Tuple[int, ...]] = None,
+                   lazyload: LazyLoad = LazyLoad.ON) \
+            -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
+        if version and version < (0, 53, 0):
+            manifest.pop("__meta__", None)
+            manifest = {
+                "scenario": manifest,
+                "mode": self.getdict("mode")
+            }
+            lazyload = LazyLoad.OFF
+
+        return super()._from_dict(manifest, keypath, version, lazyload)

siliconcompiler/constraints/timing_mode.py

@@ -0,0 +1,82 @@
+from typing import Union, List, Tuple, Optional
+
+from siliconcompiler.schema import NamedSchema, EditableSchema, Parameter, \
+    PerNode, Scope
+from siliconcompiler import Design
+
+
+class TimingModeSchema(NamedSchema):
+    """
+    Represents a single timing mode for design constraints.
+
+    This class encapsulates the SDC filesets used for a specific timing mode.
+    """
+
+    def __init__(self, name: Optional[str] = None):
+        super().__init__()
+        self.set_name(name)
+
+        schema = EditableSchema(self)
+        schema.insert(
+            'sdcfileset',
+            Parameter(
+                '[(str,str)]',
+                pernode=PerNode.OPTIONAL,
+                scope=Scope.GLOBAL,
+                shorthelp="Constraint: SDC files",
+                switch="-constraint_timing_file 'scenario <file>'",
+                example=["api: mode.set('constraint', 'timing', 'worst', 'file', 'hello.sdc')"],
+                help="""List of timing constraint sets files to use for the scenario. The
+                values are combined with any constraints specified by the design
+                'constraint' parameter. If no constraints are found, a default
+                constraint file is used based on the clock definitions."""))
+
+    def add_sdcfileset(self,
+                       design: Union[Design, str],
+                       fileset: str,
+                       clobber: bool = False,
+                       step: Optional[str] = None, index: Optional[Union[str, int]] = None):
+        """
+        Adds an SDC fileset for a given design.
+
+        Args:
+            design (:class:`Design` or str): The design object or the name of the design to
+                associate the fileset with.
+            fileset (str): The name of the SDC fileset to add.
+            clobber (bool): If True, existing SDC filesets for the design at the specified
+                    step/index will be overwritten.
+                    If False (default), the SDC fileset will be added.
+            step (str, optional): step name.
+            index (str, optional): index name.
+
+        Raises:
+            TypeError: If `design` is not a Design object or a string, or if `fileset` is not
+                a string.
+        """
+        if isinstance(design, Design):
+            design = design.name
+
+        if not isinstance(design, str):
+            raise TypeError("design must be a design object or string")
+
+        if not isinstance(fileset, str):
+            raise TypeError("fileset must be a string")
+
+        if clobber:
+            return self.set("sdcfileset", (design, fileset), step=step, index=index)
+        else:
+            return self.add("sdcfileset", (design, fileset), step=step, index=index)
+
+    def get_sdcfileset(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> List[Tuple[str, str]]:
+        """
+        Gets the list of SDC filesets.
+
+        Args:
+            step (str, optional): step name.
+            index (str, optional): index name.
+
+        Returns:
+            A list of tuples, where each tuple contains the design name and the SDC fileset name.
+        """
+        return self.get("sdcfileset", step=step, index=index)

siliconcompiler/data/templates/replay/replay.sh.j2

@@ -4,10 +4,27 @@ if [ "${BASH_SOURCE[0]}" != "$0" ]; then
     return
 fi
 
+__print_help() {
+    # Print help information for this file
+    echo "Usage: $0"
+    echo "  Options:"
+    echo "    --which           print which executable would be used"
+    echo "    --version         print the version of the executable, if supported"
+    echo "    --directory       print the execution directory"
+    echo "    --command         print the execution command"
+    echo "    --skipcd          do not change directory into replay directory"
+    echo "    --skipexports     do not export environmental variables"
+    echo "    --cmdprefix <cmd> prefix to add to the replay command, such as gdb"
+    echo "    --cmdarg <args>   prefix to add to the replay command, such as -gui"
+    echo "    --node            execute entire node"
+    echo "    -h,--help         print this help"
+}
+
 # Parse replay arguments
 CD_WORK="{{ work_dir }}"
 PRINT=""
 CMDPREFIX=""
+CMDARGS=""
 SKIPEXPORT=0
 DONODE={{ node_only }}
 while [[ $# -gt 0 ]]; do
@@ -41,27 +58,22 @@ while [[ $# -gt 0 ]]; do
             shift
             shift
             ;;
+        --cmdarg)
+            CMDARGS="$2"
+            shift
+            shift
+            ;;
         --node)
             DONODE=1
             shift
-            shift
             ;;
         -h|--help)
-            echo "Usage: $0"
-            echo "  Options:"
-            echo "    --which           print which executable would be used"
-            echo "    --version         print the version of the executable, if supported"
-            echo "    --directory       print the execution directory"
-            echo "    --command         print the execution command"
-            echo "    --skipcd          do not change directory into replay directory"
-            echo "    --skipexports     do not export environmental variables"
-            echo "    --cmdprefix <cmd> prefix to add to the replay command, such as dgb"
-            echo "    --node            execute entire node"
-            echo "    -h,--help         print this help"
+            __print_help
             exit 0
             ;;
         *)
             echo "Unknown option $1"
+            __print_help
             exit 1
             ;;
     esac
@@ -105,5 +117,6 @@ python3 -m siliconcompiler.scheduler.run_node \
 {% if cmds|length > 0 %}else
 # Command execution
 $CMDPREFIX \{% for cmd in cmds %}
-{% if not loop.first %}  {% endif %}{{ cmd }}{% if not loop.last %} \{% endif %}{% endfor %}
-{% endif %}fi
+{% if not loop.first %}  {% endif %}{{ cmd }} \{% endfor %}
+{% endif %}  ${CMDARGS}
+fi

siliconcompiler/data/templates/tcl/manifest.tcl.j2

@@ -17,12 +17,6 @@ proc sc_root {} {
 
 {% include 'tools/_common/tcl/sc_schema_access.tcl' %}
 
-# Redefine
-proc _sc_cfg_get_debug { args } {
-    {% if record_access %}puts "{{ record_access_id }} [join $args ,]"{% endif %}
-}
-
-
 #############################################
 # Tool variables
 #############################################