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

siliconcompiler/schema/schema_cfg.py

@@ -110,7 +110,9 @@ def schema_cfg(schema):
     cfg = schema_constraint(cfg)
 
     # Options
-    cfg = schema_option(cfg)
+    cfg = schema_option_frontend(cfg)
+    cfg = schema_option_runtime(cfg)
+    cfg = schema_option_other(cfg)
     cfg = schema_arg(cfg)
 
     # Technology configuration
@@ -212,7 +214,7 @@ def schema_fpga(cfg):
 ###############################################################################
 def schema_pdk(cfg):
     from siliconcompiler.pdk import PDKSchema
-    cfg.insert("pdk", "default", PDKSchema())
+    cfg.insert("pdk", "default", PDKSchema(None))
     return cfg
 
 
@@ -1016,7 +1018,7 @@ def schema_datasheet(cfg):
 ###############################################################################
 def schema_flowgraph(cfg):
     from siliconcompiler.flowgraph import FlowgraphSchema
-    cfg.insert("flowgraph", "default", FlowgraphSchema())
+    cfg.insert("flowgraph", "default", FlowgraphSchema(None))
     return cfg
 
 
@@ -1086,10 +1088,111 @@ def schema_record(cfg):
 ###########################################################################
 # Run Options
 ###########################################################################
-def schema_option(cfg):
+def schema_option_other(cfg):
     ''' Technology agnostic run time options
     '''
 
+    # Compilation
+    scparam(cfg, ['option', 'pdk'],
+            sctype='str',
+            scope=Scope.JOB,
+            shorthelp="Option: PDK target",
+            switch="-pdk <str>",
+            example=["cli: -pdk freepdk45",
+                     "api: chip.set('option', 'pdk', 'freepdk45')"],
+            schelp="""
+            Target PDK used during compilation.""")
+
+    scparam(cfg, ['option', 'stackup'],
+            sctype='str',
+            scope=Scope.JOB,
+            shorthelp="Option: stackup target",
+            switch="-stackup <str>",
+            example=["cli: -stackup 2MA4MB2MC",
+                     "api: chip.set('option', 'stackup', '2MA4MB2MC')"],
+            schelp="""
+            Target stackup used during compilation. The stackup is required
+            parameter for PDKs with multiple metal stackups.""")
+
+    scparam(cfg, ['option', 'cfg'],
+            sctype='[file]',
+            scope=Scope.JOB,
+            shorthelp="Option: configuration manifest",
+            switch="-cfg <file>",
+            example=["cli: -cfg mypdk.json",
+                     "api: chip.set('option', 'cfg', 'mypdk.json')"],
+            schelp="""
+            List of filepaths to JSON formatted schema configuration
+            manifests. The files are read in automatically when using the
+            'sc' command line application. In Python programs, JSON manifests
+            can be merged into the current working manifest using the
+            :meth:`Chip.read_manifest()` method.""")
+
+    key = 'default'
+    scparam(cfg, ['option', 'env', key],
+            sctype='str',
+            scope=Scope.JOB,
+            shorthelp="Option: environment variables",
+            switch="-env 'key <str>'",
+            example=[
+                "cli: -env 'PDK_HOME /disk/mypdk'",
+                "api: chip.set('option', 'env', 'PDK_HOME', '/disk/mypdk')"],
+            schelp="""
+            Certain tools and reference flows require global environment
+            variables to be set. These variables can be managed externally or
+            specified through the env variable.""")
+
+    scparam(cfg, ['option', 'var', key],
+            sctype='[str]',
+            scope=Scope.JOB,
+            shorthelp="Option: custom variables",
+            switch="-var 'key <str>'",
+            example=[
+                "cli: -var 'openroad_place_density 0.4'",
+                "api: chip.set('option', 'var', 'openroad_place_density', '0.4')"],
+            schelp="""
+            List of key/value strings specified. Certain tools and
+            reference flows require special parameters, this
+            should only be used for specifying variables that are
+            not directly supported by the SiliconCompiler schema.""")
+
+    scparam(cfg, ['option', 'file', key],
+            sctype='[file]',
+            scope=Scope.JOB,
+            copy=True,
+            shorthelp="Option: custom files",
+            switch="-file 'key <file>'",
+            example=[
+                "cli: -file 'openroad_tapcell ./tapcell.tcl'",
+                "api: chip.set('option', 'file', 'openroad_tapcell', './tapcell.tcl')"],
+            schelp="""
+            List of named files specified. Certain tools and
+            reference flows require special parameters, this
+            parameter should only be used for specifying files that are
+            not directly supported by the schema.""")
+
+    scparam(cfg, ['option', 'dir', key],
+            sctype='[dir]',
+            scope=Scope.JOB,
+            copy=True,
+            shorthelp="Option: custom directories",
+            switch="-dir 'key <dir>'",
+            example=[
+                "cli: -dir 'openroad_tapcell ./tapcell.tcl'",
+                "api: chip.set('option', 'dir', 'openroad_files', './openroad_support/')"],
+            schelp="""
+            List of named directories specified. Certain tools and
+            reference flows require special parameters, this
+            parameter should only be used for specifying directories that are
+            not directly supported by the schema.""")
+
+    return cfg
+
+
+def schema_option_runtime(cfg):
+    ''' Runtime run time options
+    '''
+
     scparam(cfg, ['option', 'remote'],
             sctype='bool',
             scope=Scope.JOB,
@@ -1153,28 +1256,6 @@ def schema_option(cfg):
             If the parameter is undefined, nice will not be used. For more information see
             `Unix 'nice' <https://en.wikipedia.org/wiki/Nice_(Unix)>`_.""")
 
-    # Compilation
-    scparam(cfg, ['option', 'pdk'],
-            sctype='str',
-            scope=Scope.JOB,
-            shorthelp="Option: PDK target",
-            switch="-pdk <str>",
-            example=["cli: -pdk freepdk45",
-                     "api: chip.set('option', 'pdk', 'freepdk45')"],
-            schelp="""
-            Target PDK used during compilation.""")
-
-    scparam(cfg, ['option', 'stackup'],
-            sctype='str',
-            scope=Scope.JOB,
-            shorthelp="Option: stackup target",
-            switch="-stackup <str>",
-            example=["cli: -stackup 2MA4MB2MC",
-                     "api: chip.set('option', 'stackup', '2MA4MB2MC')"],
-            schelp="""
-            Target stackup used during compilation. The stackup is required
-            parameter for PDKs with multiple metal stackups.""")
-
     scparam(cfg, ['option', 'flow'],
             sctype='str',
             scope=Scope.JOB,
@@ -1209,78 +1290,6 @@ def schema_option(cfg):
             (O99) = Experimental highest possible effort, may be unstable
             """)
 
