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

siliconcompiler/report/dashboard/components/flowgraph.py

@@ -0,0 +1,114 @@
+from siliconcompiler.report import report
+from siliconcompiler.flowgraph import _get_flowgraph_exit_nodes, _get_flowgraph_entry_nodes
+from siliconcompiler.tools._common import get_tool_task
+from siliconcompiler import NodeStatus
+
+from streamlit_agraph import Node, Edge, Config
+
+
+# for flowgraph
+NODE_COLORS = {
+    NodeStatus.SUCCESS: '#70db70',  # green
+
+    NodeStatus.SKIPPED: '#ffc299',  # orange
+
+    NodeStatus.PENDING: '#6699ff',  # blue
+    NodeStatus.QUEUED: '#6699ff',  # blue
+
+    NodeStatus.RUNNING: '#ffff4d',  # yellow
+
+    NodeStatus.ERROR: '#ff1a1a',  # red
+    NodeStatus.TIMEOUT: '#ff1a1a',  # red
+
+    "Unknown": '#6699ff',  # blue
+}
+
+
+def get_nodes_and_edges(chip):
+    """
+    Returns the nodes and edges required to make a streamlit_agraph.
+
+    Args:
+        chip (Chip) : The chip object that contains the schema read from.
+    """
+    nodes = []
+    edges = []
+
+    default_node_border_width = 1
+    successful_path_node_width = 3
+    default_edge_width = 3
+    successful_path_edge_width = 5
+
+    node_dependencies = report.get_flowgraph_edges(chip)
+    successful_path = report.get_flowgraph_path(chip)
+
+    entry_exit_nodes = _get_flowgraph_entry_nodes(chip, chip.get('option', 'flow')) + \
+        _get_flowgraph_exit_nodes(chip, chip.get('option', 'flow'))
+
+    for step, index in node_dependencies:
+        # Build node
+        node_border_width = default_node_border_width
+        if (step, index) in entry_exit_nodes:
+            node_border_width = successful_path_node_width
+
+        node_status = chip.get('record', 'status', step=step, index=index)
+        if node_status not in NODE_COLORS:
+            node_status = "Unknown"
+        node_color = NODE_COLORS[node_status]
+
+        tool, task = get_tool_task(chip, step, index)
+        node_name = f'{step}{index}'
+        label = node_name + "\n" + tool + "/" + task
+        if tool == 'builtin':
+            label = node_name + "\n" + tool
+
+        nodes.append(Node(
+            id=node_name,
+            label=label,
+            color=node_color,
+            opacity=1,
+            borderWidth=node_border_width,
+            shape='oval',
+            fixed=True))
+
+        # Build edges
+        path_taken = chip.get('record', 'inputnode', step=step, index=index)
+        all_edges = set([*node_dependencies[step, index], *path_taken])
+        for source_step, source_index in all_edges:
+            edge_width = default_edge_width
+            if (step, index) in successful_path and \
+               (source_step, source_index) in successful_path:
+                edge_width = successful_path_edge_width
+
+            dashes = False
+            color = 'black'
+            if (source_step, source_index) not in path_taken:
+                color = 'gray'
+                dashes = True
+            elif node_status != NodeStatus.SUCCESS:
+                color = 'gray'
+            elif NodeStatus.is_waiting(node_status) or NodeStatus.is_running(node_status):
+                color = 'blue'
+                dashes = True
+
+            edges.append(Edge(
+                source=f'{source_step}{source_index}',
+                target=node_name,
+                dir='up',
+                width=edge_width,
+                color=color,
+                dashes=dashes))
+
+    return nodes, edges
+
+
+def get_graph_config():
+    return Config(
+        width='100%',
+        height=1000,
+        directed=True,
+        physics=False,
+        hierarchical=True,
+        nodeSpacing=150,
+        levelSeparation=100,
+        sortMethod='directed')

siliconcompiler/report/dashboard/components/graph.py

