siliconcompiler 0.32.3__py3-none-any.whl → 0.33.0__py3-none-any.whl

siliconcompiler/__init__.py

@@ -1,9 +1,18 @@
 from siliconcompiler._common import NodeStatus, SiliconCompilerError
 
 from siliconcompiler.utils import sc_open
+from siliconcompiler.schema_obj import SchemaTmp as Schema
+
+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.checklist import ChecklistSchema
+from siliconcompiler.asic import ASICSchema
+from siliconcompiler.fpga import FPGASchema
 
 from siliconcompiler.core import Chip
-from siliconcompiler.schema import Schema
 
 from siliconcompiler._metadata import version as __version__
 
@@ -20,5 +29,13 @@ __all__ = [
     "Flow",
     "Checklist",
     "Schema",
-    "sc_open"
+    "sc_open",
+    "RecordSchema",
+    "MetricSchema",
+    "PDKSchema",
+    "FlowgraphSchema",
+    "ToolSchema",
+    "ChecklistSchema",
+    "ASICSchema",
+    "FPGASchema"
 ]

siliconcompiler/_metadata.py

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

siliconcompiler/apps/sc.py

@@ -12,14 +12,14 @@ from siliconcompiler import SiliconCompilerError
 
 def _infer_designname(chip):
     topfile = None
-    sourcesets = chip.getkeys('input')
+    sourcesets = list(chip.getkeys('input'))
     for sourceset in reversed(('rtl', 'hll')):
         if sourceset in sourcesets:
             sourcesets.remove(sourceset)
             sourcesets.insert(0, sourceset)
     for sourceset in sourcesets:
         for filetype in chip.getkeys('input', sourceset):
-            all_vals = chip.schema._getvals('input', sourceset, filetype)
+            all_vals = chip.schema.get('input', sourceset, filetype, field=None).getvalues()
             if all_vals:
                 # just look at first value
                 sources, _, _ = all_vals[0]

siliconcompiler/apps/sc_install.py

@@ -10,7 +10,7 @@ import os.path
 from collections.abc import Container
 from pathlib import Path
 import siliconcompiler
-from siliconcompiler.scheduler import _get_machine_info
+from siliconcompiler import RecordSchema
 
 
 class ChoiceOptional(Container):
@@ -71,7 +71,7 @@ def show_tool(tool, script):
 
 
 def _get_os_name():
-    machine_info = _get_machine_info()
+    machine_info = RecordSchema.get_machine_information()
     system = machine_info.get('system', "").lower()
     if system == 'linux':
         distro = machine_info.get('distro', "").lower()
@@ -91,7 +91,7 @@ def _get_os_name():
 
 
 def print_machine_info():
-    machine_info = _get_machine_info()
+    machine_info = RecordSchema.get_machine_information()
     mapped_os = _get_os_name()
 
     print("System:   ", machine_info.get('system', None))

siliconcompiler/apps/sc_issue.py

@@ -5,7 +5,7 @@ import siliconcompiler
 import tarfile
 import json
 from siliconcompiler.scheduler import _runtask, _executenode
-from siliconcompiler.issue import generate_testcase
+from siliconcompiler.utils.issue import generate_testcase
 from siliconcompiler.tools._common import get_tool_task
 
 

siliconcompiler/apps/sc_remote.py

@@ -6,8 +6,7 @@ from siliconcompiler import Chip
 from siliconcompiler import SiliconCompilerError
 from siliconcompiler.remote.client import Client, ConfigureClient
 from siliconcompiler.scheduler import _finalize_run
-from siliconcompiler.flowgraph import _get_flowgraph_entry_nodes, _get_flowgraph_node_outputs, \
-    nodes_to_execute
+from siliconcompiler.utils.flowgraph import nodes_to_execute
 
 
 def main():
@@ -158,9 +157,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 = _get_flowgraph_entry_nodes(chip, flow)
+        entry_nodes = chip.schema.get("flowgraph", flow, field="schema").get_entry_nodes()
         for entry_node in entry_nodes:
