siliconcompiler 0.28.0__py3-none-any.whl → 0.28.2__py3-none-any.whl

siliconcompiler/tools/openroad/scripts/sc_write_images.tcl

@@ -54,7 +54,7 @@ proc sc_image_heatmap { name ident image_name title { allow_bin_adjust 1 } } {
   gui::set_display_controls "Heat Maps/${name}" visible false
 }
 
-proc sc_image_placement {} {
+proc sc_image_placement { } {
   if { ![sc_has_placed_instances] } {
     return
   }
@@ -70,7 +70,7 @@ proc sc_image_placement {} {
   sc_save_image "placement" reports/images/${sc_design}.placement.png
 }
 
-proc sc_image_routing {} {
+proc sc_image_routing { } {
   if { ![sc_has_routing] } {
     return
   }
@@ -85,7 +85,7 @@ proc sc_image_routing {} {
   sc_save_image "routing" reports/images/${sc_design}.routing.png
 }
 
-proc sc_image_everything {} {
+proc sc_image_everything { } {
   global sc_design
 
   sc_image_setup_default
@@ -134,7 +134,7 @@ proc sc_image_irdrop { net corner } {
   }
 }
 
-proc sc_image_routing_congestion {} {
+proc sc_image_routing_congestion { } {
   if { ![sc_has_global_routing] } {
     return
   }
@@ -148,7 +148,7 @@ proc sc_image_routing_congestion {} {
     0
 }
 
-proc sc_image_estimated_routing_congestion {} {
+proc sc_image_estimated_routing_congestion { } {
   if { ![sc_has_placed_instances] } {
     return
   }
@@ -166,7 +166,7 @@ proc sc_image_estimated_routing_congestion {} {
   unsuppress_message GRT 10
 }
 
-proc sc_image_power_density {} {
+proc sc_image_power_density { } {
   if { ![sc_has_placed_instances] } {
     return
   }
@@ -188,7 +188,7 @@ proc sc_image_power_density {} {
   }
 }
 
-proc sc_image_placement_density {} {
+proc sc_image_placement_density { } {
   if { ![sc_has_placed_instances] } {
     return
   }
@@ -201,7 +201,7 @@ proc sc_image_placement_density {} {
     "placement density"
 }
 
-proc sc_image_clocks {} {
+proc sc_image_clocks { } {
   if { ![sc_has_placed_instances] } {
     return
   }
@@ -223,7 +223,7 @@ proc sc_image_clocks {} {
   sc_save_image "clocks" reports/images/${sc_design}.clocks.png
 }
 
-proc sc_image_clocktree {} {
+proc sc_image_clocktree { } {
   gui::show_widget "Clock Tree Viewer"
   global sc_scenarios
 
@@ -263,7 +263,7 @@ proc sc_image_clocktree {} {
   gui::hide_widget "Clock Tree Viewer"
 }
 
-proc sc_image_optimizer {} {
+proc sc_image_optimizer { } {
   global sc_design
   sc_image_setup_default
 

siliconcompiler/tools/opensta/scripts/sc_procs.tcl

@@ -2,7 +2,7 @@
 # Count the logic depth of the critical path
 ###########################
 
-proc sc_count_logic_depth {} {
+proc sc_count_logic_depth { } {
     set count 0
     set paths [find_timing_paths -sort_by_slack]
     if { [llength $paths] == 0 } {
@@ -24,7 +24,7 @@ proc sc_count_logic_depth {} {
     return [expr { $count - 1 }]
 }
 
-proc sc_design_area {} {
+proc sc_design_area { } {
     set area 0
     foreach inst [get_cells -hierarchical *] {
         set lib_cell [$inst liberty_cell]
@@ -35,7 +35,7 @@ proc sc_design_area {} {
     return $area
 }
 
-proc sc_display_report {report} {
+proc sc_display_report { report } {
     if { ![file exists $report] } {
         return
     }

siliconcompiler/tools/xdm/__init__.py

@@ -0,0 +1,28 @@
+'''
+Xyce XDM netlist converter, used to convert PSPICE and HSPICE netists into Xyce format.
+
+Sources: https://github.com/Xyce/XDM
+
+Installation: https://github.com/Xyce/XDM
+
+Status: SC integration WIP
+'''
+from siliconcompiler.tools._common import get_tool_task
+
+
+def setup(chip):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    chip.set('tool', tool, 'exe', 'xdm_bdl')
+    chip.set('tool', tool, 'vswitch', '-h')
+    chip.set('tool', tool, 'version', '>=v2.7.0', clobber=False)
+
+
+################################
+# Version Check
+################################
+def parse_version(stdout):
+    line = stdout.splitlines()[5]
+    return line.split()[1]

siliconcompiler/tools/xdm/convert.py

@@ -0,0 +1,71 @@
+from siliconcompiler.tools._common import input_provides, get_tool_task
+from siliconcompiler.tools.xdm import setup as tool_setup
+import os
+import shutil
+
+
+def setup(chip):
+    tool_setup(chip)
+
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    design = chip.top()
+
+    if f'{design}.cir' in input_provides(chip, step, index):
+        chip.add('tool', tool, 'task', task, 'input', f'{design}.cir',
+                 step=step, index=index)
+    else:
+        chip.add('tool', tool, 'task', task, 'require', 'input,netlist,spice',
+                 step=step, index=index)
+
+    chip.add('tool', tool, 'task', task, 'output', f'{design}.xyce', step=step, index=index)
+
+    chip.add('tool', tool, 'task', task, 'option', '--auto',
+             step=step, index=index)
+    chip.add('tool', tool, 'task', task, 'option', '--source_file_format hspice',
+             step=step, index=index)
+    chip.add('tool', tool, 'task', task, 'option', f'--dir_out outputs/{design}.xyce',
+             step=step, index=index)
+
+    chip.set('tool', 'xdm', 'task', 'convert', 'var', 'rename', 'true',
+             step=step, index=index, clobber=False)
+    chip.set('tool', 'xdm', 'task', 'convert', 'var', 'rename',
+             'true/false: indicate whether to rename the output file to match the '
+             'naming scheme for siliconcompiler', field='help')
+
+
+def runtime_options(chip):
+    return __get_input_file(chip)
+
+
+def __get_input_file(chip):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    design = chip.top()
+
+    if f'{design}.cir' in input_provides(chip, step, index):
+        return [f'inputs/{design}.cir']
+
+    return chip.find_files('input', 'netlist', 'spice',
+                           step=step, index=index)
+
+
+def post_process(chip):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+
+    if chip.get('tool', 'xdm', 'task', 'convert', 'var', 'rename',
+                step=step, index=index) == ['false']:
+        return
+
+    inputfile = __get_input_file(chip)[0]
+
+    outdir = f'outputs/{chip.top()}.xyce'
+
+    inputfile_base = os.path.basename(inputfile)
+    outputfile_base = f'{chip.top()}.cir'
+
+    if inputfile_base != outputfile_base:
+        shutil.move(os.path.join(outdir, inputfile_base), os.path.join(outdir, outputfile_base))

siliconcompiler/tools/xyce/__init__.py

@@ -0,0 +1,40 @@
+'''
+Xyce is a high performance SPICE-compatible circuit simulator
+capable capable of solving extremely large circuit problems by
+supporting large-scale parallel computing platforms. It also
+supports serial execution on all common desktop platforms,
+and small-scale parallel runs on Unix-like systems.
+
+Documentation: https://xyce.sandia.gov/documentation-tutorials/
+
+Sources: https://github.com/Xyce/Xyce
+
+Installation: https://xyce.sandia.gov/documentation-tutorials/building-guide/
+
+Status: SC integration WIP
+'''
+from siliconcompiler.tools._common import get_tool_task
+
+
+################################
+# Setup Tool (pre executable)
+################################
+def setup(chip):
+
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    chip.set('tool', tool, 'exe', 'Xyce')
+    chip.set('tool', tool, 'vswitch', '-v')
+    chip.set('tool', tool, 'version', '>=v7.8')
+
+    chip.set('tool', tool, 'task', task, 'regex', 'warnings', 'warning',
+             step=step, index=index, clobber=False)
+    chip.set('tool', tool, 'task', task, 'regex', 'errors', 'error',
+             step=step, index=index, clobber=False)
+
+
+def parse_version(stdout):
+    ver = stdout.split()[-1]
+    return ver.split('-')[0]

siliconcompiler/tools/xyce/simulate.py

@@ -0,0 +1,70 @@
+from siliconcompiler.tools._common import input_provides, get_tool_task
+from siliconcompiler.tools.xyce import setup as tool_setup
+import os
+
+
+def setup(chip):
+    tool_setup(chip)
+
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    design = chip.top()
+
+    if f'{design}.xyce' in input_provides(chip, step, index):
+        chip.add('tool', tool, 'task', task, 'input', f'{design}.xyce',
+                 step=step, index=index)
+    elif f'{design}.cir' in input_provides(chip, step, index):
+        chip.add('tool', tool, 'task', task, 'input', f'{design}.cir',
+                 step=step, index=index)
+    else:
+        chip.add('tool', tool, 'task', task, 'require', 'input,netlist,spice',
+                 step=step, index=index)
+
+    chip.set('tool', tool, 'task', task, 'var', 'trace', 'false',
+             step=step, index=index, clobber=False)
+    chip.set('tool', tool, 'task', task, 'var', 'trace', 'true/false, enable dumping all signals',
+             field='help')
+
+    allowed_traced = ['ASCII', 'binary']
+    chip.set('tool', tool, 'task', task, 'var', 'trace_format', 'ASCII',
+             step=step, index=index, clobber=False)
+    chip.set('tool', tool, 'task', task, 'var', 'trace_format', 'Format to use for traces. '
+             f'Allowed values are {allowed_traced}',
+             field='help')
+
+    if chip.get('tool', tool, 'task', task, 'var', 'trace_format', step=step, index=index)[0] \
+            not in allowed_traced:
+        raise ValueError(f"{chip.get('tool', tool, 'task', task, 'var', 'trace_format')[0]} "
+                         "is not an accepted value")
+
+    if chip.get('tool', tool, 'task', task, 'var', 'trace_format', step=step, index=index) == \
+            ['ASCII']:
+        chip.add('tool', tool, 'task', task, 'option', '-a',
+                 step=step, index=index)
+
+    if chip.get('tool', tool, 'task', task, 'var', 'trace',
+                step=step, index=index) == ['true']:
+        chip.add('tool', tool, 'task', task, 'output', f'{design}.raw',
+                 step=step, index=index)
+        chip.add('tool', tool, 'task', task, 'option', f'-r outputs/{design}.raw',
+                 step=step, index=index)
+
+
+def runtime_options(chip):
+    design = chip.top()
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+
+    if f'{design}.xyce' in input_provides(chip, step, index):
+        if os.path.isfile(f'inputs/{design}.xyce'):
+            return [f'inputs/{design}.xyce']
+        elif os.path.isfile(f'inputs/{design}.xyce/{design}.cir'):
+            return [f'inputs/{design}.xyce/{design}.cir']
+        else:
+            return [f'inputs/{design}.xyce']
+    elif f'{design}.cir' in input_provides(chip, step, index):
+        return [f'inputs/{design}.cir']
+
+    return chip.find_files('input', 'netlist', 'spice', step=step, index=index)

siliconcompiler/tools/yosys/syn_asic.tcl

@@ -3,7 +3,7 @@
 ####################
 source "$sc_refdir/syn_asic_fpga_shared.tcl"
 
-proc preserve_modules {} {
+proc preserve_modules { } {
     global sc_cfg
     global sc_tool
     global sc_task

siliconcompiler/toolscripts/_tools.json

@@ -0,0 +1,131 @@
+{
+  "openroad": {
+    "git-url": "https://github.com/The-OpenROAD-Project/OpenROAD.git",
+    "git-commit": "81c8892339ff090147b9e769195f32489cba38f9",
+    "docker-cmds": [
+      "# Remove OR-Tools files",
+      "RUN rm -f $SC_PREFIX/Makefile $SC_PREFIX/README.md",
+      "# Remove OpenROAD Env file",
+      "RUN rm -f $SC_PREFIX/env.sh"
+    ],
+    "auto-update": true
+  },
+  "surelog": {
+    "git-url": "https://github.com/chipsalliance/Surelog.git",
+    "git-commit": "v1.84",
+    "auto-update": true
+  },
+  "netgen": {
+    "git-url": "https://github.com/RTimothyEdwards/netgen.git",
+    "git-commit": "fb7876c7a6f9d58a3d88a49e302e682c1d12e00d",
+    "auto-update": false
+  },
+  "ghdl": {
+    "git-url": "https://github.com/ghdl/ghdl.git",
+    "git-commit": "v4.1.0",
+    "auto-update": false
+  },
+  "magic": {
+    "git-url": "https://github.com/RTimothyEdwards/magic.git",
+    "git-commit": "c7f11d2169f6af8751ae22b5d70250b331e1a667",
+    "auto-update": false
+  },
+  "bluespec": {
+    "git-url": "https://github.com/B-Lang-org/bsc.git",
+    "git-commit": "4cac6ebae076e8b8378597aba1d2119aa29ec419",
+    "auto-update": false
+  },
+  "klayout": {
+    "version": "0.29.7",
+    "git-url": "https://github.com/KLayout/klayout.git",
+    "docker-skip": true,
+    "auto-update": true,
+    "run-version": "source version.sh && echo $KLAYOUT_VERSION",
+    "release-notes": "https://www.klayout.de/development.html"
+  },
+  "sv2v": {
+    "git-url": "https://github.com/zachjs/sv2v.git",
+    "git-commit": "5374679e4bb26e115b9a9b4a2d8ef4253d7a8bf3",
+    "auto-update": true
+  },
+  "verilator": {
+    "git-url": "https://github.com/verilator/verilator.git",
+    "git-commit": "563faeb33f3b9b5374f558f54adfea11873f1cd7",
+    "auto-update": true
+  },
+  "bambu": {
+    "git-url": "https://github.com/ferrandi/PandA-bambu.git",
+    "git-commit": "v2024.03",
+    "auto-update": false,
+    "docker-cmds": [
+      "# Remove ORFS Stuff",
+      "RUN rm -rf $SC_PREFIX/share/panda/asap7",
+      "RUN rm -rf $SC_PREFIX/share/panda/nangate45",
+      "RUN rm -rf $SC_PREFIX/share/panda/scripts"
+    ]
+  },
+  "vpr": {
+    "git-url": "https://github.com/verilog-to-routing/vtr-verilog-to-routing.git",
+    "git-commit": "9dd5ff66e3ab43238f5a4cb14cafe17bc4afe527",
+    "auto-update": false
+  },
+  "icepack": {
+    "git-url": "https://github.com/YosysHQ/icestorm.git",
+    "git-commit": "d20a5e9001f46262bf0cef220f1a6943946e421d",
+    "auto-update": false
+  },
+  "nextpnr": {
+    "git-url": "https://github.com/YosysHQ/nextpnr.git",
+    "git-commit": "f89b959b5f56ba8d91e1e7f8a645b267a5a7bb89",
+    "docker-depends": "icepack"
+  },
+  "chisel": {
+    "version": "1.8.0",
+    "git-url": "https://github.com/sbt/sbt.git",
+    "auto-update": false
+  },
+  "icarus": {
+    "git-url": "https://github.com/steveicarus/iverilog.git",
+    "git-commit": "01441687235135d1c12eeef920f75d97995da333",
+    "auto-update": false
+  },
+  "yosys": {
+    "git-url": "https://github.com/YosysHQ/yosys.git",
+    "git-commit": "yosys-0.44",
+    "version-prefix": "yosys-",
+    "auto-update": true
+  },
+  "xyce": {
+    "git-url": "https://github.com/Xyce/Xyce.git",
+    "version": "7.8.0",
+    "auto-update": false
+  },
+  "slurm": {
+    "version": "22.05.7",
+    "git-url": "https://github.com/SchedMD/slurm.git",
+    "auto-update": false,
+    "docker-extra-files": [
+      "docker/slurm"
+    ],
+    "docker-cmds": [
+      "COPY slurm $SC_PREFIX/slurm_cfg",
+      "RUN mv $SC_PREFIX/slurm_cfg/install-slurm.sh $SC_PREFIX/",
+      "RUN chmod +x $SC_PREFIX/install-slurm.sh"
+    ]
+  },
+  "montage": {
+    "version": "6.9.11",
+    "auto-update": false,
+    "docker-skip": true
+  },
+  "verible": {
+    "version": "v0.0-3303-gd87f2420",
+    "git-url": "https://github.com/chipsalliance/verible.git",
+    "auto-update": false
+  },
+  "slang": {
+    "git-commit": "v7.0",
+    "git-url": "https://github.com/MikePopoloski/slang.git",
+    "auto-update": true
+  }
+}

siliconcompiler/toolscripts/_tools.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+# Copyright 2023 Silicon Compiler Authors. All Rights Reserved.
+
+import argparse
+import json
+import os
+import tempfile
+import subprocess
+import re
+
+tools = None
+data_file = os.path.join(os.path.dirname(__file__), "_tools.json")
+with open(data_file, "r") as f:
+    tools = json.load(f)
+
+
+def __make_github_url(url, old_version, new_version):
+    if 'github' not in url:
+        return None
+
+    if url.endswith('.git'):
+        url = url[0:-4]
+
+    return f'{url}/compare/{old_version}...{new_version}'
+
+
+def bump_commit(tools, tool):
+    if "git-url" not in tools[tool]:
+        return (None, None)
+
+    if not re.fullmatch(r"[a-f0-9]{40}", tools[tool]["git-commit"]):
+        return bump_commit_tag(tools, tool)
+
+    import git
+
+    with tempfile.TemporaryDirectory(prefix=tool) as repo_work_dir:
+        repo = git.Repo.clone_from(tools[tool]["git-url"], repo_work_dir)
+
+        return (repo.head.commit.hexsha,
+                __make_github_url(tools[tool]["git-url"],
+                                  tools[tool]["git-commit"],
+                                  repo.head.commit.hexsha))
+
+    return (None, None)
+
+
+def bump_commit_tag(tools, tool):
+    if "git-url" not in tools[tool]:
+        return (None, None)
+
+    import git
+
+    version_prefix = 'v'
+    if "version-prefix" in tools[tool]:
+        version_prefix = tools[tool]["version-prefix"]
+
+    with tempfile.TemporaryDirectory(prefix=tool) as repo_work_dir:
+        repo = git.Repo.clone_from(tools[tool]["git-url"], repo_work_dir)
+
+        newest = None
+        for tag in repo.tags:
+            if not tag.name.startswith(version_prefix):
+                continue
+
+            if not newest or tag.commit.committed_datetime > newest.commit.committed_datetime:
+                newest = tag
+        if newest:
+            newest = newest.name
+            return (newest,
+                    __make_github_url(tools[tool]["git-url"],
+                                      tools[tool]["git-commit"],
+                                      newest))
+
+    return (None, None)
+
+
+def bump_version(tools, tool):
+    if "git-url" not in tools[tool]:
+        return (None, None)
+
+    import git
+
+    with tempfile.TemporaryDirectory(prefix=tool) as repo_work_dir:
+        repo = git.Repo.clone_from(tools[tool]["git-url"], repo_work_dir)
+
+        if "run-version" in tools[tool]:
+            script = os.path.join(repo_work_dir, 'sc_get_version.sh')
+            with open(script, 'w') as f:
+                f.write(tools[tool]["run-version"])
+            os.chmod(script, 0o700)
+            proc = subprocess.run(['bash', script],
+                                  stdout=subprocess.PIPE,
+                                  stderr=subprocess.STDOUT,
+                                  universal_newlines=True,
+                                  cwd=repo_work_dir)
+            version = proc.stdout.strip()
+            if not version:
+                return (None, None)
+
+            releasenotes = None
+            if "release-notes" in tools[tool]:
+                releasenotes = tools[tool]["release-notes"]
+            return (version, releasenotes)
+
+        newest = None
+        for tag in repo.tags:
+            if not newest:
+                newest = tag
+            else:
+                if tag.commit.committed_datetime > newest.commit.committed_datetime:
+                    newest = tag
+        if newest:
+            newest = newest.name
+            has_v = False
+            if newest[0] == 'v':
+                newest = newest[1:]
+                has_v = True
+
+            new_version = newest
+            old_version = tools[tool]["version"]
+            if has_v:
+                new_version = f'v{new_version}'
+                old_version = f'v{old_version}'
+
+            return (newest,
+                    __make_github_url(tools[tool]["git-url"],
+                                      old_version,
+                                      new_version))
+
+        return (None, None)
+
+    return (None, None)
+
+
+def has_tool(tool):
+    return tool in tools
+
+
+def get_field(tool, field):
+    if field not in tools[tool]:
+        return None
+    return tools[tool][field]
+
+
+def get_tools():
+    return list(tools.keys())
+
+
+if __name__ == "__main__":
+    supported_tools = ", ".join(get_tools())
+    supported_fields = set()
+    for tool, fields in tools.items():
+        for field in fields:
+            supported_fields.add(field)
+    supported_fields = ", ".join(supported_fields)
+
+    parser = argparse.ArgumentParser(
+        prog="SiliconCompiler Tool Helper",
+        description="Maintains current known good versions for all install scripts to use")
+    parser.add_argument("--tool", type=str,
+                        help=f"Tool name, supported tools: {supported_tools}")
+    parser.add_argument("--json_tools", action="store_true",
+                        help="Flag to get json matrix used by github to update tools")
+
+    parser.add_argument("--field", type=str,
+                        help=f"Field to get information from, supported fields: {supported_fields}")
+    parser.add_argument("--bump_commit", action="store_true",
+                        help="Flag to indicate that the specified tool should be updated.")
+
+    args = parser.parse_args()
+
+    if args.json_tools:
+        json_tools = {'include': []}
+        for tool in get_tools():
+            field = get_field(tool, "git-url")
+            update = get_field(tool, "auto-update")
+            if field and update:
+                json_tools['include'].append({"tool": tool})
+        if len(json_tools['include']) == 0:
+            print(json.dumps({}))
+        else:
+            print(json.dumps(json_tools))
+        exit(0)
+
+    if not has_tool(args.tool):
+        print(f"{args.tool} is not a supported tool.")
+        print(f"Supported tools are: {supported_tools}")
+        exit(1)
+
+    if not args.bump_commit:
+        tool_fields = tools[args.tool]
+        if args.field not in tool_fields:
+            print(f"{args.field} is not a supported field for {args.tool}.")
+            tool_supported_fields = ", ".join(tool_fields.keys())
+            print(f"Supported fields are: {tool_supported_fields}")
+            exit(1)
+
+        print(tool_fields[args.field])
+        exit(0)
+
+    if "git-commit" in tools[args.tool]:
+        new_value, url = bump_commit(tools, args.tool)
+        if new_value and tools[args.tool]["git-commit"] != new_value:
+            print(f"Updating {args.tool} from {tools[args.tool]['git-commit']} to {new_value}")
+            if url:
+                print(f'Check {url} for changes')
+            tools[args.tool]["git-commit"] = new_value
+    elif "version" in tools[args.tool]:
+        new_value, url = bump_version(tools, args.tool)
+        if new_value and tools[args.tool]["version"] != new_value:
+            print(f"Updating {args.tool} from {tools[args.tool]['version']} to {new_value}")
+            if url:
+                print(f'Check {url} for changes')
+            tools[args.tool]["version"] = new_value
+    else:
+        print('Unsupported update tool')
+        exit(1)
+
+    with open(data_file, "w") as f:
+        f.write(json.dumps(tools, indent=2))
+
+    exit(0)