@@ -0,0 +1,208 @@
+import altair
+import math
+import pandas
+import streamlit
+
+from siliconcompiler.report import report
+
+from siliconcompiler.report.dashboard import state
+
+
+def _get_report_chips():
+    chips = []
+    for job in state.get_chips():
+        chips.append({'chip_object': state.get_chip(job), 'chip_name': job})
+    return chips
+
+
+def job_selector():
+    """
+    Displays a dataframe that can be edited to select specific jobs to include
+    in the analysis.
+    """
+    jobs = state.get_chips()
+
+    all_jobs = pandas.DataFrame({
+        'job names': jobs,
+        'selected jobs': [True] * len(jobs)
+    })
+
+    configuration = {
+        'selected jobs': streamlit.column_config.CheckboxColumn(
+            'Select runs',
+            default=True)
+    }
+
+    with streamlit.popover('Select Jobs', use_container_width=True):
+        selected_jobs = streamlit.data_editor(
+            all_jobs,
+            disabled=['job names'],
+            use_container_width=True,
+            hide_index=True,
+            column_config=configuration)
+
+        jobs = []
+        for is_selected, job_name in zip(selected_jobs['selected jobs'].tolist(),
+                                         selected_jobs['job names'].tolist()):
+            if is_selected:
+                jobs.append(job_name)
+
+        state.set_key(state.GRAPH_JOBS, jobs)
+
+
+def graph_count_selector():
+    return streamlit.slider(
+        'pick the number of graphs you want',
+        1,
+        10,
+        1,
+        label_visibility='collapsed')
+
+
+def settings(metrics, nodes, graph_number):
+    """
+    Displays selectbox for metrics and nodes which informs the graph on what
+    to display.
+
+    Args:
+        metrics (list) : A list of metrics that are set for all chips given in chips.
+        nodes (list) : A list of nodes given in the form f'{step}{index}'
+        graph_number (int) : The number of graphs there are. Used to create
+            keys to distinguish selectboxes from each other.
+    """
+    metric_selector_col, node_selector_col, settings_col = \
+        streamlit.columns(3, gap='small')
+
+    with metric_selector_col:
+        with streamlit.popover('Select a Metric', use_container_width=True):
+            selected_metric = streamlit.selectbox(
+                'Select a Metric',
+                metrics,
+                label_visibility='collapsed',
+                key=f'graph-{graph_number}-metric-selection')
+
+    with node_selector_col:
+        with streamlit.popover('Select Nodes', use_container_width=True):
+            selected_nodes = streamlit.multiselect(
+                'Select a Node',
+                nodes,
+                label_visibility='collapsed',
+                key=f'graph-{graph_number}-node-selection',
+                default=nodes)
+
+    with settings_col:
+        with streamlit.popover('Settings', use_container_width=True):
+            log_scale = streamlit.checkbox(
+                "Log scale",
+                False,
+                help="Make the y-axis log scale",
+                key=f'graph-{graph_number}-log-scale')
+
+            transpose = streamlit.checkbox(
+                "Transpose",
+                False,
+                help="Use nodes instead of jobs as the x-axis",
+                key=f'graph-{graph_number}-transpose')
+
+            chart_type = streamlit.selectbox(
+                'Chart type',
+                ['line', 'bar', 'point', 'tick'],
+                label_visibility='collapsed',
+                key=f'graph-{graph_number}-chart-selection')
+
+    return selected_metric, selected_nodes, log_scale, transpose, chart_type
+
+
+def graph(metrics, nodes, node_to_step_index_map, graph_number):
+    metric, selected_nodes, log_scale, transpose, chart_type = \
+        settings(metrics, nodes, graph_number)
+
+    nodes_as_step_and_index = []
+    for selected_node in selected_nodes:
+        step, index = node_to_step_index_map[selected_node]
+        nodes_as_step_and_index.append((step, index))
+
+    if transpose:
+        x_axis_label = 'nodes'
+        color_label = 'runs'
+    else:
+        x_axis_label = 'runs'
+        color_label = 'nodes'
+
+    y_axis_label = metric
+
+    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})'
+
+    # Prepare plot data
+    filtered_data = {
+        x_axis_label: [],
+        y_axis_label: [],
+        color_label: []
+    }
+
+    if not nodes.empty:
+        # filtering through data
+        for job_name in state.get_key(state.GRAPH_JOBS):
+            for step, index in data:
+                filtered_data['runs'].append(job_name)
+                filtered_data['nodes'].append(step + index)
+                if job_name not in data[(step, index)].keys():
+                    filtered_data[y_axis_label].append(None)
+                else:
+                    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))
+
+    y_axis = y_axis_label
+    if log_scale and chart_type != 'bar':
+        y_axis = altair.Y(y_axis_label, scale=altair.Scale(type="log"))
+
+    color = color_label
+
+    alt_chart = altair.Chart(pandas.DataFrame(filtered_data).dropna(), height=500)
+
+    if chart_type == 'line':
+        chart_mark = alt_chart.mark_line(point=True)
+    elif chart_type == 'bar':
+        chart_mark = alt_chart.mark_bar(point=True)
+    elif chart_type == 'point':
+        chart_mark = alt_chart.mark_circle(point=True)
+    elif chart_type == 'tick':
+        chart_mark = alt_chart.mark_tick(point=True)
+    else:
+        raise ValueError(f'{chart_type} not supported')
+
+    chart = chart_mark.encode(
+        x=x_axis,
+        y=y_axis,
+        color=color)
+
+    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
+
+    job_selector_col, graph_adder_col = streamlit.columns(2, gap='large')
+    with job_selector_col:
+        job_selector()
+    with graph_adder_col:
+        graphs = graph_count_selector()
+
+    streamlit.divider()
+
+    columns = 1 if graphs <= 1 else 2
+    last_row_num = int(math.floor((graphs - 1) / columns)) * columns
+
+    graph_number = 0
+    graph_cols = streamlit.columns(columns, gap='large')
+    while graph_number < graphs:
+        with graph_cols[graph_number % columns]:
+            graph(metrics, nodes, node_to_step_index_map, graph_number)
+            if graph_number < last_row_num:
+                streamlit.divider()
+        graph_number += 1

