siliconcompiler 0.28.7__py3-none-any.whl → 0.28.9__py3-none-any.whl

siliconcompiler/_metadata.py

@@ -1,5 +1,5 @@
 # Version number following semver standard.
-version = '0.28.7'
+version = '0.28.9'
 
 # Default server address for remote runs, if unspecified.
 default_server = 'https://server.siliconcompiler.com'

siliconcompiler/report/dashboard/components/graph.py

@@ -133,7 +133,7 @@ def graph(metrics, nodes, node_to_step_index_map, graph_number):
 
     data, metric_unit = report.get_chart_data(_get_report_chips(), metric, nodes_as_step_and_index)
     if metric_unit:
-        y_axis_label = f'{metric}({metric_unit})'
+        y_axis_label = f'{metric} ({metric_unit})'
 
     # Prepare plot data
     filtered_data = {
@@ -142,7 +142,12 @@ def graph(metrics, nodes, node_to_step_index_map, graph_number):
         color_label: []
     }
 
-    if not nodes.empty:
+    labels = {
+        "runs": state.get_key(state.GRAPH_JOBS),
+        "nodes": [f'{step}{index}' for step, index in data]
+    }
+
+    if nodes:
         # filtering through data
         for job_name in state.get_key(state.GRAPH_JOBS):
             for step, index in data:
@@ -154,7 +159,7 @@ def graph(metrics, nodes, node_to_step_index_map, graph_number):
                     filtered_data[y_axis_label].append(data[(step, index)][job_name])
 
     # Setup chart
-    x_axis = altair.X(x_axis_label, axis=altair.Axis(labelAngle=-75))
+    x_axis = altair.X(x_axis_label, axis=altair.Axis(labelAngle=-75), sort=labels[x_axis_label])
 
     y_axis = y_axis_label
     if log_scale and chart_type != 'bar':
@@ -183,9 +188,9 @@ def graph(metrics, nodes, node_to_step_index_map, graph_number):
     streamlit.altair_chart(chart, use_container_width=True, theme='streamlit')
 
 
-def viewer(metric_dataframe, node_to_step_index_map, metric_to_metric_unit_map):
-    metrics = metric_dataframe.index.map(lambda x: metric_to_metric_unit_map[x])
-    nodes = metric_dataframe.columns
+def viewer(node_to_step_index_map):
+    nodes, metrics = report.get_chart_selection_options(_get_report_chips())
+    metrics = sorted(metrics)
 
     job_selector_col, graph_adder_col = streamlit.columns(2, gap='large')
     with job_selector_col:

siliconcompiler/report/dashboard/layouts/vertical_flowgraph.py

@@ -91,6 +91,6 @@ def layout():
 
     if "Graphs" in tabs:
         with tabs["Graphs"]:
-            graph.viewer(metric_dataframe, node_to_step_index_map, metric_to_metric_unit_map)
+            graph.viewer(node_to_step_index_map)
 
     _common.check_rerun()

siliconcompiler/report/dashboard/layouts/vertical_flowgraph_node_tab.py

@@ -112,6 +112,6 @@ def layout():
         components.file_viewer(chip, f'{chip.getworkdir()}/{chip.design}.png')
 
     if tab_selected == "Graphs":
-        graph.viewer(metric_dataframe, node_to_step_index_map, metric_to_metric_unit_map)
+        graph.viewer(node_to_step_index_map)
 
     _common.check_rerun()

siliconcompiler/report/dashboard/layouts/vertical_flowgraph_sac_tabs.py

@@ -105,6 +105,6 @@ def layout():
         components.file_viewer(chip, f'{chip.getworkdir()}/{chip.design}.png')
 
     if tab_selected == "Graphs":
-        graph.viewer(metric_dataframe, node_to_step_index_map, metric_to_metric_unit_map)
+        graph.viewer(node_to_step_index_map)
 
     _common.check_rerun()

siliconcompiler/report/report.py

@@ -335,9 +335,28 @@ def get_files(chip, step, index):
     return logs_and_reports
 
 
