siliconcompiler 0.28.9__py3-none-any.whl → 0.29.1__py3-none-any.whl

siliconcompiler/sphinx_ext/dynamicgen.py

@@ -9,6 +9,7 @@ from sphinx.util.docutils import SphinxDirective
 from sphinx.domains.std import StandardDomain
 from sphinx.addnodes import pending_xref
 import docutils
+from siliconcompiler.utils import get_plugins
 
 import importlib
 import pkgutil
@@ -16,6 +17,7 @@ import os
 import subprocess
 
 import siliconcompiler
+from siliconcompiler.sphinx_ext import sc_root as SC_ROOT
 from siliconcompiler.schema import Schema, utils
 from siliconcompiler.sphinx_ext.utils import (
     strong,
@@ -36,9 +38,6 @@ from siliconcompiler.sphinx_ext.utils import (
 # Helpers
 #############
 
-# We need this in a few places, so just make it global
-SC_ROOT = os.path.abspath(f'{__file__}/../../../')
-
 
 def build_schema_value_table(cfg, refdoc, keypath_prefix=None, skip_zero_weight=False):
     '''Helper function for displaying values set in schema as a docutils table.'''
@@ -193,6 +192,7 @@ class DynamicGen(SphinxDirective):
             # Then use setup doc string
             self.generate_documentation_from_object(setup, path, s)
 
+        chips = None
         try:
             chips = self.configure_chip_for_docs(module)
         except Exception as e:
@@ -250,22 +250,14 @@ class DynamicGen(SphinxDirective):
 
         This function explicitly searches builtins.
         '''
-        builtins_dir = f'{SC_ROOT}/siliconcompiler/{self.PATH}'
-        if 'nobuiltins' not in self.options:
-            modules = self.get_modules_in_dir(builtins_dir)
-        else:
-            modules = []
 
-        external_paths = os.getenv(self.SEARCH_ENV, "").split(':')
-        for scpath in external_paths:
-            if not scpath:
-                continue
-            if not os.path.isdir(scpath):
-                print(f'{scpath} not found')
-                raise FileNotFoundError(scpath)
-            if builtins_dir == scpath:
-                continue
-            modules.extend(self.get_modules_in_dir(scpath))
+        modules = []
+        for plugin in get_plugins("docs", name=self.PATH):
+            for mod in plugin():
+                if isinstance(mod, str):
+                    modules.extend(self.get_modules_in_dir(mod))
+                else:
+                    modules.append(mod)
 
         return modules
 
@@ -320,15 +312,15 @@ class DynamicGen(SphinxDirective):
         else:
             return False
 
-        builtin = os.path.abspath(path).startswith(SC_ROOT)
+        src_link = None
+        for docs_link in get_plugins("docs", name="linkcode"):
+            src_link = docs_link(file=path)
+            if src_link:
+                break
 
-        if builtin:
-            relpath = path[len(SC_ROOT) + 1:]
-            gh_root = 'https://github.com/siliconcompiler/siliconcompiler/blob/main'
-            gh_link = f'{gh_root}/{relpath}'
-            filename = os.path.basename(relpath)
+        if src_link:
             p = para('Setup file: ')
-            p += link(gh_link, text=filename)
+            p += link(src_link, text=os.path.basename(path))
             s += p
 
         return True
@@ -477,7 +469,6 @@ class DynamicGen(SphinxDirective):
 class FlowGen(DynamicGen):
     PATH = 'flows'
     REF_PREFIX = 'flows'
-    SEARCH_ENV = "SC_DOCS_FLOWS"
 
     def extra_content(self, chip, modname):
         flow_path = os.path.join(self.env.app.outdir, f'_images/gen/{modname}.svg')
@@ -524,7 +515,6 @@ class FlowGen(DynamicGen):
 class PDKGen(DynamicGen):
     PATH = 'pdks'
     REF_PREFIX = 'pdks'
-    SEARCH_ENV = "SC_DOCS_PDKS"
 
     def display_config(self, chip, modname):
         '''Display parameters under `pdk`, `asic`, and `library` in nested form.'''
@@ -549,7 +539,6 @@ class PDKGen(DynamicGen):
 class LibGen(DynamicGen):
     PATH = 'libs'
     REF_PREFIX = 'libs'
-    SEARCH_ENV = "SC_DOCS_LIBS"
 
     def extra_content(self, chip, modname):
         # assume same pdk for all libraries configured by this module
@@ -592,7 +581,6 @@ class LibGen(DynamicGen):
 class ToolGen(DynamicGen):
     PATH = 'tools'
     REF_PREFIX = 'tools'
-    SEARCH_ENV = "SC_DOCS_TOOLS"
 
     def make_chip(self):
         chip = super().make_chip()
@@ -753,8 +741,8 @@ class ToolGen(DynamicGen):
         path = os.path.abspath(path)
         module_dir = os.path.dirname(path)
         for taskfile in os.listdir(module_dir):
-            if taskfile == "__init__.py":
-                # skip init
+            if taskfile.startswith("_"):
+                # skip private file
                 continue
 
             task_path = os.path.join(module_dir, taskfile)
@@ -809,7 +797,6 @@ class ToolGen(DynamicGen):
 class TargetGen(DynamicGen):
     PATH = 'targets'
     REF_PREFIX = 'targets'
-    SEARCH_ENV = "SC_DOCS_TARGETS"
 
     def build_module_list(self, chip, header, modtype, targetname, *refprefix):
         modules = chip._loaded_modules[modtype]
@@ -877,7 +864,6 @@ class TargetGen(DynamicGen):
 class AppGen(DynamicGen):
     PATH = 'apps'
     REF_PREFIX = 'apps'
-    SEARCH_ENV = "SC_DOCS_APPS"
 
     def document_module(self, module, modname, path):
         if modname[0] == "_":
@@ -897,7 +883,6 @@ class AppGen(DynamicGen):
 class ChecklistGen(DynamicGen):
     PATH = 'checklists'
     REF_PREFIX = 'checklists'
-    SEARCH_ENV = "SC_DOCS_CHECKLISTS"
 
     def display_config(self, chip, modname):
         '''Display parameters under in nested form.'''

siliconcompiler/sphinx_ext/schemagen.py

@@ -16,14 +16,15 @@ from siliconcompiler.sphinx_ext.utils import (
     build_list
 )
 from siliconcompiler.schema import utils
+from siliconcompiler.sphinx_ext import sc_root as SC_ROOT
 
 
 # Main Sphinx plugin
 class SchemaGen(SphinxDirective):
 
     def run(self):
-        cfg_path = os.path.dirname(siliconcompiler.__file__)
-        self.env.note_dependency(os.path.join(cfg_path, 'schema', 'schema_cfg.py'))
+        self.env.note_dependency(
+            os.path.join(SC_ROOT, 'siliconcompiler', 'schema', 'schema_cfg.py'))
         self.env.note_dependency(__file__)
         self.env.note_dependency(utils.__file__)
 

siliconcompiler/targets/__init__.py

@@ -0,0 +1,26 @@
+from siliconcompiler.targets import asap7_demo
+from siliconcompiler.targets import asic_demo
+from siliconcompiler.targets import fpgaflow_demo
+from siliconcompiler.targets import freepdk45_demo
+from siliconcompiler.targets import gf180_demo
+from siliconcompiler.targets import ihp130_demo
+from siliconcompiler.targets import interposer_demo
+from siliconcompiler.targets import skywater130_demo
+
+
+def get_targets():
+    '''
+    Returns a dict of builtin targets
+    '''
+    return {
+        module.__name__.split(".")[-1]: module for module in (
+            asap7_demo,
+            asic_demo,
+            fpgaflow_demo,
+            freepdk45_demo,
+            gf180_demo,
+            ihp130_demo,
+            interposer_demo,
+            skywater130_demo
+        )
+    }

siliconcompiler/targets/gf180_demo.py

@@ -1,7 +1,7 @@
 import siliconcompiler
 from siliconcompiler.flows import asicflow, asictopflow, signoffflow, synflow
 from siliconcompiler.checklists import oh_tapeout
-from siliconcompiler.tools.openroad import openroad
+from siliconcompiler.tools import openroad
 from siliconcompiler.tools._common import get_tool_tasks
 
 from lambdapdk import gf180
@@ -66,8 +66,8 @@ def setup(chip, syn_np=1, floorplan_np=1, physyn_np=1, place_np=1, cts_np=1, rou
 
     # PSM gets stuck in a loop, must be disabled for now on gf180
     for task in get_tool_tasks(chip, openroad):
-        chip.set('tool', 'openroad', 'task', task, 'var', 'psm_enable', 'false')
-    chip.set('tool', 'openroad', 'task', 'route', 'var', 'ant_check', 'false')
+        chip.set('tool', 'openroad', 'task', task, 'var', 'psm_enable', False)
+    chip.set('tool', 'openroad', 'task', 'route', 'var', 'ant_check', False)
 
 
 #########################

siliconcompiler/templates/replay/replay.py.j2

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# SiliconCompiler Replay
+# Design: {{ design }}
+# Jobname: {{ jobname }}
+# Date: {{ date }}
+
+import base64
+import os.path
+import tarfile
+import sys
+
+from io import BytesIO
+
+from siliconcompiler import Chip
+
+# Input files as a tarball encoded as base64
+INPUT_FILES = \{% for line in src_file %}
+    "{{ line }}"{% if not loop.last %} \{% endif %}{% endfor %}
+
+
+if __name__ == "__main__":
+    chip = Chip("{{ design }}")
+    chip.read_manifest(os.path.join(os.path.dirname(__file__), "sc_manifest.json"))
+
+    args = chip.create_cmdline(
+        progname="{{ design }}",
+        description="Replay script for {{ design }} / {{ jobname }}",
+        switchlist=[
+            "-builddir",
+            "-cachedir",
+            "-jobname",
+            "-to",
+            "-from",
+            "-novercheck",
+            "-continue"
+        ],
+        additional_args={
+            "-check_files": {
+                "action": "store_true",
+                "help": "Do not run, just check files"
+            }
+        })
+
+    # Extract input files
+    with BytesIO(base64.b64decode(INPUT_FILES.encode())) as fd:
+        with tarfile.open(fileobj=fd, mode='r:gz') as tar:
+            tar.extractall(path=chip._getcollectdir())
+
+    # Set tool versions{% for node, tool, version in tool_versions %}
+    chip.set("tool", "{{ tool }}", "version", "=={{ version }}", step="{{ node[0] }}", index="{{ node[1] }}"){% endfor %}
+
+    if args["check_files"]:
+        if chip.check_filepaths():
+            sys.exit(0)
+        else:
+            sys.exit(1)
+
+    # Run
+    chip.run()
+
+    # Report summary
+    chip.summary()

siliconcompiler/templates/replay/requirements.txt

@@ -0,0 +1,7 @@
+# SiliconCompiler Replay Environment
+# Design: {{ design }}
+# Jobname: {{ jobname }}
+# Date: {{ date }}
+
+{% for pkg in pkgs %}{{ pkg }}
+{% endfor %}

siliconcompiler/templates/replay/setup.sh

@@ -0,0 +1,130 @@
+#!/usr/bin/env bash
+# SiliconCompiler Replay Setup
+# Design: {{ design }}
+# Jobname: {{ jobname }}
+# Date: {{ date }}
+
+if ! [ "${BASH_SOURCE[0]}" -ef "$0" ];
+then
+    echo "${BASH_SOURCE[0]} must be executed"
+    return 1
+fi
+
+_help() {
+cat <<EOF
+{{ description }}
+Usage: $0 -dir=DIR
+                    # Directory to use for extraction, defaults to "./replay"
+       $0 -venv=DIR
+                    # Name of virtual environment, defaults to "venv"
+       $0 -print_tools
+                    # Print tool version and exit
+       $0 -extract_only
+                    # Only extract the files
+       $0 -setup_only
+                    # Only setup the runtime environment
+       $0 -assert_python
+                    # Require python versions match
+       $0 -help
+                    # Print this help information
+EOF
+}
+
+_print_tools() {
+cat <<EOF{% for line in tools %}
+{{ line }}{% endfor %}
+EOF
+}
+
+path=$(realpath replay)
+venv="venv"
+extract_only="no"
+setup_only="no"
+assert_python="no"
+
+while [ "$#" -gt 0 ]; do
+    case "${1}" in
+        -h|-help)
+            _help
+            exit 0
+            ;;
+        -extract_only)
+            extract_only="yes"
+            ;;
+        -setup_only)
+            setup_only="yes"
+            ;;
+        -assert_python)
+            assert_python="yes"
+            ;;
+        -print_tools)
+            _print_tools
+            exit 0
+            ;;
+        -dir=*)
+            path=$(realpath ${1#-dir=})
+            ;;
+        -venv=*)
+            venv=${1#-venv=}
+            ;;
+        *)
+            echo "Unknown option: ${1}" >&2
+            _help
+            exit 1
+            ;;
+    esac
+    shift 1
+done
+
+# Create output path
+mkdir -p "$path"
+
+# Change to output path directory
+cd "$path"
+
+# Add gitignore
+echo "*" > .gitignore
+
+# Extract files
+read -r -d '' SCRIPT << PythonScript{% for line in script %}
+{{ line }}{% endfor %}
+PythonScript
+
+echo "$SCRIPT" | base64 --decode | gunzip > replay.py
+chmod +x replay.py
+
+read -r -d '' MANIFEST << Manifest{% for line in manifest %}
+{{ line }}{% endfor %}
+Manifest
+
+echo "$MANIFEST" | base64 --decode | gunzip > sc_manifest.json
+
+cat > requirements.txt << PythonRequirements{% for line in requirements %}
+{{ line }}{% endfor %}
+PythonRequirements
+
+if [ "$extract_only" == "yes" ]; then
+    exit 0
+fi
+
+if [ "$(python3 -V)" != "Python {{ pythonversion }}" ]; then
+    echo "Python version mismatch: $(python3 -V) != {{ pythonversion }}"
+
+    if [ "$assert_python" == "yes" ]; then
+        exit 1
+    fi
+fi
+
+python3 -m venv $venv --clear
+
+. $venv/bin/activate
+pip3 install -r requirements.txt
+
+echo "To enable run environment: . $path/$venv/bin/activate"
+echo "To replay: $path/replay.py"
+
+if [ "$setup_only" == "yes" ]; then
+    exit 0
+fi
+
+./replay.py

siliconcompiler/tools/__init__.py

@@ -0,0 +1,60 @@
+from siliconcompiler.tools.bambu import bambu
+from siliconcompiler.tools.bluespec import bluespec
+from siliconcompiler.tools.builtin import builtin
+from siliconcompiler.tools.chisel import chisel
+from siliconcompiler.tools.execute import execute
+from siliconcompiler.tools.genfasm import genfasm
+from siliconcompiler.tools.ghdl import ghdl
+from siliconcompiler.tools.icarus import icarus
+from siliconcompiler.tools.icepack import icepack
+from siliconcompiler.tools.klayout import klayout
+from siliconcompiler.tools.magic import magic
+from siliconcompiler.tools.montage import montage
+from siliconcompiler.tools.netgen import netgen
+from siliconcompiler.tools.nextpnr import nextpnr
+from siliconcompiler.tools import openroad
+from siliconcompiler.tools import opensta
+from siliconcompiler.tools import slang
+from siliconcompiler.tools import surelog
+from siliconcompiler.tools.sv2v import sv2v
+from siliconcompiler.tools.verilator import verilator
+from siliconcompiler.tools.vivado import vivado
+from siliconcompiler.tools.vpr import vpr
+from siliconcompiler.tools import xdm
+from siliconcompiler.tools import xyce
+from siliconcompiler.tools import yosys
+
+
+def get_tools():
+    '''
+    Returns a dict of builtin tools
+    '''
+    return {
+        module.__name__.split(".")[-1]: module for module in (
+            bambu,
+            bluespec,
+            builtin,
+            chisel,
+            execute,
+            genfasm,
+            ghdl,
+            icarus,
+            icepack,
+            klayout,
+            magic,
+            montage,
+            netgen,
+            nextpnr,
+            openroad,
+            opensta,
+            slang,
+            surelog,
+            sv2v,
+            verilator,
+            vivado,
+            vpr,
+            xdm,
+            xyce,
+            yosys
+        )
+    }

siliconcompiler/tools/_common/__init__.py

@@ -411,11 +411,16 @@ def get_tool_task(chip, step, index, flow=None):
 
 def get_tool_tasks(chip, tool):
     tool_dir = os.path.dirname(tool.__file__)
-    tool_base_module = tool.__name__.split('.')[0:-1]
     tool_name = tool.__name__.split('.')[-1]
+    tool_base_module = tool.__name__.split('.')
+    if not tool.__file__.endswith('__init__.py'):
+        tool_base_module = tool_base_module[0:-1]
 
     task_candidates = []
     for task_mod in pkgutil.iter_modules([tool_dir]):
+        if task_mod.name.startswith('_'):
+            continue
+
         if task_mod.name == tool_name:
             continue
         task_candidates.append(task_mod.name)
@@ -468,3 +473,12 @@ def record_metric(chip, step, index, metric, value, source, source_unit=None):
         tool, task = get_tool_task(chip, step, index, flow=flow)
 
         chip.add('tool', tool, 'task', task, 'report', metric, source, step=step, index=index)
+
+
+def has_pre_post_script(chip):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    return chip.get('tool', tool, 'task', task, 'prescript', step=step, index=index) or \
+        chip.get('tool', tool, 'task', task, 'postscript', step=step, index=index)

siliconcompiler/tools/_common/asic.py

@@ -1,4 +1,5 @@
-from .. import _common
+from . import get_libraries as common_get_libraries
+from . import get_tool_task, pick_key
 import json
 
 
@@ -19,7 +20,7 @@ def get_libraries(chip, type):
             continue
         libs.append(lib)
 
-    for lib in _common.get_libraries(chip, include_asic=False):
+    for lib in common_get_libraries(chip, include_asic=False):
         if not chip.valid('library', lib, 'asic', f'{type}lib'):
             continue
         for sublib in chip.get('library', lib, 'asic', f'{type}lib', step=step, index=index):
@@ -55,7 +56,7 @@ def set_tool_task_var(chip,
     '''
     step = chip.get('arg', 'step')
     index = chip.get('arg', 'index')
-    tool, task = _common.get_tool_task(chip, step, index)
+    tool, task = get_tool_task(chip, step, index)
     pdkname = chip.get('option', 'pdk')
     stackup = chip.get('option', 'stackup')
 
@@ -102,11 +103,18 @@ def set_tool_task_var(chip,
                      ','.join(check_keys[-1]),
                      step=step, index=index)
 
-    require_key, value = _common.pick_key(chip, reversed(check_keys), step=step, index=index)
-    if not value:
+    def check_value(val):
+        if isinstance(val, (list, tuple)):
+            return len(val) > 0
+        return val is not None
+
+    require_key, value = pick_key(chip, reversed(check_keys), step=step, index=index)
+    if not check_value(value):
         value = default_value
 
-    if value:
+    has_value = check_value(value)
+
+    if has_value:
         chip.set('tool', tool, 'task', task, 'var', param_key, value,
                  step=step, index=index, clobber=False)
 
@@ -115,7 +123,7 @@ def set_tool_task_var(chip,
                      ','.join(require_key),
                      step=step, index=index)
 
-    if value or 'key' in require:
+    if has_value or 'key' in require:
         chip.add('tool', tool, 'task', task, 'require',
                  ','.join(['tool', tool, 'task', task, 'var', param_key]),
                  step=step, index=index)
@@ -138,7 +146,7 @@ def get_tool_task_var(chip,
     '''
     step = chip.get('arg', 'step')
     index = chip.get('arg', 'index')
-    tool, _ = _common.get_tool_task(chip, step, index)
+    tool, _ = get_tool_task(chip, step, index)
     pdkname = chip.get('option', 'pdk')
     stackup = chip.get('option', 'stackup')
 
@@ -167,7 +175,7 @@ def get_tool_task_var(chip,
             option_key = f'{tool}_{param_key}'
         check_keys.append(['option', 'var', option_key])
 
-    _, value = _common.pick_key(chip, reversed(check_keys), step=step, index=index)
+    _, value = pick_key(chip, reversed(check_keys), step=step, index=index)
 
     return value
 

siliconcompiler/tools/builtin/concatenate.py

@@ -15,7 +15,7 @@ def make_docs(chip):
     for step, index in flowgraph._get_flowgraph_entry_nodes(chip, 'asicflow'):
         scheduler._setup_node(chip, step, index)
 
-    chip.set('arg', 'step', 'combine')
+    chip.set('arg', 'step', 'import.combine')
     chip.set('arg', 'index', '0')
     setup(chip)
 

siliconcompiler/tools/ghdl/ghdl.py

@@ -12,13 +12,12 @@ Sources: https://github.com/ghdl/ghdl
 Installation: https://github.com/ghdl/ghdl
 '''
 
-from siliconcompiler.tools.ghdl import convert
-
 
 #####################################################################
 # Make Docs
 #####################################################################
 def make_docs(chip):
+    from siliconcompiler.tools.ghdl import convert
     convert.setup(chip)
     return chip
 

siliconcompiler/tools/klayout/convert_drc_db.py

@@ -1,10 +1,10 @@
 from siliconcompiler.tools._common import input_provides, input_file_node_name, get_tool_task
 
-from siliconcompiler.tools.klayout import klayout
 from siliconcompiler.tools.klayout.klayout import setup as setup_tool
 
 
 def make_docs(chip):
+    from siliconcompiler.tools.klayout import klayout
     klayout.make_docs(chip)
 
 

siliconcompiler/tools/klayout/drc.py

@@ -5,12 +5,12 @@ from siliconcompiler.tools._common import input_provides, has_input_files, \
     get_input_files, get_tool_task, record_metric
 from siliconcompiler.tools._common.asic import set_tool_task_var, get_tool_task_var
 
-from siliconcompiler.tools.klayout import klayout
 from siliconcompiler.tools.klayout.klayout import setup as setup_tool
 import xml.etree.ElementTree as ET
 
 
 def make_docs(chip):
+    from siliconcompiler.tools.klayout import klayout
     klayout.make_docs(chip)
     chip.set('tool', 'klayout', 'task', 'drc', 'var', 'drc_name', '<drc_name>',
              step='<step>', index='<index>')

siliconcompiler/tools/klayout/export.py

@@ -1,5 +1,6 @@
-
+import os
 from siliconcompiler.tools.klayout.klayout import setup as setup_tool
+from siliconcompiler.tools.klayout.klayout import runtime_options as runtime_options_tool
 from siliconcompiler.tools.klayout.screenshot import setup_gui_screenshot
 from siliconcompiler.tools._common import input_provides, get_tool_task
 from siliconcompiler.tools._common.asic import get_libraries
@@ -120,3 +121,9 @@ def setup(chip):
     if chip.get('tool', tool, 'task', task, 'var', 'screenshot',
                 step=step, index=index) == ['true']:
         setup_gui_screenshot(chip, require_input=False)
+
+
+def runtime_options(chip):
+    return runtime_options_tool(chip) + [
+        '-rd', f'SC_TOOLS_ROOT={os.path.dirname(os.path.dirname(__file__))}'
+    ]

siliconcompiler/tools/klayout/klayout.py

@@ -15,13 +15,13 @@ from pathlib import Path
 import platform
 import shutil
 from siliconcompiler.tools._common import get_tool_task
-from siliconcompiler.targets import freepdk45_demo
 
 
 ####################################################################
 # Make Docs
 ####################################################################
 def make_docs(chip):
+    from siliconcompiler.targets import freepdk45_demo
     chip.use(freepdk45_demo)
 
 
@@ -102,7 +102,7 @@ def runtime_options(chip):
     # that has no 3rd-party dependencies.
     # This must be done at runtime to work in a remote context.
 
-    return ['-rd', f'SC_ROOT={chip.scroot}']
+    return ['-rd', f'SC_KLAYOUT_ROOT={os.path.dirname(__file__)}']
 
 
 ################################