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

siliconcompiler/tool.py

@@ -61,11 +61,35 @@ class TaskExecutableNotFound(TaskError):
 
 
 class TaskSchema(NamedSchema):
-    def __init__(self, name=None):
-        super().__init__(name=name)
+    def __init__(self, name):
+        super().__init__(name)
 
         schema_task(self)
 
+    def add_parameter(self, name, type, help, defvalue=None):
+        '''
+        Adds a parameter to the task definition.
+
+        Args:
+            name (str): name of parameter
+            type (str): schema type of the parameter
+            help (str): help string for this parameter
+            defvalue (any): default value for the parameter
+        '''
+        help = trim(help)
+        param = Parameter(
+            type,
+            defvalue=defvalue,
+            scope=Scope.JOB,
+            pernode=PerNode.OPTIONAL,
+            shorthelp=help,
+            help=help
+        )
+
+        EditableSchema(self).insert("var", name, param)
+
+        return param
+
 
 class ToolSchema(NamedSchema):
     __parse_version_check_str = r"""
@@ -83,13 +107,13 @@ class ToolSchema(NamedSchema):
         r"^\s*" + __parse_version_check_str + r"\s*$",
         re.VERBOSE | re.IGNORECASE)
 
-    def __init__(self, name=None):
-        super().__init__(name=name)
+    def __init__(self, name):
+        super().__init__(name)
 
         schema_tool(self)
 
         schema = EditableSchema(self)
-        schema.insert("task", "default", TaskSchema())
+        schema.insert("task", "default", TaskSchema(None))
 
         self.set_runtime(None)
 
@@ -144,6 +168,14 @@ class ToolSchema(NamedSchema):
 
         return self.__step, self.__index
 
+    def tool(self):
+        '''
+        Returns:
+            task name
+        '''
+
+        return self.__tool
+
     def task(self):
         '''
         Returns:
@@ -351,13 +383,14 @@ class ToolSchema(NamedSchema):
                 envvars[lic_env] = ':'.join(license_file)
 
         if include_path:
-            path_param = self.get('path', field=None, step=self.__step, index=self.__index)
-            if path_param.get(field='package'):
-                raise NotImplementedError
+            path = self.find_files(
+                "path", step=self.__step, index=self.__index,
+                packages=self.__chip.get("package", field="schema").get_resolvers(),
+                cwd=self.__chip.cwd,
+                missing_ok=True)
 
             envvars["PATH"] = os.getenv("PATH", os.defpath)
 
-            path = path_param.get(field=None).resolve_path()  # TODO: needs package search
             if path:
                 envvars["PATH"] = path + os.pathsep + envvars["PATH"]
 
@@ -383,15 +416,6 @@ class ToolSchema(NamedSchema):
         '''
 
         cmdargs = []
-        cmdargs.extend(self.get('task', self.__task, 'option',
-                                step=self.__step, index=self.__index))
-
-        # Add scripts files / TODO:
-        scripts = self.__chip.find_files('tool', self.__tool, 'task', self.__task, 'script',
-                                         step=self.__step, index=self.__index)
-
-        cmdargs.extend(scripts)
-
         try:
             cmdargs.extend(self.runtime_options())
         except Exception as e:
@@ -417,6 +441,10 @@ class ToolSchema(NamedSchema):
         replay_opts["exports"] = self.get_runtime_environmental_variables(include_path=include_path)
 
         replay_opts["executable"] = self.get('exe')
+        replay_opts["step"] = self.__step
+        replay_opts["index"] = self.__index
+        replay_opts["cfg_file"] = f"inputs/{self.__chip.design}.pkg.json"
+        replay_opts["node_only"] = 0 if replay_opts["executable"] else 1
 
         vswitch = self.get('vswitch')
         if vswitch:
@@ -428,23 +456,25 @@ class ToolSchema(NamedSchema):
         # detect file paths
         file_test = re.compile(r'^[/\.]')
 
-        format_cmd = [replay_opts["executable"]]
+        if replay_opts["executable"]:
+            format_cmd = [replay_opts["executable"]]
 
-        for cmdarg in self.get_runtime_arguments():
-            add_new_line = len(format_cmd) == 1
+            for cmdarg in self.get_runtime_arguments():
+                add_new_line = len(format_cmd) == 1
 
-            if arg_test.match(cmdarg) or file_test.match(cmdarg):
-                add_new_line = True
-            else:
-                if not arg_test.match(format_cmd[-1]):
+                if arg_test.match(cmdarg) or file_test.match(cmdarg):
                     add_new_line = True
+                else:
+                    if not arg_test.match(format_cmd[-1]):
+                        add_new_line = True
 
-            cmdarg = shlex.quote(cmdarg)
-            if add_new_line:
-                format_cmd.append(cmdarg)
-            else:
-                format_cmd[-1] += f' {cmdarg}'
-
+                cmdarg = shlex.quote(cmdarg)
+                if add_new_line:
+                    format_cmd.append(cmdarg)
+                else:
+                    format_cmd[-1] += f' {cmdarg}'
+        else:
+            format_cmd = []
         replay_opts["cmds"] = format_cmd
 
         # create replay file
@@ -812,7 +842,17 @@ class ToolSchema(NamedSchema):
         pass
 
     def runtime_options(self):
-        return []
+        cmdargs = []
+        cmdargs.extend(self.get('task', self.__task, 'option',
+                                step=self.__step, index=self.__index))
+
+        # Add scripts files / TODO:
+        scripts = self.__chip.find_files('tool', self.__tool, 'task', self.__task, 'script',
+                                         step=self.__step, index=self.__index)
+
+        cmdargs.extend(scripts)
+
+        return cmdargs
 
     def run(self):
         raise NotImplementedError("must be implemented by the implementation class")
@@ -825,6 +865,9 @@ class ToolSchema(NamedSchema):
 # Migration helper
 ###########################################################################
 class ToolSchemaTmp(ToolSchema):
+    def __init__(self):
+        super().__init__(None)
+
     def __module_func(self, name, modules):
         for module in modules:
             method = getattr(module, name, None)
@@ -860,32 +903,76 @@ class ToolSchemaTmp(ToolSchema):
             return method(version)
         return ToolSchema.normalize_version(self, version)
 
+    def generate_replay_script(self, filepath, workdir, include_path=True):
+        prev_step, prev_index = self._ToolSchema__chip.get('arg', 'step'), \
+            self._ToolSchema__chip.get('arg', 'index')
+        step, index = self.node()
+        self._ToolSchema__chip.set('arg', 'step', step)
+        self._ToolSchema__chip.set('arg', 'index', index)
+        ret = ToolSchema.generate_replay_script(self, filepath, workdir, include_path=include_path)
+        self._ToolSchema__chip.set('arg', 'step', prev_step)
+        self._ToolSchema__chip.set('arg', 'index', prev_index)
+        return ret
+
     def setup(self):
         _, task = self.__tool_task_modules()
         method = self.__module_func("setup", [task])
         if method:
-            return method(self._ToolSchema__chip)
+            prev_step, prev_index = self._ToolSchema__chip.get('arg', 'step'), \
+                self._ToolSchema__chip.get('arg', 'index')
+            step, index = self.node()
+            self._ToolSchema__chip.set('arg', 'step', step)
+            self._ToolSchema__chip.set('arg', 'index', index)
+            ret = method(self._ToolSchema__chip)
+            self._ToolSchema__chip.set('arg', 'step', prev_step)
+            self._ToolSchema__chip.set('arg', 'index', prev_index)
+            return ret
         return ToolSchema.setup(self)
 
     def select_input_nodes(self):
         _, task = self.__tool_task_modules()
         method = self.__module_func("_select_inputs", [task])
         if method:
-            return method(self._ToolSchema__chip, *self.node())
+            prev_step, prev_index = self._ToolSchema__chip.get('arg', 'step'), \
+                self._ToolSchema__chip.get('arg', 'index')
+            step, index = self.node()
+            self._ToolSchema__chip.set('arg', 'step', step)
+            self._ToolSchema__chip.set('arg', 'index', index)
+            ret = method(self._ToolSchema__chip, *self.node())
+            self._ToolSchema__chip.set('arg', 'step', prev_step)
+            self._ToolSchema__chip.set('arg', 'index', prev_index)
+            return ret
         return ToolSchema.select_input_nodes(self)
 
     def pre_process(self):
         _, task = self.__tool_task_modules()
         method = self.__module_func("pre_process", [task])
         if method:
-            return method(self._ToolSchema__chip)
+            prev_step, prev_index = self._ToolSchema__chip.get('arg', 'step'), \
+                self._ToolSchema__chip.get('arg', 'index')
+            step, index = self.node()
+            self._ToolSchema__chip.set('arg', 'step', step)
+            self._ToolSchema__chip.set('arg', 'index', index)
+            ret = method(self._ToolSchema__chip)
+            self._ToolSchema__chip.set('arg', 'step', prev_step)
+            self._ToolSchema__chip.set('arg', 'index', prev_index)
+            return ret
         return ToolSchema.pre_process(self)
 
     def runtime_options(self):
         tool, task = self.__tool_task_modules()
         method = self.__module_func("runtime_options", [task, tool])
         if method:
-            return method(self._ToolSchema__chip)
+            prev_step, prev_index = self._ToolSchema__chip.get('arg', 'step'), \
+                self._ToolSchema__chip.get('arg', 'index')
+            step, index = self.node()
+            self._ToolSchema__chip.set('arg', 'step', step)
+            self._ToolSchema__chip.set('arg', 'index', index)
+            ret = ToolSchema.runtime_options(self)
+            ret.extend(method(self._ToolSchema__chip))
+            self._ToolSchema__chip.set('arg', 'step', prev_step)
+            self._ToolSchema__chip.set('arg', 'index', prev_index)
+            return ret
         return ToolSchema.runtime_options(self)
 
     def run(self):
@@ -898,7 +985,14 @@ class ToolSchemaTmp(ToolSchema):
             if self._ToolSchema__chip.get('option', 'quiet', step=step, index=index):
                 self._ToolSchema__chip.logger._console.setLevel(logging.CRITICAL)
 
+            prev_step, prev_index = self._ToolSchema__chip.get('arg', 'step'), \
+                self._ToolSchema__chip.get('arg', 'index')
+            step, index = self.node()
+            self._ToolSchema__chip.set('arg', 'step', step)
+            self._ToolSchema__chip.set('arg', 'index', index)
             retcode = method(self._ToolSchema__chip)
+            self._ToolSchema__chip.set('arg', 'step', prev_step)
+            self._ToolSchema__chip.set('arg', 'index', prev_index)
 
             self._ToolSchema__chip.logger._console.setLevel(stdout_handler_level)
 
@@ -909,7 +1003,15 @@ class ToolSchemaTmp(ToolSchema):
         _, task = self.__tool_task_modules()
         method = self.__module_func("post_process", [task])
         if method:
-            return method(self._ToolSchema__chip)
+            prev_step, prev_index = self._ToolSchema__chip.get('arg', 'step'), \
+                self._ToolSchema__chip.get('arg', 'index')
+            step, index = self.node()
+            self._ToolSchema__chip.set('arg', 'step', step)
+            self._ToolSchema__chip.set('arg', 'index', index)
+            ret = method(self._ToolSchema__chip)
+            self._ToolSchema__chip.set('arg', 'step', prev_step)
+            self._ToolSchema__chip.set('arg', 'index', prev_index)
+            return ret
         return ToolSchema.post_process(self)
 
 

siliconcompiler/tools/_common/__init__.py

@@ -377,17 +377,20 @@ def input_file_node_name(filename, step, index):
 
     file_type = get_file_ext(filename)
 
-    base = filename
-    total_ext = []
-    ext = None
-    while ext != file_type:
-        base, ext = os.path.splitext(base)
-        ext = ext[1:].lower()
-        total_ext.append(ext)
-
-    total_ext.reverse()
-
-    return f'{base}.{step}{index}.{".".join(total_ext)}'
+    if file_type:
+        base = filename
+        ext = None
+        total_ext = []
+        while ext != file_type:
+            base, ext = os.path.splitext(base)
+            ext = ext[1:].lower()
+            total_ext.append(ext)
+
+        total_ext.reverse()
+
+        return f'{base}.{step}{index}.{".".join(total_ext)}'
+    else:
+        return f'{filename}.{step}{index}'
 
 
 def add_common_file(chip, key, file):

siliconcompiler/tools/builtin/concatenate.py

@@ -3,7 +3,7 @@ import os
 from siliconcompiler import sc_open, SiliconCompilerError
 from siliconcompiler import utils
 from siliconcompiler.tools._common import input_provides, input_file_node_name, get_tool_task
-from siliconcompiler import scheduler
+from siliconcompiler.scheduler.schedulernode import SchedulerNode
 
 
 def make_docs(chip):
@@ -12,7 +12,7 @@ def make_docs(chip):
     chip.set('option', 'flow', 'asicflow')
 
     for step, index in chip.schema.get("flowgraph", "asicflow", field="schema").get_entry_nodes():
-        scheduler._setup_node(chip, step, index)
+        SchedulerNode(chip, step, index).setup()
 
     chip.set('arg', 'step', 'import.combine')
     chip.set('arg', 'index', '0')

siliconcompiler/tools/builtin/verify.py

@@ -1,6 +1,5 @@
 from siliconcompiler.tools.builtin import _common
 from siliconcompiler.schema.parametertype import NodeType
-from siliconcompiler.scheduler import _haltstep
 from siliconcompiler.tools.builtin.builtin import set_io_files
 from siliconcompiler import utils, SiliconCompilerError
 from siliconcompiler.tools._common import get_tool_task
@@ -59,7 +58,7 @@ def _select_inputs(chip, step, index):
             chip.error(f"{step}{index} fails '{metric}' metric: {value}{op}{goal}")
 
     if not passes:
-        _haltstep(chip, flow, step, index)
+        return []
 
     return inputs
 

siliconcompiler/tools/openroad/scripts/common/procs.tcl

@@ -634,36 +634,38 @@ proc sc_setup_sta { } {
         set_timing_derate -late $sta_late_timing_derate
     }
 
-    # Create path groups
-    if {
-        [lindex [sc_cfg_tool_task_get var sta_define_path_groups] 0] == "true" &&
-        [llength [sta::path_group_names]] == 0
-    } {
-        sc_path_group -name in2out -from [all_inputs -no_clocks] -to [all_outputs]
-
+    if { [sc_check_version 19370] } {
+        # Create path groups
         if {
-            [llength [all_clocks]] == 1 ||
-            [lindex [sc_cfg_tool_task_get var sta_unique_path_groups_per_clock] 0] == "false"
+            [lindex [sc_cfg_tool_task_get var sta_define_path_groups] 0] == "true" &&
+            [llength [sta::path_group_names]] == 0
         } {
-            sc_path_group -name in2reg -from [all_inputs -no_clocks] -to [all_registers]
-            sc_path_group -name reg2reg -from [all_registers] -to [all_registers]
-            sc_path_group -name reg2out -from [all_registers] -to [all_outputs]
-        } else {
-            foreach clock [all_clocks] {
-                set clk_name [get_property $clock name]
-                sc_path_group -name in2reg.${clk_name} \
-                    -from [all_inputs -no_clocks] \
-                    -to [all_registers -clock $clock]
-                sc_path_group -name reg2reg.${clk_name} \
-                    -from [all_registers -clock $clock] \
-                    -to [all_registers -clock $clock]
-                sc_path_group -name reg2out.${clk_name} \
-                    -from [all_registers -clock $clock] \
-                    -to [all_outputs]
+            sc_path_group -name in2out -from [all_inputs -no_clocks] -to [all_outputs]
+
+            if {
+                [llength [all_clocks]] == 1 ||
+                [lindex [sc_cfg_tool_task_get var sta_unique_path_groups_per_clock] 0] == "false"
+            } {
+                sc_path_group -name in2reg -from [all_inputs -no_clocks] -to [all_registers]
+                sc_path_group -name reg2reg -from [all_registers] -to [all_registers]
+                sc_path_group -name reg2out -from [all_registers] -to [all_outputs]
+            } else {
+                foreach clock [all_clocks] {
+                    set clk_name [get_property $clock name]
+                    sc_path_group -name in2reg.${clk_name} \
+                        -from [all_inputs -no_clocks] \
+                        -to [all_registers -clock $clock]
+                    sc_path_group -name reg2reg.${clk_name} \
+                        -from [all_registers -clock $clock] \
+                        -to [all_registers -clock $clock]
+                    sc_path_group -name reg2out.${clk_name} \
+                        -from [all_registers -clock $clock] \
+                        -to [all_outputs]
+                }
             }
         }
+        utl::info FLW 1 "Timing path groups: [sta::path_group_names]"
     }
-    utl::info FLW 1 "Timing path groups: [sta::path_group_names]"
 
     # Check timing setup
     if { [sc_cfg_tool_task_check_in_list check_setup var reports] } {

siliconcompiler/tools/slang/__init__.py

@@ -11,6 +11,7 @@ Sources: https://github.com/MikePopoloski/slang
 Installation: https://sv-lang.com/building.html
 '''
 import os
+import shlex
 
 try:
     import pyslang
@@ -121,7 +122,6 @@ def common_runtime_options(chip):
     ###############################
     # Set up user-provided parameters to ensure we elaborate the correct modules
     for param, value in opts['param']:
-        value = value.replace('"', '\\"')
         options.extend(['-G', f'{param}={value}'])
 
     return options
@@ -135,7 +135,8 @@ def _get_driver(chip, options_func, ignored_diagnotics=None):
 
     parse_options = pyslang.CommandLineOptions()
     parse_options.ignoreProgramName = True
-    opts = " ".join(options)
+    opts = shlex.join(options)
+    chip.logger.info(f"runtime arguments: {opts}")
     code = 0
     if not driver.parseCommandLine(opts, parse_options):
         code = 1

siliconcompiler/tools/vpr/route.py

@@ -44,6 +44,45 @@ def setup(chip, clobber=True):
     chip.add('tool', tool, 'task', task, 'output', design + '.net', step=step, index=index)
     chip.add('tool', tool, 'task', task, 'output', design + '.place', step=step, index=index)
 
+    # Add a parameter for generating a post-implementation netlist for external
+    # static timing analysis.
+    chip.set('tool', tool, 'task', task, 'var', 'gen_post_implementation_netlist',
+             False, step=step, index=index, clobber=False)
+
+    chip.set('tool', tool, 'task', task, 'var', 'gen_post_implementation_netlist',
+             'set to true to have VPR generate a post-implementation netlist',
+             field='help')
+
+    chip.set('tool', tool, 'task', task, 'require',
+             ",".join(['tool', tool, 'task', task, 'var', 'gen_post_implementation_netlist']),
+             step=step, index=index)
+
+    # Add a parameter to control the timing corner used when generating SDF files.
+    chip.set('tool', tool, 'task', task, 'var', 'timing_corner', 'typical',
+             step=step, index=index, clobber=False)
+
+    chip.set('tool', tool, 'task', task, 'var', 'timing_corner',
+             'set the timing corner for files generated by the post-implementation netlist',
+             field='help')
+
+    chip.set('tool', tool, 'task', task, 'require',
+             ",".join(['tool', tool, 'task', task, 'var', 'timing_corner']),
+             step=step, index=index)
+
+    # Add the post-implementation timing netlist outputs if requested.
+    gen_post_implementation_netlist = chip.get('tool', tool, 'task', task, 'var',
+                                               'gen_post_implementation_netlist',
+                                               step=step, index=index)[0]
+    timing_corner = chip.get('tool', tool, 'task', task, 'var', 'timing_corner',
+                             step=step, index=index)[0]
+    if gen_post_implementation_netlist == 'true':
+        chip.add('tool', tool, 'task', task, 'output', f'{design}.vg',
+                 step=step, index=index)
+        chip.add('tool', tool, 'task', task, 'output', f'{design}.sdc',
+                 step=step, index=index)
+        chip.add('tool', tool, 'task', task, 'output', f'{design}.{timing_corner}.sdf',
+                 step=step, index=index)
+
 
 def runtime_options(chip):
     '''Command line options to vpr for the route step
@@ -104,6 +143,21 @@ def runtime_options(chip):
         options.append("--graphics_commands")
         options.append(graphics_command_str)
 
+    # Generate a post-implementation netlist for use in external timing analysis
+    # if requested.
+    gen_post_implementation_netlist = chip.get('tool', tool, 'task', task, 'var',
+                                               'gen_post_implementation_netlist',
+                                               step=step, index=index)[0]
+    if gen_post_implementation_netlist == 'true':
+        # Generate the netlist.
+        options.extend(["--gen_post_synthesis_netlist", "on"])
+        # Generate the SDC file.
+        options.extend(["--gen_post_implementation_sdc", "on"])
+        # Create undriven nets for unconnected inputs.
+        options.extend(["--post_synth_netlist_unconn_inputs", "nets"])
+        # Turn off module parameters.
+        options.extend(["--post_synth_netlist_module_parameters", "off"])
+
     return options
 
 
@@ -122,3 +176,18 @@ def post_process(chip):
     shutil.copy2(f'inputs/{design}.blif', 'outputs')
     shutil.copy2(f'inputs/{design}.net', 'outputs')
     shutil.copy2(f'inputs/{design}.place', 'outputs')
+
+    # Copy and rename the post-implementation netlist results into the output
+    # directory to be used in external timing analysis.
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+    gen_post_implementation_netlist = chip.get('tool', tool, 'task', task, 'var',
+                                               'gen_post_implementation_netlist',
+                                               step=step, index=index)[0]
+    timing_corner = chip.get('tool', tool, 'task', task, 'var', 'timing_corner',
+                             step=step, index=index)[0]
+    if gen_post_implementation_netlist == 'true':
+        shutil.move(f'{design}_post_synthesis.v', f'outputs/{design}.vg')
+        shutil.move(f'{design}_post_synthesis.sdc', f'outputs/{design}.sdc')
+        shutil.move(f'{design}_post_synthesis.sdf', f'outputs/{design}.{timing_corner}.sdf')

siliconcompiler/tools/yosys/sc_synth_asic.tcl

@@ -120,10 +120,6 @@ if { [lindex [sc_cfg_tool_task_get var use_slang] 0] == "true" && [sc_load_plugi
     set slang_params []
     if { [sc_cfg_exists option param] } {
         dict for {key value} [sc_cfg_get option param] {
-            if { ![string is integer $value] } {
-                set value [concat \"$value\"]
-            }
-
             lappend slang_params -G "${key}=${value}"
         }
     }

siliconcompiler/toolscripts/_tools.json

@@ -1,7 +1,7 @@
 {
   "openroad": {
     "git-url": "https://github.com/The-OpenROAD-Project/OpenROAD.git",
-    "git-commit": "b0107893ea0693f3cf09bbf95450a38c1b26b950",
+    "git-commit": "4b729ea474e9bd0a3513579b41a8c96fe20dc75e",
     "docker-cmds": [
       "# Remove OR-Tools files",
       "RUN rm -f $SC_PREFIX/Makefile $SC_PREFIX/README.md",
@@ -17,7 +17,7 @@
   },
   "opensta": {
     "git-url": "https://github.com/parallaxsw/OpenSTA.git",
-    "git-commit": "71bdfb99049f33a010bb23527c5c921c925378a0",
+    "git-commit": "343b93b6336962b2dbcc5b7c7500c01df0367696",
     "auto-update": true
   },
   "netgen": {
@@ -41,12 +41,17 @@
     "auto-update": false
   },
   "klayout": {
-    "version": "0.30.1",
+    "version": "0.30.2",
     "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"
+    "release-notes": "https://www.klayout.de/development.html",
+    "docker-cmds": [
+      "RUN echo \"#!/bin/bash\" > $SC_PREFIX/install-klayout.sh",
+      "RUN echo \"sudo apt-get install -y $SC_PREFIX/klayout.deb\" >> $SC_PREFIX/install-klayout.sh",
+      "RUN echo \"sudo rm $SC_PREFIX/klayout.deb\" >> $SC_PREFIX/install-klayout.sh",
+      "RUN chmod +x $SC_PREFIX/install-klayout.sh"
+    ]
   },
   "sv2v": {
     "git-url": "https://github.com/zachjs/sv2v.git",
@@ -96,7 +101,7 @@
   },
   "yosys": {
     "git-url": "https://github.com/YosysHQ/yosys.git",
-    "git-commit": "v0.53",
+    "git-commit": "v0.54",
     "version-prefix": "",
     "auto-update": true
   },
@@ -135,7 +140,7 @@
     "auto-update": false
   },
   "slang": {
-    "git-commit": "v8.0",
+    "git-commit": "v8.1",
     "git-url": "https://github.com/MikePopoloski/slang.git",
     "auto-update": true
   },
@@ -146,7 +151,7 @@
   },
   "yosys-slang": {
     "git-url": "https://github.com/povik/yosys-slang.git",
-    "git-commit": "34753c07b7bd285b784b3a2c756cfac56e1a26ab",
+    "git-commit": "e863336db656b1f0ec82f7af65249b6a4ee3e56c",
     "docker-depends": "yosys",
     "auto-update": true
   },

siliconcompiler/toolscripts/ubuntu22/install-klayout.sh

@@ -35,4 +35,8 @@ wget -O klayout.deb $url
 # Install package
 sudo apt-get install -y ./klayout.deb
 
+if [ ! -z ${SC_PREFIX+x} ]; then
+    sudo cp ./klayout.deb "${SC_PREFIX}/"
+fi
+
 cd -

siliconcompiler/toolscripts/ubuntu24/install-klayout.sh

@@ -37,4 +37,8 @@ wget -O klayout.deb $url
 # Install package
 sudo apt-get install -y ./klayout.deb
 
+if [ ! -z ${SC_PREFIX+x} ]; then
+    sudo cp ./klayout.deb "${SC_PREFIX}/"
+fi
+
 cd -