+def get_chart_selection_options(chips):
+    '''
+    Returns all the nodes and metrics available in the provided chips
+
+    Args:
+        chips (list) : A list of dictionaries with the form
+            {'chip_object': chip, 'chip_name': name}.
+    '''
+    nodes = set()
+    metrics = set()
+    for chip_and_chip_name in chips:
+        chip = chip_and_chip_name['chip_object']
+        nodes_list, _, _, _, chip_metrics, _ = \
+            utils._collect_data(chip, format_as_string=False)
+        nodes.update(set([f'{step}{index}' for step, index in nodes_list]))
+        metrics.update(set(chip_metrics))
+    return nodes, metrics
+
+
 def get_chart_data(chips, metric, nodes):
     '''
-    Returns returns a a tuple where the first element is a 2d dictionary of
+    Returns returns a tuple where the first element is a 2d dictionary of
     data points, following the forms {step+index: {chip_name: value}} where
     each dictionary can have many keys. The second element is a string that represents the unit.
 

siliconcompiler/scheduler/send_messages.py

@@ -81,40 +81,44 @@ def send(chip, msg_type, step, index):
     msg['To'] = ", ".join(to)
     msg['X-Entity-Ref-ID'] = uuid.uuid4().hex  # keep emails from getting grouped
 
-    if msg_type == "summary":
-        layout_img = report_utils._find_summary_image(chip)
-        if layout_img and os.path.isfile(layout_img):
-            with open(layout_img, 'rb') as img_file:
-                img_attach = MIMEApplication(img_file.read())
-                img_attach.add_header('Content-Disposition',
-                                      'attachment',
-                                      filename=os.path.basename(layout_img))
-                msg.attach(img_attach)
-
-        nodes_to_execute = get_executed_nodes(chip, flow)
-        nodes, errors, metrics, metrics_unit, metrics_to_show, _ = \
-            report_utils._collect_data(chip, flow=flow, flowgraph_nodes=nodes_to_execute)
-
-        text_msg = get_file_template('email/summary.j2').render(
-            design=chip.design,
-            nodes=nodes,
-            errors=errors,
-            metrics=metrics,
-            metrics_unit=metrics_unit,
-            metric_keys=metrics_to_show)
-    else:
-        # Attach logs
-        for log in (f'sc_{step}{index}.log', f'{step}.log'):
-            log_file = f'{chip.getworkdir(step=step, index=index)}/{log}'
-            if os.path.exists(log_file):
-                with sc_open(log_file) as f:
-                    log_attach = MIMEApplication(f.read())
-                    log_name, _ = os.path.splitext(log)
-                    # Make attachment a txt file to avoid issues with tools not loading .log
-                    log_attach.add_header('Content-Disposition',
+    if cred["max_file_size"] > 0:
+        if msg_type == "summary":
+            layout_img = report_utils._find_summary_image(chip)
+            if layout_img and os.path.isfile(layout_img):
+                with open(layout_img, 'rb') as img_file:
+                    img_attach = MIMEApplication(img_file.read())
+                    img_attach.add_header('Content-Disposition',
                                           'attachment',
-                                          filename=f'{log_name}.txt')
-                    msg.attach(log_attach)
+                                          filename=os.path.basename(layout_img))
+                    msg.attach(img_attach)
+
+            nodes_to_execute = get_executed_nodes(chip, flow)
+            nodes, errors, metrics, metrics_unit, metrics_to_show, _ = \
+                report_utils._collect_data(chip, flow=flow, flowgraph_nodes=nodes_to_execute)
+
+            text_msg = get_file_template('email/summary.j2').render(
+                design=chip.design,
+                nodes=nodes,
+                errors=errors,
+                metrics=metrics,
+                metrics_unit=metrics_unit,
+                metric_keys=metrics_to_show)
+        else:
+            # Attach logs
+            for log in (f'sc_{step}{index}.log', f'{step}.log'):
+                log_file = f'{chip.getworkdir(step=step, index=index)}/{log}'
+                if os.path.exists(log_file):
+                    with sc_open(log_file) as f:
+                        file_content = f.read().splitlines()
+                        # Limit to max_file_size
+                        file_content = file_content[-cred["max_file_size"]:]
+                        log_attach = MIMEApplication("\n".join(file_content))
+                        log_name, _ = os.path.splitext(log)
+                        # Make attachment a txt file to avoid issues with tools not loading .log
+                        log_attach.add_header('Content-Disposition',
+                                              'attachment',
+                                              filename=f'{log_name}.txt')
+                        msg.attach(log_attach)
 
         records = {}
         for record in chip.getkeys('record'):

siliconcompiler/scheduler/validation/email_credentials.json

@@ -47,6 +47,13 @@
             "examples": [true],
             "type": "boolean",
             "default": true
+        },
+        "max_file_size": {
+            "title": "Max line in log file",
+            "description": "Maximum number of file lines to include in log",
+            "examples": [1000],
+            "type": "integer",
+            "default": 1000
         }
     },
 

siliconcompiler/targets/fpgaflow_demo.py

@@ -16,25 +16,24 @@ def make_docs(chip):
 ####################################################
 # Target Setup
 ####################################################
-def setup(chip):
+def setup(chip, partname=None):
     '''
     Demonstration target for running the open-source fpgaflow.
     '''
 
     # 1. Configure fpga part
-    part_name = chip.get('fpga', 'partname')
-    if not part_name:
+    if not partname:
+        partname = chip.get('fpga', 'partname')
+
+    if not partname:
         raise SiliconCompilerError('FPGA partname has not been set.', chip=chip)
 
     # 2.  Load all available FPGAs
     chip.use(lattice_ice40)
     chip.use(vpr_example)
 
-    if part_name not in chip.getkeys('fpga'):
-        raise SiliconCompilerError(f'{part_name} has not been loaded', chip=chip)
-
     # 3. Load flow
-    chip.use(fpgaflow, partname=part_name)
+    chip.use(fpgaflow, partname=partname)
 
     # 4. Select default flow
     chip.set('option', 'flow', 'fpgaflow', clobber=False)

siliconcompiler/tools/_common/__init__.py

@@ -115,17 +115,17 @@ def get_input_files(chip, *key, add_library_files=True):
         add_library_files (bool): When True, files from library keys
             will be included
     '''
