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

siliconcompiler/schema/schema_cfg.py

@@ -1,16 +1,9 @@
 # Copyright 2022 Silicon Compiler Authors. All Rights Reserved.
 
-import json
+from . import EditableSchema, Parameter, Scope, PerNode
+from .utils import trim
 
-# Default import must be relative, to facilitate tools with Python interfaces
-# (such as KLayout) directly importing the schema package. However, the fallback
-# allows running this script directly to generate defaults.json.
-try:
-    from .utils import trim, Scope, PerNode
-except ImportError:
-    from siliconcompiler.schema.utils import trim, Scope, PerNode
-
-SCHEMA_VERSION = '0.50.0'
+SCHEMA_VERSION = '0.51.3'
 
 
 #############################################################################
@@ -32,94 +25,29 @@ def scparam(cfg,
             switch=None,
             example=None,
             schelp=None,
-            enum=None,
             pernode=PerNode.NEVER):
-
-    # 1. descend keypath until done
-    # 2. create key if missing
-    # 3. populate leaf cell when keypath empty
-    if keypath:
-        key = keypath[0]
-        keypath.pop(0)
-        if key not in cfg.keys():
-            cfg[key] = {}
-        scparam(cfg[key],
-                keypath,
-                sctype=sctype,
-                scope=scope,
-                require=require,
-                defvalue=defvalue,
-                copy=copy,
-                lock=lock,
-                hashalgo=hashalgo,
-                signature=signature,
-                notes=notes,
-                unit=unit,
-                shorthelp=shorthelp,
-                switch=switch,
-                example=example,
-                schelp=schelp,
-                enum=enum,
-                pernode=pernode)
-    else:
-
-        # removing leading spaces as if schelp were a docstring
-        schelp = trim(schelp)
-
-        # setting values based on types
-        # note (bools are never lists)
-        if sctype == 'bool':
-            if defvalue is None:
-                defvalue = False
-        if '[' in sctype:
-            if signature is None:
-                signature = []
-            if defvalue is None:
-                defvalue = []
-
-        # mandatory for all
-        cfg['type'] = str(sctype)
-        cfg['scope'] = Scope(scope).value
-        cfg['require'] = bool(require)
-        cfg['lock'] = bool(lock)
-        if switch and not isinstance(switch, list):
-            switch = [switch]
-        cfg['switch'] = [str(s) for s in switch] if switch else None
-        cfg['shorthelp'] = str(shorthelp) if shorthelp else None
-        cfg['example'] = [str(e) for e in example] if example else None
-        cfg['help'] = str(schelp) if schelp else None
-        cfg['notes'] = str(notes) if notes else None
-        # never, optional, required
-        cfg['pernode'] = PerNode(pernode).value
-        cfg['node'] = {}
-        cfg['node']['default'] = {}
-        cfg['node']['default']['default'] = {}
-        cfg['node']['default']['default']['value'] = defvalue
-        cfg['node']['default']['default']['signature'] = signature
-
-        if enum is not None:
-            cfg['enum'] = [str(e) for e in enum]
-
-        # unit for floats/ints
-        if unit is not None:
-            cfg['unit'] = str(unit)
-
-        if 'dir' in sctype or 'file' in sctype:
-            cfg['hashalgo'] = str(hashalgo)
-            cfg['copy'] = bool(copy)
-            cfg['node']['default']['default']['filehash'] = []
-            cfg['node']['default']['default']['package'] = []
-
-        # file only values
-        if 'file' in sctype:
-            cfg['node']['default']['default']['date'] = []
-            cfg['node']['default']['default']['author'] = []
+    cfg.insert(*keypath, Parameter(
+        sctype,
+        require=require,
+        defvalue=defvalue,
+        scope=scope,
+        copy=copy,
+        lock=lock,
+        hashalgo=hashalgo,
+        notes=notes,
+        unit=unit,
+        shorthelp=shorthelp,
+        switch=switch,
+        example=example,
+        help=trim(schelp),
+        pernode=pernode
+    ))
 
 
 #############################################################################
 # CHIP CONFIGURATION
 #############################################################################
-def schema_cfg():
+def schema_cfg(schema):
     '''Method for defining Chip configuration schema
     All the keys defined in this dictionary are reserved words.
     '''
@@ -129,11 +57,7 @@ def schema_cfg():
     # Software version syncs with SC releases (from _metadata)
 
     # Basic schema setup