-            outputs = _get_flowgraph_node_outputs(chip, flow, entry_node)
+            outputs = chip.schema.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,7 +84,7 @@ def main():
     input_mode = []
     for fileset in chip.getkeys('input'):
         for mode in chip.getkeys('input', fileset):
-            if chip.schema._getvals('input', fileset, mode):
+            if chip.schema.get('input', fileset, mode, field=None).getvalues():
                 input_mode = [('input', fileset, mode)]
 
     filename = None
@@ -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._getvals(*key):
+                    for files, _, _ in chip.schema.get(*key, field=None).getvalues():
                         for file in files:
                             if get_file_ext(file) == ext:
                                 return file

siliconcompiler/apps/utils/replay.py

@@ -86,7 +86,8 @@ def main():
 
     pythonversion = set()
     nodes = set()
-    for version, step, index in chip.schema._getvals('history', jobname, 'record', 'pythonversion'):
+    for version, step, index in chip.schema.get('history', jobname, 'record', 'pythonversion',
+                                                field=None).getvalues():
         pythonversion.add(version)
         nodes.add((step, index))
 
@@ -127,7 +128,8 @@ def main():
     os.makedirs(os.path.dirname(path), exist_ok=True)
 
     starttimes = set()
-    for starttime, step, index in chip.schema._getvals('history', jobname, 'record', 'starttime'):
+    for starttime, step, index in chip.schema.get('history', jobname, 'record', 'starttime',
+                                                  field=None).getvalues():
         starttimes.add(datetime.strptime(starttime, '%Y-%m-%d %H:%M:%S'))
     starttime = min(starttimes).strftime('%Y-%m-%d %H:%M:%S')
 
@@ -162,7 +164,7 @@ def main():
         fd.flush()
         script = convert_base64(compress(fd.getvalue()))
 
-    manifest = convert_base64(compress(json.dumps(chip.schema.cfg, indent=2)))
+    manifest = convert_base64(compress(json.dumps(chip.schema.getdict(), indent=2)))
 
     tool_info = []
     for tool, version in tools.items():

siliconcompiler/asic.py