-    scparam(cfg, ['option', 'cfg'],
-            sctype='[file]',
-            scope=Scope.JOB,
-            shorthelp="Option: configuration manifest",
-            switch="-cfg <file>",
-            example=["cli: -cfg mypdk.json",
-                     "api: chip.set('option', 'cfg', 'mypdk.json')"],
-            schelp="""
-            List of filepaths to JSON formatted schema configuration
-            manifests. The files are read in automatically when using the
-            'sc' command line application. In Python programs, JSON manifests
-            can be merged into the current working manifest using the
-            :meth:`Chip.read_manifest()` method.""")
-
-    key = 'default'
-    scparam(cfg, ['option', 'env', key],
-            sctype='str',
-            scope=Scope.JOB,
-            shorthelp="Option: environment variables",
-            switch="-env 'key <str>'",
-            example=[
-                "cli: -env 'PDK_HOME /disk/mypdk'",
-                "api: chip.set('option', 'env', 'PDK_HOME', '/disk/mypdk')"],
-            schelp="""
-            Certain tools and reference flows require global environment
-            variables to be set. These variables can be managed externally or
-            specified through the env variable.""")
-
-    scparam(cfg, ['option', 'var', key],
-            sctype='[str]',
-            scope=Scope.JOB,
-            shorthelp="Option: custom variables",
-            switch="-var 'key <str>'",
-            example=[
-                "cli: -var 'openroad_place_density 0.4'",
-                "api: chip.set('option', 'var', 'openroad_place_density', '0.4')"],
-            schelp="""
-            List of key/value strings specified. Certain tools and
-            reference flows require special parameters, this
-            should only be used for specifying variables that are
-            not directly supported by the SiliconCompiler schema.""")
-
-    scparam(cfg, ['option', 'file', key],
-            sctype='[file]',
-            scope=Scope.JOB,
-            copy=True,
-            shorthelp="Option: custom files",
-            switch="-file 'key <file>'",
-            example=[
-                "cli: -file 'openroad_tapcell ./tapcell.tcl'",
-                "api: chip.set('option', 'file', 'openroad_tapcell', './tapcell.tcl')"],
-            schelp="""
-            List of named files specified. Certain tools and
-            reference flows require special parameters, this
-            parameter should only be used for specifying files that are
-            not directly supported by the schema.""")
-
-    scparam(cfg, ['option', 'dir', key],
-            sctype='[dir]',
-            scope=Scope.JOB,
-            copy=True,
-            shorthelp="Option: custom directories",
-            switch="-dir 'key <dir>'",
-            example=[
-                "cli: -dir 'openroad_tapcell ./tapcell.tcl'",
-                "api: chip.set('option', 'dir', 'openroad_files', './openroad_support/')"],
-            schelp="""
-            List of named directories specified. Certain tools and
-            reference flows require special parameters, this
-            parameter should only be used for specifying directories that are
-            not directly supported by the schema.""")
-
     scparam(cfg, ['option', 'loglevel'],
             sctype='<info,warning,error,critical,debug,quiet>',
             pernode=PerNode.OPTIONAL,
@@ -1374,18 +1383,6 @@ def schema_option(cfg):
             EDA tool. If the step is a command line tool, then the flow
             drops into a Python interpreter.""")
 
-    scparam(cfg, ['option', 'library'],
-            sctype='[str]',
-            scope=Scope.JOB,
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Option: library list",
-            switch="-library <str>",
-            example=["cli: -library lambdalib_asap7",
-                     "api: chip.set('option', 'library', 'lambdalib_asap7')"],
-            schelp="""
-            List of soft libraries to be linked in during import.""")
-
-    # Booleans
     scparam(cfg, ['option', 'clean'],
             sctype='bool',
             scope=Scope.JOB,
@@ -1478,100 +1475,6 @@ def schema_option(cfg):
             being recorded in the manifest so only turn on this feature
             if you have control of the final manifest.""")
 
