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

siliconcompiler/tools/klayout/klayout_convert_drc_db.py

@@ -0,0 +1,182 @@
+# KLayout script to export an OpenROAD marker DB from a DRC db
+#
+# Based on:
+# https://github.com/The-OpenROAD-Project/OpenROAD-flow-scripts/blob/master/flow/util/convertDrc.py
+
+import pya
+import glob
+import json
+import os
+import sys
+
+
+def convert_drc(view, path):
+    rdb_id = view.create_rdb(os.path.basename(path))
+    rdb = view.rdb(rdb_id)
+    print(f"[INFO] reading {path}")
+    rdb.load(path)
+
+    source = os.path.abspath(path)
+
+    ordb = {
+        "source": source,
+        "description": "KLayout DRC conversion",
+        "category": {}
+    }
+
+    for category in rdb.each_category():
+        if category.num_items() == 0:
+            # ignore categories with no data
+            continue
+
+        ordb_category = {
+            "description": category.description,
+            "source": source,
+            "violations": []
+        }
+        ordb["category"][category.name()] = ordb_category
+
+        for item in rdb.each_item_per_category(category.rdb_id()):
+            violation = {
+                "visited": item.is_visited(),
+                "visible": True,
+                "waived": "waived" in item.tags_str
+            }
+
+            ordb_category["violations"].append(violation)
+
+            shapes = []
+            violation["shape"] = shapes
+
+            text = []
+
+            for value in item.each_value():
+                if value.is_box():
+                    shapes.append({
+                        "type": "box",
+                        "points": [{
+                            "x": value.box().left,
+                            "y": value.box().bottom
+                        }, {
+                            "x": value.box().right,
+                            "y": value.box().top
+                        }]
+                    })
+                elif value.is_edge():
+                    shapes.append({
+                        "type": "line",
+                        "points": [{
+                            "x": value.edge().p1.x,
+                            "y": value.edge().p1.y
+                        }, {
+                            "x": value.edge().p2.x,
+                            "y": value.edge().p2.y
+                        }]
+                    })
+                elif value.is_edge_pair():
+                    edge1 = value.edge_pair().first
+                    edge2 = value.edge_pair().second
+
+                    shapes.append({
+                        "type": "line",
+                        "points": [{
+                            "x": edge1.p1.x,
+                            "y": edge1.p1.y
+                        }, {
+                            "x": edge1.p2.x,
+                            "y": edge1.p2.y
+                        }]
+                    })
+                    shapes.append({
+                        "type": "line",
+                        "points": [{
+                            "x": edge2.p1.x,
+                            "y": edge2.p1.y
+                        }, {
+                            "x": edge2.p2.x,
+                            "y": edge2.p2.y
+                        }]
+                    })
+                elif value.is_polygon():
+                    points = []
+                    for edge in value.polygon().each_edge():
+                        points.append({
+                            "x": edge.p1.x,
+                            "y": edge.p1.y
+                        })
+                    points.append({
+                        "x": edge.p2.x,
+                        "y": edge.p2.y
+                    })
+                    shapes.append({
+                        "type": "polygon",
+                        "points": points
+                    })
+                elif value.is_path():
+                    points = []
+                    for edge in value.path().polygon().each_edge():
+                        points.append({
+                            "x": edge.p1.x,
+                            "y": edge.p1.y
+                        })
+                    points.append({
+                        "x": edge.p2.x,
+                        "y": edge.p2.y
+                    })
+                    shapes.append({
+                        "type": "polygon",
+                        "points": points
+                    })
+                elif value.is_text():
+                    text.append(value.text())
+                elif value.is_string():
+                    text.append(value.string())
+                else:
+                    print("[WARN] Unknown violation shape:", value)
+
+            comment = ""
+            if hasattr(item, 'comment'):
+                comment = item.comment
+            if text:
+                if comment:
+                    comment += ": "
+                comment += ", ".join(text)
+
+            if comment:
+                violation["comment"] = comment
+
+    return ordb
+
+
+def main():
+    # SC_ROOT provided by CLI
+    sys.path.append(SC_ROOT)  # noqa: F821
+
+    from tools.klayout.klayout_utils import get_schema
+
+    schema = get_schema(manifest='sc_manifest.json')
+
+    design = schema.get('design')
+
+    app = pya.Application.instance()
+    win = app.main_window()
+
+    # Create a dummy view to use for loading
+    cell_view = win.create_layout(0)
+    layout_view = cell_view.view()
+
+    ordb = {}
+    for file in glob.glob(f'inputs/{design}*.lyrdb') + glob.glob('inputs/{design}*.ascii'):
+        name = os.path.basename(file)
+
+        ordb[name] = convert_drc(layout_view, file)
+
+    with open(f"outputs/{design}.json", "w") as outfile:
+        json.dump(
+            ordb,
+            outfile,
+            indent=2)
+
+
+if __name__ == '__main__':
+    main()