siliconcompiler/report/dashboard/layouts/__init__.py

@@ -0,0 +1,20 @@
+from siliconcompiler.report.dashboard.layouts import vertical_flowgraph
+from siliconcompiler.report.dashboard.layouts import vertical_flowgraph_sac_tabs
+from siliconcompiler.report.dashboard.layouts import vertical_flowgraph_node_tab
+
+__LAYOUTS = {
+    "vertical_flowgraph": vertical_flowgraph.layout,
+    "vertical_flowgraph_sac_tabs": vertical_flowgraph_sac_tabs.layout,
+    "vertical_flowgraph_node_tab": vertical_flowgraph_node_tab.layout
+}
+
+
+def get_all_layouts():
+    return list(__LAYOUTS.keys())
+
+
+def get_layout(name):
+    if name not in __LAYOUTS:
+        raise ValueError(f"{name} is not a layout")
+
+    return __LAYOUTS[name]

siliconcompiler/report/dashboard/layouts/_common.py

@@ -0,0 +1,43 @@
+import streamlit_antd_components as sac
+
+from siliconcompiler.report.dashboard import state
+
+
+def check_rerun():
+    # Determine if node was modified
+    if state.set_key(state.SELECTED_NODE, state.get_selected_node()):
+        state.set_key(state.APP_RERUN, "Node")
+
+    if state.get_key(state.APP_RERUN) == "Node":
+        state.set_key(state.SELECT_TAB, "Node Information")
+        state.del_key(state.TAB_STATE)
+    elif state.get_key(state.APP_RERUN) == "File":
+        state.set_key(state.SELECT_TAB, "File Viewer")
+        state.del_key(state.TAB_STATE)
+    else:
+        state.set_key(state.SELECT_TAB, None)
+
+
+def sac_tabs(tab_headings):
+    index = 0
+
+    if state.get_key(state.SELECT_TAB):
+        for n, tab in enumerate(tab_headings):
+            if state.get_key(state.SELECT_TAB) == tab.label:
+                index = n
+    elif state.get_key(state.TAB_INDEX) is not None:
+        index = state.get_key(state.TAB_INDEX)
+
+    tab_selected = sac.tabs(
+        tab_headings,
+        align='center',
+        variant='outline',
+        use_container_width=True,
+        index=index,
+        key=state.TAB_STATE)
+
+    for n, tab in enumerate(tab_headings):
+        if tab_selected == tab.label:
+            state.set_key(state.TAB_INDEX, n)
+
+    return tab_selected