-    scparam(cfg, ['option', 'entrypoint'],
-            sctype='str',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Option: program entry point",
-            switch="-entrypoint <str>",
-            example=["cli: -entrypoint top",
-                     "api: chip.set('option', 'entrypoint', 'top')"],
-            schelp="""Alternative entrypoint for compilation and
-            simulation. The default entry point is :keypath:`design`.""")
-
-    scparam(cfg, ['option', 'idir'],
-            sctype='[dir]',
-            shorthelp="Option: design search paths",
-            copy=True,
-            switch=['+incdir+<dir>',
-                    '-I <dir>',
-                    '-idir <dir>'],
-            example=[
-                "cli: +incdir+./mylib",
-                "cli: -I ./mylib",
-                "cli: -idir ./mylib",
-                "api: chip.set('option', 'idir', './mylib')"],
-            schelp="""
-            Search paths to look for files included in the design using
-            the ```include`` statement.""")
-
-    scparam(cfg, ['option', 'ydir'],
-            sctype='[dir]',
-            shorthelp="Option: design module search paths",
-            copy=True,
-            switch=['-y <dir>',
-                    '-ydir <dir>'],
-            example=[
-                "cli: -y './mylib'",
-                "cli: -ydir './mylib'",
-                "api: chip.set('option', 'ydir', './mylib')"],
-            schelp="""
-            Search paths to look for verilog modules found in the the
-            source list. The import engine will look for modules inside
-            files with the specified :keypath:`option,libext` param suffix.""")
-
-    scparam(cfg, ['option', 'vlib'],
-            sctype='[file]',
-            shorthelp="Option: design libraries",
-            copy=True,
-            switch=['-v <file>',
-                    '-vlib <file>'],
-            example=["cli: -v './mylib.v'",
-                     "cli: -vlib './mylib.v'",
-                     "api: chip.set('option', 'vlib', './mylib.v')"],
-            schelp="""
-            List of library files to be read in. Modules found in the
-            libraries are not interpreted as root modules.""")
-
-    scparam(cfg, ['option', 'define'],
-            sctype='[str]',
-            shorthelp="Option: design pre-processor symbol",
-            switch=["-D<str>",
-                    "-define <str>"],
-            example=["cli: -DCFG_ASIC=1",
-                     "cli: -define CFG_ASIC=1",
-                     "api: chip.set('option', 'define', 'CFG_ASIC=1')"],
-            schelp="""Symbol definition for source preprocessor.""")
-
-    scparam(cfg, ['option', 'libext'],
-            sctype='[str]',
-            shorthelp="Option: design file extensions",
-            switch=["+libext+<str>",
-                    "-libext <str>"],
-            example=[
-                "cli: +libext+sv",
-                "cli: -libext sv",
-                "api: chip.set('option', 'libext', 'sv')"],
-            schelp="""
-            List of file extensions that should be used for finding modules.
-            For example, if :keypath:`option,ydir` is specified as ./lib", and '.v'
-            is specified as libext then the files ./lib/\\*.v ", will be searched for
-            module matches.""")
-
-    name = 'default'
-    scparam(cfg, ['option', 'param', name],
-            sctype='str',
-            shorthelp="Option: design parameter",
-            switch="-param 'name <str>'",
-            example=[
-                "cli: -param 'N 64'",
-                "api: chip.set('option', 'param', 'N', '64')"],
-            schelp="""
-            Sets a top verilog level design module parameter. The value
-            is limited to basic data literals. The parameter override is
-            passed into tools such as Verilator and Yosys. The parameters
-            support Verilog integer literals (64'h4, 2'b0, 4) and strings.
-            Name of the top level module to compile.""")
-
     scparam(cfg, ['option', 'continue'],
             sctype='bool',
             pernode=PerNode.OPTIONAL,
@@ -1754,175 +1657,133 @@ def schema_option(cfg):
     return cfg
 
 
-############################################
-# Package information
-############################################
-def schema_package(cfg):
-
-    userid = 'default'
+def schema_option_frontend(cfg):
+    ''' Frontend options
+    '''
 
-    scparam(cfg, ['package', 'version'],
-            sctype='str',
-            scope=Scope.GLOBAL,
-            shorthelp="Package: version",
-            switch="-package_version <str>",
-            example=[
-                "cli: -package_version 1.0",
-                "api: chip.set('package', 'version', '1.0')"],
-            schelp="""Package version. Can be a branch, tag, commit hash,
-            or a semver compatible version.""")
+    scparam(cfg, ['option', 'library'],
+            sctype='[str]',
+            scope=Scope.JOB,
+            pernode=PerNode.OPTIONAL,
+            shorthelp="Option: library list",
+            switch="-library <str>",
+            example=["cli: -library lambdalib_asap7",
+                     "api: chip.set('option', 'library', 'lambdalib_asap7')"],
+            schelp="""
+            List of soft libraries to be linked in during import.""")
 
-    scparam(cfg, ['package', 'description'],
+    scparam(cfg, ['option', 'entrypoint'],
             sctype='str',
-            scope=Scope.GLOBAL,
-            shorthelp="Package: description",
-            switch="-package_description <str>",
-            example=[
-                "cli: -package_description 'Yet another cpu'",
-                "api: chip.set('package', 'description', 'Yet another cpu')"],
-            schelp="""Package short one line description for package
-            managers and summary reports.""")
+            pernode=PerNode.OPTIONAL,
+            shorthelp="Option: program entry point",
+            switch="-entrypoint <str>",
+            example=["cli: -entrypoint top",
+                     "api: chip.set('option', 'entrypoint', 'top')"],
+            schelp="""Alternative entrypoint for compilation and
+            simulation. The default entry point is :keypath:`design`.""")
 
-    scparam(cfg, ['package', 'keyword'],
-            sctype='str',
-            scope=Scope.GLOBAL,
-            shorthelp="Package: keyword",
-            switch="-package_keyword <str>",
+    scparam(cfg, ['option', 'idir'],
+            sctype='[dir]',
+            shorthelp="Option: design search paths",
+            copy=True,
+            switch=['+incdir+<dir>',
+                    '-I <dir>',
+                    '-idir <dir>'],
             example=[
-                "cli: -package_keyword cpu",
-                "api: chip.set('package', 'keyword', 'cpu')"],
-            schelp="""Package keyword(s) used to characterize package.""")
-    scparam(cfg, ['package', 'doc', 'homepage'],
-            sctype='str',
-            scope=Scope.GLOBAL,
-            shorthelp="Package: documentation homepage",
-            switch="-package_doc_homepage <str>",
-            example=[
-                "cli: -package_doc_homepage index.html",
-                "api: chip.set('package', 'doc', 'homepage', 'index.html')"],
-            schelp="""
-            Package documentation homepage. Filepath to design docs homepage.
-            Complex designs can can include a long non standard list of
-            documents dependent. A single html entry point can be used to
-            present an organized documentation dashboard to the designer.""")
-
-    doctypes = ['datasheet',
-                'reference',
-                'userguide',
-                'quickstart',
-                'releasenotes',
-                'testplan',
-                'signoff',
-                'tutorial']
-
-    for item in doctypes:
-        scparam(cfg, ['package', 'doc', item],
-                sctype='[file]',
-                scope=Scope.GLOBAL,
-                shorthelp=f"Package: {item} document",
-                switch=f"-package_doc_{item} <file>",
-                example=[
-                    f"cli: -package_doc_{item} {item}.pdf",
-                    f"api: chip.set('package', 'doc', '{item}', '{item}.pdf')"],
-                schelp=f"""Package list of {item} documents.""")
+                "cli: +incdir+./mylib",
+                "cli: -I ./mylib",
+                "cli: -idir ./mylib",
+                "api: chip.set('option', 'idir', './mylib')"],
+            schelp="""
+            Search paths to look for files included in the design using
+            the ```include`` statement.""")
 