siliconcompiler/tools/klayout/operations.py

@@ -109,6 +109,8 @@ def setup(chip):
     _, task = get_tool_task(chip, step, index)
     clobber = False
 
+    chip.set('tool', tool, 'task', task, 'threads', 1, step=step, index=index, clobber=clobber)
+
     script = 'klayout_operations.py'
     option = ['-z', '-nc', '-rx', '-r']
     chip.set('tool', tool, 'task', task, 'script', script, step=step, index=index, clobber=clobber)

siliconcompiler/tools/klayout/screenshot.py

@@ -24,6 +24,8 @@ def setup(chip):
     _, task = get_tool_task(chip, step, index)
     clobber = False
 
+    chip.set('tool', tool, 'task', task, 'threads', 1, step=step, index=index, clobber=clobber)
+
     setup_gui_screenshot(chip)
 
     option = ['-nc', '-z', '-rm']

siliconcompiler/tools/klayout/show.py

@@ -73,12 +73,12 @@ def setup(chip):
 
     step = chip.get('arg', 'step')
     index = chip.get('arg', 'index')
-    _, task = get_tool_task(chip, step, index)
+    tool, task = get_tool_task(chip, step, index)
+    clobber = False
 
-    general_gui_setup(chip, task, False)
+    chip.set('tool', tool, 'task', task, 'threads', 1, step=step, index=index, clobber=clobber)
 
-    tool = 'klayout'
-    clobber = False
+    general_gui_setup(chip, task, False)
 
     option = ['-nc', '-rm']
     chip.set('tool', tool, 'task', task, 'option', option, step=step, index=index, clobber=clobber)

siliconcompiler/tools/magic/drc.py

@@ -1,8 +1,10 @@
 import re
 
 from siliconcompiler.tools.magic.magic import setup as setup_tool
+from siliconcompiler.tools.magic.magic import process_file
 from siliconcompiler import sc_open
 from siliconcompiler.tools._common import get_tool_task, record_metric
+from siliconcompiler.tools._common.asic import get_mainlib, get_libraries
 
 
 def setup(chip):
@@ -22,6 +24,25 @@ def setup(chip):
     chip.set('tool', tool, 'task', task, 'output', f'{design}.drc.mag', step=step, index=index)
 
 
+def pre_process(chip):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    pdk = chip.get('option', 'pdk')
+    stackup = chip.get('option', 'stackup')
+    mainlib = get_mainlib(chip)
+    libtype = chip.get('library', mainlib, 'asic', 'libarch', step=step, index=index)
+    process_file('lef', chip, 'pdk', pdk, 'aprtech', 'magic', stackup, libtype, 'lef')
+
+    for lib in get_libraries(chip, 'logic'):
+        process_file('lef', chip, 'library', lib, 'output', stackup, 'lef')
+
+    for lib in get_libraries(chip, 'macro'):
+        if lib in chip.get('tool', tool, 'task', task, 'var', 'exclude', step=step, index=index):
+            process_file('lef', chip, 'library', lib, 'output', stackup, 'lef')
+
+
 ################################
 # Post_process (post executable)
 ################################

siliconcompiler/tools/magic/extspice.py

@@ -1,5 +1,7 @@
 from siliconcompiler.tools.magic.magic import setup as setup_tool
