siliconcompiler 0.32.2__py3-none-any.whl → 0.33.0__py3-none-any.whl

siliconcompiler/tools/opensta/scripts/sc_timing.tcl

@@ -2,7 +2,7 @@
 # Reading SC Schema
 ###############################
 
-source ./sc_manifest.tcl > /dev/null
+source ./sc_manifest.tcl
 
 ##############################
 # Schema Adapter
@@ -38,6 +38,12 @@ foreach corner [dict keys [sc_cfg_get constraint timing]] {
 # MACROS
 set sc_macrolibs [sc_get_asic_libraries macro]
 
+###############################
+# Source helper functions
+###############################
+
+source "$sc_refdir/sc_procs.tcl"
+
 ###############################
 # Read Files
 ###############################
@@ -104,6 +110,34 @@ if { [file exists "inputs/${sc_design}.sdc"] } {
     read_sdc "${sdc}"
 }
 
+# Create path groups
+if { [llength [sta::path_group_names]] == 0 } {
+    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 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]
+        }
+    }
+}
+puts "Timing path groups: [sta::path_group_names]"
+
 ###############################
 
 foreach corner $sc_scenarios {
@@ -116,12 +150,6 @@ foreach corner $sc_scenarios {
     }
 }
 
-###############################
-# Source helper functions
-###############################
-
-source "$sc_refdir/sc_procs.tcl"
-
 ###############################
 # Report Metrics
 ###############################

siliconcompiler/tools/opensta/timing.py

@@ -45,6 +45,10 @@ def setup(chip):
     set_tool_task_var(chip, param_key='top_n_paths',
                       default_value='10',
                       schelp='number of paths to report timing for')
+    set_tool_task_var(chip, param_key='unique_path_groups_per_clock',
+                      default_value=False,
+                      skip=['pdk', 'lib'],
+                      schelp='true/false, if true will generate separate path groups per clock')
 
     modes = get_timing_modes(chip)
 
@@ -165,13 +169,13 @@ def post_process(chip):
                     metric = None
                 elif metric in ('holdslack', 'setupslack'):
                     if slack:
-                        record_metric(chip, step, index, metric, float(slack.group(1)),
+                        record_metric(chip, step, index, metric, float(slack.group(1).split()[-1]),
                                       __report_map(chip, metric, logfile),
                                       source_unit=timescale)
                         metric = None
                 elif metric in ('setuptns', 'holdtns'):
                     if tns:
-                        record_metric(chip, step, index, metric, float(tns.group(1)),
+                        record_metric(chip, step, index, metric, float(tns.group(1).split()[-1]),
                                       __report_map(chip, metric, logfile),
                                       source_unit=timescale)
                         metric = None

siliconcompiler/tools/slang/__init__.py

@@ -70,38 +70,38 @@ def common_runtime_options(chip):
                                  'param'])
 
     if opts['libext']:
-        options.append(f'--libext {",".join(opts["libext"])}')
+        options.extend(['--libext', f'{",".join(opts["libext"])}'])
 
     #####################
     # Library directories
     #####################
     if opts['ydir']:
-        options.append(f'-y {",".join(opts["ydir"])}')
+        options.extend(['-y', f'{",".join(opts["ydir"])}'])
 
     #####################
     # Library files
     #####################
     if opts['vlib']:
-        options.append(f'-libfile {",".join(opts["vlib"])}')
+        options.extend(['-libfile', f'{",".join(opts["vlib"])}'])
 
     #####################
     # Include paths
     #####################
     if opts['idir']:
-        options.append(f'--include-directory {",".join(opts["idir"])}')
+        options.extend(['--include-directory', f'{",".join(opts["idir"])}'])
 
     #######################
     # Variable Definitions
     #######################
     for value in opts['define']:
-        options.append('-D ' + value)
+        options.extend(['-D', value])
 
     #######################
     # Command files
     #######################
     cmdfiles = get_input_files(chip, 'input', 'cmdfile', 'f')
     if cmdfiles:
-        options.append(f'-F {",".join(cmdfiles)}')
+        options.extend(['-F', f'{",".join(cmdfiles)}'])
 
     #######################
     # Sources
@@ -114,7 +114,7 @@ def common_runtime_options(chip):
     #######################
     # Top Module
     #######################
-    options.append('--top ' + chip.top(step, index))
+    options.extend(['--top', chip.top(step, index)])
 
     ###############################
     # Parameters (top module only)
@@ -122,7 +122,7 @@ 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.append(f'-G {param}={value}')
+        options.extend(['-G', f'{param}={value}'])
 
     return options
 
@@ -211,5 +211,5 @@ def _diagnostics(chip, driver, compilation):
     for diag in compilation.getAllDiagnostics():
         diags.issue(diag)
 
-    record_metric(chip, step, index, 'errors', diags.numErrors, [])
-    record_metric(chip, step, index, 'warnings', diags.numWarnings, [])
+    record_metric(chip, step, index, 'errors', diags.numErrors, [f'sc_{step}{index}.log'])
+    record_metric(chip, step, index, 'warnings', diags.numWarnings, [f'sc_{step}{index}.log'])

siliconcompiler/tools/surelog/parse.py

@@ -83,13 +83,13 @@ def runtime_options(chip):
     # Library directories
     #####################
     for value in opts['ydir']:
-        cmdlist.append('-y ' + value)
+        cmdlist.extend(['-y', value])
 
     #####################
     # Library files
     #####################
     for value in opts['vlib']:
-        cmdlist.append('-v ' + value)
+        cmdlist.extend(['-v', value])
 
     #####################
     # Include paths
@@ -107,7 +107,7 @@ def runtime_options(chip):
     # Command files
     #######################
     for value in get_input_files(chip, 'input', 'cmdfile', 'f'):
-        cmdlist.append('-f ' + value)
+        cmdlist.extend(['-f', + value])
 
     #######################
     # Sources
@@ -120,7 +120,7 @@ def runtime_options(chip):
     #######################
     # Top Module
     #######################
-    cmdlist.append(f'-top {chip.top(step, index)}')
+    cmdlist.extend(['-top', chip.top(step, index)])
 
     ###############################
     # Parameters (top module only)

siliconcompiler/tools/sv2v/convert.py

@@ -23,6 +23,26 @@ def setup(chip):
     chip.set('tool', tool, 'vswitch', '--numeric-version')
     chip.set('tool', tool, 'version', '>=0.0.9', clobber=False)
 
+    chip.add('tool', tool, 'task', task, 'require',
+             ",".join(['tool', tool, 'task', task, 'var', 'skip_convert']), step=step, index=index)
+    chip.set('tool', tool, 'task', task, 'var', 'skip_convert',
+             'true/false, if true will skip converting system verilog to verilog', field='help')
+    skip = chip.get('tool', tool, 'task', task, 'var', 'skip_convert', step=step, index=index)
+    if skip:
+        skip = skip[0] == "true"
+    else:
+        skip = False
+    chip.set('tool', tool, 'task', task, 'var', 'skip_convert', skip,
+             step=step, index=index, clobber=False)
+
+    chip.set('tool', tool, 'task', task, 'input', f'{topmodule}.sv', step=step, index=index)
+
+    if skip:
+        chip.set('tool', tool, 'task', task, 'output', f'{topmodule}.sv', step=step, index=index)
+        return "passing system verilog along"
+
+    chip.set('tool', tool, 'task', task, 'output', f'{topmodule}.v', step=step, index=index)
+
     chip.set('tool', tool, 'task', task, 'threads', utils.get_cores(chip),
              step=step, index=index, clobber=False)
 
@@ -41,6 +61,3 @@ def setup(chip):
              step=step, index=index)
     chip.add('tool', tool, 'task', task, 'option', "--write=outputs/" + topmodule + ".v",
              step=step, index=index)
