siliconcompiler 0.26.5__py3-none-any.whl

siliconcompiler/apps/sc_remote.py

@@ -0,0 +1,199 @@
+# Copyright 2023 Silicon Compiler Authors. All Rights Reserved.
+import copy
+import os
+import sys
+
+from siliconcompiler import Chip
+from siliconcompiler import SiliconCompilerError
+from siliconcompiler.remote.client import cancel_job, check_progress, delete_job, \
+    remote_ping, remote_run_loop, _remote_ping
+from siliconcompiler.remote.client import configure_server, configure_whitelist, configure_print
+from siliconcompiler.scheduler import _finalize_run
+from siliconcompiler.flowgraph import _get_flowgraph_entry_nodes, _get_flowgraph_node_outputs, \
+    nodes_to_execute
+
+
+def main():
+    progname = "sc-remote"
+    description = """
+-----------------------------------------------------------
+SC app that provides an entry point to common remote / server
+interactions.
+
+To generate a configuration file, use:
+    sc-remote -configure
+
+    or to specify a specific server and/or port:
+    sc-remote -configure -server https://example.com
+    sc-remote -configure -server https://example.com:1234
+
+    to add or remove directories from upload whitelist, these
+        also support globbing:
+    sc-remote -configure -add ./fine_to_upload
+    sc-remote -configure -remove ./no_longer_okay_to_upload
+
+    to display the full configuration of the credentials file
+    sc-remote -configure -list
+
+To check an ongoing job's progress, use:
+    sc-remote -cfg <stepdir>/outputs/<design>.pkg.json
+
+To cancel an ongoing job, use:
+    sc-remote -cancel -cfg <stepdir>/outputs/<design>.pkg.json
+
+To reconnect an ongoing job, use:
+    sc-remote -reconnect -cfg <stepdir>/outputs/<design>.pkg.json
+
+To delete a job, use:
+    sc-remote -delete -cfg <stepdir>/outputs/<design>.pkg.json
+-----------------------------------------------------------
+"""
+
+    # Argument Parser
+    progname = 'sc-remote'
+    chip = Chip(progname)
+    switchlist = ['-cfg', '-credentials']
+    extra_args = {
+        '-configure': {'action': 'store_true',
+                       'help': 'create configuration file for the remote',
+                       'sc_print': False},
+        '-server': {'help': 'address of server for configure (only valid with -configure)',
+                    'metavar': '<server>',
+                    'sc_print': False},
+        '-add': {'help': 'path to add to the upload whitelist (only valid with -configure)',
+                 'metavar': '<path>',
+                 'nargs': '+',
+                 'sc_print': False},
+        '-remove': {'help': 'path to remove from the upload whitelist (only valid with -configure)',
+                    'metavar': '<path>',
+                    'nargs': '+',
+                    'sc_print': False},
+        '-list': {'help': 'print the current configuration (only valid with -configure)',
+                  'action': 'store_true',
+                  'sc_print': False},
+        '-reconnect': {'action': 'store_true',
+                       'help': 'reconnect to a running job on the remote',
+                       'sc_print': False},
+        '-cancel': {'action': 'store_true',
+                    'help': 'cancel a running job on the remote',
+                    'sc_print': False},
+        '-delete': {'action': 'store_true',
+                    'help': 'delete a job on the remote',
+                    'sc_print': False},
+    }
+
+    try:
+        args = chip.create_cmdline(progname,
+                                   switchlist=switchlist,
+                                   additional_args=extra_args,
+                                   description=description)
+    except Exception as e:
+        chip.logger.error(e)
+        return 1
+
+    # Sanity checks.
+    exclusive = ['configure', 'reconnect', 'cancel', 'delete']
+    cfg_only = ['reconnect', 'cancel', 'delete']
+
+    exclusive_count = sum([1 for arg in exclusive if args[arg]])
+    if exclusive_count > 1:
+        chip.logger.error(f'Error: {", ".join(["-"+e for e in exclusive])} are mutually exclusive')
+        return 1
+    chip_cfg = chip.get('option', 'cfg')
+    if chip_cfg and not any([args[arg] for arg in cfg_only]):
+        chip.logger.error(f'Error: -cfg is required for {", ".join(["-"+e for e in cfg_only])}')
+    if any([args[arg] for arg in cfg_only]) and args['server']:
+        chip.logger.error('Error: -server cannot be specified with '
+                          f'{", ".join(["-"+e for e in cfg_only])}')
+
+    if args['configure']:
+        if args['list']:
+            configure_print(chip)
+            return 0
+
+        if not args['add'] and not args['remove']:
+            try:
+                configure_server(chip, server=args['server'])
+            except ValueError as e:
+                chip.logger.error(e)
+                return 1
+        else:
+            try:
+                configure_whitelist(chip, add=args['add'], remove=args['remove'])
+            except ValueError as e:
+                chip.logger.error(e)
+                return 1
+
+        return 0
+
+    # Main logic.
+    # If no job-related options are specified, fetch and report basic info.
+    # Create temporary Chip object and check on the server.
+    try:
+        remote_ping(chip)
+    except SiliconCompilerError as e:
+        chip.logger.error(f'{e}')
+        return 1
+
+    # If the -cancel flag is specified, cancel the job.
+    if args['cancel']:
+        try:
+            cancel_job(chip)
+        except SiliconCompilerError as e:
+            chip.logger.error(f'{e}')
+            return 1
+
+    # If the -delete flag is specified, delete the job.
+    elif args['delete']:
+        try:
+            delete_job(chip)
+        except SiliconCompilerError as e:
+            chip.logger.error(f'{e}')
+            return 1
+
+    # If the -reconnect flag is specified, re-enter the client flow
+    # in its "check_progress/ until job is done" loop.
+    elif args['reconnect']:
+        # Start from successors of entry nodes, so entry nodes are not fetched from remote.
+        environment = copy.deepcopy(os.environ)
+        flow = chip.get('option', 'flow')
+        entry_nodes = _get_flowgraph_entry_nodes(chip, flow)
+        for entry_node in entry_nodes:
+            outputs = _get_flowgraph_node_outputs(chip, flow, entry_node)
+            chip.set('option', 'from', list(map(lambda node: node[0], outputs)))
+        # Enter the remote run loop.
+        chip._init_logger(step='remote', index='0', in_run=True)
+        try:
+            rsp = _remote_ping(chip)
+            remote_run_loop(chip, rsp['progress_interval'])
+        except SiliconCompilerError as e:
+            chip.logger.error(f'{e}')
+            return 1
+
+        # Wrap up run
+        for step, index in nodes_to_execute(chip):
+            manifest = os.path.join(chip.getworkdir(step=step, index=index),
+                                    'outputs',
+                                    f'{chip.design}.pkg.json')
+            if os.path.exists(manifest):
+                chip.schema.read_journal(manifest)
+        _finalize_run(chip, environment)
+
+        # Summarize the run.
+        chip.summary()
+
+    # If only a manifest is specified, make a 'check_progress/' request and report results:
+    elif chip_cfg:
+        try:
+            check_progress(chip)
+        except SiliconCompilerError as e:
+            chip.logger.error(f'{e}')
+            return 1
+
+    # Done
+    return 0
+
+
+#########################
+if __name__ == "__main__":
+    sys.exit(main())