+from siliconcompiler.tools.magic.magic import process_file
 from siliconcompiler.tools._common import get_tool_task
+from siliconcompiler.tools._common.asic import get_mainlib, get_libraries
 
 
 def setup(chip):
@@ -17,3 +19,22 @@ def setup(chip):
     design = chip.top()
 
     chip.add('tool', tool, 'task', task, 'output', f'{design}.spice', step=step, index=index)
+
+
+def pre_process(chip):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    pdk = chip.get('option', 'pdk')
+    stackup = chip.get('option', 'stackup')
+    mainlib = get_mainlib(chip)
+    libtype = chip.get('library', mainlib, 'asic', 'libarch', step=step, index=index)
+    process_file('lef', chip, 'pdk', pdk, 'aprtech', 'magic', stackup, libtype, 'lef')
+
+    for lib in get_libraries(chip, 'logic'):
+        process_file('lef', chip, 'library', lib, 'output', stackup, 'lef')
+
+    for lib in get_libraries(chip, 'macro'):
+        if lib in chip.get('tool', tool, 'task', task, 'var', 'exclude', step=step, index=index):
+            process_file('lef', chip, 'library', lib, 'output', stackup, 'lef')

siliconcompiler/tools/magic/magic.py

@@ -9,9 +9,12 @@ Installation: https://github.com/RTimothyEdwards/magic
 Sources: https://github.com/RTimothyEdwards/magic
 '''
 
+import gzip
+import shutil
 import os
 from siliconcompiler.tools._common import input_provides, get_tool_task
 from siliconcompiler.targets import freepdk45_demo
+from siliconcompiler import utils
 
 
 ####################################################################
@@ -79,6 +82,32 @@ def parse_version(stdout):
     return stdout.strip('\n')
 
 
+def process_file(file_type, chip, *key):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    if chip.get(*key, field='pernode') == 'never':
+        files = chip.find_files(*key)
+    else:
+        files = chip.find_files(*key, step=step, index=index)
+
+    for file in files:
+        if file.lower().endswith('.gz'):
+            new_file_name = f'inputs/sc_{utils.get_hashed_filename(file[:-3])}'
+
+            with gzip.open(file, 'rt', encoding="utf-8") as fin:
+                with open(new_file_name, 'w') as fout:
+                    fout.write(fin.read().encode("ascii", "ignore").decode("ascii"))
+        else:
+            new_file_name = f'inputs/sc_{utils.get_hashed_filename(file)}'
+            shutil.copy(file, new_file_name)
+
+        chip.add('tool', tool, 'task', task, 'file', f'read_{file_type}',
+                 os.path.join(chip.getworkdir(step=step, index=index), new_file_name),
+                 step=step, index=index)
+
+
 ##################################################
 if __name__ == "__main__":
 

siliconcompiler/tools/magic/sc_drc.tcl

@@ -23,18 +23,8 @@ set sc_design [sc_top]
 set sc_macrolibs [sc_get_asic_libraries macro]
 set sc_stackup [sc_cfg_get option stackup]
 
-if { [sc_cfg_tool_task_exists var exclude] } {
-    set sc_exclude [sc_cfg_tool_task_get var exclude]
-} else {
-    set sc_exclude [list]
-}
-
-# Ignore specific libraries by reading their LEFs (causes magic to abstract them)
-foreach lib $sc_macrolibs {
-    puts $lib
-    if { [lsearch -exact $sc_exclude $lib] >= 0 } {
-        lef read [sc_cfg_get library $lib output $sc_stackup lef]
-    }
+foreach sc_lef [sc_cfg_tool_task_get file read_lef] {
+    lef read $sc_lef
 }
 
 gds noduplicates true

siliconcompiler/tools/magic/sc_extspice.tcl

@@ -14,21 +14,9 @@ set sc_techlef [sc_cfg_get pdk $sc_pdk aprtech magic $sc_stackup $sc_libtype lef
 set sc_liblef [sc_cfg_get library $sc_mainlib output $sc_stackup lef]
 set sc_macrolibs [sc_get_asic_libraries macro]
 
-if { [sc_cfg_tool_task_exists var exclude] } {
-    set sc_exclude [sc_cfg_tool_task_get var exclude]
-} else {
-    set sc_exclude [list]
-}
-
-lef read $sc_techlef
-lef read $sc_liblef
-
-# Ignore specific libraries by reading their LEFs (causes magic to abstract them)
-foreach lib $sc_macrolibs {
-    puts $lib
-    if { [lsearch -exact $sc_exclude $lib] >= 0 } {
-        lef read [sc_cfg_get library $lib output $sc_stackup lef]
-    }
+foreach sc_lef [sc_cfg_tool_task_get file read_lef] {
+    puts "Reading LEF $sc_lef"
+    lef read $sc_lef
 }
 
 if { [file exists "inputs/$sc_design.gds"] } {

siliconcompiler/tools/openroad/floorplan.py

@@ -1,4 +1,5 @@
 from siliconcompiler.tools._common import input_provides, add_common_file, get_tool_task
+from siliconcompiler.tools._common.asic import set_tool_task_var
 from siliconcompiler.tools.openroad.openroad import setup as setup_tool
 from siliconcompiler.tools.openroad.openroad import build_pex_corners
 from siliconcompiler.tools.openroad.openroad import post_process as or_post_process
@@ -46,6 +47,10 @@ def setup(chip):
              'script to insert the padring',
              field='help')
 
+    set_tool_task_var(chip, param_key='remove_synth_buffers',
+                      default_value=True,
+                      schelp='remove buffers inserted by synthesis')
+
     snap = chip.get('tool', tool, 'task', task, 'var', 'ifp_snap_strategy',
                     step=step, index=index)[0]
     snaps_allowed = ('none', 'site', 'manufacturing_grid')

siliconcompiler/tools/openroad/openroad.py

@@ -38,7 +38,7 @@ def setup_tool(chip, exit=True, clobber=True):
 
     chip.set('tool', tool, 'exe', tool)
     chip.set('tool', tool, 'vswitch', '-version')
-    chip.set('tool', tool, 'version', '>=v2.0-13145', clobber=clobber)
+    chip.set('tool', tool, 'version', '>=v2.0-16580', clobber=clobber)
     chip.set('tool', tool, 'format', 'tcl', clobber=clobber)
 
     # exit automatically in batch mode and not breakpoint
@@ -274,7 +274,10 @@ def post_process(chip):
                  "floating_nets.rpt",
                  f"{chip.design}_antenna.rpt",
                  f"{chip.design}_antenna_post_repair.rpt"],
-        "drcs": [f"{chip.design}_drc.rpt"]
+        "drcs": [f"{chip.design}_drc.rpt",
+                 f"markers/{chip.design}.drc.rpt",
+                 f"markers/{chip.design}.drc.json",
+                 f"images/markers/{chip.design}.drc.png"]
     }
     metric_reports["leakagepower"] = metric_reports["peakpower"]
 
@@ -583,10 +586,16 @@ def _define_pad_params(chip):
 
 
 def _define_rsz_params(chip):
+    set_tool_task_var(chip, param_key='rsz_skip_setup_repair',
+                      default_value=False,
+                      schelp='skip setup timing repair')
     set_tool_task_var(chip, param_key='rsz_setup_slack_margin',
                       default_value='0.0',
                       schelp='specifies the margin to apply when performing setup repair '
                              'in library timing units')
+    set_tool_task_var(chip, param_key='rsz_skip_hold_repair',
+                      default_value=False,
+                      schelp='skip hold timing repair')
     set_tool_task_var(chip, param_key='rsz_hold_slack_margin',
                       default_value='0.0',
                       schelp='specifies the margin to apply when performing setup repair '
@@ -667,6 +676,10 @@ def _define_dpl_params(chip):
                       default_value='false',
                       schelp='true/false, disallow single site gaps in detail placement')
 
+    set_tool_task_var(chip, param_key='dpl_use_decap_fillers',
+                      default_value='true',
+                      schelp='true/false, use decap fillers along with non-decap fillers')
+
 
 def _define_cts_params(chip):
     step = chip.get('arg', 'step')
@@ -846,6 +859,41 @@ def _define_mpl_params(chip):
                       schelp='minimum number of macros to use while clustering for macro placement')
     set_tool_task_var(chip, param_key='rtlmp_max_macros',
                       schelp='maximum number of macros to use while clustering for macro placement')
+    set_tool_task_var(chip, param_key='rtlmp_max_levels',
+                      schelp='maximum depth of physical hierarchical tree')
+    set_tool_task_var(chip, param_key='rtlmp_min_aspect_ratio',
+                      schelp='Specifies the minimum aspect ratio of its width to height of a '
+                             'standard cell cluster')
+    set_tool_task_var(chip, param_key='rtlmp_fence',
+                      schelp='Defines the global fence bounding box coordinates '
+                             '(llx, lly, urx, ury)')
+    set_tool_task_var(chip, param_key='rtlmp_bus_planning',
+                      schelp='Flag to enable bus planning')
+    set_tool_task_var(chip, param_key='rtlmp_target_dead_space',
+                      schelp='Specifies the target dead space percentage, which influences '
+                             'the utilization of standard cell clusters')
+
+    set_tool_task_var(chip, param_key='rtlmp_area_weight',
+                      schelp='Weight for the area of current floorplan')
+    set_tool_task_var(chip, param_key='rtlmp_outline_weight',
+                      schelp='Weight for violating the fixed outline constraint, meaning that all '
+                             'clusters should be placed within the shape of their parent cluster')
+    set_tool_task_var(chip, param_key='rtlmp_wirelength_weight',
+                      schelp='Weight for half-perimeter wirelength')
+    set_tool_task_var(chip, param_key='rtlmp_guidance_weight',
+                      schelp='Weight for guidance cost or clusters being placed near specified '
+                             'regions if users provide such constraints')
+    set_tool_task_var(chip, param_key='rtlmp_fence_weight',
+                      schelp='Weight for fence cost, or how far the macro is from zero '
+                             'fence violation')
+    set_tool_task_var(chip, param_key='rtlmp_blockage_weight',
+                      schelp='Weight for the boundary, or how far the hard macro clusters are '
+                             'from boundaries')
+    set_tool_task_var(chip, param_key='rtlmp_notch_weight',
+                      schelp='Weight for the notch, or the existence of dead space that cannot be '
+                             'used for placement & routing')
+    set_tool_task_var(chip, param_key='rtlmp_macro_blockage_weight',
+                      schelp='Weight for macro blockage, or the overlapping instances of the macro')
 
 
 def _define_ord_params(chip):
@@ -920,9 +968,12 @@ def _set_reports(chip, reports):
     def check_enabled(type):
         for key in (('tool', tool, 'task', task, 'var', f'skip_{type}'),
                     ('option', 'var', f'openroad_skip_{type}')):
-            if chip.valid(*key) and \
-               chip.get(*key, step=step, index=index) == ["true"]:
-                return False
+            if chip.valid(*key):
+                if chip.get(*key, field='pernode') == 'never':
+                    if chip.get(*key) == ["true"]:
+                        return False
+                    elif chip.get(*key, step=step, index=index) == ["true"]:
+                        return False
         return True
 
     for report in reports:

siliconcompiler/tools/openroad/scripts/sc_apr.tcl

@@ -265,10 +265,24 @@ set openroad_mpl_macro_place_channel [dict get $openroad_task_vars macro_place_c
 set openroad_ppl_arguments [dict get $openroad_task_vars ppl_arguments]
 
 set openroad_rtlmp_enable [lindex [dict get $openroad_task_vars rtlmp_enable] 0]
+set openroad_rtlmp_max_levels [lindex [dict get $openroad_task_vars rtlmp_max_levels] 0]
 set openroad_rtlmp_min_instances [lindex [dict get $openroad_task_vars rtlmp_min_instances] 0]
 set openroad_rtlmp_max_instances [lindex [dict get $openroad_task_vars rtlmp_max_instances] 0]
 set openroad_rtlmp_min_macros [lindex [dict get $openroad_task_vars rtlmp_min_macros] 0]
 set openroad_rtlmp_max_macros [lindex [dict get $openroad_task_vars rtlmp_max_macros] 0]
+set openroad_rtlmp_min_aspect_ratio [lindex [dict get $openroad_task_vars rtlmp_min_aspect_ratio] 0]
+set openroad_rtlmp_fence [dict get $openroad_task_vars rtlmp_fence]
+set openroad_rtlmp_bus_planning [lindex [dict get $openroad_task_vars rtlmp_bus_planning] 0]
+set openroad_rtlmp_target_dead_space \
+  [lindex [dict get $openroad_task_vars rtlmp_target_dead_space] 0]
+set openroad_rtlmp_area_weight [lindex [dict get $openroad_task_vars rtlmp_area_weight] 0]
+set openroad_rtlmp_outline_weight [lindex [dict get $openroad_task_vars rtlmp_outline_weight] 0]
+set openroad_rtlmp_wirelength_weight \
+  [lindex [dict get $openroad_task_vars rtlmp_wirelength_weight] 0]
+set openroad_rtlmp_guidance_weight [lindex [dict get $openroad_task_vars rtlmp_guidance_weight] 0]
+set openroad_rtlmp_fence_weight [lindex [dict get $openroad_task_vars rtlmp_fence_weight] 0]
+set openroad_rtlmp_notch_weight [lindex [dict get $openroad_task_vars rtlmp_notch_weight] 0]
+set openroad_rtlmp_blockage_weight [lindex [dict get $openroad_task_vars rtlmp_blockage_weight] 0]
 
 set openroad_gpl_place_density [lindex [dict get $openroad_task_vars place_density] 0]
 set openroad_gpl_padding [lindex [dict get $openroad_task_vars pad_global_place] 0]
@@ -427,6 +441,7 @@ if { $sc_task != "floorplan" } {
 # Setup reports directories
 file mkdir reports/timing
 file mkdir reports/power
+file mkdir reports/markers
 
 if { $sc_task == "show" || $sc_task == "screenshot" } {
   if { $sc_task == "screenshot" } {

siliconcompiler/tools/openroad/scripts/sc_cts.tcl

@@ -31,8 +31,6 @@ if { [llength [all_clocks]] > 0 } {
 
   sc_detailed_placement
 
-  estimate_parasitics -placement
-
   set repair_timing_args []
   if { $openroad_rsz_skip_pin_swap == "true" } {
     lappend repair_timing_args "-skip_pin_swap"
@@ -41,18 +39,25 @@ if { [llength [all_clocks]] > 0 } {
     lappend repair_timing_args "-skip_gate_cloning"
   }
 
-  repair_timing -setup -verbose \
-    -setup_margin $openroad_rsz_setup_slack_margin \
-    -hold_margin $openroad_rsz_hold_slack_margin \
-    -repair_tns $openroad_rsz_repair_tns \
-    {*}$repair_timing_args
+  if { [lindex [sc_cfg_tool_task_get var rsz_skip_setup_repair] 0] != "true" } {
+    estimate_parasitics -placement
 
-  estimate_parasitics -placement
-  repair_timing -hold -verbose \
-    -setup_margin $openroad_rsz_setup_slack_margin \
-    -hold_margin $openroad_rsz_hold_slack_margin \
-    -repair_tns $openroad_rsz_repair_tns \
-    {*}$repair_timing_args
+    repair_timing -setup -verbose \
+      -setup_margin $openroad_rsz_setup_slack_margin \
+      -hold_margin $openroad_rsz_hold_slack_margin \
+      -repair_tns $openroad_rsz_repair_tns \
+      {*}$repair_timing_args
+  }
+
+  if { [lindex [sc_cfg_tool_task_get var rsz_skip_hold_repair] 0] != "true" } {
+    estimate_parasitics -placement
+
+    repair_timing -hold -verbose \
+      -setup_margin $openroad_rsz_setup_slack_margin \
+      -hold_margin $openroad_rsz_hold_slack_margin \
+      -repair_tns $openroad_rsz_repair_tns \
+      {*}$repair_timing_args
+  }
 
   sc_detailed_placement
 }