-
-    chip.set('tool', tool, 'task', task, 'input', f'{topmodule}.sv', step=step, index=index)
-    chip.set('tool', tool, 'task', task, 'output', f'{topmodule}.v', step=step, index=index)

siliconcompiler/tools/verilator/compile.py

@@ -161,12 +161,12 @@ def runtime_options(chip):
 
     if c_flags:
         cflags_str = ' '.join(c_flags)
-        cmdlist.extend(['-CFLAGS', f'"{cflags_str}"'])
+        cmdlist.extend(['-CFLAGS', cflags_str])
 
     ld_flags = chip.get('tool', tool, 'task', task, 'var', 'ldflags', step=step, index=index)
     if ld_flags:
         ldflags_str = ' '.join(ld_flags)
-        cmdlist.extend(['-LDFLAGS', f'"{ldflags_str}"'])
+        cmdlist.extend(['-LDFLAGS', ldflags_str])
 
     for value in get_input_files(chip, 'input', 'hll', 'c'):
         cmdlist.append(value)

siliconcompiler/tools/verilator/verilator.py

@@ -144,9 +144,9 @@ def runtime_options(chip):
         cmdlist.append(f'inputs/{design}.v')
     else:
         for value in frontend_opts['ydir']:
-            cmdlist.append(f'-y {value}')
+            cmdlist.extend(['-y', value])
         for value in frontend_opts['vlib']:
-            cmdlist.append(f'-v {value}')
+            cmdlist.extend(['-v', value])
         for value in frontend_opts['idir']:
             cmdlist.append(f'-I{value}')
         for value in frontend_opts['define']:
@@ -160,7 +160,7 @@ def runtime_options(chip):
             cmdlist.append(value)
 
     for value in get_input_files(chip, 'input', 'cmdfile', 'f'):
-        cmdlist.append(f'-f {value}')
+        cmdlist.extend(['-f', value])
 
     return cmdlist
 

siliconcompiler/tools/vpr/place.py

@@ -62,7 +62,7 @@ def runtime_options(chip):
         graphics_command_str = " ".join(graphics_commands)
 
         options.append("--graphics_commands")
-        options.append(f"\"{graphics_command_str}\"")
+        options.append(graphics_command_str)
 
     return options
 

siliconcompiler/tools/vpr/route.py

@@ -62,8 +62,8 @@ def runtime_options(chip):
 
     options.append('--route')
     # To run only the routing step we need to pass in the placement files
-    options.append(f'--net_file inputs/{design}.net')
-    options.append(f'--place_file inputs/{design}.place')
+    options.extend(['--net_file', f'inputs/{design}.net'])
+    options.extend(['--place_file', f'inputs/{design}.place'])
 
     enable_images = chip.get('tool', tool, 'task', task, 'var', 'enable_images',
                              step=step, index=index)[0]
@@ -72,7 +72,7 @@ def runtime_options(chip):
                                 step=step, index=index)
 
     if (len(route_iterations) > 0):
-        options.append(f'--max_router_iterations {route_iterations[0]}')
+        options.extend(['--max_router_iterations', route_iterations[0]])
 
     if enable_images == 'true':
         design = chip.top()
@@ -102,7 +102,7 @@ def runtime_options(chip):
         graphics_command_str = " ".join(graphics_commands)
 
         options.append("--graphics_commands")
-        options.append(f"\"{graphics_command_str}\"")
+        options.append(graphics_command_str)
 
     return options
 

siliconcompiler/tools/vpr/screenshot.py

@@ -49,6 +49,6 @@ def runtime_options(chip):
         raise SiliconCompilerError(f"Incorrect file type {show_type}", chip=chip)
 
     options.append("--graphics_commands")
-    options.append(f"\"{screenshot_command_str}\"")
+    options.append(screenshot_command_str)
 
     return options

siliconcompiler/tools/vpr/show.py

@@ -64,14 +64,14 @@ def generic_show_options(chip):
         raise SiliconCompilerError("Blif file does not exist", chip=chip)
 
     if os.path.exists(net_file):