-    step = chip.get('arg', 'step')
-    index = chip.get('arg', 'index')
 
     files = []
     for key in __get_keys(chip, *key, include_library_files=False):
+        step, index = __get_step_index(chip, *key)
         files.extend(chip.find_files(*key, step=step, index=index))
 
     if add_library_files:
         for item in get_libraries(chip, include_asic=False):
             lib_key = ('library', item, *key)
             if __is_key_valid(chip, *lib_key):
+                step, index = __get_step_index(chip, *lib_key)
                 files.extend(chip.find_files(*lib_key, step=step, index=index))
 
     return __remove_duplicates(chip, files, list(key))

siliconcompiler/tools/_common/asic.py

@@ -1,4 +1,5 @@
 from .. import _common
+import json
 
 
 def get_mainlib(chip):
@@ -169,3 +170,49 @@ def get_tool_task_var(chip,
     _, value = _common.pick_key(chip, reversed(check_keys), step=step, index=index)
 
     return value
+
+
+class CellArea:
+    def __init__(self):
+        self.__areas = {}
+
+    def addCell(self, name=None, module=None,
+                cellarea=None, cellcount=None,
+                macroarea=None, macrocount=None,
+                stdcellarea=None, stdcellcount=None):
+        if not name and not module:
+            return
+
+        if all([metric is None for metric in (
+                cellarea, cellcount,
+                macroarea, macrocount,
+                stdcellarea, stdcellcount)]):
+            return
+
+        if not name:
+            name = module
+
+        # ensure name is unique
+        check_name = name
+        idx = 0
+        while check_name in self.__areas:
+            check_name = f'{name}{idx}'
+            idx += 1
+        name = check_name
+
+        self.__areas[name] = {
+            "module": module,
+            "cellarea": cellarea,
+            "cellcount": cellcount,
+            "macroarea": macroarea,
+            "macrocount": macrocount,
+            "stdcellarea": stdcellarea,
+            "stdcellcount": stdcellcount
+        }
+
+    def size(self):
+        return len(self.__areas)
+
+    def writeReport(self, path):
+        with open(path, 'w') as f:
+            json.dump(self.__areas, f, indent=4)

siliconcompiler/tools/klayout/klayout_show.py

@@ -3,7 +3,7 @@ import os
 import sys
 
 
-def show(schema, tech, input_path, output_path, screenshot=False):
+def show(schema, tech, input_path, output_path, screenshot=False, report=None):
     # Extract info from manifest
     flow = schema.get('option', 'flow')
     step = schema.get('arg', 'step')
@@ -80,6 +80,14 @@ def show(schema, tech, input_path, output_path, screenshot=False):
             __screenshot(schema, layout_view, output_path)
         else:
             __screenshot_montage(schema, layout_view, xbins, ybins)
+    else:
+        if report:
+            rdb_id = layout_view.create_rdb(os.path.basename(report))
+            rdb = layout_view.rdb(rdb_id)
+            print(f"[INFO] reading DRC report: {report}")
+            rdb.load(report)
+
+            layout_view.show_rdb(rdb_id, cell_view.index())
 
 
 def __screenshot(schema, layout_view, output_path):
@@ -215,24 +223,56 @@ def main():
     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):
