carm-paraver 1.0.0.dev1__tar.gz → 1.0.1.dev0__tar.gz

{carm_paraver-1.0.0.dev1 → carm_paraver-1.0.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-paraver
-Version: 1.0.0.dev1
+Version: 1.0.1.dev0
 Summary: Dash-based CARM analysis for Paraver traces
 Author: CARM Contributors
 Requires-Python: >=3.9
@@ -19,6 +19,8 @@ Dynamic: license-file
 
 This GUI allows the analysis of [Paraver](https://tools.bsc.es/paraver) traces on the Cache-Aware Roofline Model (CARM) for floating-point operations. It can be launched from the Paraver interface and send labeled events back to Paraver for visualization.
 
+The CARM allows for roofline analysis of your application, displaying its computational bursts as points on the roofline. This can be used to identify bottlenecks and optimization opportunities for the respective code section. Points on the memory-bound or the compute-bound sections of the roof benefit from different optimization strategies, and the distance of your points to the roofline can be used to identify how much performance can be gained by optimizing your code.
+
 # Requirements
 - Python (tested with 3.9.25, 3.10.12, 3.12.3)
 - [Paraver, Extrae](https://tools.bsc.es/downloads)

{carm_paraver-1.0.0.dev1 → carm_paraver-1.0.1.dev0}/README.md

@@ -2,6 +2,8 @@
 
 This GUI allows the analysis of [Paraver](https://tools.bsc.es/paraver) traces on the Cache-Aware Roofline Model (CARM) for floating-point operations. It can be launched from the Paraver interface and send labeled events back to Paraver for visualization.
 
+The CARM allows for roofline analysis of your application, displaying its computational bursts as points on the roofline. This can be used to identify bottlenecks and optimization opportunities for the respective code section. Points on the memory-bound or the compute-bound sections of the roof benefit from different optimization strategies, and the distance of your points to the roofline can be used to identify how much performance can be gained by optimizing your code.
+
 # Requirements
 - Python (tested with 3.9.25, 3.10.12, 3.12.3)
 - [Paraver, Extrae](https://tools.bsc.es/downloads)

{carm_paraver-1.0.0.dev1 → carm_paraver-1.0.1.dev0}/carm_paraver/Paraver_CARM.py

@@ -23,6 +23,7 @@ from typing import Any
 import dash
 import dash_bootstrap_components as dbc
 import dash_daq as daq
+import numpy as np
 
 # Third Party Libraries
 # Run: pip install dash dash-bootstrap-components dash-daq numpy pandas plotly
@@ -70,6 +71,60 @@ def set_process_death_signal():
         raise OSError("prctl failed")
 
 
+class ProgressBar:
+    """Prints a terminal progress bar that updates in-place, ensuring 100% is printed exactly once."""
+
+    def __init__(self, total: int, bar_width: int = 30):
+        self.total = total
+        self.bar_width = bar_width
+        self._done = False
+
+    def update(self, processed: int) -> None:
+        """Print the progress bar for the given number of processed items.
+
+        When ``processed >= total`` the bar is shown at 100% followed by a
+        newline; subsequent calls are no-ops.
+        """
+        if self._done:
+            return
+
+        if self.total <= 0:
+            return
+
+        if processed >= self.total:
+            self._print(1.0)
+            print()
+            self._done = True
+        else:
+            progress = min(processed / self.total, 0.99)
+            self._print(progress)
+
+    def _print(self, progress: float) -> None:
+        if progress >= 1.0:
+            segments = self.bar_width
+        else:
+            segments = min(math.ceil(self.bar_width * progress), self.bar_width - 1)
+        print(
+            f"[{'#' * segments}{' ' * (self.bar_width - segments)}] {progress * 100:.1f}%",
+            end="\r",
+            flush=True,
+        )
+
+
+def _carm_btn(label: str, button_id: str, tooltip: str | None = None):
+    """Create a sidebar button with optional Tooltip."""
+    btn = dbc.Button(
+        label,
+        id=button_id,
+        className="mb-2",
+        style={"width": "100%"},
+        n_clicks=0,
+    )
+    if tooltip:
+        return html.Div([btn, dbc.Tooltip(tooltip, target=button_id)])
+    return btn
+
+
 set_process_death_signal()
 
 VERSION = "1.0.0"
@@ -556,6 +611,7 @@ if memory_counters <= missing_files:
             flush=True,
         )
     no_mem = True
+    sys.exit(1)
 
 # Check if all FP (floating point) counters are missing
 if fp_counters <= missing_files:
@@ -571,8 +627,6 @@ if fp_counters <= missing_files:
         )
     sys.exit(1)
 
-if no_mem:
-    sys.exit(1)
 
 if "Intel_Loads" not in missing_files and "Intel_Stores" not in missing_files and "Intel_Loads_Stores" in missing_files:
     missing_files.remove("Intel_Loads_Stores")
@@ -582,16 +636,16 @@ if any("SP" in s for s in found_files):
 if any("DP" in s for s in found_files):
     dp_counters_available = True
 
-
 missing_msg = (
-    "\nAdd these counters to your XML file to monitor all possible events, \nthese counters should remain in a single "
-    "counter set:\n\n  "
+    "Counters for some events are missing from the trace. If any of the following operations\nare relevant to your "
+    "application, you should add the corresponding counters:\n\n"
     + "\n  ".join(
         [
             f"{f.replace('_', ' ')} -> {intel_performance_counters_mapping.get(f, 'No mapping found')}"
             for f in missing_files
         ]
     )
+    + "\n\nThe analysis will proceed with the available counters.\nSee the documentation for more details."
 )
 
 is_modal_open = len(missing_files) > 0
@@ -739,6 +793,7 @@ rows_chars = len(str(total_rows))
 step = max(1, total_rows // 100) if total_rows > 0 else 1
 prog_bar_width = 30  # Total width of the progress bar
 processed = 0
+bar = ProgressBar(total_rows, prog_bar_width)
 if total_rows > 50_000:
     print(
         f"WARNING: Displaying a large number of rows ({total_rows}) may slow down the UI. Consider zooming "
@@ -765,17 +820,9 @@ else:
     counter_data_df = counter_data_df.copy()
 
 for row in counter_data_df.itertuples(index=False):
-    # Print progress bar N times and at the end of processing
-    if processed % step == 0 or processed == total_rows:
-        # print a progress bar
-        progress = processed / total_rows
-        segments = math.ceil(prog_bar_width * progress)
-        print(
-            f"[{'#' * segments}{' ' * (prog_bar_width - segments)}] {progress * 100:.1f}%",
-            end="\r",
-            flush=True,
-        )
     processed += 1
+    if processed % step == 0 or processed == total_rows:
+        bar.update(processed)
     duration = row.Duration * scaling_unit
     timestamp = row.Timestamp
     # if FLOP counters are all zero or NaN, skip calculations and set metrics to zero/defaults
@@ -916,15 +963,6 @@ for row in counter_data_df.itertuples(index=False):
 
 del counter_data_df
 
-# Finish progress bar
-if total_rows > 0:
-    print(
-        f"[{'#' * prog_bar_width}] {100:.1f}%",
-        end="\r",
-        flush=True,
-    )
-    print()
-
 _runtime = time.time() - _time_start
 print(f"Finished processing {total_rows} rows in {_runtime:.2f} seconds. ")
 
@@ -1464,26 +1502,31 @@ sidebar2 = dbc.Offcanvas(
             className="mb-2",
             style={"color": "white", "textAlign": "center", "fontSize": "20px"},
         ),
-        dbc.Button(
-            "Send Timestamps Roof Labels",
-            id="button-roof-labels",
-            className="mb-2",
-            style={"width": "100%"},
-            n_clicks=0,
+        _carm_btn(
+            "Send Roof Labels",
+            "button-roof-labels",
+            "Labels each timestamp based on which roof is above it (L2, DRAM, etc.)",
         ),
-        dbc.Button(
-            "Send Timestamps LD/ST Percentage Colors",
-            id="button-carm-ldst-colors",
-            className="mb-2",
-            style={"width": "100%"},
-            n_clicks=0,
+        _carm_btn(
+            "Send LD/ST Ratio",
+            "button-carm-ldst-colors",
+            "Labels each timestamp based on the load-store ratio",
         ),
-        dbc.Button(
-            "Send Timestamps SP/DP Percentage Colors",
-            id="button-carm-spdp-colors",
-            className="mb-2",
-            style={"width": "100%"},
-            n_clicks=0,
+        _carm_btn(
+            "Send SP/DP Ratio",
+            "button-carm-spdp-colors",
+            "Labels each timestamp based on the single-precision/double-precision ratio",
+        ),
+        _carm_btn("Send Performance", "button-carm-gflops", "Labels each timestamp based on the GFLOPS performance"),
+        _carm_btn(
+            "Send Arithmetic Intensity", "button-carm-ai", "Labels each timestamp based on the arithmetic intensity"
+        ),
+        _carm_btn(
+            "Send Roof Proximity",
+            "button-carm-roof-proximity",
+            "Labels each timestamp based on its proximity to each of the roofs. e.g. 0.2 relative to the L1 means a "
+            "perfectly optimization could achieve a 5x speedup. A value of 1.0 means the timestamp is at or above the "
+            "roof.",
         ),
     ],
     id="offcanvas2",
@@ -1603,57 +1646,29 @@ app.layout = dbc.Container(
                                                                 ),
                                                             ],
                                                             style={
-                                                                "display": "inline-block",
-                                                                "width": "770px",
-                                                                "margin": "0px 20px auto 15px",
+                                                                "width": "100%",
+                                                                "margin": "0 10px",
                                                             },
                                                         ),
                                                     ]
                                                 ),
                                                 style={
-                                                    "height": "100px",
+                                                    # "height": "100px",
                                                     "margin": "0px auto 10px auto",
                                                     "padding": "0px",
                                                     "text-align": "center",
+                                                    "flex": "1",
                                                 },
                                             ),
                                             dbc.Card(
                                                 dbc.CardBody(
                                                     [
-                                                        html.Div(
-                                                            [
-                                                                html.P(
-                                                                    f"Execution Timestamps To Plot ({time_unit})",
-                                                                    style={
-                                                                        "textAlign": "center",
-                                                                        "fontWeight": "bold",
-                                                                        "margin": "0 200px",
-                                                                        "margin-top": "-6px",
-                                                                    },
-                                                                ),
-                                                                html.P(
-                                                                    "Grouping",
-                                                                    style={
-                                                                        "textAlign": "center",
-                                                                        "fontWeight": "bold",
-                                                                        "margin": "0 40px",
-                                                                    },
-                                                                ),
-                                                                html.P(
-                                                                    "Average",
-                                                                    style={
-                                                                        "textAlign": "center",
-                                                                        "fontWeight": "bold",
-                                                                        "margin": "0 5px",
-                                                                        "display": "none",
-                                                                    },
-                                                                ),
-                                                            ],
+                                                        html.P(
+                                                            f"Execution Timestamps To Plot ({time_unit})",
                                                             style={
-                                                                "display": "flex",
-                                                                "justify-content": "center",
-                                                                "align-items": "center",
-                                                                "margin-bottom": "10px",
+                                                                "textAlign": "center",
+                                                                "fontWeight": "bold",
+                                                                "margin-top": "-6px",
                                                             },
                                                         ),
                                                         dcc.Store(id="data-points-store"),
@@ -1669,8 +1684,6 @@ app.layout = dbc.Container(
                                                                         "fontSize": "24px",
                                                                         "backgroundColor": "transparent",
                                                                         "cursor": "pointer",
-                                                                        "margin-top": "-22px",
-                                                                        "margin-left": "-30px",
                                                                         "margin-right": "10px",
                                                                     },
                                                                 ),
@@ -1691,11 +1704,19 @@ app.layout = dbc.Container(
                                                                         ),
                                                                     ],
                                                                     style={
-                                                                        "display": "inline-block",
-                                                                        "width": "710px",
+                                                                        "flex": "1",
+                                                                        "min-width": "0",
                                                                         "margin": "0px",
                                                                     },
                                                                 ),
+                                                                html.Span(
+                                                                    "Grouping",
+                                                                    style={
+                                                                        "fontWeight": "bold",
+                                                                        "marginLeft": "15px",
+                                                                        "whiteSpace": "nowrap",
+                                                                    },
+                                                                ),
                                                                 html.Div(
                                                                     [
                                                                         html.Button(
@@ -1723,15 +1744,13 @@ app.layout = dbc.Container(
                                                                     ],
                                                                     style={
                                                                         "display": "inline-block",
-                                                                        "margin-top": "-15px",
-                                                                        "margin-left": "15px",
+                                                                        "margin-left": "5px",
                                                                     },
                                                                 ),
                                                                 dbc.Checkbox(
                                                                     id="average-checkbox",
                                                                     label="",
                                                                     style={
-                                                                        "margin-top": "-15px",
                                                                         "margin-left": "40px",
                                                                         "display": "none",
                                                                     },
@@ -1746,11 +1765,11 @@ app.layout = dbc.Container(
                                                     ]
                                                 ),
                                                 style={
-                                                    "height": "100px",
-                                                    "width": "1070px",
+                                                    # "height": "100px",
                                                     "margin": "0px 10px 10px 10px",
                                                     "padding": "0px",
                                                     "text-align": "center",
+                                                    "flex": "1",
                                                 },
                                             ),
                                         ],
@@ -2377,6 +2396,180 @@ def generate_color_csv(n_clicks_ldst, n_clicks_spdp, graph):
     return
 
 
+@app.callback(
+    Input("button-carm-gflops", "n_clicks"),
+    Input("graph-lines", "data"),
+    prevent_initial_call=True,
+)
+def generate_gflops_csv(n_clicks, lines):
+    global full_base_statistics_df, prv_trace_path, time_unit
+    ctx = callback_context
+    if not ctx.triggered:
+        raise PreventUpdate
+
+    trigger_id = ctx.triggered[0]["prop_id"].split(".")[0]
+    if trigger_id != "button-carm-gflops":
+        raise PreventUpdate
+
+    if lines is None:
+        print("Graph lines data is None, cannot generate GFLOPS CSV.", flush=True)
+        return
+
+    df: pd.DataFrame = full_base_statistics_df.copy()
+    timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+    min_gflops = df["GFLOPS"].min()
+    max_gflops = df["GFLOPS"].max()
+    metadata_line = (
+        f"#{timestamp}:CSV:RUNAPP:{prv_trace_path}:{time_unit}:window_in_null_gradient_mode:{min_gflops}:{max_gflops}"
+    )
+
+    csv_df = df[["ThreadID", "Timestamp", "Duration", "GFLOPS"]].copy()
+    csv_df["GFLOPS"] = csv_df["GFLOPS"].apply(lambda x: f"{x:.10f}")
+    csv_df = csv_df.sort_values(
+        ["ThreadID", "Timestamp"],
+        key=lambda col: ut.natural_sort_series(col) if col.name == "ThreadID" else col,
+    )
+
+    output_dir = os.path.dirname(prv_trace_path)
+    csv_filepath = os.path.join(output_dir, "carm_gflops.csv")
+    with open(csv_filepath, "w") as f:
+        f.write(metadata_line + "\n")
+        csv_df.to_csv(f, index=False, header=False, sep="\t")
+
+    print("carm_gflops.csv file written.", flush=True)
+
+    return
+
+
+@app.callback(
+    Input("button-carm-ai", "n_clicks"),
+    Input("graph-lines", "data"),
+    prevent_initial_call=True,
+)
+def generate_ai_csv(n_clicks, lines):
+    global full_base_statistics_df, prv_trace_path, time_unit
+    ctx = callback_context
+    if not ctx.triggered:
+        raise PreventUpdate
+
+    trigger_id = ctx.triggered[0]["prop_id"].split(".")[0]
+    if trigger_id != "button-carm-ai":
+        raise PreventUpdate
+
+    if lines is None:
+        print("Graph lines data is None, cannot generate AI CSV.", flush=True)
+        return
+
+    df: pd.DataFrame = full_base_statistics_df.copy()
+    timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+    min_ai = df["Arithmetic_Intensity"].min()
+    max_ai = df["Arithmetic_Intensity"].max()
+    metadata_line = (
+        f"#{timestamp}:CSV:RUNAPP:{prv_trace_path}:{time_unit}:window_in_null_gradient_mode:{min_ai}:{max_ai}"
+    )
+
+    csv_df = df[["ThreadID", "Timestamp", "Duration", "Arithmetic_Intensity"]].copy()
+    csv_df["Arithmetic_Intensity"] = csv_df["Arithmetic_Intensity"].apply(lambda x: f"{x:.10f}")
+    csv_df = csv_df.sort_values(
+        ["ThreadID", "Timestamp"],
+        key=lambda col: ut.natural_sort_series(col) if col.name == "ThreadID" else col,
+    )
+
+    output_dir = os.path.dirname(prv_trace_path)
+    csv_filepath = os.path.join(output_dir, "carm_ai.csv")
+    with open(csv_filepath, "w") as f:
+        f.write(metadata_line + "\n")
+        csv_df.to_csv(f, index=False, header=False, sep="\t")
+
+    print("carm_ai.csv file written.", flush=True)
+
+    return
+
+
+@app.callback(
+    Input("button-carm-roof-proximity", "n_clicks"),
+    Input("graph-lines", "data"),
+    prevent_initial_call=True,
+)
+def generate_roof_proximity_csv(n_clicks, lines):
+    global full_base_statistics_df, prv_trace_path, time_unit
+    ctx = callback_context
+    if not ctx.triggered:
+        raise PreventUpdate
+
+    trigger_id = ctx.triggered[0]["prop_id"].split(".")[0]
+    if trigger_id != "button-carm-roof-proximity":
+        raise PreventUpdate
+
+    if lines is None:
+        print("Graph lines data is None, cannot generate roof proximity CSV.", flush=True)
+        return
+
+    df: pd.DataFrame = full_base_statistics_df.copy()
+    timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+    output_dir = os.path.dirname(prv_trace_path)
+
+    ai = df["Arithmetic_Intensity"].values
+    perf = df["GFLOPS"].values
+
+    level_names = {"L1": "l1", "L2": "l2", "L3": "l3", "DRAM": "dram"}
+
+    for level, suffix in level_names.items():
+        if level not in lines:
+            continue
+
+        roof = lines[level]
+        start_x, start_y = roof["start"]
+        ridge_x, ridge_y = roof["ridge"]
+        end_x, end_y = roof["end"]
+
+        roof_vals = np.zeros_like(ai)
+
+        left = ai <= ridge_x
+        if np.any(left):
+            if ridge_x == start_x:
+                roof_vals[left] = start_y
+            else:
+                slope = (ridge_y - start_y) / (ridge_x - start_x)
+                roof_vals[left] = start_y + slope * (ai[left] - start_x)
+
+        right = ai > ridge_x
+        if np.any(right):
+            if end_x == ridge_x:
+                roof_vals[right] = ridge_y
+            else:
+                slope = (end_y - ridge_y) / (end_x - ridge_x)
+                roof_vals[right] = ridge_y + slope * (ai[right] - ridge_x)
+
+        valid = (ai > 0) & (perf > 0) & (roof_vals > 0)
+        ratios = np.where(valid, np.minimum(perf / roof_vals, 1.0), 0.0)
+
+        metadata_line = f"#{timestamp}:CSV:RUNAPP:{prv_trace_path}:{time_unit}:window_in_null_gradient_mode:0.0:1.0"
+
+        rel_df = pd.DataFrame(
+            {
+                "ThreadID": df["ThreadID"],
+                "Timestamp": df["Timestamp"],
+                "Duration": df["Duration"],
+                "Ratio": ratios,
+            }
+        )
+        rel_df["Ratio"] = rel_df["Ratio"].apply(lambda x: f"{x:.10f}")
+        rel_df = rel_df.sort_values(
+            ["ThreadID", "Timestamp"],
+            key=lambda col: ut.natural_sort_series(col) if col.name == "ThreadID" else col,
+        )
+
+        csv_filepath = os.path.join(output_dir, f"carm_rel_{suffix}.csv")
+        with open(csv_filepath, "w") as f:
+            f.write(metadata_line + "\n")
+            rel_df.to_csv(f, index=False, header=False, sep="\t")
+
+        print(f"carm_rel_{suffix}.csv file written.", flush=True)
+
+    return
+
+
 @app.callback(
     Output("slider-components", "style"),
     Output("paraver-sync-check", "disabled"),
@@ -4072,13 +4265,13 @@ app.clientside_callback(
 
 
 def run_server() -> None:
-    log = logging.getLogger("werkzeug")
-    log.setLevel(logging.ERROR)
+    logging.getLogger("werkzeug").setLevel(logging.ERROR)
+    logging.getLogger("dash.dash").setLevel(logging.ERROR)
 
     # Force the host to a loopback address instead of letting Dash/Flask resolve the local hostname, which seems to
     # cause issues in some distributions.
     host = "127.0.0.1"
-    print(f"Starting Dash app on {host}:{SELECTED_PORT}")
+    print(f"Starting Dash app on http://{host}:{SELECTED_PORT}/")
 
     from werkzeug.middleware.profiler import ProfilerMiddleware
 

{carm_paraver-1.0.0.dev1 → carm_paraver-1.0.1.dev0}/carm_paraver/assets/style.css

@@ -3,30 +3,25 @@ body {
 }
 
 
-/* Style for making the slider track thicker and darker */
-.rc-slider-track {
-    height: 11px; /* Thicker track */
-    width: 100px;
-    background-color: #000000; /* Darker track color */
+/* Style for making the slider filled range (track) thicker and darker */
+.dash-slider-range {
+    height: 11px; /* Thicker range */
+    background-color: #000000; /* Darker range color */
 }
 
-
 /* Style for making the slider thumb (handle) thicker and darker */
-.rc-slider-handle {
-    top: 7px;
+.dash-slider-thumb {
     width: 15px; /* Bigger handle width */
     height: 15px; /* Bigger handle height */
     background-color: #333; /* Darker handle color */
     border-color: #333; /* Darker border color for the handle */
 }
-
-.rc-slider-rail {
-    height: 10px; /* Bigger handle height */
-    background-color: #b8b6b6; /* Darker handle color */
-    border-color: #b8b6b6; /* Darker border color for the handle */
+/* Style for making the slider track (rail) thicker and darker */
+.dash-slider-track {
+    height: 10px; /* Thicker track */
+    background-color: #b8b6b6; /* Darker track color */
 }
-
-.rc-slider-dot {
+.dash-slider-dot {
     position: absolute;
     bottom: -2px;
     margin-left: -2px;
@@ -37,9 +32,9 @@ body {
     cursor: pointer;
     border-radius: 50%;
     vertical-align: middle;
-  }
-
+}
 
-.cQJXpB .chrome-picker {
+/* Color picker — remove border-radius rounding */
+.chrome-picker {
     border-radius: 0% !important;
 }

{carm_paraver-1.0.0.dev1 → carm_paraver-1.0.1.dev0}/carm_paraver.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-paraver
-Version: 1.0.0.dev1
+Version: 1.0.1.dev0
 Summary: Dash-based CARM analysis for Paraver traces
 Author: CARM Contributors
 Requires-Python: >=3.9
@@ -19,6 +19,8 @@ Dynamic: license-file
 
 This GUI allows the analysis of [Paraver](https://tools.bsc.es/paraver) traces on the Cache-Aware Roofline Model (CARM) for floating-point operations. It can be launched from the Paraver interface and send labeled events back to Paraver for visualization.
 
+The CARM allows for roofline analysis of your application, displaying its computational bursts as points on the roofline. This can be used to identify bottlenecks and optimization opportunities for the respective code section. Points on the memory-bound or the compute-bound sections of the roof benefit from different optimization strategies, and the distance of your points to the roofline can be used to identify how much performance can be gained by optimizing your code.
+
 # Requirements
 - Python (tested with 3.9.25, 3.10.12, 3.12.3)
 - [Paraver, Extrae](https://tools.bsc.es/downloads)

{carm_paraver-1.0.0.dev1 → carm_paraver-1.0.1.dev0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "carm-paraver"
-version = "1.0.0.dev1"
+version = "1.0.1.dev0"
 description = "Dash-based CARM analysis for Paraver traces"
 readme = "README.md"
 requires-python = ">=3.9"