-        options.append(f'--net_file {net_file}')
+        options.extend(['--net_file', net_file])
     else:
         raise SiliconCompilerError("Net file does not exist", chip=chip)
 
     if os.path.exists(route_file) and os.path.exists(place_file):
         options.append('--analysis')
-        options.append(f'--place_file {place_file}')
-        options.append(f'--route_file {route_file}')
+        options.extend(['--place_file', place_file])
+        options.extend(['--route_file', route_file])
     elif os.path.exists(place_file):
         # NOTE: This is a workaround to display the VPR GUI on the output of the place step.
         # VPR GUI can be invoked during the place, route or analysis steps - not after they are run.
@@ -81,8 +81,8 @@ def generic_show_options(chip):
         # the placed design. Setting max_router_iterations to 0 avoids running routing iterations
         # and provides a fast way to invoke VPR GUI on the placed design.
         options.append('--route')
-        options.append('--max_router_iterations 0')
-        options.append(f'--place_file {place_file}')
+        options.extend(['--max_router_iterations', 0])
+        options.extend(['--place_file', place_file])
     else:
         raise SiliconCompilerError("Place file does not exist", chip=chip)
 

siliconcompiler/tools/vpr/vpr.py

@@ -103,15 +103,15 @@ def runtime_options(chip):
 
     device_code = chip.get('fpga', part_name, 'var', 'vpr_device_code')
 
-    options.append(f"--device {device_code[0]}")
+    options.extend(["--device", device_code[0]])
 
     # Medium-term solution:  VPR performs hash digest checks that
     # fail if file paths are changed between steps.  We wish to
     # disable the digest checks to work around this
-    options.append("--verify_file_digests off")
+    options.extend(["--verify_file_digests", "off"])
 
-    options.append(f"--write_block_usage {__block_file}")
-    options.append("--outfile_prefix outputs/")
+    options.extend(["--write_block_usage", __block_file])
+    options.extend(["--outfile_prefix", "outputs/"])
 
     if chip.valid('fpga', part_name, 'file', 'archfile') and \
        chip.get('fpga', part_name, 'file', 'archfile'):
@@ -133,25 +133,25 @@ def runtime_options(chip):
             "Only one architecture XML file can be passed to VPR", chip=chip)
 
     threads = chip.get('tool', tool, 'task', task, 'threads', step=step, index=index)
-    options.append(f"--num_workers {threads}")
+    options.extend(["--num_workers", threads])
 
     # For most architectures, constant nets need to be routed
     # like regular nets to be functionally correct (however inefficient
     # that might be...); these two options help control that
-    options.append('--constant_net_method route')
-    options.append('--const_gen_inference none')
+    options.extend(['--constant_net_method', 'route'])
+    options.extend(['--const_gen_inference', 'none'])
 
     # If we allow VPR to sweep dangling primary I/Os and logic blocks
     # it can interfere with circuit debugging; so disable that
-    options.append('--sweep_dangling_primary_ios off')
+    options.extend(['--sweep_dangling_primary_ios', 'off'])
     # If you don't sweep dangling primary I/Os, but sweeping nets
     # VPR can crash:
-    options.append('--sweep_dangling_nets off')
+    options.extend(['--sweep_dangling_nets', 'off'])
     # If you don't sweep dangling nets then the timing engine requires
     # you to set an option allowing dangling nodes
-    options.append('--allow_dangling_combinational_nodes on')
-    options.append('--sweep_constant_primary_outputs off')
-    options.append('--sweep_dangling_blocks off')
+    options.extend(['--allow_dangling_combinational_nodes', 'on'])
+    options.extend(['--sweep_constant_primary_outputs', 'off'])
+    options.extend(['--sweep_dangling_blocks', 'off'])
 
     # Explicitly specify the clock modeling type in the part driver
     # to avoid ambiguity and future-proof against new VPR clock models