siliconcompiler/report/dashboard/layouts/vertical_flowgraph.py

@@ -0,0 +1,96 @@
+import os
+import streamlit
+
+from siliconcompiler.report.dashboard import components
+from siliconcompiler.report.dashboard.components import graph
+from siliconcompiler.report.dashboard import state
+from siliconcompiler.report.dashboard import utils
+from siliconcompiler.report.dashboard.layouts import _common
+
+
+def layout():
+    chip = state.get_chip()
+    metric_dataframe, node_to_step_index_map, metric_to_metric_unit_map = \
+        utils.generate_metric_dataframe(chip)
+
+    components.page_header()
+
+    tab_headings = ["Metrics", "Manifest", "File Viewer"]
+    if os.path.isfile(f'{chip.getworkdir()}/{chip.design}.png'):
+        tab_headings.append("Design Preview")
+
+    has_graphs = len(state.get_key(state.LOADED_CHIPS)) > 1
+    if has_graphs:
+        tab_headings.append("Graphs")
+
+    tabs = {
+        name: tab for name, tab in zip(tab_headings, streamlit.tabs(tab_headings))
+    }
+
+    with tabs["Metrics"]:
+        # Add flowgraph
+        if state.get_key(state.DISPLAY_FLOWGRAPH):
+            default_flowgraph_width_in_percent = 0.4
+            flowgraph_col_width_in_pixels = 520
+            flowgraph_col_width_in_percent = \
+                state.compute_component_size(
+                    default_flowgraph_width_in_percent,
+                    flowgraph_col_width_in_pixels)
+
+            flowgraph_col, metrics_container = \
+                streamlit.columns(
+                    [flowgraph_col_width_in_percent, 1 - flowgraph_col_width_in_percent],
+                    gap="large")
+
+            with flowgraph_col:
+                header_col, flowgraph_toggle_container = streamlit.columns(2, gap="large")
+                with header_col:
+                    streamlit.header('Flowgraph')
+                components.flowgraph_viewer(chip)
+        else:
+            flowgraph_toggle_container = streamlit.container()
+            metrics_container = streamlit.container()
+
+        with flowgraph_toggle_container:
+            streamlit.markdown("")
+            streamlit.markdown("")
+
+            if state.set_key(state.DISPLAY_FLOWGRAPH, not streamlit.checkbox(
+                    'Hide flowgraph',
+                    help='Click here to hide the flowgraph')):
+                state.set_key(state.APP_RERUN, "Flowgraph")
+
+        with metrics_container:
+            components.metrics_viewer(metric_dataframe, metric_to_metric_unit_map)
+
+            header_col, settings_col = \
+                streamlit.columns(
+                    [0.7, 0.3],
+                    gap='small')
+            with header_col:
+                streamlit.header('Node Information')
+            with settings_col:
+                components.node_selector(list(node_to_step_index_map.keys()))
+
+            if state.get_selected_node():
+                step, index = node_to_step_index_map[state.get_selected_node()]
+                components.node_viewer(chip, step, index, metric_dataframe)
+
+    with tabs["Manifest"]:
+        components.manifest_viewer(chip)
+
+    with tabs["File Viewer"]:
+        components.file_viewer(
+            chip,
+            state.get_key(state.SELECTED_FILE),
+            page_key=state.SELECTED_FILE_PAGE)
+
+    if "Design Preview" in tabs:
+        with tabs["Design Preview"]:
+            components.file_viewer(chip, f'{chip.getworkdir()}/{chip.design}.png')
+
+    if "Graphs" in tabs:
+        with tabs["Graphs"]:
+            graph.viewer(metric_dataframe, node_to_step_index_map, metric_to_metric_unit_map)
+
+    _common.check_rerun()

siliconcompiler/report/dashboard/layouts/vertical_flowgraph_node_tab.py