siliconcompiler/apps/sc_server.py

@@ -0,0 +1,39 @@
+# Copyright 2020 Silicon Compiler Authors. All Rights Reserved.
+
+import sys
+
+from siliconcompiler.remote.server import Server
+
+
+###############################################
+# Main method to run the sc-server application.
+###############################################
+def main():
+    progname = "sc-server"
+    description = """
+-----------------------------------------------------------
+Silicon Compiler Collection Remote Job Server (sc-server)
+-----------------------------------------------------------
+"""
+
+    server = Server()
+
+    try:
+        server.create_cmdline(
+            progname,
+            description=description)
+    except ValueError as e:
+        server.logger.error(f'{e}')
+        return 1
+
+    try:
+        server.run()
+    except Exception as e:
+        server.logger.error(f'{e}')
+        return 1
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

siliconcompiler/apps/sc_show.py

@@ -0,0 +1,142 @@
+# Copyright 2020 Silicon Compiler Authors. All Rights Reserved.
+import sys
+import os
+import siliconcompiler
+from siliconcompiler.utils import get_default_iomap
+from siliconcompiler.apps._common import load_manifest, manifest_switches
+from siliconcompiler.utils import get_file_ext
+
+
+def main():
+    progname = "sc-show"
+    description = """
+    --------------------------------------------------------------
+    Restricted SC app that displays the layout of a design
+    based on a file provided or tries to display the final
+    layout based on loading the json manifest from:
+    build/<design>/job0/<design>.pkg.json
+
+    Examples:
+
+    sc-show -design adder
+    (displays build/adder/job0/write_gds/0/outputs/adder.gds)
+
+    sc-show -design adder -arg_step floorplan
+    (displays build/adder/job0/floorplan/0/outputs/adder.def)
+
+    sc-show -design adder -arg_step place -arg_index 1
+    (displays build/adder/job0/place/1/outputs/adder.def)
+
+    sc-show -design adder -jobname rtl2gds
+    (displays build/adder/rtl2gds/write_gds/0/outputs/adder.gds)
+
+    sc-show -cfg build/adder/rtl2gds/adder.pkg.json
+    (displays build/adder/rtl2gds/write_gds/0/outputs/adder.gds)
+
+    sc-show -design adder -ext odb
+    (displays build/adder/job0/write_data/0/outputs/adder.odb)
+
+    sc-show build/adder/job0/route/1/outputs/adder.def
+    (displays build/adder/job0/route/1/outputs/adder.def)
+    """
+
+    # TODO: this is a hack to get around design name requirement: since legal
+    # design names probably can't contain spaces, we can detect if it is unset.
+    UNSET_DESIGN = '  unset  '
+
+    # Create a base chip class.
+    chip = siliconcompiler.Chip(UNSET_DESIGN)
+
+    # Fill input map with default mapping only for showable files
+    input_map = {}
+    default_input_map = get_default_iomap()
+    for ext in chip._showtools:
+        if ext in default_input_map:
+            input_map[ext] = default_input_map[ext]
+
+    extension_arg = {
+        'metavar': '<ext>',
+        'help': '(optional) Specify the extension of the file to show.',
+        'sc_print': False
+    }
+    screenshot_arg = {
+        'action': 'store_true',
+        'help': '(optional) Will generate a screenshot and exit.',
+        'sc_print': False
+    }
+
+    try:
+        args = chip.create_cmdline(
+            progname,
+            switchlist=[*manifest_switches(),
+                        '-input',
+                        '-loglevel'],
+            description=description,
+            input_map=input_map,
+            additional_args={
+                '-ext': extension_arg,
+                '-screenshot': screenshot_arg
+            })
+    except Exception as e:
+        chip.logger.error(e)
+        return 1
+
+    # Error checking
+    design = chip.get('design')
+    design_set = design != UNSET_DESIGN
+
+    # Search input keys for files
+    input_mode = []
+    for fileset in chip.getkeys('input'):
+        for mode in chip.getkeys('input', fileset):
+            if chip.schema._getvals('input', fileset, mode):
+                input_mode = [('input', fileset, mode)]
+
+    if not (design_set or input_mode):
+        chip.logger.error('Nothing to load: please define a target with '
+                          '-cfg, -design, and/or inputs.')
+        return 1
+
+    filename = None
+    if input_mode:
+        check_ext = list(chip._showtools.keys())
+
+        if args['ext']:
+            check_ext = [args['ext']]
+
+        def get_file_from_keys():
+            for ext in check_ext:
+                for key in input_mode:
+                    for files, _, _ in chip.schema._getvals(*key):
+                        for file in files:
+                            if get_file_ext(file) == ext:
+                                return file
+            return None
+
+        filename = get_file_from_keys()
+
+    if not load_manifest(chip, filename):
+        return 1
+
+    # Read in file
+    if filename:
+        chip.logger.info(f"Displaying {filename}")
+
+    if not chip.find_files('option', 'builddir', missing_ok=True):
+        chip.logger.warning("Unable to access original build directory "
+                            f"\"{chip.get('option', 'builddir')}\", using \"build\" instead")
+        chip.set('option', 'builddir', 'build')
+
+    success = chip.show(filename,
+                        extension=args['ext'],
+                        screenshot=args['screenshot'])
+
+    if args['screenshot'] and os.path.isfile(success):
+        chip.logger.info(f'Screenshot file: {success}')
+
+    return 0 if success else 1
+
+
+#########################
+if __name__ == "__main__":
+    sys.exit(main())