+    sc_fileext = schema.get('tool', 'klayout', 'task', task, 'var', 'show_filetype',
+                            step=step, index=index)[0]
+    sc_report = None
+    if sc_fileext in ('lyrdb', 'ascii'):
+        sc_report = schema.get('tool', 'klayout', 'task', task, 'var', 'show_filepath',
+                               step=step, index=index)[0]
+
+        sc_filename = None
+        for fileext in ('gds', 'oas'):
+            for ext in (f'{fileext}.gz', fileext):
+                sc_filename = f"inputs/{design}.{ext}"
+                if os.path.exists(sc_filename):
+                    break
+                sc_filename = None
+            if sc_filename:
                 break
 
+        if not sc_filename:
+            show_step = schema.get('arg', 'step')
+            if schema.valid('tool', 'klayout', 'task', task, 'var', 'show_step'):
+                show_index = schema.get('tool', 'klayout', 'task', task, 'var', 'show_step',
+                                        step=step, index=index)[0]
+            show_index = schema.get('arg', 'index')
+            if schema.valid('tool', 'klayout', 'task', task, 'var', 'show_index'):
+                show_index = schema.get('tool', 'klayout', 'task', task, 'var', 'show_index',
+                                        step=step, index=index)[0]
+            for fileext in ('gds', 'oas'):
+                if schema.valid('input', 'layout', fileext) and \
+                   schema.get('input', 'layout', fileext, step=show_step, index=show_index):
+                    sc_filename = schema.get('input', 'layout', fileext,
+                                             step=show_step, index=show_index)[0]
+                    if sc_filename:
+                        break
+    else:
+        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:
+            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'))
+         screenshot=(task == 'screenshot'), report=sc_report)
 
     if sc_exit:
         pya.Application.instance().exit(0)

siliconcompiler/tools/openroad/openroad.py

@@ -17,7 +17,8 @@ from siliconcompiler import sc_open
 from siliconcompiler import utils
 from siliconcompiler.tools._common import input_provides, add_common_file, \
     get_tool_task, record_metric
-from siliconcompiler.tools._common.asic import get_mainlib, set_tool_task_var, get_libraries
+from siliconcompiler.tools._common.asic import get_mainlib, set_tool_task_var, get_libraries, \
+    CellArea
 from siliconcompiler.targets import asap7_demo
 
 
@@ -268,8 +269,12 @@ def post_process(chip):
                      "timing/hold.rpt",
                      "timing/hold.topN.rpt"],
         "holdpaths": ["timing/hold.topN.rpt"],
-        "unconstrained": ["timing/unconstrained.topN.rpt"],
-        "peakpower": [f"power/{corner}.rpt" for corner in chip.getkeys('constraint', 'timing')],
+        "unconstrained": ["timing/unconstrained.rpt", "timing/unconstrained.topN.rpt"],
+        "peakpower": [
+            *[f"power/{corner}.rpt" for corner in chip.getkeys('constraint', 'timing')],
+            *[f"images/heatmap/power_density/{corner}.png"
+              for corner in chip.getkeys('constraint', 'timing')]
+        ],
         "drvs": ["timing/drv_violators.rpt",
                  "floating_nets.rpt",
                  f"{chip.design}_antenna.rpt",
@@ -277,7 +282,9 @@ def post_process(chip):
         "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"]
+                 f"images/markers/{chip.design}.drc.png"],
+        "utilization": ["images/heatmap/placement_density.png"],
+        "wirelength": [f"images/{chip.design}.routing.png"]
     }
     metric_reports["leakagepower"] = metric_reports["peakpower"]
 
