siliconcompiler 0.26.5__py3-none-any.whl

siliconcompiler/tools/klayout/klayout_show.py

@@ -0,0 +1,242 @@
+import pya
+import os
+import sys
+
+
+def show(schema, tech, input_path, output_path, screenshot=False):
+    # Extract info from manifest
+    flow = schema.get('option', 'flow')
+    step = schema.get('arg', 'step')
+    index = schema.get('arg', 'index')
+    task = schema.get('flowgraph', flow, step, index, 'task')
+
+    if 'hide_layers' in schema.getkeys('tool', 'klayout', 'task', task, 'var'):
+        sc_hide_layers = schema.get('tool', 'klayout', 'task', task, 'var', 'hide_layers',
+                                    step=step, index=index)
+    else:
+        sc_hide_layers = []
+
+    # Load KLayout technology file
+    layoutOptions = tech.load_layout_options
+
+    # These may be disabled in our KLayout tech file for reasons relating to GDS
+    # export, but for the purposes of viewing we'll hardcode them to True.
+    layoutOptions.lefdef_config.produce_blockages = True
+    layoutOptions.lefdef_config.produce_cell_outlines = True
+    layoutOptions.lefdef_config.produce_obstructions = True
+
+    # Always use LEF geometry even when LEF file contains FOREIGN statement.
+    layoutOptions.lefdef_config.macro_resolution_mode = 1
+
+    tech.load_layout_options = layoutOptions
+
+    app = pya.Application.instance()
+    main_window = pya.MainWindow.instance()
+    if not main_window:
+        print('[WARNING] unable to show layout as the main window is not available')
+        return
+
+    # Opinionated default KLayout configuration
+    # see ~/.klayout/klayoutrc for a list of configuration keys
+
+    # show all cells
+    app.set_config('full-hierarchy-new-cell', 'true')
+    # no tip pop-ups
+    app.set_config('tip-window-hidden', ','.join(['only-top-level-shown-by-default=3',
+                                                  'editor-mode=4',
+                                                  'editor-mode=0']))
+    # hide text
+    app.set_config('text-visible', 'false')
+    # dark background
+    app.set_config('background-color', '#212121')
+
+    # Display the file!
+    print(f"[INFO] Opening {input_path}")
+    cell_view = main_window.load_layout(input_path, tech.name)
+    layout_view = cell_view.view()
+
+    # Hide layers that shouldn't be shown in the current view.
+    for layer in layout_view.each_layer():
+        layer_ldt = f'{layer.source_layer}/{layer.source_datatype}'
+        layer_name = layer.source_name
+        if not layer_name:
+            layer_name = layer.name
+        print_layer = layer_name
+        if ' ' in layer_name:
+            layer_name = layer_name.split()[0]
+        if (layer_name in sc_hide_layers) or \
+           (layer_ldt in sc_hide_layers):
+            print(f"[INFO] Turning off layer: {print_layer} : {layer_ldt}")
+            layer.visible = False
+
+    # If 'screenshot' mode is set, save image and exit.
+    if screenshot:
+        xbins = int(schema.get('tool', 'klayout', 'task', task, 'var', 'xbins',
+                               step=step, index=index)[0])
+        ybins = int(schema.get('tool', 'klayout', 'task', task, 'var', 'ybins',
+                               step=step, index=index)[0])
+
+        if xbins == 1 and ybins == 1:
+            __screenshot(schema, layout_view, output_path)
+        else:
+            __screenshot_montage(schema, layout_view, xbins, ybins)
+
+
+def __screenshot(schema, layout_view, output_path):
+    flow = schema.get('option', 'flow')
+    step = schema.get('arg', 'step')
+    index = schema.get('arg', 'index')
+    task = schema.get('flowgraph', flow, step, index, 'task')
+
+    # Save a screenshot. TODO: Get aspect ratio from sc_cfg?
+    horizontal_resolution = int(schema.get('tool', 'klayout', 'task', task, 'var',
+                                           'show_horizontal_resolution',
+                                           step=step, index=index)[0])
+    vertical_resolution = int(schema.get('tool', 'klayout', 'task', task, 'var',
+                                         'show_vertical_resolution',
+                                         step=step, index=index)[0])
+
+    print(f'[INFO] Saving screenshot to {output_path}')
+    layout_view.save_image(output_path, horizontal_resolution, vertical_resolution)
+
+
+def __screenshot_montage(schema, view, xbins, ybins):
+    flow = schema.get('option', 'flow')
+    step = schema.get('arg', 'step')
+    index = schema.get('arg', 'index')
+    task = schema.get('flowgraph', flow, step, index, 'task')
+
+    app = pya.Application.instance()
+    options = (
+        "grid-show-ruler",
+        "grid-visible",
+        "text-visible"
+    )
+    for option in options:
+        app.set_config(option, "false")
+
+    app.set_config("background-color", "#000000")  # Black
+
+    design = schema.get('option', 'entrypoint')
+    if not design:
+        design = schema.get('design')
+
+    horizontal_resolution = int(schema.get('tool', 'klayout', 'task', task, 'var',
+                                           'show_horizontal_resolution',
+                                           step=step, index=index)[0])
+    vertical_resolution = int(schema.get('tool', 'klayout', 'task', task, 'var',
+                                         'show_vertical_resolution',
+                                         step=step, index=index)[0])
+    margin = float(schema.get('tool', 'klayout', 'task', task, 'var',
+                              'margin',
+                              step=step, index=index)[0])
+    linewidth = int(schema.get('tool', 'klayout', 'task', task, 'var',
+                               'linewidth',
+                               step=step, index=index)[0])
+    oversampling = int(schema.get('tool', 'klayout', 'task', task, 'var',
+                                  'oversampling',
+                                  step=step, index=index)[0])
+
+    view.zoom_fit()
+    cell = view.active_cellview().cell
+
+    view_box = cell.dbbox()
+    view_box.left -= margin
+    view_box.bottom -= margin
+    view_box.right += margin
+    view_box.top += margin
+
+    x_incr = int(view_box.width() / xbins)
+    y_incr = int(view_box.height() / ybins)
+
+    if (view_box.width() > view_box.height()):
+        y_px = vertical_resolution
+        x_px = int((float(x_incr) / y_incr) * y_px)
+    else:
+        x_px = horizontal_resolution
+        y_px = int((float(y_incr) / x_incr) * x_px)
+
+    for x in range(xbins):
+        for y in range(ybins):
+            yidx = ybins - y - 1
+            output_file = f"{design}_X{x}_Y{yidx}.png"
+
+            x_start = view_box.left + x_incr * x
+            y_start = view_box.bottom + y_incr * y
+
+            subbox = pya.DBox(
+                x_start,
+                y_start,
+                x_start + x_incr,
+                y_start + y_incr)
+
+            sub_img_spec = {
+                "width": x_px,
+                "height": y_px,
+                "linewidth": linewidth,
+                "oversampling": oversampling,
+                "resolution": 0,
+                "target_box": subbox,
+                "monochrome": False
+            }
+
+            img_path = os.path.join('outputs', output_file)
+            print(f'[INFO] Saving screenshot (({subbox.left}, {subbox.bottom}), '
+                  f'({subbox.right}, {subbox.top})) to {img_path}')
+            view.save_image_with_options(
+                img_path,
+                sub_img_spec["width"],
+                sub_img_spec["height"],
+                sub_img_spec["linewidth"],
+                sub_img_spec["oversampling"],
+                sub_img_spec["resolution"],
+                sub_img_spec["target_box"],
+                sub_img_spec["monochrome"]
+            )
+
+
+def main():
+    # SC_ROOT provided by CLI, and is only accessible when this is main module
+    sys.path.append(SC_ROOT)  # noqa: F821
+
+    from tools.klayout.klayout_utils import (
+        technology,
+        get_schema
+    )
+
+    schema = get_schema(manifest='sc_manifest.json')
+
+    flow = schema.get('option', 'flow')
+    step = schema.get('arg', 'step')
+    index = schema.get('arg', 'index')
+    task = schema.get('flowgraph', flow, step, index, 'task')
+
+    design = schema.get('option', 'entrypoint')
+    if not design:
+        design = schema.get('design')
+
+    if 'show_filepath' in schema.getkeys('tool', 'klayout', 'task', task, 'var') and \
+       schema.get('tool', 'klayout', 'task', task, 'var', 'show_filepath',
+                  step=step, index=index):
+        sc_filename = schema.get('tool', 'klayout', 'task', task, 'var', 'show_filepath',
+                                 step=step, index=index)[0]
+    else:
+        sc_fileext = schema.get('tool', 'klayout', 'task', task, 'var', 'show_filetype',
+                                step=step, index=index)[0]
+        for ext in (f'{sc_fileext}.gz', sc_fileext):
+            sc_filename = f"inputs/{design}.{ext}"
+            if os.path.exists(sc_filename):
+                break
+
+    sc_exit = schema.get('tool', 'klayout', 'task', task, 'var', 'show_exit',
+                         step=step, index=index) == ["true"]
+
+    show(schema, technology(design, schema), sc_filename, f'outputs/{design}.png',
+         screenshot=(task == 'screenshot'))
+
+    if sc_exit:
+        pya.Application.instance().exit(0)
+
+
+if __name__ == '__main__':
+    main()