-    scparam(cfg, ['package', 'license'],
-            sctype='[str]',
-            scope=Scope.GLOBAL,
-            shorthelp="Package: license identifiers",
-            switch="-package_license <str>",
+    scparam(cfg, ['option', 'ydir'],
+            sctype='[dir]',
+            shorthelp="Option: design module search paths",
+            copy=True,
+            switch=['-y <dir>',
+                    '-ydir <dir>'],
             example=[
-                "cli: -package_license 'Apache-2.0'",
-                "api: chip.set('package', 'license', 'Apache-2.0')"],
-            schelp="""Package list of SPDX license identifiers.""")
+                "cli: -y './mylib'",
+                "cli: -ydir './mylib'",
+                "api: chip.set('option', 'ydir', './mylib')"],
+            schelp="""
+            Search paths to look for verilog modules found in the the
+            source list. The import engine will look for modules inside
+            files with the specified :keypath:`option,libext` param suffix.""")
 
-    scparam(cfg, ['package', 'licensefile'],
+    scparam(cfg, ['option', 'vlib'],
             sctype='[file]',
-            scope=Scope.GLOBAL,
-            shorthelp="Package: license files",
-            switch="-package_licensefile <file>",
-            example=[
-                "cli: -package_licensefile './LICENSE'",
-                "api: chip.set('package', 'licensefile', './LICENSE')"],
-            schelp="""Package list of license files for to be
-            applied in cases when a SPDX identifier is not available.
-            (eg. proprietary licenses).""")
+            shorthelp="Option: design libraries",
+            copy=True,
+            switch=['-v <file>',
+                    '-vlib <file>'],
+            example=["cli: -v './mylib.v'",
+                     "cli: -vlib './mylib.v'",
+                     "api: chip.set('option', 'vlib', './mylib.v')"],
+            schelp="""
+            List of library files to be read in. Modules found in the
+            libraries are not interpreted as root modules.""")
 