@@ -163,11 +163,11 @@ def runtime_options(chip):
         # When dedicated networks are used, tell VPR to use the two-stage router,
         # otherwise not.
         if (selected_clock_model == 'ideal'):
-            options.append(f'--clock_modeling {selected_clock_model}')
+            options.extend(['--clock_modeling', selected_clock_model])
         elif (selected_clock_model == 'route'):
-            options.append(f'--clock_modeling {selected_clock_model}')
+            options.extend(['--clock_modeling', selected_clock_model])
         elif (selected_clock_model == 'dedicated_network'):
-            options.append(f'--clock_modeling {selected_clock_model}')
+            options.extend(['--clock_modeling', selected_clock_model])
             options.append('--two_stage_clock_routing')
         else:
             raise SiliconCompilerError(
@@ -181,24 +181,24 @@ def runtime_options(chip):
                                     file_not_found_msg="SDC file not found")
 
     if sdc_file:
-        sdc_arg = f"--sdc_file {sdc_file}"
-        options.append(sdc_arg)
+        options.append("--sdc_file")
+        options.append(sdc_file)
 
         report_type = chip.get('tool', tool, 'task', task, 'var', 'timing_report_type',
                                step=step, index=index)[0]
-        options.append(f'--timing_report_detail {report_type}')
+        options.extend(['--timing_report_detail', report_type])
         report_paths = chip.get('tool', tool, 'task', task, 'var', 'timing_paths',
                                 step=step, index=index)[0]
-        options.append(f'--timing_report_npaths {report_paths}')
+        options.extend(['--timing_report_npaths', report_paths])
     else:
-        options.append("--timing_analysis off")
+        options.extend(["--timing_analysis", "off"])
 
     # Per the scheme implemented in the placement pre-process step,
     # if a constraints file exists it will always be in the auto_constraints()
     # location:
     if (os.path.isfile(auto_constraints())):
-        pin_constraint_arg = f"--read_vpr_constraints {auto_constraints()}"
-        options.append(pin_constraint_arg)
+        options.append("--read_vpr_constraints")
+        options.append(auto_constraints())
 
     # Routing graph XML:
     rr_graph = find_single_file(chip, 'fpga', part_name, 'file', 'graphfile',
@@ -208,7 +208,7 @@ def runtime_options(chip):
         chip.logger.info("No VPR RR graph file specified")
         chip.logger.info("Routing architecture will come from architecture XML file")
     else:
-        options.append("--read_rr_graph " + rr_graph)
+        options.extend(["--read_rr_graph", rr_graph])
 
     # ***NOTE: For real FPGA chips you need to specify the routing channel
     #          width explicitly.  VPR requires an explicit routing channel
@@ -222,7 +222,7 @@ def runtime_options(chip):
     if (len(num_routing_channels) == 0):
         raise SiliconCompilerError("Number of routing channels not specified", chip=chip)
     elif (len(num_routing_channels) == 1):
-        options.append("--route_chan_width " + num_routing_channels[0])
+        options.extend(["--route_chan_width", num_routing_channels[0]])
     elif (len(num_routing_channels) > 1):
         raise SiliconCompilerError(
             "Only one routing channel width argument can be passed to VPR", chip=chip)

siliconcompiler/tools/xdm/convert.py

@@ -24,9 +24,9 @@ def setup(chip):
 
     chip.add('tool', tool, 'task', task, 'option', '--auto',
              step=step, index=index)
-    chip.add('tool', tool, 'task', task, 'option', '--source_file_format hspice',
+    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',
+    chip.add('tool', tool, 'task', task, 'option', ['--dir_out', f'outputs/{design}.xyce'],
              step=step, index=index)
 
     chip.set('tool', 'xdm', 'task', 'convert', 'var', 'rename', 'true',

siliconcompiler/tools/xyce/simulate.py

@@ -48,7 +48,7 @@ def setup(chip):
                 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',
+        chip.add('tool', tool, 'task', task, 'option', ['-r', f'outputs/{design}.raw'],
                  step=step, index=index)