@@ -0,0 +1,120 @@
+from siliconcompiler.schema import BaseSchema
+from siliconcompiler.schema import EditableSchema, Parameter, PerNode, Scope
+from siliconcompiler.schema.utils import trim
+
+
+class ASICSchema(BaseSchema):
+    def __init__(self):
+        super().__init__()
+
+        schema_asic(self)
+
+
+###############################################################################
+# ASIC
+###############################################################################
+def schema_asic(schema):
+    schema = EditableSchema(schema)
+
+    schema.insert(
+        'logiclib',
+        Parameter(
+            '[str]',
+            scope=Scope.JOB,
+            pernode=PerNode.OPTIONAL,
+            shorthelp="ASIC: logic libraries",
+            switch="-asic_logiclib <str>",
+            example=["cli: -asic_logiclib nangate45",
+                     "api: chip.set('asic', 'logiclib', 'nangate45')"],
+            help=trim("""List of all selected logic libraries libraries
+            to use for optimization for a given library architecture
+            (9T, 11T, etc).""")))
+
+    schema.insert(
+        'macrolib',
+        Parameter(
+            '[str]',
+            scope=Scope.JOB,
+            pernode=PerNode.OPTIONAL,
+            shorthelp="ASIC: macro libraries",
+            switch="-asic_macrolib <str>",
+            example=["cli: -asic_macrolib sram64x1024",
+                     "api: chip.set('asic', 'macrolib', 'sram64x1024')"],
+            help=trim("""
+            List of macro libraries to be linked in during synthesis and place
+            and route. Macro libraries are used for resolving instances but are
+            not used as targets for logic synthesis.""")))
+
+    schema.insert(
+        'delaymodel',
+        Parameter(
+            'str',
+            scope=Scope.JOB,
+            pernode=PerNode.OPTIONAL,
+            shorthelp="ASIC: delay model",
+            switch="-asic_delaymodel <str>",
+            example=["cli: -asic_delaymodel ccs",
+                     "api: chip.set('asic', 'delaymodel', 'ccs')"],
+            help=trim("""
+            Delay model to use for the target libs. Commonly supported values
+            are nldm and ccs.""")))
+
+    # TODO: Expand on the exact definitions of these types of cells.
+    # minimize typing
+    names = ['decap',
+             'tie',
+             'hold',
+             'clkbuf',
+             'clkgate',
+             'clklogic',
+             'dontuse',
+             'filler',
+             'tap',
+             'endcap',
+             'antenna']
+
+    for item in names:
+        schema.insert(
+            'cells', item,
+            Parameter(
+                '[str]',
+                pernode=PerNode.OPTIONAL,
+                shorthelp=f"ASIC: {item} cell list",
+                switch=f"-asic_cells_{item} '<str>'",
+                example=[
+                    f"cli: -asic_cells_{item} '*eco*'",
+                    f"api: chip.set('asic', 'cells', '{item}', '*eco*')"],
+                help=trim("""
+                List of cells grouped by a property that can be accessed
+                directly by the designer and tools. The example below shows how
+                all cells containing the string 'eco' could be marked as dont use
+                for the tool.""")))
+
+    schema.insert(
+        'libarch',
+        Parameter(
+            'str',
+            pernode=PerNode.OPTIONAL,
+            shorthelp="ASIC: library architecture",
+            switch="-asic_libarch '<str>'",
+            example=[
+                "cli: -asic_libarch '12track'",
+                "api: chip.set('asic', 'libarch', '12track')"],
+            help=trim("""
+            The library architecture (e.g. library height) used to build the
+            design. For example a PDK with support for 9 and 12 track libraries
+            might have 'libarchs' called 9t and 12t.""")))
+
+    libarch = 'default'
+    schema.insert(
+        'site', libarch,
+        Parameter(
+            '[str]',
+            pernode=PerNode.OPTIONAL,
+            shorthelp="ASIC: library sites",
+            switch="-asic_site 'libarch <str>'",
+            example=[
+                "cli: -asic_site '12track Site_12T'",
+                "api: chip.set('asic', 'site', '12track', 'Site_12T')"],
+            help=trim("""
+            Site names for a given library architecture.""")))

siliconcompiler/checklist.py