-    scparam(cfg, ['package', 'organization'],
+    scparam(cfg, ['option', 'define'],
             sctype='[str]',
-            scope=Scope.GLOBAL,
-            shorthelp="Package: sponsoring organization",
-            switch="-package_organization <str>",
-            example=[
-                "cli: -package_organization 'humanity'",
-                "api: chip.set('package', 'organization', 'humanity')"],
-            schelp="""Package sponsoring organization. The field can be left
-            blank if not applicable.""")
-
-    record = ['name',
-              'email',
-              'username',
-              'location',
-              'organization',
-              'publickey']
-
-    for item in record:
-        scparam(cfg, ['package', 'author', userid, item],
-                sctype='str',
-                scope=Scope.GLOBAL,
-                shorthelp=f"Package: author {item}",
-                switch=f"-package_author_{item} 'userid <str>'",
-                example=[
-                    f"cli: -package_author_{item} 'wiley wiley@acme.com'",
-                    f"api: chip.set('package', 'author', 'wiley', '{item}', 'wiley@acme.com')"],
-                schelp=f"""Package author {item} provided with full name as key and
-                {item} as value.""")
-
-    source = 'default'
+            shorthelp="Option: design pre-processor symbol",
+            switch=["-D<str>",
+                    "-define <str>"],
+            example=["cli: -DCFG_ASIC=1",
+                     "cli: -define CFG_ASIC=1",
+                     "api: chip.set('option', 'define', 'CFG_ASIC=1')"],
+            schelp="""Symbol definition for source preprocessor.""")
 