-    cfg = {}
-
-    # Place holder dictionaries updated by core methods()
-    cfg['history'] = {}
-    cfg['library'] = {}
+    cfg = EditableSchema(schema)
 
     scparam(cfg, ['schemaversion'],
             sctype='str',
@@ -196,7 +120,6 @@ def schema_cfg():
 
     # Tool flows
     cfg = schema_tool(cfg)
-    cfg = schema_task(cfg)
     cfg = schema_flowgraph(cfg)
 
     # Metrics
@@ -213,16 +136,14 @@ def schema_cfg():
     # Packaging
     cfg = schema_schematic(cfg)
 
-    return cfg
-
 
 ###############################################################################
 # SCHEMATIC
 ###############################################################################
-def schema_schematic(cfg, name='default'):
+def schema_schematic(cfg):
     ''' Schematic
     '''
-
+    name = 'default'
     scparam(cfg, ['schematic', 'component', name, 'partname'],
             sctype='str',
             shorthelp="Schematic: component model",
@@ -232,8 +153,7 @@ def schema_schematic(cfg, name='default'):
             schelp="""Component part-name ("aka cell-name") specified on a per instance basis.""")
 
     scparam(cfg, ['schematic', 'pin', name, 'dir'],
-            sctype='enum',
-            enum=['input', 'output', 'inout'],
+            sctype='<input,output,inout>',
             shorthelp="Schematic: pin direction",
             switch="-schematic_pin_dir 'name <str>'",
             example=["cli: -schematic_pin_dir 'A input'",
@@ -282,444 +202,38 @@ def schema_schematic(cfg, name='default'):
 # FPGA
 ###############################################################################
 def schema_fpga(cfg):
-    ''' FPGA configuration
-    '''
-
-    partname = 'default'
-    key = 'default'
-
-    scparam(cfg, ['fpga', 'partname'],
-            sctype='str',
-            shorthelp="FPGA: part name",
-            switch="-fpga_partname <str>",
-            example=["cli: -fpga_partname fpga64k",
-                     "api: chip.set('fpga', 'partname', 'fpga64k')"],
-            schelp="""
-            Complete part name used as a device target by the FPGA compilation
-            tool. The part name must be an exact string match to the partname
-            hard coded within the FPGA EDA tool.""")
-
-    scparam(cfg, ['fpga', partname, 'vendor'],
-            sctype='str',
-            shorthelp="FPGA: vendor name",
-            switch="-fpga_vendor 'partname <str>'",
-            example=["cli: -fpga_vendor 'fpga64k acme'",
-                     "api: chip.set('fpga', 'fpga64k', 'vendor', 'acme')"],
-            schelp="""
-            Name of the FPGA vendor for the FPGA partname.""")
-
-    scparam(cfg, ['fpga', partname, 'lutsize'],
-            sctype='int',
-            shorthelp="FPGA: lutsize",
-            switch="-fpga_lutsize 'partname <int>'",
-            example=["cli: -fpga_lutsize 'fpga64k 4'",
-                     "api: chip.set('fpga', 'fpga64k', 'lutsize', '4')"],
-            schelp="""
-            Specify the number of inputs in each lookup table (LUT) for the
-            FPGA partname.  For architectures with fracturable LUTs, this is
-            the number of inputs of the unfractured LUT.""")
-
-    scparam(cfg, ['fpga', partname, 'file', key],
-            sctype='[file]',
-            scope=Scope.GLOBAL,
-            shorthelp="FPGA: file",
-            switch="-fpga_file 'partname key <file>'",
-            example=["cli: -fpga_file 'fpga64k file archfile my_arch.xml'",
-                     "api: chip.set('fpga', 'fpga64k', 'file', 'archfile', 'my_arch.xml')"],
-            schelp="""
-            Specify a file for the FPGA partname.""")
-
-    scparam(cfg, ['fpga', partname, 'var', key],
-            sctype='[str]',
-            shorthelp="FPGA: var",
-            switch="-fpga_var 'partname key <str>'",
-            example=["cli: -fpga_var 'fpga64k channelwidth 100'",
-                     "api: chip.set('fpga', 'fpga64k', 'var', 'channelwidth', '100')"],
-            schelp="""
-            Specify a variable value for the FPGA partname.""")
-
+    from siliconcompiler.fpga import FPGASchema
+    cfg.insert("fpga", FPGASchema())
     return cfg
 
 
 ###############################################################################
 # PDK
 ###############################################################################
-def schema_pdk(cfg, stackup='default'):
-    ''' Process design kit configuration
-    '''
-
-    tool = 'default'
-    filetype = 'default'
-    pdkname = 'default'
-
-    scparam(cfg, ['pdk', pdkname, 'foundry'],
-            sctype='str',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: foundry name",
-            switch="-pdk_foundry 'pdkname <str>'",
-            example=["cli: -pdk_foundry 'asap7 virtual'",
-                     "api: chip.set('pdk', 'asap7', 'foundry', 'virtual')"],
-            schelp="""
-            Name of foundry corporation. Examples include intel, gf, tsmc,
-            samsung, skywater, virtual. The \'virtual\' keyword is reserved for
-            simulated non-manufacturable processes.""")
-
-    scparam(cfg, ['pdk', pdkname, 'node'],
-            sctype='float',
-            scope=Scope.GLOBAL,
-            unit='nm',
-            shorthelp="PDK: process node",
-            switch="-pdk_node 'pdkname <float>'",
-            example=["cli: -pdk_node 'asap7 130'",
-                     "api: chip.set('pdk', 'asap7', 'node', 130)"],
-            schelp="""
-            Approximate relative minimum dimension of the process target specified
-            in nanometers. The parameter is required for flows and tools that
-            leverage the value to drive technology dependent synthesis and APR
-            optimization. Node examples include 180, 130, 90, 65, 45, 32, 22 14,
-            10, 7, 5, 3.""")
-
-    scparam(cfg, ['pdk', pdkname, 'version'],
-            sctype='str',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: version",
-            switch="-pdk_version 'pdkname <str>'",
-            example=["cli: -pdk_version 'asap7 1.0'",
-                     "api: chip.set('pdk', 'asap7', 'version', '1.0')"],
-            schelp="""
-            Alphanumeric string specifying the version of the PDK. Verification of
-            correct PDK and IP versions is a hard ASIC tapeout require in all
-            commercial foundries. The version number can be used for design manifest
-            tracking and tapeout checklists.""")
-
-    scparam(cfg, ['pdk', pdkname, 'stackup'],
-            sctype='[str]',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: metal stackups",
-            switch="-pdk_stackup 'pdkname <str>'",
-            example=["cli: -pdk_stackup 'asap7 2MA4MB2MC'",
-                     "api: chip.add('pdk', 'asap7', 'stackup', '2MA4MB2MC')"],
-            schelp="""
-            List of all metal stackups offered in the process node. Older process
-            nodes may only offer a single metal stackup, while advanced nodes
-            offer a large but finite list of metal stacks with varying combinations
-            of metal line pitches and thicknesses. Stackup naming is unique to a
-            foundry, but is generally a long string or code. For example, a 10
-            metal stackup with two 1x wide, four 2x wide, and 4x wide metals,
-            might be identified as 2MA4MB2MC, where MA, MB, and MC denote wiring
-            layers with different properties (thickness, width, space). Each
-            stackup will come with its own set of routing technology files and
-            parasitic models specified in the pdk_pexmodel and pdk_aprtech
-            parameters.""")
-
-    scparam(cfg, ['pdk', pdkname, 'minlayer', stackup],
-            sctype='str',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: minimum routing layer",
-            switch="-pdk_minlayer 'pdk stackup <str>'",
-            example=[
-                "cli: -pdk_minlayer 'asap7 2MA4MB2MC M2'",
-                "api: chip.set('pdk', 'asap7', 'minlayer', '2MA4MB2MC', 'M2')"],
-            schelp="""
-            Minimum metal layer to be used for automated place and route
-            specified on a per stackup basis.""")
-
-    scparam(cfg, ['pdk', pdkname, 'maxlayer', stackup],
-            sctype='str',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: maximum routing layer",
-            switch="-pdk_maxlayer 'pdk stackup <str>'",
-            example=[
-                "cli: -pdk_maxlayer 'asap7 2MA4MB2MC M8'",
-                "api: chip.set('pdk', 'asap7', 'maxlayer', 'MA4MB2MC', 'M8')"],
-            schelp="""
-            Maximum metal layer to be used for automated place and route
-            specified on a per stackup basis.""")
-
-    scparam(cfg, ['pdk', pdkname, 'wafersize'],
-            sctype='float',
-            scope=Scope.GLOBAL,
-            unit='mm',
-            shorthelp="PDK: wafer size",
-            switch="-pdk_wafersize 'pdkname <float>'",
-            example=["cli: -pdk_wafersize 'asap7 300'",
-                     "api: chip.set('pdk', 'asap7', 'wafersize', 300)"],
-            schelp="""
-            Wafer diameter used in wafer based manufacturing process.
-            The standard diameter for leading edge manufacturing is 300mm. For
-            older process technologies and specialty fabs, smaller diameters
-            such as 200, 150, 125, and 100 are common. The value is used to
-            calculate dies per wafer and full factory chip costs.""")
-
-    scparam(cfg, ['pdk', pdkname, 'panelsize'],
-            sctype='[(float,float)]',
-            scope=Scope.GLOBAL,
-            unit='mm',
-            shorthelp="PDK: panel size",
-            switch="-pdk_panelsize 'pdkname <(float,float)>'",
-            example=[
-                "cli: -pdk_panelsize 'asap7 (45.72,60.96)'",
-                "api: chip.set('pdk', 'asap7', 'panelsize', (45.72, 60.96))"],
-            schelp="""
-            List of panel sizes supported in the manufacturing process.
-            """)
-
-    scparam(cfg, ['pdk', pdkname, 'unitcost'],
-            sctype='float',
-            scope=Scope.GLOBAL,
-            unit='USD',
-            shorthelp="PDK: unit cost",
-            switch="-pdk_unitcost 'pdkname <float>'",
-            example=["cli: -pdk_unitcost 'asap7 10000'",
-                     "api: chip.set('pdk', 'asap7', 'unitcost', 10000)"],
-            schelp="""
-            Raw cost per unit shipped by the factory, not accounting for yield
-            loss.""")
-
-    scparam(cfg, ['pdk', pdkname, 'd0'],
-            sctype='float',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: process defect density",
-            switch="-pdk_d0 'pdkname <float>'",
-            example=["cli: -pdk_d0 'asap7 0.1'",
-                     "api: chip.set('pdk', 'asap7', 'd0', 0.1)"],
-            schelp="""
-            Process defect density (d0) expressed as random defects per cm^2. The
-            value is used to calculate yield losses as a function of area, which in
-            turn affects the chip full factory costs. Two yield models are
-            supported: Poisson (default), and Murphy. The Poisson based yield is
-            calculated as dy = exp(-area * d0/100). The Murphy based yield is
-            calculated as dy = ((1-exp(-area * d0/100))/(area * d0/100))^2.""")
-
-    scparam(cfg, ['pdk', pdkname, 'scribe'],
-            sctype='(float,float)',
-            scope=Scope.GLOBAL,
-            unit='mm',
-            shorthelp="PDK: horizontal scribe line width",
-            switch="-pdk_scribe 'pdkname <(float,float)>'",
-            example=["cli: -pdk_scribe 'asap7 (0.1,0.1)'",
-                     "api: chip.set('pdk', 'asap7', 'scribe', (0.1, 0.1))"],
-            schelp="""
-            Width of the horizontal and vertical scribe line used during die separation.
-            The process is generally completed using a mechanical saw, but can be
-            done through combinations of mechanical saws, lasers, wafer thinning,
-            and chemical etching in more advanced technologies. The value is used
-            to calculate effective dies per wafer and full factory cost.""")
-
-    scparam(cfg, ['pdk', pdkname, 'edgemargin'],
-            sctype='float',
-            scope=Scope.GLOBAL,
-            unit='mm',
-            shorthelp="PDK: wafer edge keep-out margin",
-            switch="-pdk_edgemargin 'pdkname <float>'",
-            example=[
-                "cli: -pdk_edgemargin 'asap7 1'",
-                "api: chip.set('pdk', 'asap7', 'edgemargin', 1)"],
-            schelp="""
-            Keep-out distance/margin from the edge inwards. The edge
-            is prone to chipping and need special treatment that preclude
-            placement of designs in this area. The edge value is used to
-            calculate effective units per wafer/panel and full factory cost.""")
-
-    simtype = 'default'
-    scparam(cfg, ['pdk', pdkname, 'devmodel', tool, simtype, stackup],
-            sctype='[file]',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: device models",
-            switch="-pdk_devmodel 'pdkname tool simtype stackup <file>'",
-            example=[
-            "cli: -pdk_devmodel 'asap7 xyce spice M10 asap7.sp'",
-            "api: chip.set('pdk', 'asap7', 'devmodel', 'xyce', 'spice', 'M10', 'asap7.sp')"],
-            schelp="""
-            List of filepaths to PDK device models for different simulation
-            purposes and for different tools. Examples of device model types
-            include spice, aging, electromigration, radiation. An example of a
-            'spice' tool is xyce. Device models are specified on a per metal stack
-            basis. Process nodes with a single device model across all stacks will
-            have a unique parameter record per metal stack pointing to the same
-            device model file. Device types and tools are dynamic entries
-            that depend on the tool setup and device technology. Pseudo-standardized
-            device types include spice, em (electromigration), and aging.""")
-
-    corner = 'default'
-    scparam(cfg, ['pdk', pdkname, 'pexmodel', tool, stackup, corner],
-            sctype='[file]',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: parasitic TCAD models",
-            switch="-pdk_pexmodel 'pdkname tool stackup corner <file>'",
-            example=[
-                "cli: -pdk_pexmodel 'asap7 fastcap M10 max wire.mod'",
-                "api: chip.set('pdk', 'asap7', 'pexmodel', 'fastcap', 'M10', 'max', 'wire.mod')"],
-            schelp="""
-            List of filepaths to PDK wire TCAD models used during automated
-            synthesis, APR, and signoff verification. Pexmodels are specified on
-            a per metal stack basis. Corner values depend on the process being
-            used, but typically include nomenclature such as min, max, nominal.
-            For exact names, refer to the DRM. Pexmodels are generally not
-            standardized and specified on a per tool basis. An example of pexmodel
-            type is 'fastcap'.""")
-
-    src = 'default'
-    dst = 'default'
-    scparam(cfg, ['pdk', pdkname, 'layermap', tool, src, dst, stackup],
-            sctype='[file]',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: layer map file",
-            switch="-pdk_layermap 'pdkname tool src dst stackup <file>'",
-            example=[
-                "cli: -pdk_layermap 'asap7 klayout db gds M10 asap7.map'",
-                "api: chip.set('pdk', 'asap7', 'layermap', 'klayout', 'db', 'gds', 'M10', "
-                "'asap7.map')"],
-            schelp="""
-            Files describing input/output mapping for streaming layout data from
-            one format to another. A foundry PDK will include an official layer
-            list for all user entered and generated layers supported in the GDS
-            accepted by the foundry for processing, but there is no standardized
-            layer definition format that can be read and written by all EDA tools.
-            To ensure mask layer matching, key/value type mapping files are needed
-            to convert EDA databases to/from GDS and to convert between different
-            types of EDA databases. Layer maps are specified on a per metal
-            stackup basis. The 'src' and 'dst' can be names of SC supported tools
-            or file formats (like 'gds').""")
-
-    scparam(cfg, ['pdk', pdkname, 'display', tool, stackup],
-            sctype='[file]',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: display file",
-            switch="-pdk_display 'pdkname tool stackup <file>'",
-            example=[
-                "cli: -pdk_display 'asap7 klayout M10 display.lyt'",
-                "api: chip.set('pdk', 'asap7', 'display', 'klayout', 'M10', 'display.cfg')"],
-            schelp="""
-            Display configuration files describing colors and pattern schemes for
-            all layers in the PDK. The display configuration file is entered on a
-            stackup and tool basis.""")
-
-    # TODO: create firm list of accepted files
-    libarch = 'default'
-    scparam(cfg, ['pdk', pdkname, 'aprtech', tool, stackup, libarch, filetype],
-            sctype='[file]',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: APR technology files",
-            switch="-pdk_aprtech 'pdkname tool stackup libarch filetype <file>'",
-            example=[
-                "cli: -pdk_aprtech 'asap7 openroad M10 12t lef tech.lef'",
-                "api: chip.set('pdk', 'asap7', 'aprtech', 'openroad', 'M10', '12t', 'lef', "
-                "'tech.lef')"],
-            schelp="""
-            Technology file containing setup information needed to enable DRC clean APR
-            for the specified stackup, libarch, and format. The 'libarch' specifies the
-            library architecture (e.g. library height). For example a PDK with support
-            for 9 and 12 track libraries might have 'libarchs' called 9t and 12t.
-            The standard filetype for specifying place and route design rules for a
-            process node is through a 'lef' format technology file. The
-            'filetype' used in the aprtech is used by the tool specific APR TCL scripts
-            to set up the technology parameters. Some tools may require additional
-            files beyond the tech.lef file. Examples of extra file types include
-            antenna, tracks, tapcell, viarules, and em.""")
-
-    checks = ['lvs', 'drc', 'erc', 'fill']
-    name = 'default'
-    for item in checks:
-        scparam(cfg, ['pdk', pdkname, item, 'runset', tool, stackup, name],
-                sctype='[file]',
-                scope=Scope.GLOBAL,
-                shorthelp=f"PDK: {item.upper()} runset files",
-                switch=f"-pdk_{item}_runset 'pdkname tool stackup name <file>'",
-                example=[
-                    f"cli: -pdk_{item}_runset 'asap7 magic M10 basic $PDK/{item}.rs'",
-                    f"api: chip.set('pdk', 'asap7', '{item}', 'runset', 'magic', 'M10', 'basic', "
-                    f"'$PDK/{item}.rs')"],
-                schelp=f"""Runset files for {item.upper()} task.""")
-
-        scparam(cfg, ['pdk', pdkname, item, 'waiver', tool, stackup, name],
-                sctype='[file]',
-                scope=Scope.GLOBAL,
-                shorthelp=f"PDK: {item.upper()} waiver files",
-                switch=f"-pdk_{item}_waiver 'pdkname tool stackup name <file>'",
-                example=[
-                    f"cli: -pdk_{item}_waiver 'asap7 magic M10 basic $PDK/{item}.txt'",
-                    f"api: chip.set('pdk', 'asap7', '{item}', 'waiver', 'magic', 'M10', 'basic', "
-                    f"'$PDK/{item}.txt')"],
-                schelp=f"""Waiver files for {item.upper()} task.""")
-
-    ###############
-    # EDA vars
-    ###############
-
-    key = 'default'
-    scparam(cfg, ['pdk', pdkname, 'file', tool, key, stackup],
-            sctype='[file]',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: custom file",
-            switch="-pdk_file 'pdkname tool key stackup <file>'",
-            example=[
-                "cli: -pdk_file 'asap7 xyce spice M10 asap7.sp'",
-                "api: chip.set('pdk', 'asap7', 'file', 'xyce', 'spice', 'M10', 'asap7.sp')"],
-            schelp="""
-            List of named files specified on a per tool and per stackup basis.
-            The parameter should only be used for specifying files that are
-            not directly supported by the SiliconCompiler PDK schema.""")
-
-    scparam(cfg, ['pdk', pdkname, 'dir', tool, key, stackup],
-            sctype='[dir]',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: custom directory",
-            switch="-pdk_dir 'pdkname tool key stackup <dir>'",
-            example=[
-                "cli: -pdk_dir 'asap7 xyce rfmodel M10 rftechdir'",
-                "api: chip.set('pdk', 'asap7', 'dir', 'xyce', 'rfmodel', 'M10', "
-                "'rftechdir')"],
-            schelp="""
-            List of named directories specified on a per tool and per stackup basis.
-            The parameter should only be used for specifying files that are
-            not directly supported by the SiliconCompiler PDK schema.""")
-
-    scparam(cfg, ['pdk', pdkname, 'var', tool, key, stackup],
-            sctype='[str]',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: custom, variable",
-            switch="-pdk_var 'pdkname tool stackup key <str>'",
-            example=[
-                "cli: -pdk_var 'asap7 xyce modeltype M10 bsim4'",
-                "api: chip.set('pdk', 'asap7', 'var', 'xyce', 'modeltype', 'M10', 'bsim4')"],
-            schelp="""
-            List of key/value strings specified on a per tool and per stackup basis.
-            The parameter should only be used for specifying variables that are
-            not directly supported by the SiliconCompiler PDK schema.""")
-
-    ###############
-    # Docs
-    ###############
-
-    doctype = 'default'
-    scparam(cfg, ['pdk', pdkname, 'doc', doctype],
-            sctype='[file]',
-            scope=Scope.GLOBAL,
-            shorthelp="PDK: documentation",
-            switch="-pdk_doc 'pdkname doctype <file>'",
-            example=["cli: -pdk_doc 'asap7 reference reference.pdf'",
-                     "api: chip.set('pdk', 'asap7', 'doc', 'reference', 'reference.pdf')"],
-            schelp="""Filepath to pdk documentation.""")
-
+def schema_pdk(cfg):
+    from siliconcompiler.pdk import PDKSchema
+    cfg.insert("pdk", "default", PDKSchema())
     return cfg
 
 
 ###############################################################################
 # Datasheet ("specification/contract")
 ###############################################################################
-def schema_datasheet(cfg, partname='default', mode='default'):
+def schema_datasheet(cfg):
 
+    partname = 'default'
+    mode = 'default'
+
+    ds_type = ['digital', 'analog', 'ams', 'passive',
+               'soc', 'fpga',
+               'adc', 'dac',
+               'pmic', 'buck', 'boost', 'ldo',
+               'sram', 'dram', 'flash', 'rom',
+               'interface', 'clock', 'amplifier',
+               'filter', 'mixer', 'modulator', 'lna']
     # Part type
     scparam(cfg, ['datasheet', 'type'],
-            sctype='enum',
-            enum=['digital', 'analog', 'ams', 'passive',
-                  'soc', 'fpga',
-                  'adc', 'dac',
-                  'pmic', 'buck', 'boost', 'ldo',
-                  'sram', 'dram', 'flash', 'rom',
-                  'interface', 'clock', 'amplifier',
-                  'filter', 'mixer', 'modulator', 'lna'],
+            sctype=f'<{",".join(ds_type)}>',
             shorthelp="Datasheet: type",
             switch="-datasheet_type '<str>'",
             example=[
@@ -781,10 +295,7 @@ def schema_datasheet(cfg, partname='default', mode='default'):
 
     # Grade
     scparam(cfg, ['datasheet', 'grade'],
-            sctype='enum',
-            enum=['consumer', 'industrial',
-                  'medical', 'automotive',
-                  'military', 'space'],
+            sctype='<consumer,industrial,menidal,automotive,military,space>',
             shorthelp="Datasheet: manufacturing grade",
             switch="-datasheet_grade '<str>'",
             example=[
@@ -816,9 +327,7 @@ def schema_datasheet(cfg, partname='default', mode='default'):
 
     # Status
     scparam(cfg, ['datasheet', 'status'],
-            sctype='enum',
-            enum=['preview', 'active', 'deprecated',
-                  'last time buy', 'obsolete'],
+            sctype='<preview,active,deprecated,last time buy,obsolete>',
             shorthelp="Datasheet: product status",
             switch="-datasheet_status '<str>'",
             example=[
@@ -896,23 +405,23 @@ def schema_datasheet(cfg, partname='default', mode='default'):
     # IO
     ######################
 
+    io_arch = ['spi', 'uart', 'i2c', 'pwm', 'qspi', 'sdio', 'can', 'jtag',
+               'spdif', 'i2s',
+               'gpio', 'lvds', 'serdes', 'pio',
+               'ddr3', 'ddr4', 'ddr5',
+               'lpddr4', 'lpddr5',
+               'hbm2', 'hbm3', 'hbm4',
+               'onfi', 'sram',
+               'hdmi', 'mipi-csi', 'mipi-dsi', 'slvs',
+               'sata',
+               'usb1', 'usb2', 'usb3',
+               'pcie3', 'pcie4', 'pcie5', 'pcie6',
+               'cxl',
+               'ethernet', 'rmii', 'rgmii', 'sgmii', 'xaui',
+               '10gbase-kr', '25gbase-kr', 'xfi', 'cei28g',
+               'jesd204', 'cpri']
     scparam(cfg, ['datasheet', 'io', partname, 'arch'],
-            sctype='enum',
-            enum=['spi', 'uart', 'i2c', 'pwm', 'qspi', 'sdio', 'can', 'jtag',
-                  'spdif', 'i2s',
-                  'gpio', 'lvds', 'serdes', 'pio',
-                  'ddr3', 'ddr4', 'ddr5',
-                  'lpddr4', 'lpddr5',
-                  'hbm2', 'hbm3', 'hbm4',
-                  'onfi', 'sram',
-                  'hdmi', 'mipi-csi', 'mipi-dsi', 'slvs',
-                  'sata',
-                  'usb1', 'usb2', 'usb3',
-                  'pcie3', 'pcie4', 'pcie5', 'pcie6',
-                  'cxl',
-                  'ethernet', 'rmii', 'rgmii', 'sgmii', 'xaui',
-                  '10gbase-kr', '25gbase-kr', 'xfi', 'cei28g',
-                  'jesd204', 'cpri'],
+            sctype=f'<{",".join(io_arch)}>',
             shorthelp="Datasheet: io standard",
             switch="-datasheet_io_arch 'partname <str>'",
             example=[
@@ -960,11 +469,11 @@ def schema_datasheet(cfg, partname='default', mode='default'):
                 "api: chip.set('datasheet','proc','cpu','features', 'SIMD')"],
             schelp="""List of maker specified processor features specified on a per core basis.""")
 
+    proc_datatypes = ['int4', 'int8', 'int16', 'int32', 'int64', 'int128',
+                      'uint4', 'uint8', 'uint16', 'uint32', 'uint64', 'uint128',
+                      'bfloat16', 'fp16', 'fp32', 'fp64', 'fp128']
     scparam(cfg, ['datasheet', 'proc', partname, 'datatypes'],
-            sctype='[enum]',
-            enum=['int4', 'int8', 'int16', 'int32', 'int64', 'int128',
-                  'uint4', 'uint8', 'uint16', 'uint32', 'uint64', 'uint128',
-                  'bfloat16', 'fp16', 'fp32', 'fp64', 'fp128'],
+            sctype=f'[<{",".join(proc_datatypes)}>]',
             shorthelp="Datasheet: processor datatypes",
             switch="-datasheet_proc_datatypes 'partname <str>'",
             example=[
@@ -1057,7 +566,8 @@ def schema_datasheet(cfg, partname='default', mode='default'):
                 shorthelp=f"Datasheet: memory {v[0]}",
                 switch=f"-datasheet_memory_{i} 'partname <(float,float,float)>'",
                 example=[
-                    f"cli: -datasheet_memory_{i} 'partname {v[1]}'",
+                    f"cli: -datasheet_memory_{i} "
+                    f"'partname ({','.join([str(val) for val in v[1]])})'",
                     f"api: chip.set('datasheet', 'memory', partname, '{i}', {v[1]})"],
                 schelp=f"""Memory {v[1]} specified on a per memory basis.""")
 
@@ -1075,7 +585,8 @@ def schema_datasheet(cfg, partname='default', mode='default'):
                 shorthelp=f"Datasheet: memory {v[0]}",
                 switch=f"-datasheet_memory_{i} 'partname <(int,int,int)>'",
                 example=[
-                    f"cli: -datasheet_memory_{i} 'partname {v[1]}'",
+                    f"cli: -datasheet_memory_{i} "
+                    f"'partname ({','.join([str(val) for val in v[1]])})'",
                     f"api: chip.set('datasheet', 'memory', partname, '{i}', {v[1]})"],
                 schelp=f"""Memory {v[1]} specified on a per memory basis.""")
 
@@ -1130,7 +641,7 @@ def schema_datasheet(cfg, partname='default', mode='default'):
             shorthelp="Datasheet: analog features",
             switch="-datasheet_analog_features 'partname <str>'",
             example=[
-                "cli: -datasheet_analog_features '0 differential input'",
+                "cli: -datasheet_analog_features '0 \"differential input\"'",
                 "api: chip.set('datasheet','analog','adc0','features', 'differential input')"],
             schelp="""List of maker specified analog features.""")
 
@@ -1186,7 +697,7 @@ def schema_datasheet(cfg, partname='default', mode='default'):
                 shorthelp=f"Datasheet: analog {v[0]}",
                 switch=f"-datasheet_analog_{i} 'partname <(float,float,float)>'",
                 example=[
-                    f"cli: -datasheet_analog_{i} 'i0 {v[1]}'",
+                    f"cli: -datasheet_analog_{i} 'i0 ({','.join([str(val) for val in v[1]])})'",
                     f"api: chip.set('datasheet', 'analog', 'abc123', '{i}', {v[1]})"],
                 schelp=f"""Analog {v[1]}.""")
 
@@ -1216,7 +727,7 @@ def schema_datasheet(cfg, partname='default', mode='default'):
                 shorthelp=f"Datasheet: limit {v[0]}",
                 switch=f"-datasheet_limit_{i} '<(float,float)>'",
                 example=[
-                    f"cli: -datasheet_limit_{i} '{v[1]}'",
+                    f"cli: -datasheet_limit_{i} ({','.join([str(val) for val in v[1]])})",
                     f"api: chip.set('datasheet', 'limit', '{i}', {v[1]}"],
                 schelp=f"""Limit {v[0]}. Values are tuples of (min, max).
                 """)
@@ -1248,8 +759,7 @@ def schema_datasheet(cfg, partname='default', mode='default'):
     #########################
 
     scparam(cfg, ['datasheet', 'package', partname, 'type'],
-            sctype='enum',
-            enum=['bga', 'lga', 'csp', 'qfn', 'qfp', 'sop', 'die', 'wafer'],
+            sctype='<bga,lga,csp,qfn,qfp,sop,die,wafer>',
             shorthelp="Datasheet: package type",
             switch="-datasheet_package_type 'partname <str>'",
             example=[
@@ -1309,7 +819,7 @@ def schema_datasheet(cfg, partname='default', mode='default'):
                 shorthelp=f"Datasheet: package {v[0]}",
                 switch=f"-datasheet_package_{i} 'partname <(float,float,float)>'",
                 example=[
-                    f"cli: -datasheet_package_{i} 'abcd {v[1]}'",
+                    f"cli: -datasheet_package_{i} 'abcd ({','.join([str(val) for val in v[1]])})'",
                     f"api: chip.set('datasheet', 'package', 'abcd', '{i}', {v[1]}"],
                 schelp=f"""Package {v[0]}. Values are tuples of
                 (min, nominal, max).""")
@@ -1344,7 +854,7 @@ def schema_datasheet(cfg, partname='default', mode='default'):
             shorthelp="Datasheet: package anchor",
             switch="-datasheet_package_anchor 'partname <(float,float)>'",
             example=[
-                "cli: -datasheet_package_anchor 'i0 (3.0, 3.0)'",
+                "cli: -datasheet_package_anchor 'i0 (3.0,3.0)'",
                 "api: chip.set('datasheet', 'package', 'i0', 'anchor', (3.0, 3.0))"],
             schelp="""
             Package anchor point with respect to the lower left corner of the package.
@@ -1358,8 +868,7 @@ def schema_datasheet(cfg, partname='default', mode='default'):
 
     # Pin type
     scparam(cfg, ['datasheet', 'pin', partname, 'type', mode],
-            sctype='enum',
-            enum=['digital', 'analog', 'clock', 'supply', 'ground'],
+            sctype='<digital,analog,clock,supply,ground>',
             shorthelp="Datasheet: pin type",
             switch="-datasheet_pin_type 'partname mode <str>'",
             example=[
@@ -1369,8 +878,7 @@ def schema_datasheet(cfg, partname='default', mode='default'):
 
     # Pin direction
     scparam(cfg, ['datasheet', 'pin', partname, 'dir', mode],
-            sctype='enum',
-            enum=['input', 'output', 'inout'],
+            sctype='<input,output,inout>',
             shorthelp="Datasheet: pin direction",
             switch="-datasheet_pin_dir 'partname mode <str>'",
             example=[
@@ -1411,8 +919,7 @@ def schema_datasheet(cfg, partname='default', mode='default'):
 
     # Pin reset value
     scparam(cfg, ['datasheet', 'pin', partname, 'resetvalue', mode],
-            sctype='enum',
-            enum=['weak1', 'weak0', 'strong0', 'strong1', 'highz'],
+            sctype='<weak1,weak0,strong0,strong1,highz>',
             shorthelp="Datasheet: pin reset value",
             switch="-datasheet_pin_resetvalue 'partname mode <str>'",
             example=[
@@ -1471,7 +978,8 @@ def schema_datasheet(cfg, partname='default', mode='default'):
                 shorthelp=f"Datasheet: pin {val[0]}",
                 switch=f"-datasheet_pin_{item} 'pin mode <(float,float,float)>'",
                 example=[
-                    f"cli: -datasheet_pin_{item} 'sclk global {val[1]}'",
+                    f"cli: -datasheet_pin_{item} 'sclk global "
+                    f"({','.join([str(v) for v in val[1]])})'",
                     f"api: chip.set('datasheet', 'pin', 'sclk', '{item}', "
                     f"'global', {val[1]}"],
                 schelp=f"""Pin {val[0]}. Values are tuples of (min, typical, max).""")
@@ -1494,7 +1002,8 @@ def schema_datasheet(cfg, partname='default', mode='default'):
                 shorthelp=f"Datasheet: pin {v[0]}",
                 switch=f"-datasheet_pin_{i} 'pin mode relpin <(float,float,float)>'",
                 example=[
-                    f"cli: -datasheet_pin_{i} 'a glob clock {v[1]}'",
+                    f"cli: -datasheet_pin_{i} "
+                    f"'a glob clock ({','.join([str(val) for val in v[1]])})'",
                     f"api: chip.set('datasheet', 'pin', 'a', '{i}', 'glob', 'ck', {v[1]}"],
                 schelp=f"""Pin {v[0]} specified on a per pin, mode, and relpin basis.
                 Values are tuples of (min, typical, max).""")
@@ -1505,526 +1014,18 @@ def schema_datasheet(cfg, partname='default', mode='default'):
 ###############################################################################
 # Flow Configuration
 ###############################################################################
-def schema_flowgraph(cfg, flow='default', step='default', index='default'):
-
-    # flowgraph input
-    scparam(cfg, ['flowgraph', flow, step, index, 'input'],
-            sctype='[(str,str)]',
-            shorthelp="Flowgraph: step input",
-            switch="-flowgraph_input 'flow step index <(str,str)>'",
-            example=[
-                "cli: -flowgraph_input 'asicflow cts 0 (place,0)'",
-                "api: chip.set('flowgraph', 'asicflow', 'cts', '0', 'input', ('place', '0'))"],
-            schelp="""A list of inputs for the current step and index, specified as a
-            (step, index) tuple.""")
-
-    # flowgraph metric weights
-    metric = 'default'
-    scparam(cfg, ['flowgraph', flow, step, index, 'weight', metric],
-            sctype='float',
-            shorthelp="Flowgraph: metric weights",
-            switch="-flowgraph_weight 'flow step index metric <float>'",
-            example=[
-                "cli: -flowgraph_weight 'asicflow cts 0 area_cells 1.0'",
-                "api: chip.set('flowgraph', 'asicflow', 'cts', '0', 'weight', 'area_cells', 1.0)"],
-            schelp="""Weights specified on a per step and per metric basis used to give
-            effective "goodness" score for a step by calculating the sum all step
-            real metrics results by the corresponding per step weights.""")
-
-    scparam(cfg, ['flowgraph', flow, step, index, 'goal', metric],
-            sctype='float',
-            shorthelp="Flowgraph: metric goals",
-            switch="-flowgraph_goal 'flow step index metric <float>'",
-            example=[
-                "cli: -flowgraph_goal 'asicflow cts 0 area_cells 1.0'",
-                "api: chip.set('flowgraph', 'asicflow', 'cts', '0', 'goal', 'errors', 0)"],
-            schelp="""Goals specified on a per step and per metric basis used to
-            determine whether a certain task can be considered when merging
-            multiple tasks at a minimum or maximum node. A task is considered
-            failing if the absolute value of any of its metrics are larger than
-            the goal for that metric, if set.""")
-
-    # flowgraph tool
-    scparam(cfg, ['flowgraph', flow, step, index, 'tool'],
-            sctype='str',
-            shorthelp="Flowgraph: tool selection",
-            switch="-flowgraph_tool 'flow step index <str>'",
-            example=[
-                "cli: -flowgraph_tool 'asicflow place 0 openroad'",
-                "api: chip.set('flowgraph', 'asicflow', 'place', '0', 'tool', 'openroad')"],
-            schelp="""Name of the tool name used for task execution.""")
-
-    # task (belonging to tool)
-    scparam(cfg, ['flowgraph', flow, step, index, 'task'],
-            sctype='str',
-            shorthelp="Flowgraph: task selection",
-            switch="-flowgraph_task 'flow step index <str>'",
-            example=[
-                "cli: -flowgraph_task 'asicflow myplace 0 place'",
-                "api: chip.set('flowgraph', 'asicflow', 'myplace', '0', 'task', 'place')"],
-            schelp="""Name of the tool associated task used for step execution.""")
-
-    scparam(cfg, ['flowgraph', flow, step, index, 'taskmodule'],
-            sctype='str',
-            shorthelp="Flowgraph: task module",
-            switch="-flowgraph_taskmodule 'flow step index <str>'",
-            example=[
-                "cli: -flowgraph_taskmodule 'asicflow place 0 "
-                "siliconcompiler.tools.openroad.place'",
-                "api: chip.set('flowgraph', 'asicflow', 'place', '0', 'taskmodule', "
-                "'siliconcompiler.tools.openroad.place')"],
-            schelp="""
-            Full python module name of the task module used for task setup and execution.
-            """)
-
-    # flowgraph arguments
-    scparam(cfg, ['flowgraph', flow, step, index, 'args'],
-            sctype='[str]',
-            shorthelp="Flowgraph: setup arguments",
-            switch="-flowgraph_args 'flow step index <str>'",
-            example=[
-                "cli: -flowgraph_args 'asicflow cts 0 0'",
-                "api: chip.add('flowgraph', 'asicflow', 'cts', '0', 'args', '0')"],
-            schelp="""User specified flowgraph string arguments specified on a per
-            step and per index basis.""")
-
+def schema_flowgraph(cfg):
+    from siliconcompiler.flowgraph import FlowgraphSchema
+    cfg.insert("flowgraph", "default", FlowgraphSchema())
     return cfg
 
 
 ###########################################################################
 # Tool Setup
 ###########################################################################
-
-def schema_tool(cfg, tool='default'):
-
-    version = 'default'
-
-    scparam(cfg, ['tool', tool, 'exe'],
-            sctype='str',
-            shorthelp="Tool: executable name",
-            switch="-tool_exe 'tool <str>'",
-            example=["cli: -tool_exe 'openroad openroad'",
-                     "api: chip.set('tool', 'openroad', 'exe', 'openroad')"],
-            schelp="""Tool executable name.""")
-
-    scparam(cfg, ['tool', tool, 'sbom', version],
-            sctype='[file]',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Tool: software BOM",
-            switch="-tool_sbom 'tool version <file>'",
-            example=[
-                "cli: -tool_sbom 'yosys 1.0.1 ys_sbom.json'",
-                "api: chip.set('tool', 'yosys', 'sbom', '1.0', 'ys_sbom.json')"],
-            schelp="""
-            Paths to software bill of material (SBOM) document file of the tool
-            specified on a per version basis. The SBOM includes critical
-            package information about the tool including the list of included
-            components, licenses, and copyright. The SBOM file is generally
-            provided as in a a standardized open data format such as SPDX.""")
-
-    scparam(cfg, ['tool', tool, 'path'],
-            sctype='dir',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Tool: executable path",
-            switch="-tool_path 'tool <dir>'",
-            example=[
-                "cli: -tool_path 'openroad /usr/local/bin'",
-                "api: chip.set('tool', 'openroad', 'path', '/usr/local/bin')"],
-            schelp="""
-            File system path to tool executable. The path is prepended to the
-            system PATH environment variable for batch and interactive runs. The
-            path parameter can be left blank if the :keypath:`tool,<tool>,exe` is already in the
-            environment search path.""")
-
-    scparam(cfg, ['tool', tool, 'vswitch'],
-            sctype='[str]',
-            shorthelp="Tool: executable version switch",
-            switch="-tool_vswitch 'tool <str>'",
-            example=["cli: -tool_vswitch 'openroad -version'",
-                     "api: chip.set('tool', 'openroad', 'vswitch', '-version')"],
-            schelp="""
-            Command line switch to use with executable used to print out
-            the version number. Common switches include ``-v``, ``-version``,
-            ``--version``. Some tools may require extra flags to run in batch mode.""")
-
-    scparam(cfg, ['tool', tool, 'vendor'],
-            sctype='str',
-            shorthelp="Tool: vendor",
-            switch="-tool_vendor 'tool <str>'",
-            example=["cli: -tool_vendor 'yosys yosys'",
-                     "api: chip.set('tool', 'yosys', 'vendor', 'yosys')"],
-            schelp="""
-            Name of the tool vendor. Parameter can be used to set vendor
-            specific technology variables in the PDK and libraries. For
-            open source projects, the project name should be used in
-            place of vendor.""")
-
-    scparam(cfg, ['tool', tool, 'version'],
-            sctype='[str]',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Tool: version",
-            switch="-tool_version 'tool <str>'",
-            example=["cli: -tool_version 'openroad >=v2.0'",
-                     "api: chip.set('tool', 'openroad', 'version', '>=v2.0')"],
-            schelp="""
-            List of acceptable versions of the tool executable to be used. Each
-            entry in this list must be a version specifier as described by Python
-            `PEP-440 <https://peps.python.org/pep-0440/#version-specifiers>`_.
-            During task execution, the tool is called with the 'vswitch' to
-            check the runtime executable version. If the version of the system
-            executable is not allowed by any of the specifiers in 'version',
-            then the job is halted pre-execution. For backwards compatibility,
-            entries that do not conform to the standard will be interpreted as a
-            version with an '==' specifier. This check can be disabled by
-            setting :keypath:`option,novercheck` to True.""")
-
-    scparam(cfg, ['tool', tool, 'format'],
-            sctype='enum',
-            enum=["json", "tcl", "yaml"],
-            shorthelp="Tool: file format",
-            switch="-tool_format 'tool <str>'",
-            example=["cli: -tool_format 'yosys tcl'",
-                     "api: chip.set('tool', 'yosys', 'format', 'tcl')"],
-            schelp="""
-            File format for tool manifest handoff.""")
-
-    key = 'default'
-    scparam(cfg, ['tool', tool, 'licenseserver', key],
-            sctype='[str]',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Tool: license servers",
-            switch="-tool_licenseserver 'name key <str>'",
-            example=[
-                "cli: -tool_licenseserver 'atask ACME_LICENSE 1700@server'",
-                "api: chip.set('tool', 'acme', 'licenseserver', 'ACME_LICENSE', '1700@server')"],
-            schelp="""
-            Defines a set of tool specific environment variables used by the executable
-            that depend on license key servers to control access. For multiple servers,
-            separate each server by a 'colon'. The named license variable are read at
-            runtime (:meth:`.run()`) and the environment variables are set.
-            """)
-
-    return cfg
-
-
-def schema_task(cfg, tool='default', task='default', step='default', index='default'):
-
-    key = 'default'
-    suffix = 'default'
-
-    scparam(cfg, ['tool', tool, 'task', task, 'warningoff'],
-            sctype='[str]',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: warning filter",
-            switch="-tool_task_warningoff 'tool task <str>'",
-            example=[
-                "cli: -tool_task_warningoff 'verilator lint COMBDLY'",
-                "api: chip.set('tool', 'verilator', 'task', 'lint', 'warningoff', 'COMBDLY')"],
-            schelp="""
-            A list of tool warnings for which printing should be suppressed.
-            Generally this is done on a per design basis after review has
-            determined that warning can be safely ignored The code for turning
-            off warnings can be found in the specific task reference manual.
-            """)
-
-    scparam(cfg, ['tool', tool, 'task', task, 'regex', suffix],
-            sctype='[str]',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: regex filter",
-            switch="-tool_task_regex 'tool task suffix <str>'",
-            example=[
-                "cli: -tool_task_regex 'openroad place errors \"-v ERROR\"'",
-                "api: chip.set('tool', 'openroad', 'task', 'place', 'regex', 'errors', "
-                "'-v ERROR')"],
-            schelp="""
-            A list of piped together grep commands. Each entry represents a set
-            of command line arguments for grep including the regex pattern to
-            match. Starting with the first list entry, each grep output is piped
-            into the following grep command in the list. Supported grep options
-            include ``-v`` and ``-e``. Patterns starting with "-" should be
-            directly preceded by the ``-e`` option. The following example
-            illustrates the concept.
-
-            UNIX grep:
-
-            .. code-block:: bash
-
-                $ grep WARNING place.log | grep -v "bbox" > place.warnings
-
-            SiliconCompiler::
-
-                chip.set('task', 'openroad', 'regex', 'place', '0', 'warnings',
-                         ["WARNING", "-v bbox"])
-
-            The "errors" and "warnings" suffixes are special cases. When set,
-            the number of matches found for these regexes will be added to the
-            errors and warnings metrics for the task, respectively. This will
-            also cause the logfile to be added to the :keypath:`tool, <tool>,
-            task, <task>, report` parameter for those metrics, if not already present.""")
-
-    # Configuration: cli-option, tcl var, env var, file
-    scparam(cfg, ['tool', tool, 'task', task, 'option'],
-            sctype='[str]',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: executable options",
-            switch="-tool_task_option 'tool task <str>'",
-            example=[
-                "cli: -tool_task_option 'openroad cts -no_init'",
-                "api: chip.set('tool', 'openroad', 'task', 'cts', 'option', '-no_init')"],
-            schelp="""
-            List of command line options for the task executable, specified on
-            a per task and per step basis. Options must not include spaces.
-            For multiple argument options, each option is a separate list element.
-            """)
-
-    scparam(cfg, ['tool', tool, 'task', task, 'var', key],
-            sctype='[str]',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: script variables",
-            switch="-tool_task_var 'tool task key <str>'",
-            example=[
-                "cli: -tool_task_var 'openroad cts myvar 42'",
-                "api: chip.set('tool', 'openroad', 'task', 'cts', 'var', 'myvar', '42')"],
-            schelp="""
-            Task script variables specified as key value pairs. Variable
-            names and value types must match the name and type of task and reference
-            script consuming the variable.""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'env', key],
-            sctype='str',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: environment variables",
-            switch="-tool_task_env 'tool task env <str>'",
-            example=[
-                "cli: -tool_task_env 'openroad cts MYVAR 42'",
-                "api: chip.set('tool', 'openroad', 'task', 'cts', 'env', 'MYVAR', '42')"],
-            schelp="""
-            Environment variables to set for individual tasks. Keys and values
-            should be set in accordance with the task's documentation. Most
-            tasks do not require extra environment variables to function.""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'file', key],
-            sctype='[file]',
-            pernode=PerNode.OPTIONAL,
-            copy=True,
-            shorthelp="Task: custom setup files",
-            switch="-tool_task_file 'tool task key <file>'",
-            example=[
-                "cli: -tool_task_file 'openroad floorplan macroplace macroplace.tcl'",
-                "api: chip.set('tool', 'openroad', 'task', 'floorplan', 'file', 'macroplace', "
-                "'macroplace.tcl')"],
-            schelp="""
-            Paths to user supplied files mapped to keys. Keys and filetypes must
-            match what's expected by the task/reference script consuming the
-            file.
-            """)
-
-    scparam(cfg, ['tool', tool, 'task', task, 'dir', key],
-            sctype='[dir]',
-            pernode=PerNode.OPTIONAL,
-            copy=True,
-            shorthelp="Task: custom setup directories",
-            switch="-tool_task_dir 'tool task key <dir>'",
-            example=[
-                "cli: -tool_task_dir 'verilator compile cincludes include'",
-                "api: chip.set('tool', 'verilator', 'task', 'compile', 'dir', 'cincludes', "
-                "'include')"],
-            schelp="""
-            Paths to user supplied directories mapped to keys. Keys must match
-            what's expected by the task/reference script consuming the
-            directory.
-            """)
-
-    # Definitions of inputs, outputs, requirements
-    scparam(cfg, ['tool', tool, 'task', task, 'input'],
-            sctype='[file]',
-            pernode=PerNode.REQUIRED,
-            shorthelp="Task: input files",
-            switch="-tool_task_input 'tool task <file>'",
-            example=[
-                "cli: -tool_task_input 'openroad place place 0 oh_add.def'",
-                "api: chip.set('tool', 'openroad', 'task', 'place', 'input', 'oh_add.def', "
-                "step='place', index='0')"],
-            schelp="""
-            List of data files to be copied from previous flowgraph steps 'output'
-            directory. The list of steps to copy files from is defined by the
-            list defined by the dictionary key :keypath:`flowgraph,<step>,<index>',input`.
-            All files must be available for flow to continue. If a file
-            is missing, the program exists on an error.""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'output'],
-            sctype='[file]',
-            pernode=PerNode.REQUIRED,
-            shorthelp="Task: output files",
-            switch="-tool_task_output 'tool task <file>'",
-            example=[
-                "cli: -tool_task_output 'openroad place place 0 oh_add.def'",
-                "api: chip.set('tool', 'openroad', 'task', 'place', 'output', 'oh_add.def', "
-                "step='place', index='0')"],
-            schelp="""
-            List of data files written to the 'output' directory of the
-            tool/task/step/index used in the keypath. All files must be available
-            for flow to continue. If a file is missing, the program exists on an error.""")
-
-    dest_enum = ['log', 'output', 'none']
-    scparam(cfg, ['tool', tool, 'task', task, 'stdout', 'destination'],
-            sctype='enum',
-            enum=dest_enum,
-            defvalue='log',
-            scope=Scope.JOB,
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: destination for stdout",
-            switch="-tool_task_stdout_destination 'tool task <str>'",
-            example=["cli: -tool_task_stdout_destination 'ghdl import log'",
-                     "api: chip.set('tool', 'ghdl', 'task', 'import', 'stdout', 'destination', "
-                     "'log')"],
-            schelp="""
-            Defines where to direct the output generated over stdout.
-            Supported options are:
-            none: the stream generated to STDOUT is ignored.
-            log: the generated stream is stored in <step>.<suffix>; if not in quiet mode,
-            it is additionally dumped to the display.
-            output: the generated stream is stored in outputs/<design>.<suffix>.""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'stdout', 'suffix'],
-            sctype='str',
-            defvalue='log',
-            scope=Scope.JOB,
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: file suffix for redirected stdout",
-            switch="-tool_task_stdout_suffix 'tool task <str>'",
-            example=["cli: -tool_task_stdout_suffix 'ghdl import log'",
-                     "api: chip.set('tool', ghdl', 'task', 'import', 'stdout', 'suffix', 'log')"],
-            schelp="""
-            Specifies the file extension for the content redirected from stdout.""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'stderr', 'destination'],
-            sctype='enum',
-            enum=dest_enum,
-            defvalue='log',
-            scope=Scope.JOB,
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: destination for stderr",
-            switch="-tool_task_stderr_destination 'tool task <str>'",
-            example=["cli: -tool_task_stderr_destination 'ghdl import log'",
-                     "api: chip.set('tool', ghdl', 'task', 'import', 'stderr', 'destination', "
-                     "'log')"],
-            schelp="""
-            Defines where to direct the output generated over stderr.
-            Supported options are:
-            none: the stream generated to STDERR is ignored
-            log: the generated stream is stored in <step>.<suffix>; if not in quiet mode,
-            it is additionally dumped to the display.
-            output: the generated stream is stored in outputs/<design>.<suffix>""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'stderr', 'suffix'],
-            sctype='str',
-            defvalue='log',
-            scope=Scope.JOB,
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: file suffix for redirected stderr",
-            switch="-tool_task_stderr_suffix 'tool task <str>'",
-            example=["cli: -tool_task_stderr_suffix 'ghdl import log'",
-                     "api: chip.set('tool', 'ghdl', 'task', 'import', 'stderr', 'suffix', 'log')"],
-            schelp="""
-            Specifies the file extension for the content redirected from stderr.""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'require'],
-            sctype='[str]',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: parameter requirements",
-            switch="-tool_task_require 'tool task <str>'",
-            example=[
-                "cli: -tool_task_require 'openroad cts design'",
-                "api: chip.set('tool', 'openroad', 'task', 'cts', 'require', 'design')"],
-            schelp="""
-            List of keypaths to required task parameters. The list is used
-            by :meth:`.check_manifest()` to verify that all parameters have been set up before
-            step execution begins.""")
-
-    metric = 'default'
-    scparam(cfg, ['tool', tool, 'task', task, 'report', metric],
-            sctype='[file]',
-            pernode=PerNode.REQUIRED,
-            shorthelp="Task: metric report files",
-            switch="-tool_task_report 'tool task metric <file>'",
-            example=[
-                "cli: -tool_task_report 'openroad place holdtns place 0 place.log'",
-                "api: chip.set('tool', 'openroad', 'task', 'place', 'report', 'holdtns', "
-                "'place.log', step='place', index='0')"],
-            schelp="""
-            List of report files associated with a specific 'metric'. The file path
-            specified is relative to the run directory of the current task.""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'refdir'],
-            sctype='[dir]',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: script directory",
-            switch="-tool_task_refdir 'tool task <dir>'",
-            example=[
-                "cli: -tool_task_refdir 'yosys syn ./myref'",
-                "api: chip.set('tool', 'yosys', 'task', 'syn_asic', 'refdir', './myref')"],
-            schelp="""
-            Path to directories containing reference flow scripts, specified
-            on a per step and index basis.""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'script'],
-            sctype='[file]',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: entry script",
-            switch="-tool_task_script 'tool task <file>'",
-            example=[
-                "cli: -tool_task_script 'yosys syn syn.tcl'",
-                "api: chip.set('tool', 'yosys', 'task', 'syn_asic', 'script', 'syn.tcl')"],
-            schelp="""
-            Path to the entry script called by the executable specified
-            on a per task and per step basis.""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'prescript'],
-            sctype='[file]',
-            pernode=PerNode.OPTIONAL,
-            copy=True,
-            shorthelp="Task: pre-step script",
-            switch="-tool_task_prescript 'tool task <file>'",
-            example=[
-                "cli: -tool_task_prescript 'yosys syn syn_pre.tcl'",
-                "api: chip.set('tool', 'yosys', 'task', 'syn_asic', 'prescript', 'syn_pre.tcl')"],
-            schelp="""
-            Path to a user supplied script to execute after reading in the design
-            but before the main execution stage of the step. Exact entry point
-            depends on the step and main script being executed. An example
-            of a prescript entry point would be immediately before global
-            placement.""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'postscript'],
-            sctype='[file]',
-            pernode=PerNode.OPTIONAL,
-            copy=True,
-            shorthelp="Task: post-step script",
-            switch="-tool_task_postscript 'tool task <file>'",
-            example=[
-                "cli: -tool_task_postscript 'yosys syn syn_post.tcl'",
-                "api: chip.set('tool', 'yosys', 'task', 'syn_asic', 'postscript', 'syn_post.tcl')"],
-            schelp="""
-            Path to a user supplied script to execute after the main execution
-            stage of the step but before the design is saved.
-            Exact entry point depends on the step and main script being
-            executed. An example of a postscript entry point would be immediately
-            after global placement.""")
-
-    scparam(cfg, ['tool', tool, 'task', task, 'threads'],
-            sctype='int',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="Task: thread parallelism",
-            switch="-tool_task_threads 'tool task <int>'",
-            example=["cli: -tool_task_threads 'magic drc 64'",
-                     "api: chip.set('tool', 'magic', 'task', 'drc', 'threads', '64')"],
-            schelp="""
-            Thread parallelism to use for execution specified on a per task and per
-            step basis. If not specified, SC queries the operating system and sets
-            the threads based on the maximum thread count supported by the
-            hardware.""")
-
+def schema_tool(cfg):
+    from siliconcompiler.tool import ToolSchemaTmp
+    cfg.insert("tool", "default", ToolSchemaTmp())
     return cfg
 
 