@@ -300,6 +307,8 @@ def post_process(chip):
             chip.logger.error(f'Unable to parse metrics from OpenROAD: {e}')
             metrics = {}
 
+        _generate_cell_area_report(chip.top(), metrics)
+
         or_units = {}
         for unit, or_unit in [('time', 'run__flow__platform__time_units'),
                               ('capacitance', 'run__flow__platform__capacitance_units'),
@@ -424,6 +433,114 @@ def post_process(chip):
             record_metric(chip, step, index, 'drcs', drcs, get_metric_sources('drcs'))
 
 
+def _generate_cell_area_report(design, ord_metrics):
+    cellarea_report = CellArea()
+
+    prefix = "sc__cellarea__design__instance"
+
+    filtered_data = {}
+    for key, value in ord_metrics.items():
+        if key.startswith(prefix):
+            filtered_data[key[len(prefix)+2:]] = value
+
+    modules = set()
+    modules.add("")
+    for key in filtered_data.keys():
+        if "__in_module:" in key:
+            module = key[key.find("__in_module:"):]
+            modules.add(module)
+
+    def process_cell(group):
+        data = {}
+        for key, value in filtered_data.items():
+            if (group != "" and key.endswith(group)):
+                key = key[:key.find("__in_module:")]
+                data[key] = value
+            elif (group == "" and "__in_module" not in key):
+                data[key] = value
+
+        cell_type = None
+        cell_name = None
+
+        if not group:
+            cell_type = design
+            cell_name = design
+        else:
+            cell_type = group[len("__in_module:"):]
+
+        cellarea = None
+        cellcount = None
+
+        macroarea = None
+        macrocount = None
+
+        stdcell_types = (
+            'tie_cell',
+            'standard_cell',
+            'buffer',
+            'clock_buffer',
+            'timing_repair_buffer',
+            'inverter',
+            'clock_inverter',
+            'timing_Repair_inverter',
+            'clock_gate_cell',
+            'level_shifter_cell',
+            'sequential_cell',
+            'multi_input_combinational_cell',
+            'other'
+            )
+
+        stdcell_info_area = []
+        stdcell_info_count = []
+        stdcellarea = None
+        stdcellcount = None
+
+        for key, value in data.items():
+            if key == 'name':
+                cell_name = value
+            elif key == 'count':
+                cellcount = value
+            elif key == 'area':
+                cellarea = value
+            elif key.startswith('count__class'):
+                _, cell_class = key.split(':')
+                if cell_class == 'macro':
+                    macrocount = value
+                elif cell_class in stdcell_types:
+                    stdcell_info_count.append(value)
+            elif key.startswith('area__class'):
+                _, cell_class = key.split(':')
+                if cell_class == 'macro':
+                    macroarea = value
+                elif cell_class in stdcell_types:
+                    stdcell_info_area.append(value)
+
+        if stdcell_info_count:
+            stdcellcount = sum(stdcell_info_count)
+        if stdcell_info_area:
+            stdcellarea = sum(stdcell_info_area)
+
+        cellarea_report.addCell(
+            name=cell_name,
+            module=cell_type,
+            cellarea=cellarea,
+            cellcount=cellcount,
+            macroarea=macroarea,
+            macrocount=macrocount,
+            stdcellarea=stdcellarea,
+            stdcellcount=stdcellcount)
+
+        if filtered_data:
+            return True
+        return False
+
+    for module in modules:
+        process_cell(module)
+
+    if cellarea_report.size() > 0:
+        cellarea_report.writeReport("reports/hierarchical_cell_area.json")
+
+
 ######
 def get_library_timing_keypaths(chip, lib):
     step = chip.get('arg', 'step')

siliconcompiler/tools/openroad/scripts/sc_procs.tcl

@@ -483,3 +483,12 @@ proc sc_convert_rotation { rot } {
     default { utl::error FLW 1 "$rot not recognized" }
   }
 }
+
+proc sc_check_version { min_required } {
+  set version [split [ord::openroad_version] "-"]
+  if { [lindex $version 0] != "v2.0" } {
+    return false
+  }
+
+  return [expr { [lindex $version 1] >= $min_required }]
+}