-    scparam(cfg, ['package', 'source', source, 'path'],
-            sctype='str',
-            scope=Scope.GLOBAL,
-            shorthelp="Package: data source path",
-            switch="-package_source_path 'source <str>'",
-            example=[
-                "cli: -package_source_path "
-                "'freepdk45_data ssh://git@github.com/siliconcompiler/freepdk45/'",
-                "api: chip.set('package', 'source', "
-                "'freepdk45_data', 'path', 'ssh://git@github.com/siliconcompiler/freepdk45/')"],
-            schelp="""
-            Package data source path, allowed paths:
-
-            * /path/on/network/drive
-            * file:///path/on/network/drive
-            * git+https://github.com/xyz/xyz
-            * git://github.com/xyz/xyz
-            * git+ssh://github.com/xyz/xyz
-            * ssh://github.com/xyz/xyz
-            * https://github.com/xyz/xyz/archive
-            * https://zeroasic.com/xyz.tar.gz
-            * python://siliconcompiler
-            """)
+    scparam(cfg, ['option', 'libext'],
+            sctype='[str]',
+            shorthelp="Option: design file extensions",
+            switch=["+libext+<str>",
+                    "-libext <str>"],
+            example=[
+                "cli: +libext+sv",
+                "cli: -libext sv",
+                "api: chip.set('option', 'libext', 'sv')"],
+            schelp="""
+            List of file extensions that should be used for finding modules.
+            For example, if :keypath:`option,ydir` is specified as ./lib", and '.v'
+            is specified as libext then the files ./lib/\\*.v ", will be searched for
+            module matches.""")
 
-    scparam(cfg, ['package', 'source', source, 'ref'],
+    name = 'default'
+    scparam(cfg, ['option', 'param', name],
             sctype='str',
-            scope=Scope.GLOBAL,
-            shorthelp="Package: data source reference",
-            switch="-package_source_ref 'source <str>'",
+            shorthelp="Option: design parameter",
+            switch="-param 'name <str>'",
             example=[
-                "cli: -package_source_ref 'freepdk45_data 07ec4aa'",
-                "api: chip.set('package', 'source', 'freepdk45_data', 'ref', '07ec4aa')"],
-            schelp="""Package data source reference""")
+                "cli: -param 'N 64'",
+                "api: chip.set('option', 'param', 'N', '64')"],
+            schelp="""
+            Sets a top verilog level design module parameter. The value
+            is limited to basic data literals. The parameter override is
+            passed into tools such as Verilator and Yosys. The parameters
+            support Verilog integer literals (64'h4, 2'b0, 4) and strings.
+            Name of the top level module to compile.""")
 
     return cfg
 
 
+############################################
+# Package information
+############################################
+def schema_package(cfg):
+    from siliconcompiler.packageschema import PackageSchema
+    cfg.insert("package", PackageSchema())
+    return cfg
+
+
 ############################################
 # Design Checklist
 ############################################
 def schema_checklist(cfg):
     from siliconcompiler.checklist import ChecklistSchema
-    cfg.insert("checklist", "default", ChecklistSchema())
+    cfg.insert("checklist", "default", ChecklistSchema(None))
     return cfg