siliconcompiler/tools/klayout/klayout_utils.py

@@ -0,0 +1,176 @@
+import pya
+import importlib.util as importlib_util
+import os
+import shutil
+import sys
+
+
+def get_streams(schema):
+    sc_step = schema.get('arg', 'step')
+    sc_index = schema.get('arg', 'index')
+    sc_flow = schema.get('option', 'flow')
+    sc_task = schema.get('flowgraph', sc_flow, sc_step, sc_index, 'task')
+
+    streams = ('gds', 'oas')
+    if schema.valid('tool', 'klayout', 'task', sc_task, 'var', 'stream'):
+        sc_stream = schema.get('tool', 'klayout', 'task', sc_task, 'var', 'stream',
+                               step=sc_step, index=sc_index)[0]
+    else:
+        sc_stream = streams[0]
+    return [sc_stream, *[s for s in streams if s != sc_stream]]
+
+
+def technology(design, schema):
+    from tools._common.asic import get_libraries
+
+    sc_step = schema.get('arg', 'step')
+    sc_index = schema.get('arg', 'index')
+    sc_pdk = schema.get('option', 'pdk')
+
+    if schema.valid('option', 'stackup'):
+        sc_stackup = schema.get('option', 'stackup')
+    else:
+        sc_stackup = schema.get('pdk', sc_pdk, 'stackup')[0]
+    sc_mainlib = schema.get('asic', 'logiclib', step=sc_step, index=sc_index)[0]
+    sc_libtype = schema.get('library', sc_mainlib, 'asic', 'libarch', step=sc_step, index=sc_index)
+
+    sc_libs = []
+    sc_libs += get_libraries(schema, 'logic')
+    sc_libs += get_libraries(schema, 'macro')
+
+    local_files = {
+        'lyt': f'inputs/{design}.lyt',
+        'lyp': f'inputs/{design}.lyp'
+    }
+
+    tech = pya.Technology.create_technology('sc_tech')
+    # Load technology file
+    tech_file = None
+    if os.path.exists(local_files['lyt']):
+        tech_file = local_files['lyt']
+    elif schema.valid('pdk', sc_pdk, 'layermap', 'klayout', 'def', 'klayout', sc_stackup):
+        tech_file = schema.get('pdk', sc_pdk, 'layermap', 'klayout', 'def', 'klayout', sc_stackup)
+        if tech_file:
+            tech_file = tech_file[0]
+
+    if tech_file:
+        print(f"[INFO] Loading technology file: {tech_file}")
+        tech.load(tech_file)
+    else:
+        tech.name = f'{sc_pdk} for {sc_stackup}'
+        tech.description = f'{", ".join(sc_libs)}'
+
+    if schema.valid('pdk', sc_pdk, 'var', 'klayout', 'units', sc_stackup):
+        units = float(schema.get('pdk', sc_pdk, 'var', 'klayout', 'units', sc_stackup)[0])
+        tech.dbu = units
+    print(f"[INFO] Technology database units are: {tech.dbu}um")
+
+    lefs = []
+
+    foundry_lef = schema.get('pdk', sc_pdk, 'aprtech', 'klayout', sc_stackup, sc_libtype, 'lef')
+    if foundry_lef:
+        foundry_lef = foundry_lef[0]
+        lefs.append(foundry_lef)
+    else:
+        foundry_lef = None
+
+    for lib in sc_libs:
+        lefs.extend(schema.get('library', lib, 'output', sc_stackup, 'lef',
+                               step=sc_step, index=sc_index))
+
+    layoutOptions = tech.load_layout_options
+
+    layoutOptions.lefdef_config.macro_resolution_mode = 1
+    layoutOptions.lefdef_config.via_cellname_prefix = "VIA_"
+    pathed_files = set()
+    for lef_file in layoutOptions.lefdef_config.lef_files:
+        if foundry_lef and not os.path.isabs(lef_file):
+            lef_file = os.path.join(os.path.dirname(foundry_lef), lef_file)
+        lef_file = os.path.abspath(lef_file)
+        if os.path.isfile(lef_file):
+            pathed_files.add(os.path.abspath(lef_file))
+
+    for lef in lefs:
+        pathed_files.add(os.path.abspath(lef))
+
+    layoutOptions.lefdef_config.lef_files = list(pathed_files)
+    layoutOptions.lefdef_config.read_lef_with_def = False
+    layoutOptions.lefdef_config.dbu = tech.dbu
+
+    layoutOptions.lefdef_config.produce_fills = True
+
+    for lef_file in layoutOptions.lefdef_config.lef_files:
+        print(f"[INFO] LEF file: {lef_file}")
+
+    # Set layer properties
+    layer_properties = tech.layer_properties_file
+    if layer_properties:
+        layer_properties = layer_properties[0]
+        if not os.path.isabs(layer_properties):
+            layer_properties = os.path.abspath(os.path.join(os.path.dirname(tech_file),
+                                                            layer_properties))
+    if os.path.exists(local_files['lyp']):
+        layer_properties = os.path.abspath(local_files['lyp'])
+    elif schema.valid('pdk', sc_pdk, 'display', 'klayout', sc_stackup):
+        pdk_layer_props = schema.get('pdk', sc_pdk, 'display', 'klayout', sc_stackup)
+        if pdk_layer_props:
+            layer_properties = pdk_layer_props[0]
+
+    if layer_properties and os.path.exists(layer_properties):
+        tech.layer_properties_file = layer_properties
+        print(f"[INFO] Layer properties: {layer_properties}")
+
+    # Set layer map
+    map_file = layoutOptions.lefdef_config.map_file
+    if map_file:
+        map_file = map_file[0]
+        if not os.path.isabs(map_file):
+            map_file = os.path.abspath(os.path.join(os.path.dirname(tech_file),
+                                                    map_file))
+    for s in get_streams(schema):
+        if schema.valid('pdk', sc_pdk, 'layermap', 'klayout', 'def', s, sc_stackup):
+            map_file = schema.get('pdk', sc_pdk, 'layermap', 'klayout', 'def', s, sc_stackup)
+            if map_file:
+                map_file = map_file[0]
+                break
+
+    if map_file and os.path.exists(map_file):
+        layoutOptions.lefdef_config.map_file = map_file
+        print(f"[INFO] Layer map: {map_file}")
+
+    tech.load_layout_options = layoutOptions
+
+    return tech
+
+
+def save_technology(design, tech):
+    tech.default_base_path = '.'
+    tech.base_path = '.'
+
+    if tech.layer_properties_file:
+        layer_file = f'{design}.lyp'
+        shutil.copyfile(tech.layer_properties_file,
+                        f'outputs/{layer_file}')
+        tech.layer_properties_file = layer_file
+
+    tech.save(f'outputs/{design}.lyt')
+
+
+def get_write_options(filename, timestamps):
+    write_options = pya.SaveLayoutOptions()
+    write_options.gds2_write_timestamps = timestamps
+    write_options.set_format_from_filename(filename)
+
+    return write_options
+
+
+def get_schema(manifest):
+    scroot = os.path.join(os.path.dirname(__file__), '..', '..')
+    module_name = 'schema'
+    schema_base = os.path.join(scroot, module_name, '__init__.py')
+    spec = importlib_util.spec_from_file_location(module_name, schema_base)
+    module = importlib_util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+    # Return schema
+    return module.Schema(manifest=manifest)