siliconcompiler/apps/smake.py

@@ -0,0 +1,232 @@
+# Copyright 2023 Silicon Compiler Authors. All Rights Reserved.
+import argparse
+import sys
+import os
+import importlib
+from inspect import getmembers, isfunction, getfullargspec
+from siliconcompiler._metadata import version
+from siliconcompiler.schema import utils
+
+
+__default_source_file = "make.py"
+
+
+def __process_file(path):
+    if not os.path.exists(path):
+        return {}, None, None
+    mod_name = 'scmake'
+    spec = importlib.util.spec_from_file_location(mod_name, path)
+    make = importlib.util.module_from_spec(spec)
+    sys.modules[mod_name] = make
+    syspath = sys.path.copy()
+    sys.path.insert(0, os.getcwd())
+    spec.loader.exec_module(make)
+    sys.path = syspath
+
+    args = {}
+    for name, func in getmembers(make, isfunction):
+        if name.startswith('_'):
+            continue
+
+        # generate doc
+        docstring = utils.trim(func.__doc__)
+        if not docstring:
+            docstring = f"run \"{name}\""
+        short_help = docstring.splitlines()[0]
+
+        func_spec = getfullargspec(func)
+
+        func_args = {}
+        for arg in func_spec.args:
+            arg_type = str
+            if arg in func_spec.annotations:
+                arg_type = func_spec.annotations[arg]
+            func_args[arg] = {
+                "type": arg_type
+            }
+
+        if func_spec.defaults:
+            for arg, defval in zip(reversed(func_spec.args), reversed(func_spec.defaults)):
+                func_args[arg]["default"] = defval
+
+                if defval is None:
+                    continue
+
+                if type(defval) is not func_args[arg]["type"]:
+                    if isinstance(defval, (bool, str, float, int)):
+                        func_args[arg]["type"] = type(defval)
+
+        args[name] = {
+            "function": func,
+            "help": short_help,
+            "full_help": docstring,
+            "args": func_args
+        }
+
+    if args:
+        default_arg = list(args.keys())[0]
+    else:
+        default_arg = None
+
+    default_arg = getattr(make, '__scdefault', default_arg)
+
+    module_help = utils.trim(make.__doc__)
+
+    return args, default_arg, module_help
+
+
+def main(source_file=None):
+    progname = "smake"
+    description = f"""-----------------------------------------------------------
+SC app that provides an Makefile like interface to python
+configuration files. This utility app will analyze a file
+"{__default_source_file}" or the file specified with --file to determine
+the available targets.
+
+To view the help, use:
+    smake --help
+
+    or view the help for a specific target:
+    smake --help <target>
+
+To run a target, use:
+    smake <target>
+
+    or run a target from a file other than "{__default_source_file}":
+    smake --file <file> <target>
+
+    or run a target in a different directory:
+    smake --directory <directory> <target>
+
+To run a target with supported arguments, use:
+    smake <target> --flow asicflow
+-----------------------------------------------------------"""
+
+    # handle source file identification before arg parse
+    file_args = None
+    if not source_file:
+        source_file = __default_source_file
+        file_args = ('--file', '-f')
+        for file_arg in file_args:
+            if file_arg in sys.argv:
+                source_file_idx = sys.argv.index(file_arg) + 1
+                if source_file_idx < len(sys.argv):
+                    source_file = sys.argv[source_file_idx]
+                else:
+                    source_file = None
+                break
+
+    # handle directory identification before arg parse
+    source_dir = os.getcwd()
+    dir_args = ('--directory', '-C')
+    for file_arg in dir_args:
+        if file_arg in sys.argv:
+            source_dir_idx = sys.argv.index(file_arg) + 1
+            if source_dir_idx < len(sys.argv):
+                source_dir = sys.argv[source_dir_idx]
+            else:
+                source_dir = None
+            break
+
+    if source_dir:
+        if not os.path.isdir(source_dir):
+            print(f"Unable to change directory to {source_dir}")
+            return 1
+
+        os.chdir(source_dir)
+
+    make_args = {}
+    default_arg = None
+    module_help = None
+    if source_file:
+        make_args, default_arg, module_help = __process_file(source_file)
+
+    if module_help:
+        description += \
+            f"\n\n{module_help}\n\n-----------------------------------------------------------"
+
+    parser = argparse.ArgumentParser(
+        progname,
+        description=description,
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+
+    if file_args:
+        parser.add_argument(
+            *file_args,
+            metavar='<file>',
+            help=f'Use file as makefile, default is {__default_source_file}')
+
+    parser.add_argument(
+        *dir_args,
+        metavar='<directory>',
+        help='Change to directory <directory> before reading the makefile.')
+
+    parser.add_argument(
+        '--version', '-v',
+        action='version',
+        version=version)
+
+    targetparsers = parser.add_subparsers(
+        dest='target',
+        metavar='<target>',
+        help='Target to execute')
+
+    for arg, info in make_args.items():
+        subparse = targetparsers.add_parser(
+            arg,
+            description=info['full_help'],
+            help=info['help'],
+            formatter_class=argparse.RawDescriptionHelpFormatter)
+
+        for subarg, subarg_info in info['args'].items():
+            # print(subarg, subarg_info)
+            add_args = {}
+
+            if "default" not in subarg_info:
+                add_args["required"] = True
+            else:
+                if type(subarg_info["default"]) is subarg_info["type"]:
+                    add_args["default"] = subarg_info["default"]
+
+            if subarg_info["type"] is bool:
+                def str2bool(v):
+                    # modified from:
+                    # https://github.com/pypa/distutils/blob/8993718731b951ee36d08cb784f02aa13542ce15/distutils/util.py
+                    val = v.lower()
+                    if val in ('y', 'yes', 't', 'true', 'on', '1'):
+                        return True
+                    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
+                        return False
+                    else:
+                        raise ValueError(f"invalid truth value {val!r}")
+                subarg_info["type"] = str2bool
+
+            subparse.add_argument(
+                f'--{subarg}',
+                dest=f'sub_{subarg}',
+                metavar=f'<{subarg}>',
+                type=subarg_info["type"],
+                **add_args)
+
+    args = parser.parse_args()
+    target = args.target
+    if not target:
+        target = default_arg
+
+    if not os.path.isfile(source_file):
+        print(f"Unable to load {source_file}")
+        return 1
+
+    call_args = {}
+    args_vars = vars(args)
+    for arg in make_args[target]["args"]:
+        if f'sub_{arg}' in args_vars and args_vars[f'sub_{arg}'] is not None:
+            call_args[arg] = args_vars[f'sub_{arg}']
+    make_args[target]["function"](**call_args)
+
+    return 0
+
+
+#########################
+if __name__ == "__main__":
+    sys.exit(main())

siliconcompiler/checklists/oh_tapeout.py

@@ -0,0 +1,41 @@
+import siliconcompiler
+
+
+def setup(chip):
+    '''Subset of OH! library tapeout checklist.
+
+    https://github.com/aolofsson/oh/blob/master/docs/tapeout_checklist.md
+    '''
+    standard = 'oh_tapeout'
+
+    checklist = siliconcompiler.Checklist(chip, standard)
+
+    # Automated
+    checklist.set('checklist', standard, 'drc_clean', 'description',
+                  'Is block DRC clean?')
+    checklist.set('checklist', standard, 'drc_clean', 'criteria', 'drcs==0')
+
+    checklist.set('checklist', standard, 'lvs_clean', 'description',
+                  'Is block LVS clean?')
+    checklist.set('checklist', standard, 'lvs_clean', 'criteria', 'drcs==0')
+
+    checklist.set('checklist', standard, 'setup_time', 'description',
+                  'Setup time met?')
+    checklist.set('checklist', standard, 'setup_time', 'criteria', 'setupslack>=0')
+
+    checklist.set('checklist', standard, 'errors_warnings', 'description',
+                  'Are all EDA warnings/errors acceptable?')
+    checklist.set('checklist', standard, 'errors_warnings', 'criteria',
+                  ['errors==0', 'warnings==0'])
+
+    # Manual
+    checklist.set('checklist', standard, 'spec', 'description',
+                  'Is there a written specification?')
+
+    return checklist
+
+
+##################################################
+if __name__ == "__main__":
+    checklist = setup(siliconcompiler.Chip('<checklist>'))
+    checklist.write_manifest(f"{checklist.top()}.json")