@@ -2067,480 +1068,18 @@ def schema_arg(cfg):
 ###########################################################################
 # Metrics to Track
 ###########################################################################
-def schema_metric(cfg, step='default', index='default'):
-
-    metrics = {'errors': 'errors',
-               'warnings': 'warnings',
-               'drvs': 'design rule violations',
-               'drcs': 'physical design rule violations',
-               'unconstrained': 'unconstrained timing paths'}
-
-    for item, val in metrics.items():
-        scparam(cfg, ['metric', item],
-                sctype='int',
-                shorthelp=f"Metric: total {item}",
-                switch=f"-metric_{item} 'step index <int>'",
-                example=[
-                    f"cli: -metric_{item} 'dfm 0 0'",
-                    f"api: chip.set('metric', '{item}', 0, step='dfm', index=0)"],
-                pernode=PerNode.REQUIRED,
-                schelp=f"""Metric tracking the total number of {val} on a
-                per step and index basis.""")
-
-    scparam(cfg, ['metric', 'coverage'],
-            sctype='float',
-            unit='%',
-            shorthelp="Metric: coverage",
-            switch="-metric_coverage 'step index <float>'",
-            example=[
-                "cli: -metric_coverage 'place 0 99.9'",
-                "api: chip.set('metric', 'coverage', 99.9, step='place', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp="""
-            Metric tracking the test coverage in the design expressed as a percentage
-            with 100 meaning full coverage. The meaning of the metric depends on the
-            task being executed. It can refer to code coverage, feature coverage,
-            stuck at fault coverage.""")
-
-    scparam(cfg, ['metric', 'security'],
-            sctype='float',
-            unit='%',
-            shorthelp="Metric: security",
-            switch="-metric_security 'step index <float>'",
-            example=[
-                "cli: -metric_security 'place 0 100'",
-                "api: chip.set('metric', 'security', 100, step='place', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp="""
-            Metric tracking the level of security (1/vulnerability) of the design.
-            A completely secure design would have a score of 100. There is no
-            absolute scale for the security metrics (like with power, area, etc)
-            so the metric will be task and tool dependent.""")
-
-    metrics = {'luts': 'FPGA LUTs used',
-               'dsps': 'FPGA DSP slices used',
-               'brams': 'FPGA BRAM tiles used'}
-
-    for item, val in metrics.items():
-        scparam(cfg, ['metric', item],
-                sctype='int',
-
-                shorthelp=f"Metric: {val}",
-                switch=f"-metric_{item} 'step index <int>'",
-                example=[
-                    f"cli: -metric_{item} 'place 0 100'",
-                    f"api: chip.set('metric', '{item}', 100, step='place', index=0)"],
-                pernode=PerNode.REQUIRED,
-                schelp=f"""
-                Metric tracking the total {val} used by the design as reported
-                by the implementation tool. There is no standardized definition
-                for this metric across vendors, so metric comparisons can
-                generally only be done between runs on identical tools and
-                device families.""")
-
-    metrics = {'cellarea': 'cell area (ignoring fillers)',
-               'totalarea': 'physical die area',
-               'macroarea': 'macro cell area',
-               'padcellarea': 'io pad cell area',
-               'stdcellarea': 'standard cell area'}
-
-    for item, val in metrics.items():
-        scparam(cfg, ['metric', item],
-                sctype='float',
-                unit='um^2',
-                shorthelp=f"Metric: {item}",
-                switch=f"-metric_{item} 'step index <float>'",
-                example=[
-                    f"cli: -metric_{item} 'place 0 100.00'",
-                    f"api: chip.set('metric', '{item}', 100.00, step='place', index=0)"],
-                pernode=PerNode.REQUIRED,
-                schelp=f"""
-                Metric tracking the total {val} occupied by the design.""")
-
-    scparam(cfg, ['metric', 'utilization'],
-            sctype='float',
-            unit='%',
-            shorthelp="Metric: area utilization",
-            switch="-metric_utilization step index <float>",
-            example=[
-                "cli: -metric_utilization 'place 0 50.00'",
-                "api: chip.set('metric', 'utilization', 50.00, step='place', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp="""
-            Metric tracking the area utilization of the design calculated as
-            100 * (cellarea/totalarea).""")
-
-    scparam(cfg, ['metric', 'logicdepth'],
-            sctype='int',
-            shorthelp="Metric: logic depth",
-            switch="-metric_logicdepth step index <int>",
-            example=[
-                "cli: -metric_logicdepth 'place 0 8'",
-                "api: chip.set('metric', 'logicdepth', 8, step='place', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp="""
-            Metric tracking the logic depth of the design. This is determined
-            by the number of logic gates between the start of the critital timing
-            path to the end of the path.""")
-
-    metrics = {'peakpower': 'worst case total peak power',
-               'averagepower': 'average workload power',
-               'leakagepower': 'leakage power with rails active but without any dynamic '
-                               'switching activity'}
-
-    for item, val in metrics.items():
-        scparam(cfg, ['metric', item],
-                sctype='float',
-                unit='mw',
-                shorthelp=f"Metric: {item}",
-                switch=f"-metric_{item} 'step index <float>'",
-                example=[
-                    f"cli: -metric_{item} 'place 0 0.01'",
-                    f"api: chip.set('metric', '{item}', 0.01, step='place', index=0)"],
-                pernode=PerNode.REQUIRED,
-                schelp=f"""
-                Metric tracking the {val} of the design specified on a per step
-                and index basis. Power metric depend heavily on the method
-                being used for extraction: dynamic vs static, workload
-                specification (vcd vs saif), power models, process/voltage/temperature.
-                The power {item} metric tries to capture the data that would
-                usually be reflected inside a datasheet given the appropriate
-                footnote conditions.""")
-
-    scparam(cfg, ['metric', 'irdrop'],
-            sctype='float',
-            unit='mv',
-            shorthelp="Metric: peak IR drop",
-            switch="-metric_irdrop 'step index <float>'",
-            example=[
-                "cli: -metric_irdrop 'place 0 0.05'",
-                "api: chip.set('metric', 'irdrop', 0.05, step='place', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp="""
-            Metric tracking the peak IR drop in the design based on extracted
-            power and ground rail parasitics, library power models, and
-            switching activity. The switching activity calculated on a per
-            node basis is taken from one of three possible sources, in order
-            of priority: VCD file, SAIF file, 'activityfactor' parameter.""")
-
-    metrics = {'holdpaths': 'hold',
-               'setuppaths': 'setup'}
-
-    for item, val in metrics.items():
-        scparam(cfg, ['metric', item],
-                sctype='int',
-                shorthelp=f"Metric: {item}",
-                switch=f"-metric_{item} 'step index <int>'",
-                example=[
-                    f"cli: -metric_{item} 'place 0 10'",
-                    f"api: chip.set('metric', '{item}', 10, step='place', index=0)"],
-                pernode=PerNode.REQUIRED,
-                schelp=f"""
-                Metric tracking the total number of timing paths violating {val}
-                constraints.""")
-
-    metrics = {'holdslack': 'worst hold slack (positive or negative)',
-               'holdwns': 'worst negative hold slack (positive values truncated to zero)',
-               'holdtns': 'total negative hold slack (TNS)',
-               'holdskew': 'hold clock skew',
-               'setupslack': 'worst setup slack (positive or negative)',
-               'setupwns': 'worst negative setup slack (positive values truncated to zero)',
-               'setuptns': 'total negative setup slack (TNS)',
-               'setupskew': 'setup clock skew'}
-
-    for item, val in metrics.items():
-        scparam(cfg, ['metric', item],
-                sctype='float',
-                unit='ns',
-                shorthelp=f"Metric: {item}",
-                switch=f"-metric_{item} 'step index <float>'",
-                example=[
-                    f"cli: -metric_{item} 'place 0 0.01'",
-                    f"api: chip.set('metric', '{item}', 0.01, step='place', index=0)"],
-                pernode=PerNode.REQUIRED,
-                schelp=f"""
-                Metric tracking the {val} on a per step and index basis.""")
-
-    metrics = {'fmax': 'maximum clock frequency'}
-
-    for item, val in metrics.items():
-        scparam(cfg, ['metric', item],
-                sctype='float',
-                unit='Hz',
-                shorthelp=f"Metric: {item}",
-                switch=f"-metric_{item} 'step index <float>'",
-                example=[
-                    f"cli: -metric_{item} 'place 0 100e6'",
-                    f"api: chip.set('metric', '{item}', 100e6, step='place', index=0)"],
-                pernode=PerNode.REQUIRED,
-                schelp=f"""
-                Metric tracking the {val} on a per step and index basis.""")
-
-    metrics = {'macros': 'macros',
-               'cells': 'cell instances',
-               'registers': 'register instances',
-               'buffers': 'buffer instances',
-               'inverters': 'inverter instances',
-               'transistors': 'transistors',
-               'pins': 'pins',
-               'nets': 'nets',
-               'vias': 'vias'}
-
-    for item, val in metrics.items():
-        scparam(cfg, ['metric', item],
-                sctype='int',
-                shorthelp=f"Metric: {item}",
-                switch=f"-metric_{item} 'step index <int>'",
-                example=[
-                    f"cli: -metric_{item} 'place 0 100'",
-                    f"api: chip.set('metric', '{item}', 50, step='place', index=0)"],
-                pernode=PerNode.REQUIRED,
-                schelp=f"""
-                Metric tracking the total number of {val} in the design
-                on a per step and index basis.""")
-
-    item = 'wirelength'
-    scparam(cfg, ['metric', item],
-            sctype='float',
-            unit='um',
-            shorthelp=f"Metric: {item}",
-            switch=f"-metric_{item} 'step index <float>'",
-            example=[
-                f"cli: -metric_{item} 'place 0 100.0'",
-                f"api: chip.set('metric', '{item}', 50.0, step='place', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp=f"""
-            Metric tracking the total {item} of the design on a per step
-            and index basis.""")
-
-    item = 'overflow'
-    scparam(cfg, ['metric', item],
-            sctype='int',
-            shorthelp=f"Metric: {item}",
-            switch=f"-metric_{item} 'step index <int>'",
-            example=[
-                f"cli: -metric_{item} 'place 0 0'",
-                f"api: chip.set('metric', '{item}', 50, step='place', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp="""
-            Metric tracking the total number of overflow tracks for the routing
-            on per step and index basis. Any non-zero number suggests an over
-            congested design. To analyze where the congestion is occurring
-            inspect the router log files for detailed per metal overflow
-            reporting and open up the design to find routing hotspots.""")
-
-    item = 'memory'
-    scparam(cfg, ['metric', item],
-            sctype='float',
-            unit='B',
-            scope=Scope.JOB,
-            shorthelp=f"Metric: {item}",
-            switch=f"-metric_{item} 'step index <float>'",
-            example=[
-                f"cli: -metric_{item} 'dfm 0 10e9'",
-                f"api: chip.set('metric', '{item}', 10e9, step='dfm', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp="""
-            Metric tracking total peak program memory footprint on a per
-            step and index basis.""")
-
-    item = 'exetime'
-    scparam(cfg, ['metric', item],
-            sctype='float',
-            unit='s',
-            shorthelp=f"Metric: {item}",
-            switch=f"-metric_{item} 'step index <float>'",
-            example=[
-                f"cli: -metric_{item} 'dfm 0 10.0'",
-                f"api: chip.set('metric', '{item}', 10.0, step='dfm', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp="""
-            Metric tracking time spent by the EDA executable :keypath:`tool,<tool>,exe` on a
-            per step and index basis. It does not include the SiliconCompiler
-            runtime overhead or time waiting for I/O operations and
-            inter-processor communication to complete.""")
-
-    item = 'tasktime'
-    scparam(cfg, ['metric', item],
-            sctype='float',
-            unit='s',
-            shorthelp=f"Metric: {item}",
-            switch=f"-metric_{item} 'step index <float>'",
-            example=[
-                f"cli: -metric_{item} 'dfm 0 10.0'",
-                f"api: chip.set('metric', '{item}', 10.0, step='dfm', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp="""
-            Metric tracking the total amount of time spent on a task from
-            beginning to end, including data transfers and pre/post
-            processing.""")
-
-    item = 'totaltime'
-    scparam(cfg, ['metric', item],
-            sctype='float',
-            unit='s',
-            shorthelp=f"Metric: {item}",
-            switch=f"-metric_{item} 'step index <float>'",
-            example=[
-                f"cli: -metric_{item} 'dfm 0 10.0'",
-                f"api: chip.set('metric', '{item}', 10.0, step='dfm', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp="""
-            Metric tracking the total amount of time spent from the beginning
-            of the run up to and including the current step and index.""")
-
+def schema_metric(cfg):
+    from siliconcompiler.metric import MetricSchema
+    cfg.insert("metric", MetricSchema())
     return cfg
 
 
 ###########################################################################
 # Design Tracking
 ###########################################################################
-def schema_record(cfg, step='default', index='default'):
-
-    # setting up local data structure
-    # <key> : ['short help', 'example' 'extended help']
-
-    records = {'userid': ['userid',
-                          'wiley',
-                          ''],
-               'publickey': ['public key',
-                             '<key>',
-                             ''],
-               'machine': ['machine name',
-                           'carbon',
-                           '(myhost, localhost, ...'],
-               'macaddr': ['MAC address',
-                           '<addr>',
-                           ''],
-               'ipaddr': ['IP address',
-                          '<addr>',
-                          ''],
-               'platform': ['platform name',
-                            'linux',
-                            '(linux, windows, freebsd)'],
-               'distro': ['distro name',
-                          'ubuntu',
-                          '(ubuntu, redhat, centos)'],
-               'arch': ['hardware architecture',
-                        'x86_64',
-                        '(x86_64, rv64imafdc)'],
-               'starttime': ['start time',
-                             '2021-09-06 12:20:20',
-                             'Time is reported in the ISO 8601 format YYYY-MM-DD HR:MIN:SEC'],
-               'endtime': ['end time',
-                           '2021-09-06 12:20:20',
-                           'Time is reported in the ISO 8601 format YYYY-MM-DD HR:MIN:SEC'],
-               'region': ['cloud region',
-                          'US Gov Boston',
-                          """Recommended naming methodology:
-
-                          * local: node is the local machine
-                          * onprem: node in on-premises IT infrastructure
-                          * public: generic public cloud
-                          * govcloud: generic US government cloud
-                          * <region>: cloud and entity specific region string name
-                          """],
-               'scversion': ['software version',
-                             '1.0',
-                             """Version number for the SiliconCompiler software."""],
-               'toolversion': ['tool version',
-                               '1.0',
-                               """The tool version captured corresponds to the 'tool'
-                               parameter within the 'tool' dictionary."""],
-               'toolpath': ['tool path',
-                            '/usr/bin/openroad',
-                            """Full path to tool executable used to run this
-                            task."""],
-               'toolargs': ['tool CLI arguments',
-                            '-I include/ foo.v',
-                            'Arguments passed to tool via CLI.'],
-               'pythonversion': ['Python version',
-                                 '3.12.3',
-                                 """Version of python used to run this task."""],
-               'osversion': ['O/S version',
-                             '20.04.1-Ubuntu',
-                             """Since there is not standard version system for operating
-                             systems, extracting information from is platform dependent.
-                             For Linux based operating systems, the 'osversion' is the
-                             version of the distro."""],
-               'kernelversion': ['O/S kernel version',
-                                 '5.11.0-34-generic',
-                                 """Used for platforms that support a distinction
-                                 between os kernels and os distributions."""]}
-
-    for item, val in records.items():
-        helpext = trim(val[2])
-        scparam(cfg, ['record', item],
-                sctype='str',
-                shorthelp=f"Record: {val[0]}",
-                switch=f"-record_{item} 'step index <str>'",
-                example=[
-                    f"cli: -record_{item} 'dfm 0 {val[1]}'",
-                    f"api: chip.set('record', '{item}', '{val[1]}', step='dfm', index=0)"],
-                pernode=PerNode.REQUIRED,
-                schelp=f'Record tracking the {val[0]} per step and index basis. {helpext}')
-
-    scparam(cfg, ['record', 'toolexitcode'],
-            sctype='int',
-            shorthelp="Record: tool exit code",
-            switch="-record_toolexitcode 'step index <int>'",
-            example=[
-                "cli: -record_toolexitcode 'dfm 0 0'",
-                "api: chip.set('record', 'toolexitcode', 0, step='dfm', index=0)"],
-            pernode=PerNode.REQUIRED,
-            schelp='Record tracking the tool exit code per step and index basis.')
-
-    # Non-per-node records.
-    scparam(cfg, ['record', 'remoteid'],
-            sctype='str',
-            shorthelp="Record: remote job ID",
-            switch="-record_remoteid '<str>'",
-            example=[
-                "cli: -record_remoteid '0123456789abcdeffedcba9876543210'",
-                "api: chip.set('record', 'remoteid', '0123456789abcdeffedcba9876543210')"],
-            schelp='Record tracking the job ID for a remote run.')
-
-    scparam(cfg, ['record', 'pythonpackage'],
-            sctype='[str]',
-            shorthelp="Record: python packages",
-            switch="-record_pythonpackage '<str>'",
-            example=[
-                "cli: -record_pythonpackage 'siliconcompiler==0.28.0'",
-                "api: chip.set('record', 'pythonpackage', 'siliconcompiler==0.28.0')"],
-            schelp='Record tracking for the python packages installed.')
-
-    # flowgraph status
-    scparam(cfg, ['record', 'status'],
-            sctype='enum',
-            pernode=PerNode.REQUIRED,
-            enum=[  # keep in sync with NodeStatus
-                "pending",
-                "queued",
-                "running",
-                "success",
-                "error",
-                "skipped",
-                "timeout"],
-            shorthelp="Record: node execution status",
-            switch="-record_status 'step index <str>'",
-            example=[
-                "cli: -record_status 'syn 0 success'",
-                "api: chip.set('record', 'status', 'success', step='syn', index='0')"],
-            schelp="""Record tracking for the status of a node.""")
-
-    # flowgraph select
-    scparam(cfg, ['record', 'inputnode'],
-            sctype='[(str,str)]',
-            pernode=PerNode.REQUIRED,
-            shorthelp="Record: node inputs",
-            switch="-record_inputnode 'step index <(str,str)>'",
-            example=[
-                "cli: -record_inputnode 'cts 0 (place,42)'",
-                "api: chip.set('record', 'inputnode', ('place', '42'), step='syn', index='0')"],
-            schelp="""
-            List of selected inputs for the current step/index specified as
-            (in_step, in_index) tuple.""")
-
+def schema_record(cfg):
+    from siliconcompiler.record import RecordSchema
+    cfg.insert("record", RecordSchema())
     return cfg
 
 
@@ -2743,8 +1282,7 @@ def schema_option(cfg):
             not directly supported by the schema.""")
 
     scparam(cfg, ['option', 'loglevel'],
-            sctype='enum',
-            enum=["info", "warning", "error", "critical", "debug", "quiet"],
+            sctype='<info,warning,error,critical,debug,quiet>',
             pernode=PerNode.OPTIONAL,
             scope=Scope.JOB,
             defvalue='info',
@@ -3077,8 +1615,7 @@ def schema_option(cfg):
 
     # job scheduler
     scparam(cfg, ['option', 'scheduler', 'name'],
-            sctype='enum',
-            enum=["slurm", "lsf", "sge", "docker"],
+            sctype='<slurm,lsf,sge,docker>',
             scope=Scope.JOB,
             pernode=PerNode.OPTIONAL,
             shorthelp="Option: scheduler platform",
@@ -3169,8 +1706,7 @@ def schema_option(cfg):
             For more information, see the job scheduler documentation.""")
 
     scparam(cfg, ['option', 'scheduler', 'msgevent'],
-            sctype='[enum]',
-            enum=['all', 'summary', 'begin', 'end', 'timeout', 'fail'],
+            sctype='[<all,summary,begin,end,timeout,fail>]',
             scope=Scope.JOB,
             pernode=PerNode.OPTIONAL,
             shorthelp="Option: message event trigger",
@@ -3385,123 +1921,8 @@ def schema_package(cfg):
 # Design Checklist
 ############################################
 def schema_checklist(cfg):
-
-    item = 'default'
-    standard = 'default'
-    metric = 'default'
-
-    scparam(cfg, ['checklist', standard, item, 'description'],
-            sctype='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')"],
-            schelp="""
-            A short one line description of the checklist item.""")
-
-    scparam(cfg, ['checklist', standard, item, 'requirement'],
-            sctype='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')"],
-            schelp="""
-            A complete requirement description of the checklist item
-            entered as a multi-line string.""")
-
-    scparam(cfg, ['checklist', standard, item, 'dataformat'],
-            sctype='str',
-            scope=Scope.GLOBAL,
-            shorthelp="Checklist: item data format",
-            switch="-checklist_dataformat 'standard item <str>'",
-            example=[
-                "cli: -checklist_dataformat 'ISO D000 dataformat README'",
-                "api: chip.set('checklist', 'ISO', 'D000', 'dataformat', 'README')"],
-            schelp="""
-            Free text description of the type of data files acceptable as
-            checklist signoff validation.""")
-
-    scparam(cfg, ['checklist', standard, item, 'rationale'],
-            sctype='[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')"],
-            schelp="""
-            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.""")
-
-    scparam(cfg, ['checklist', standard, item, 'criteria'],
-            sctype='[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')"],
-            schelp="""
-            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'.""")
-
-    scparam(cfg, ['checklist', standard, item, 'task'],
-            sctype='[(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'))"],
-            schelp="""
-            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.""")
-
-    scparam(cfg, ['checklist', standard, item, 'report'],
-            sctype='[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')"],
-            schelp="""
-            Filepath to report(s) of specified type documenting the successful
-            validation of the checklist item.""")
-
-    scparam(cfg, ['checklist', standard, item, 'waiver', metric],
-            sctype='[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')"],
-            schelp="""
-            Filepath to report(s) documenting waivers for the checklist
-            item specified on a per metric basis.""")
-
-    scparam(cfg, ['checklist', standard, item, 'ok'],
-            sctype='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)"],
-            schelp="""
-            Boolean check mark for the checklist item. A value of
-            True indicates a human has inspected the all item dictionary
-            parameters check out.""")
-
+    from siliconcompiler.checklist import ChecklistSchema
+    cfg.insert("checklist", "default", ChecklistSchema())
     return cfg
 
 