siliconcompiler/tools/klayout/operations.py

@@ -0,0 +1,194 @@
+from siliconcompiler import SiliconCompilerError
+from siliconcompiler.tools.klayout.klayout import setup as setup_tool
+from siliconcompiler.tools._common import input_provides, get_tool_task
+
+
+def setup(chip):
+    '''
+    Perform unit operations on stream files. Currently supports:
+
+        * rotating (rotate)
+        * renaming (rename)
+        * merging streams (merge)
+        * adding streams together (add)
+        * adding outline to top (outline)
+        * swapping cells (swap)
+        * adding new top cell (add_top)
+        * renaming cells (rename_cell)
+        * flatten
+        * deleting layers
+        * merging shapes
+        * writing (write)
+        * converting properties into text labels on design (convert_property)
+
+    To rotate:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', 'rotate')
+
+    To rename:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', \\
+        'rename:tool,klayout,task,operations,var,new_name')
+    >>> chip.set('tool', 'klayout, 'task', 'operations', 'var', 'new_name', \\
+        'chip_top')
+
+    To merge streams:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', \\
+        'merge:tool,klayout,task,operations,file,fill_stream')
+    >>> chip.set('tool', 'klayout, 'task', 'operations', 'file', 'fill_stream', \\
+        './fill.gds')
+
+    or to get it from the inputs to this task:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', \\
+        'merge:fill.gds')
+
+    To add streams:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', \\
+        'add:tool,klayout,task,operations,file,fill_stream')
+    >>> chip.set('tool', 'klayout, 'task', 'operations', 'file', 'fill_stream', \\
+        './fill.gds')
+
+    or to get it from the inputs to this task:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', \\
+        'add:fill.gds')
+
+    To add outline:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', \\
+        'outline:tool,klayout,task,operations,var,outline')
+    >>> chip.set('tool', 'klayout, 'task', 'operations', 'var', 'outline', \\
+        ['10', '1'])  # layer / purpose pair
+
+    To swap layout cells:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', \\
+        'swap:tool,klayout,task,operations,var,cell_swap')
+    >>> chip.set('tool', 'klayout, 'task', 'operations', 'var', 'cell_swap', \\
+        ['dummy_ANDX2=ANDX2', 'dummy_NANDX2=NANDX2'])
+
+    To rename cells:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', \\
+        'rename_cell:tool,klayout,task,operations,var,rename_cell')
+    >>> chip.set('tool', 'klayout, 'task', 'operations', 'var', 'rename_cell', \\
+        ['dummy_ANDX2=ANDX2', 'dummy_NANDX2=NANDX2'])
+
+    To add new top cell:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', \\
+        'add_top:tool,klayout,task,operations,var,new_name')
+    >>> chip.set('tool', 'klayout, 'task', 'operations', 'var', 'new_name', \\
+        'chip_top')
+
+    To write out a new file:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', \\
+        'write:combined.gds')
+
+    To convert stream properties to text labels:
+
+    >>> chip.add('tool', 'klayout, 'task', 'operations', 'var', 'operations', \\
+        'convert_property:tool,klayout,task,operations,var,convert_c4_bumps')
+    >>> chip.set('tool', 'klayout, 'task', 'operations', 'var', 'convert_c4_bumps', \\
+        ['10', '2', \\  # layer / purpose pair for the source of the labels
+         '3' \\  # stream property number
+         '85', '5'])  #  (optional) destination layer / purpose pair, if not provided
+                      # the source pair will be used instead.
+    '''
+
+    # Generic tool setup.
+    setup_tool(chip)
+
+    tool = 'klayout'
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    _, task = get_tool_task(chip, step, index)
+    clobber = False
+
+    script = 'klayout_operations.py'
+    option = ['-z', '-nc', '-rx', '-r']
+    chip.set('tool', tool, 'task', task, 'script', script, step=step, index=index, clobber=clobber)
+    chip.set('tool', tool, 'task', task, 'option', option, step=step, index=index, clobber=clobber)
+
+    # Set stream extension
+    streams = ('gds', 'oas')
+    chip.set('tool', tool, 'task', task, 'var', 'stream', 'gds',
+             step=step, index=index, clobber=False)
+    chip.set('tool', tool, 'task', task, 'var', 'stream',
+             f'Extension to use for stream generation ({streams})',
+             field='help')
+    default_stream = chip.get('tool', tool, 'task', task, 'var', 'stream',
+                              step=step, index=index)[0]
+    # Input/Output requirements for default flow
+    design = chip.top()
+    if f'{design}.{default_stream}' in input_provides(chip, step, index):
+        chip.add('tool', tool, 'task', task, 'input', f'{design}.{default_stream}',
+                 step=step, index=index)
+    else:
+        chip.add('tool', tool, 'task', task, 'require', f'input,layout,{default_stream}')
+    chip.add('tool', tool, 'task', task, 'output', f'{design}.{default_stream}',
+             step=step, index=index)
+
+    # Export GDS with timestamps by default.
+    chip.set('tool', tool, 'task', task, 'var', 'timestamps', 'true',
+             step=step, index=index, clobber=False)
+    chip.set('tool', tool, 'task', task, 'var', 'timestamps',
+             'Export GDSII with timestamps',
+             field='help')
+
+    klayout_ops = ('merge',
+                   'add',
+                   'rotate',
+                   'outline',
+                   'rename',
+                   'swap',
+                   'add_top',
+                   'write',
+                   'convert_property',
+                   'flatten',
+                   'merge_shapes',
+                   'delete_layers',
+                   'rename_cell')
+    ops = chip.get('tool', tool, 'task', task, 'var', 'operations', step=step, index=index)
+    for op in ops:
+        klayout_op = op.split(':', 1)
+        if len(klayout_op) == 1:
+            klayout_op = klayout_op[0]
+            args = ""
+        else:
+            klayout_op, args = klayout_op
+
+        if klayout_op not in klayout_ops:
+            raise SiliconCompilerError(
+                f'{klayout_op} is not a supported operation in klayout: {klayout_ops}',
+                chip=chip)
+
+        if klayout_op in ('add', 'merge'):
+            if ',' in args:
+                chip.add('tool', tool, 'task', task, 'require', args, step=step, index=index)
+            elif args:
+                chip.add('tool', tool, 'task', task, 'input', args, step=step, index=index)
+            else:
+                raise SiliconCompilerError(
+                    f'{klayout_op} requires a filename to read or a keypath', chip=chip)
+        elif klayout_op in ('outline',
+                            'rename',
+                            'swap',
+                            'add_top',
+                            'convert_property',
+                            'merge_shapes',
+                            'delete_layers',
+                            'rename_cell'):
+            chip.add('tool', tool, 'task', task, 'require', args, step=step, index=index)
+        elif klayout_op in ('rotate', 'flatten'):
+            if args:
+                raise SiliconCompilerError('rotate does not take any arguments', chip=chip)
+        elif klayout_op in ('write'):
+            if not args:
+                raise SiliconCompilerError('write requires a filename to save to', chip=chip)
+            chip.add('tool', tool, 'task', task, 'output', args,
+                     step=step, index=index)