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

siliconcompiler/__init__.py

@@ -3,16 +3,21 @@ from siliconcompiler._common import NodeStatus, SiliconCompilerError
 from siliconcompiler.utils import sc_open
 from siliconcompiler.schema_obj import SchemaTmp as Schema
 
+from siliconcompiler.packageschema import PackageSchema
+
 from siliconcompiler.design import DesignSchema
 from siliconcompiler.record import RecordSchema
 from siliconcompiler.metric import MetricSchema
 from siliconcompiler.pdk import PDKSchema
 from siliconcompiler.flowgraph import FlowgraphSchema
-from siliconcompiler.tool import ToolSchema
+from siliconcompiler.tool import ToolSchema, TaskSchema
 from siliconcompiler.checklist import ChecklistSchema
 from siliconcompiler.asic import ASICSchema
 from siliconcompiler.fpga import FPGASchema
 
+from siliconcompiler.project import Project
+from siliconcompiler.library import LibrarySchema, StdCellLibrarySchema
+
 from siliconcompiler.core import Chip
 
 from siliconcompiler._metadata import version as __version__
@@ -31,13 +36,20 @@ __all__ = [
     "Checklist",
     "Schema",
     "sc_open",
+
     "DesignSchema",
+    "LibrarySchema",
     "RecordSchema",
     "MetricSchema",
     "PDKSchema",
     "FlowgraphSchema",
     "ToolSchema",
+    "TaskSchema",
     "ChecklistSchema",
     "ASICSchema",
-    "FPGASchema"
+    "FPGASchema",
+    "PackageSchema",
+
+    "Project",
+    "StdCellLibrarySchema"
 ]

siliconcompiler/_metadata.py

@@ -1,5 +1,5 @@
 # Version number following semver standard.
-version = '0.34.0'
+version = '0.34.2'
 
 # Default server address for remote runs, if unspecified.
 default_server = 'https://server.siliconcompiler.com'

siliconcompiler/apps/_common.py

@@ -114,7 +114,7 @@ def pick_manifest(chip, src_file=None):
         if (step, index) in all_manifests[chip.design][jobname]:
             return all_manifests[chip.design][jobname][(step, index)]
         else:
-            chip.logger.error(f'{step}{index} is not a valid node.')
+            chip.logger.error(f'{step}/{index} is not a valid node.')
             return None
 
     if (None, None) in all_manifests[chip.design][jobname]:

siliconcompiler/apps/sc.py

@@ -19,7 +19,7 @@ def _infer_designname(chip):
             sourcesets.insert(0, sourceset)
     for sourceset in sourcesets:
         for filetype in chip.getkeys('input', sourceset):
-            all_vals = chip.schema.get('input', sourceset, filetype, field=None).getvalues()
+            all_vals = chip.get('input', sourceset, filetype, field=None).getvalues()
             if all_vals:
                 # just look at first value
                 sources, _, _ = all_vals[0]

siliconcompiler/apps/sc_issue.py

@@ -142,7 +142,7 @@ To run a testcase, use:
         chip.set('arg', 'step', step)
         chip.set('arg', 'index', index)
         tool, task = get_tool_task(chip, step, index)
-        chip.logger.info(f'Preparing run for {step}{index} - {tool}/{task}')
+        chip.logger.info(f'Preparing run for {step}/{index} - {tool}/{task}')
 
         # Modify run environment to point to extracted files
         builddir_key = ['option', 'builddir']

siliconcompiler/apps/sc_remote.py

@@ -154,10 +154,10 @@ To delete a job, use:
     elif args['reconnect']:
         # Start from successors of entry nodes, so entry nodes are not fetched from remote.
         flow = chip.get('option', 'flow')
-        entry_nodes = chip.schema.get("flowgraph", flow, field="schema").get_entry_nodes()
+        entry_nodes = chip.get("flowgraph", flow, field="schema").get_entry_nodes()
         for entry_node in entry_nodes:
-            outputs = chip.schema.get("flowgraph", flow,
-                                      field='schema').get_node_outputs(*entry_node)
+            outputs = chip.get("flowgraph", flow,
+                               field='schema').get_node_outputs(*entry_node)
             chip.set('option', 'from', list(map(lambda node: node[0], outputs)))
         # Enter the remote run loop.
         try:

siliconcompiler/apps/sc_show.py

@@ -84,8 +84,8 @@ def main():
     input_mode = []
     for fileset in chip.getkeys('input'):
         for mode in chip.getkeys('input', fileset):
-            if chip.schema.get('input', fileset, mode, field=None).getvalues():
-                input_mode = [('input', fileset, mode)]
+            if chip.get('input', fileset, mode, field=None).getvalues():
+                input_mode.append(('input', fileset, mode))
 
     filename = None
     if input_mode:
@@ -97,7 +97,7 @@ def main():
         def get_file_from_keys():
             for ext in check_ext:
                 for key in input_mode:
-                    for files, _, _ in chip.schema.get(*key, field=None).getvalues():
+                    for files, _, _ in chip.get(*key, field=None).getvalues():
                         for file in files:
                             if get_file_ext(file) == ext:
                                 return file

siliconcompiler/apps/utils/replay.py

@@ -87,8 +87,8 @@ def main():
 
     pythonversion = set()
     nodes = set()
-    for version, step, index in chip.schema.get('history', jobname, 'record', 'pythonversion',
-                                                field=None).getvalues():
+    for version, step, index in chip.get('history', jobname, 'record', 'pythonversion',
+                                         field=None).getvalues():
         pythonversion.add(version)
         nodes.add((step, index))
 
@@ -128,7 +128,7 @@ def main():
     path = os.path.abspath(args['file'])
     os.makedirs(os.path.dirname(path), exist_ok=True)
 
-    record_schema = chip.schema.get('history', jobname, 'record', field="schema")
+    record_schema = chip.get('history', jobname, 'record', field="schema")
     starttime = datetime.fromtimestamp(
         record_schema.get_earliest_time(RecordTime.START)).strftime(
             '%Y-%m-%d %H:%M:%S')
@@ -164,7 +164,7 @@ def main():
         fd.flush()
         script = convert_base64(compress(fd.getvalue()))
 
-    manifest = convert_base64(compress(json.dumps(chip.schema.getdict(), indent=2)))
+    manifest = convert_base64(compress(json.dumps(chip.getdict(), indent=2)))
 
     tool_info = []
     for tool, version in tools.items():

siliconcompiler/checklist.py

@@ -1,14 +1,215 @@
+import re
+
+import os.path
+
 from siliconcompiler.schema import NamedSchema
 from siliconcompiler.schema import EditableSchema, Parameter, Scope
 from siliconcompiler.schema.utils import trim
 
+from siliconcompiler import NodeStatus, utils
+
 
 class ChecklistSchema(NamedSchema):
-    def __init__(self, name):
-        super().__init__(name=name)
+    def __init__(self, name=None):
+        super().__init__()
+        self.set_name(name)
 
         schema_checklist(self)
 