@@ -0,0 +1,117 @@
+import os
+import streamlit
+
+from siliconcompiler.report.dashboard import components
+from siliconcompiler.report.dashboard.components import graph
+from siliconcompiler.report.dashboard import state
+from siliconcompiler.report.dashboard import utils
+from siliconcompiler.report.dashboard.utils import file_utils
+from siliconcompiler.report.dashboard.layouts import _common
+import streamlit_antd_components as sac
+
+
+def layout():
+    chip = state.get_chip()
+    metric_dataframe, node_to_step_index_map, metric_to_metric_unit_map = \
+        utils.generate_metric_dataframe(chip)
+
+    components.page_header()
+
+    tab_headings = [
+        sac.TabsItem(
+            "Metrics",
+            icon='stack'),
+        sac.TabsItem(
+            "Node Information",
+            icon='diagram-2'),
+        sac.TabsItem(
+            "Manifest",
+            icon=file_utils.get_file_icon('manifest.pkg.json')),
+        sac.TabsItem(
+            "File Viewer",
+            icon=file_utils.get_file_icon(state.get_key(state.SELECTED_FILE))),
+        sac.TabsItem(
+            "Design Preview",
+            icon=file_utils.get_file_icon('design.png'),
+            disabled=not os.path.isfile(f'{chip.getworkdir()}/{chip.design}.png')),
+        sac.TabsItem(
+            "Graphs",
+            icon='graph-up',
+            disabled=len(state.get_key(state.LOADED_CHIPS)) == 1)
+    ]
+
+    tab_selected = _common.sac_tabs(tab_headings)
+
+    if tab_selected == "Metrics":
+        # Add flowgraph
+        if state.get_key(state.DISPLAY_FLOWGRAPH):
+            default_flowgraph_width_in_percent = 0.4
+            flowgraph_col_width_in_pixels = 520
+            flowgraph_col_width_in_percent = \
+                state.compute_component_size(
+                    default_flowgraph_width_in_percent,
+                    flowgraph_col_width_in_pixels)
+
+            flowgraph_col, metrics_container = \
+                streamlit.columns(
+                    [flowgraph_col_width_in_percent, 1 - flowgraph_col_width_in_percent],
+                    gap="large")
+
+            with flowgraph_col:
+                header_col, flowgraph_toggle_container = streamlit.columns(2, gap="large")
+                with header_col:
+                    streamlit.header('Flowgraph')
+                components.flowgraph_viewer(chip)
+        else:
+            flowgraph_toggle_container = streamlit.container()
+            metrics_container = streamlit.container()
+
+        with flowgraph_toggle_container:
+            streamlit.markdown("")
+            streamlit.markdown("")
+
+            if state.set_key(state.DISPLAY_FLOWGRAPH, not streamlit.checkbox(
+                    'Hide flowgraph',
+                    help='Click here to hide the flowgraph')):
+                state.set_key(state.APP_RERUN, "Flowgraph")
+
+        with metrics_container:
+            components.metrics_viewer(
+                metric_dataframe,
+                metric_to_metric_unit_map,
+                height=1000)
+
+    if tab_selected == "Node Information":
+        header_col, settings_col = \
+            streamlit.columns(
+                [0.7, 0.3],
+                gap='small')
+        with header_col:
+            streamlit.header('Node Information')
+        with settings_col:
+            components.node_selector(list(node_to_step_index_map.keys()))
+
+        if state.get_selected_node():
+            step, index = node_to_step_index_map[state.get_selected_node()]
+            current_file = state.get_key(state.SELECTED_FILE)
+            components.node_viewer(chip, step, index, metric_dataframe, height=1000)
+            if state.get_key(state.SELECTED_FILE) and \
+                    current_file != state.get_key(state.SELECTED_FILE):
+                state.set_key(state.APP_RERUN, "File")
+
+    if tab_selected == "Manifest":
+        components.manifest_viewer(chip)
+
+    if tab_selected == "File Viewer":
+        components.file_viewer(
+            chip,
+            state.get_key(state.SELECTED_FILE),
+            page_key=state.SELECTED_FILE_PAGE)
+
+    if tab_selected == "Design Preview":
+        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)
+
+    _common.check_rerun()