siliconcompiler/tools/openroad/scripts/sc_report.tcl

@@ -168,3 +168,22 @@ foreach markerdb [[ord::get_db_block] getMarkerCategories] {
   $markerdb writeTR "reports/markers/${sc_design}.[$markerdb getName].rpt"
   $markerdb writeJSON "reports/markers/${sc_design}.[$markerdb getName].json"
 }
+
+if { [sc_check_version 17038] } {
+  utl::push_metrics_stage "sc__cellarea__{}"
+  tee -file reports/cell_usage.rpt {report_cell_usage -verbose}
+
+  foreach modinst [[ord::get_db_block] getModInsts] {
+    tee -quiet -append -file reports/cell_usage.rpt { puts "" }
+    tee -quiet -append -file reports/cell_usage.rpt {
+      puts "########################################################"
+    }
+    tee -quiet -append -file reports/cell_usage.rpt { puts "" }
+
+    utl::metric "design__instance__name__in_module:[[$modinst getMaster] getName]" \
+      [$modinst getHierarchicalName]
+    tee -quiet -append -file reports/cell_usage.rpt \
+      "report_cell_usage -verbose [$modinst getHierarchicalName]"
+  }
+  utl::pop_metrics_stage
+}

siliconcompiler/tools/vivado/bitstream.py

@@ -11,9 +11,15 @@ def setup(chip):
     vivado.setup_task(chip, task)
 
     design = chip.top()
-    chip.set('tool', tool, 'task', task, 'input', f'{design}_checkpoint.dcp',
+    chip.set('tool', tool, 'task', task, 'input', f'{design}.dcp',
              step=step, index=index)
-    chip.set('tool', tool, 'task', task, 'output', f'{design}.bit',
+    chip.set('tool', tool, 'task', task, 'output', f'{design}.dcp',
+             step=step, index=index)
+    chip.add('tool', tool, 'task', task, 'output', f'{design}.xdc',
+             step=step, index=index)
+    chip.add('tool', tool, 'task', task, 'output', f'{design}.vg',
+             step=step, index=index)
+    chip.add('tool', tool, 'task', task, 'output', f'{design}.bit',
              step=step, index=index)
 
 

siliconcompiler/tools/vivado/place.py

@@ -11,9 +11,13 @@ def setup(chip):
     vivado.setup_task(chip, task)
 
     design = chip.top()
-    chip.set('tool', tool, 'task', task, 'input', f'{design}_checkpoint.dcp',
+    chip.set('tool', tool, 'task', task, 'input', f'{design}.dcp',
              step=step, index=index)
-    chip.set('tool', tool, 'task', task, 'output', f'{design}_checkpoint.dcp',
+    chip.set('tool', tool, 'task', task, 'output', f'{design}.dcp',
+             step=step, index=index)
+    chip.add('tool', tool, 'task', task, 'output', f'{design}.xdc',
+             step=step, index=index)
+    chip.add('tool', tool, 'task', task, 'output', f'{design}.vg',
              step=step, index=index)
 
 

siliconcompiler/tools/vivado/route.py

@@ -11,9 +11,13 @@ def setup(chip):
     vivado.setup_task(chip, task)
 
     design = chip.top()
-    chip.set('tool', tool, 'task', task, 'input', f'{design}_checkpoint.dcp',
+    chip.set('tool', tool, 'task', task, 'input', f'{design}.dcp',
              step=step, index=index)
-    chip.set('tool', tool, 'task', task, 'output', f'{design}_checkpoint.dcp',
+    chip.set('tool', tool, 'task', task, 'output', f'{design}.dcp',
+             step=step, index=index)
+    chip.add('tool', tool, 'task', task, 'output', f'{design}.xdc',
+             step=step, index=index)
+    chip.add('tool', tool, 'task', task, 'output', f'{design}.vg',
              step=step, index=index)
 
 

siliconcompiler/tools/vivado/scripts/sc_bitstream.tcl

@@ -1,4 +1,4 @@
-open_checkpoint "inputs/${sc_design}_checkpoint.dcp"
+open_checkpoint "inputs/${sc_design}.dcp"
 if { $sc_constraint != "" } {
     write_bitstream -force -file "outputs/${sc_design}.bit"
 } else {