@@ -0,0 +1,150 @@
+from siliconcompiler.schema import NamedSchema
+from siliconcompiler.schema import EditableSchema, Parameter, Scope
+from siliconcompiler.schema.utils import trim
+
+
+class ChecklistSchema(NamedSchema):
+    def __init__(self, name=None):
+        super().__init__(name=name)
+
+        schema_checklist(self)
+
+
+############################################
+# Design Checklist
+############################################
+def schema_checklist(schema):
+    schema = EditableSchema(schema)
+
+    item = 'default'
+    metric = 'default'
+
+    schema.insert(
+        item, 'description',
+        Parameter(
+            'str',
+            scope=Scope.GLOBAL,
+            shorthelp="Checklist: item description",
+            switch="-checklist_description 'standard item <str>'",
+            example=[
+                "cli: -checklist_description 'ISO D000 A-DESCRIPTION'",
+                "api: chip.set('checklist', 'ISO', 'D000', 'description', 'A-DESCRIPTION')"],
+            help=trim("""
+            A short one line description of the checklist item.""")))
+
+    schema.insert(
+        item, 'requirement',
+        Parameter(
+            'str',
+            scope=Scope.GLOBAL,
+            shorthelp="Checklist: item requirement",
+            switch="-checklist_requirement 'standard item <str>'",
+            example=[
+                "cli: -checklist_requirement 'ISO D000 DOCSTRING'",
+                "api: chip.set('checklist', 'ISO', 'D000', 'requirement', 'DOCSTRING')"],
+            help=trim("""
+            A complete requirement description of the checklist item
+            entered as a multi-line string.""")))
+
+    schema.insert(
+        item, 'dataformat',
+        Parameter(
+            'str',
+            scope=Scope.GLOBAL,
+            shorthelp="Checklist: item data format",
+            switch="-checklist_dataformat 'standard item <str>'",
+            example=[
+                "cli: -checklist_dataformat 'ISO D000 README'",
+                "api: chip.set('checklist', 'ISO', 'D000', 'dataformat', 'README')"],
+            help=trim("""
+            Free text description of the type of data files acceptable as
+            checklist signoff validation.""")))
+
+    schema.insert(
+        item, 'rationale',
+        Parameter(
+            '[str]',
+            scope=Scope.GLOBAL,
+            shorthelp="Checklist: item rational",
+            switch="-checklist_rationale 'standard item <str>'",
+            example=[
+                "cli: -checklist_rationale 'ISO D000 reliability'",
+                "api: chip.set('checklist', 'ISO', 'D000', 'rationale', 'reliability')"],
+            help=trim("""
+            Rationale for the the checklist item. Rationale should be a
+            unique alphanumeric code used by the standard or a short one line
+            or single word description.""")))
+
+    schema.insert(
+        item, 'criteria',
+        Parameter(
+            '[str]',
+            scope=Scope.GLOBAL,
+            shorthelp="Checklist: item criteria",
+            switch="-checklist_criteria 'standard item <str>'",
+            example=[
+                "cli: -checklist_criteria 'ISO D000 errors==0'",
+                "api: chip.set('checklist', 'ISO', 'D000', 'criteria', 'errors==0')"],
+            help=trim("""
+            Simple list of signoff criteria for checklist item which
+            must all be met for signoff. Each signoff criteria consists of
+            a metric, a relational operator, and a value in the form.
+            'metric op value'.""")))
+
+    schema.insert(
+        item, 'task',
+        Parameter(
+            '[(str,str,str)]',
+            scope=Scope.GLOBAL,
+            shorthelp="Checklist: item task",
+            switch="-checklist_task 'standard item <(str,str,str)>'",
+            example=[
+                "cli: -checklist_task 'ISO D000 (job0,place,0)'",
+                "api: chip.set('checklist', 'ISO', 'D000', 'task', ('job0', 'place', '0'))"],
+            help=trim("""
+            Flowgraph job and task used to verify the checklist item.
+            The parameter should be left empty for manual and for tool
+            flows that bypass the SC infrastructure.""")))
+
+    schema.insert(
+        item, 'report',
+        Parameter(
+            '[file]',
+            scope=Scope.GLOBAL,
+            shorthelp="Checklist: item report",
+            switch="-checklist_report 'standard item <file>'",
+            example=[
+                "cli: -checklist_report 'ISO D000 my.rpt'",
+                "api: chip.set('checklist', 'ISO', 'D000', 'report', 'my.rpt')"],
+            help=trim("""
+            Filepath to report(s) of specified type documenting the successful
+            validation of the checklist item.""")))
+
+    schema.insert(
+        item, 'waiver', metric,
+        Parameter(
+            '[file]',
+            scope=Scope.GLOBAL,
+            shorthelp="Checklist: item metric waivers",
+            switch="-checklist_waiver 'standard item metric <file>'",
+            example=[
+                "cli: -checklist_waiver 'ISO D000 bold my.txt'",
+                "api: chip.set('checklist', 'ISO', 'D000', 'waiver', 'hold', 'my.txt')"],
+            help=trim("""
+            Filepath to report(s) documenting waivers for the checklist
+            item specified on a per metric basis.""")))
+
+    schema.insert(
+        item, 'ok',
+        Parameter(
+            'bool',
+            scope=Scope.GLOBAL,
+            shorthelp="Checklist: item ok",
+            switch="-checklist_ok 'standard item <bool>'",
+            example=[
+                "cli: -checklist_ok 'ISO D000 true'",
+                "api: chip.set('checklist', 'ISO', 'D000', 'ok', True)"],
+            help=trim("""
+            Boolean check mark for the checklist item. A value of
+            True indicates a human has inspected the all item dictionary
+            parameters check out.""")))