@@ -3509,99 +1930,8 @@ def schema_checklist(cfg):
 # ASIC Setup
 ###########################
 def schema_asic(cfg):
-    '''ASIC Automated Place and Route Parameters'''
-
-    scparam(cfg, ['asic', 'logiclib'],
-            sctype='[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')"],
-            schelp="""List of all selected logic libraries libraries
-            to use for optimization for a given library architecture
-            (9T, 11T, etc).""")
-
-    scparam(cfg, ['asic', 'macrolib'],
-            sctype='[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')"],
-            schelp="""
-            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.""")
-
-    scparam(cfg, ['asic', 'delaymodel'],
-            sctype='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')"],
-            schelp="""
-            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:
-        scparam(cfg, ['asic', 'cells', item],
-                sctype='[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*')"],
-                schelp="""
-                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.""")
-
-    scparam(cfg, ['asic', 'libarch'],
-            sctype='str',
-            pernode=PerNode.OPTIONAL,
-            shorthelp="ASIC: library architecture",
-            switch="-asic_libarch '<str>'",
-            example=[
-                "cli: -asic_libarch '12track'",
-                "api: chip.set('asic', 'libarch', '12track')"],
-            schelp="""
-            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'
-    scparam(cfg, ['asic', 'site', libarch],
-            sctype='[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')"],
-            schelp="""
-            Site names for a given library architecture.""")
-
+    from siliconcompiler.asic import ASICSchema
+    cfg.insert("asic", ASICSchema())
     return cfg
 
 