+    def check(self, items=None, check_ok=False, require_reports=True):
+        '''
+        Check items in a checklist.
+
+        Checks the status of items in a checklist for the standard provided. If
+        a specific list of items is unspecified, all items are checked.
+
+        All items have an associated 'task' parameter, which indicates which
+        tasks can be used to automatically validate the item. For an item to be
+        checked, all tasks must satisfy the item's criteria, unless waivers are
+        provided. In addition, that task must have generated EDA report files
+        for each metric in the criteria.
+
+        For items without an associated task, the only requirement is that at
+        least one report has been added to that item.
+
+        When 'check_ok' is True, every item must also have its 'ok' parameter
+        set to True, indicating that a human has reviewed the item.
+
+        Args:
+            items (list of str): Items to check from standard.
+            check_ok (bool): Whether to check item 'ok' parameter.
+            verbose (bool): Whether to print passing criteria.
+            require_reports (bool): Whether to assert the presence of reports.
+
+        Returns:
+            Status of item check.
+
+        Examples:
+            >>> status = chip.check_checklist('d000')
+            Returns status.
+        '''
+        error = False
+
+        schema_root = self._parent(root=True)
+        logger = getattr(schema_root, "logger", None)
+        cwd = getattr(schema_root, "cwd", os.getcwd())
+
+        assert hasattr(schema_root, "history"), f"{schema_root}"
+
+        if logger:
+            logger.info(f'Checking checklist {self.name()}')
+
+        if items is None:
+            items = self.getkeys()
+
+        # these tasks are recorded by SC so there are no reports
+        metrics_without_reports = (
+            'tasktime',
+            'totaltime',
+            'exetime',
+            'memory')
+
+        for item in items:
+            if item not in self.getkeys():
+                if logger:
+                    logger.error(f'{item} is not a check in {self.name()}.')
+                error = True
+                continue
+
+            allow_missing_reports = True
+
+            has_check = False
+
+            all_criteria = self.get(item, 'criteria')
+            for criteria in all_criteria:
+                m = re.match(r'^(\w+)\s*([\>\=\<]+)\s*([+\-]?\d+(\.\d+)?(e[+\-]?\d+)?)$',
+                             criteria.strip())
+                if not m:
+                    raise ValueError(f"Illegal checklist criteria: {criteria}")
+
+                metric = m.group(1)
+                op = m.group(2)
+
+                if metric not in metrics_without_reports:
+                    allow_missing_reports = False
+
+                tasks = self.get(item, 'task')
+                for job, step, index in tasks:
+                    job_data = schema_root.history(job)
+
+                    flow = job_data.get("flowgraph", job_data.get('option', 'flow'), field="schema")
+
+                    if (step, index) not in flow.get_nodes():
+                        error = True
+                        if logger:
+                            logger.error(f'{step}/{index} not found in flowgraph for {job}')
+                        continue
+
+                    if job_data.get('record', 'status', step=step, index=index) == \
+                            NodeStatus.SKIPPED:
+                        if logger:
+                            logger.warning(f'{step}/{index} was skipped')
+                        continue
+
+                    has_check = True
+
+                    # Automated checks
+                    tool = flow.get(step, index, 'tool')
+                    task = flow.get(step, index, 'task')
+
+                    if metric not in job_data.getkeys("metric"):
+                        if logger:
+                            logger.error(f"Criteria must use legal metrics only: {criteria}")
+                            error = True
+                            continue
+
+                    if job_data.get("metric", metric, field='type') == 'int':
+                        goal = int(m.group(3))
+                        number_format = 'd'
+                    else:
+                        goal = float(m.group(3))
+
+                        if goal == 0.0 or (abs(goal) > 1e-3 and abs(goal) < 1e5):
+                            number_format = '.3f'
+                        else:
+                            number_format = '.3e'
+
+                    value = job_data.get('metric', metric, step=step, index=index)
+                    criteria_ok = utils.safecompare(self, value, op, goal)
+                    if metric in self.getkeys(item, 'waiver'):
+                        waivers = self.get(item, 'waiver', metric)
+                    else:
+                        waivers = []
+
+                    criteria_str = f'{metric}{op}{goal:{number_format}}'
+                    compare_str = f'{value:{number_format}}{op}{goal:{number_format}}'
+                    step_desc = f'job {job} with step {step}/{index} and task {tool}/{task}'
+                    if not criteria_ok and waivers:
+                        if logger:
+                            logger.warning(f'{item} criteria {criteria_str} ({compare_str}) unmet '
+                                           f'by {step_desc}, but found waivers.')
+                    elif not criteria_ok:
+                        if logger:
+                            logger.error(f'{item} criteria {criteria_str} ({compare_str}) unmet '
+                                         f'by {step_desc}.')
+                        error = True
+                    elif criteria_ok:
+                        if logger:
+                            logger.info(f'{item} criteria {criteria_str} met by {step_desc}.')
+
+                    has_reports = \
+                        job_data.valid('tool', tool, 'task', task, 'report', metric) and \
+                        job_data.get('tool', tool, 'task', task, 'report', metric,
+                                     step=step, index=index)
+
+                    if allow_missing_reports and not has_reports:
+                        # No reports available and it is allowed
+                        continue
+
+                    reports = []
+                    try:
+                        if has_reports:
+                            reports = job_data.find_files(
+                                'tool', tool, 'task', task, 'report', metric,
+                                step=step, index=index,
+                                missing_ok=not require_reports)
+                    except FileNotFoundError:
+                        reports = []
+                        continue
+
+                    if require_reports and not reports:
+                        if logger:
+                            logger.error(f'No reports generated for metric {metric} in '
+                                         f'{step_desc}')
+                        error = True
+
+                    for report in reports:
+                        if not report:
+                            continue
+
+                        report = os.path.relpath(report, cwd)
+                        if report not in self.get(item, 'report'):
+                            self.add(item, 'report', report)
+
+            if has_check:
+                if require_reports and \
+                        not allow_missing_reports and \
+                        not self.get(item, 'report'):
+                    # TODO: validate that report exists?
+                    if logger:
+                        logger.error(f'No report documenting item {item}')
+                    error = True
+
+                if check_ok and not self.get(item, 'ok'):
+                    if logger:
+                        logger.error(f"Item {item} 'ok' field not checked")
+                    error = True
+
+        if not error and logger:
+            logger.info('Check succeeded!')
+
+        return not error
+
 
 ############################################
 # Design Checklist

siliconcompiler/constraints/__init__.py

@@ -0,0 +1,17 @@
+from siliconcompiler.constraints.asic_timing import \
+    ASICTimingConstraintSchema, ASICTimingScenarioSchema
+from siliconcompiler.constraints.asic_floorplan import ASICAreaConstraint
+from siliconcompiler.constraints.asic_pins import \
+    ASICPinConstraint, ASICPinConstraints
+from siliconcompiler.constraints.asic_component import \
+    ASICComponentConstraint, ASICComponentConstraints
+
+__all__ = [
+    "ASICTimingConstraintSchema",
+    "ASICTimingScenarioSchema",
+    "ASICAreaConstraint",
+    "ASICPinConstraint",
+    "ASICPinConstraints",
+    "ASICComponentConstraint",
+    "ASICComponentConstraints"
+]