@@ -3759,16 +2089,16 @@ def schema_constraint(cfg):
             Placement keepout halo around the named component, specified as a
             (horizontal, vertical) tuple.""")
 
+    rotations = ['R0', 'R90', 'R180', 'R270',
+                 'MX', 'MX_R90', 'MX_R180', 'MX_R270',
+                 'MY', 'MY_R90', 'MY_R180', 'MY_R270',
+                 'MZ', 'MZ_R90', 'MZ_R180', 'MZ_R270',
+                 'MZ_MX', 'MZ_MX_R90', 'MZ_MX_R180', 'MZ_MX_R270',
+                 'MZ_MY', 'MZ_MY_R90', 'MZ_MY_R180', 'MZ_MY_R270']
     scparam(cfg, ['constraint', 'component', inst, 'rotation'],
-            sctype='enum',
+            sctype=f'<{",".join(rotations)}>',
             pernode=PerNode.OPTIONAL,
             defvalue='R0',
-            enum=['R0', 'R90', 'R180', 'R270',
-                  'MX', 'MX_R90', 'MX_R180', 'MX_R270',
-                  'MY', 'MY_R90', 'MY_R180', 'MY_R270',
-                  'MZ', 'MZ_R90', 'MZ_R180', 'MZ_R270',
-                  'MZ_MX', 'MZ_MX_R90', 'MZ_MX_R180', 'MZ_MX_R270',
-                  'MZ_MY', 'MZ_MY_R90', 'MZ_MY_R180', 'MZ_MY_R270'],
             shorthelp="Constraint: component rotation",
             switch="-constraint_component_rotation 'inst <str>'",
             example=[
@@ -3816,8 +2146,7 @@ def schema_constraint(cfg):
             substrates, interposers).""")
 
     scparam(cfg, ['constraint', 'component', inst, 'side'],
-            sctype='enum',
-            enum=['left', 'right', 'front', 'back', 'top', 'bottom'],
+            sctype='<left,right,front,back,top,bottom>',
             pernode=PerNode.OPTIONAL,
             shorthelp="Constraint: component side",
             switch="-constraint_component_side 'inst <str>'",
@@ -3899,9 +2228,7 @@ def schema_constraint(cfg):
             guidelines.""")
 
     scparam(cfg, ['constraint', 'pin', name, 'shape'],
-            sctype='enum',
-            enum=['circle', 'rectangle', 'square',
-                  'hexagon', 'octagon', 'oval', 'pill', 'polygon'],
+            sctype='<circle,rectangle,square,hexagon,octagon,oval,pill,polygon>',
             pernode=PerNode.OPTIONAL,
             shorthelp="Constraint: pin shape",
             switch="-constraint_pin_shape 'name <str>'",
@@ -4139,7 +2466,7 @@ def schema_constraint(cfg):
     scparam(cfg, ['constraint', 'aspectratio'],
             sctype='float',
             pernode=PerNode.OPTIONAL,
-            defvalue='1.0',
+            defvalue=1.0,
             scope=Scope.JOB,
             shorthelp="Constraint: layout aspect ratio",
             switch="-constraint_aspectratio <float>",
@@ -4153,10 +2480,3 @@ def schema_constraint(cfg):
             is supplied.""")
 
     return cfg
-
-
-##############################################################################
-# Main routine
-if __name__ == "__main__":
-    cfg = schema_cfg()
-    print(json.dumps(cfg, indent=4, sort_keys=True))