carm-roofline 1.0.2.dev0__tar.gz → 1.0.2.dev1__tar.gz

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-roofline
-Version: 1.0.2.dev0
+Version: 1.0.2.dev1
 Summary: CARM: Cache-Aware Roofline Model benchmarking and visualization toolkit
 Author: CHaMP Team
 License:                                  Apache License

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/architecture/identity.py

@@ -112,7 +112,7 @@ def _levels_from_topology(topology: MemoryTopologyLike | None) -> tuple[MemoryLe
             levels.append(
                 MemoryLevelSignature(
                     name=lvl.name,
-                    size_bytes=int(lvl.size.value),
+                    size_bytes=int(lvl.size),
                     instances=lvl.instances,
                     num_sharing_threads=lvl.num_sharing_threads,
                 )

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/benchmark/output/arithmetic.py

@@ -33,7 +33,7 @@ def _collect_gops_by_isa(isa_suites: dict[str, ISABenchmarkSuite]) -> dict[str,
             if not isinstance(bench.results, ArithmeticBenchmarkResult):
                 continue
 
-            gops_value = float(bench.results.performance.value) / 1e9
+            gops_value = float(bench.results.performance) / 1e9
             if not math.isfinite(gops_value):
                 warn(f"Skipping invalid GOPS value for ISA {isa}: {gops_value}")
                 continue
@@ -73,7 +73,7 @@ def _print_table(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite])
             )
 
             ops_per_inst = isa_instance.ops_per_inst(benchmark.params.data_type, benchmark.params.operation)
-            total_insts = (benchmark.params.num_ops.value // ops_per_inst) * res.num_repetitions if ops_per_inst else 0
+            total_insts = (int(benchmark.params.num_ops) // ops_per_inst) * res.num_repetitions if ops_per_inst else 0
             cycles = Cycles.from_time_and_frequency(res.time_taken, frequency)
             ipc = 0.0 if cycles.value == 0 else total_insts / cycles.value
             ops_per_cycle = ops_per_inst * ipc
@@ -84,17 +84,17 @@ def _print_table(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite])
                     "operation": benchmark.params.operation.name,
                     "benchmark": benchmark_name,
                     "threads": benchmark.params.num_threads,
-                    "gops": float(res.performance.value) / 1e9,
+                    "gops": float(res.performance) / 1e9,
                     "gops_display": str(res.performance),
                     "ipc": ipc,
-                    "frequency_hz": float(frequency.value),
+                    "frequency_hz": float(frequency),
                     "frequency_display": str(frequency),
                     "ops_per_instruction": ops_per_inst,
                     "ops_per_cycle": ops_per_cycle,
-                    "time_seconds": float(res.time_taken.value),
+                    "time_seconds": float(res.time_taken),
                     "time_display": str(res.time_taken),
                     "repetitions": int(res.num_repetitions),
-                    "cycles": float(cycles.value),
+                    "cycles": float(cycles),
                     "cycles_display": str(cycles),
                 }
             )

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/benchmark/output/jsonl.py

@@ -40,7 +40,7 @@ def _serialize_arithmetic(
     assert isinstance(res, ArithmeticBenchmarkResult)
 
     ops_per_inst = isa_instance.ops_per_inst(bench.params.data_type, bench.params.operation)
-    total_insts = (bench.params.num_ops.value // ops_per_inst) * res.num_repetitions if ops_per_inst else 0
+    total_insts = (int(bench.params.num_ops) // ops_per_inst) * res.num_repetitions if ops_per_inst else 0
     cycles = Cycles.from_time_and_frequency(res.time_taken, frequency)
     ipc = 0.0 if cycles.value == 0 else total_insts / cycles.value
 
@@ -54,15 +54,15 @@ def _serialize_arithmetic(
         "timestamp": timestamp,
         "machine": machine,
         "operation": bench.params.operation.name,
-        "num_ops": int(bench.params.num_ops.value),
-        "performance_gops": res.performance.value / 1e9,
+        "num_ops": int(bench.params.num_ops),
+        "performance_gops": float(res.performance) / 1e9,
         "ipc": ipc,
-        "frequency_hz": frequency.value,
+        "frequency_hz": float(frequency),
         "ops_per_instruction": ops_per_inst,
         "ops_per_cycle": ops_per_inst * ipc,
-        "time_seconds": res.time_taken.value,
+        "time_seconds": float(res.time_taken),
         "repetitions": res.num_repetitions,
-        "cycles": cycles.value,
+        "cycles": int(cycles),
     }
 
 
@@ -81,7 +81,7 @@ def _serialize_memory(
     assert isinstance(res, MemoryBenchmarkResult)
 
     bpi = isa_instance.bytes_per_inst(bench.params.data_type)
-    total_insts = (bench.working_set_bytes.value // bpi) * res.num_repetitions
+    total_insts = (int(bench.working_set_bytes) // bpi) * res.num_repetitions
     cycles = Cycles.from_time_and_frequency(res.time_taken, frequency)
     ipc = 0.0 if cycles.value == 0 else total_insts / cycles.value
 
@@ -99,14 +99,14 @@ def _serialize_memory(
         "num_stores": bench.params.num_st,
         "cache_level": bench.cache_level,
         "memory_level_name": bench.params.memory_level_name,
-        "size_per_thread_bytes": bench.params.size_per_thread.value,
-        "working_set_bytes": bench.working_set_bytes.value,
+        "size_per_thread_bytes": int(bench.params.size_per_thread),
+        "working_set_bytes": int(bench.working_set_bytes),
         "layout_mode": bench.params.layout_mode.value,
-        "bandwidth_gbps": res.bandwidth.value / 1e9,
+        "bandwidth_gbps": float(res.bandwidth) / 1e9,
         "ipc": ipc,
-        "time_seconds": res.time_taken.value,
+        "time_seconds": float(res.time_taken),
         "repetitions": res.num_repetitions,
-        "cycles": cycles.value,
+        "cycles": int(cycles),
     }
 
 

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/benchmark/output/memory.py

@@ -40,7 +40,7 @@ def _collect_bandwidth_by_label(isa_suites: dict[str, ISABenchmarkSuite]) -> dic
                 continue
 
             level = res.cache_level or "unknown"
-            bandwidth_value = float(res.bandwidth.value) / 1e9
+            bandwidth_value = float(res.bandwidth) / 1e9
             if not math.isfinite(bandwidth_value):
                 warn(f"Skipping invalid bandwidth value for {isa}/{name}: {bandwidth_value}")
                 continue
@@ -84,7 +84,7 @@ def _print_table(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite])
             assert bench.results is not None  # for type checker
             level = bench.results.cache_level or "unknown"
             bytes_per_inst = isa_instance.bytes_per_inst(bench.params.data_type)
-            total_insts = (bench.working_set_bytes.value // bytes_per_inst) * bench.results.num_repetitions
+            total_insts = (int(bench.working_set_bytes) // bytes_per_inst) * bench.results.num_repetitions
             cycles = Cycles.from_time_and_frequency(bench.results.time_taken, frequency)
 
             ipc = total_insts / cycles.value

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/benchmark/output/memory_sweep.py

@@ -79,7 +79,7 @@ def _print_table(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite])
         for _name, bench in sorted(mem_benchmarks.items(), key=lambda kv: kv[0]):
             assert bench.results is not None  # for type checker
             bytes_per_inst = isa_instance.bytes_per_inst(bench.params.data_type)
-            total_insts = (bench.working_set_bytes.value // bytes_per_inst) * bench.results.num_repetitions
+            total_insts = (int(bench.working_set_bytes) // bytes_per_inst) * bench.results.num_repetitions
             cycles = Cycles.from_time_and_frequency(bench.results.time_taken, frequency)
             cache_level = bench.results.cache_level or "unknown"
             table.add_row(
@@ -114,22 +114,22 @@ def _collect_sweep_series(
             for ws_bytes, cache_level, bandwidth in suite.get_sweep_data():
                 if bandwidth is None:
                     continue
-                bw_val = float(bandwidth.value) / 1e9
+                bw_val = float(bandwidth) / 1e9
                 if not math.isfinite(bw_val):
                     continue
-                points.append((ws_bytes.value, cache_level, bw_val))
+                points.append((int(ws_bytes), cache_level, bw_val))
         else:
             mem_benchmarks = suite.get_memory_benchmarks()
             for _name, bench in sorted(mem_benchmarks.items(), key=lambda kv: kv[0]):
                 res = bench.results
                 if not isinstance(res, MemoryBenchmarkResult):
                     continue
-                bw_val = float(res.bandwidth.value) / 1e9
+                bw_val = float(res.bandwidth) / 1e9
                 if not math.isfinite(bw_val):
                     continue
                 ws = bench.working_set_bytes
                 cache_level = res.cache_level or "unknown"
-                points.append((ws.value, cache_level, bw_val))
+                points.append((int(ws), cache_level, bw_val))
 
         if points:
             points.sort(key=lambda t: t[0])

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/benchmark/output/roofline.py

@@ -114,7 +114,7 @@ def _cache_sizes_kib(context: CARMContext) -> tuple[int, int, int]:
             size = getattr(level, "size", None)
             if size is None:
                 continue
-            kib = int(size.value // 1024)
+            kib = int(size) // 1024
             if name == "L1":
                 l1_kib = kib
             elif name == "L2":
@@ -131,7 +131,7 @@ def _cache_sizes_kib(context: CARMContext) -> tuple[int, int, int]:
 def _find_dram_working_set_bytes(suite: ISABenchmarkSuite) -> int:
     for bench in suite.get_memory_benchmarks().values():
         if bench.cache_level == "DRAM" and getattr(bench, "working_set_bytes", None) is not None:
-            return int(bench.working_set_bytes.value)
+            return int(bench.working_set_bytes)
     return 0
 
 
@@ -175,8 +175,8 @@ def _aggregate_level_metrics(
         level = bench.cache_level
         assert level is not None
         bytes_per_inst = isa_instance.bytes_per_inst(bench.params.data_type)
-        bandwidth_by_level[level] = float(bench.results.bandwidth.value) / 1e9
-        total_insts = (bench.working_set_bytes.value // bytes_per_inst) * bench.results.num_repetitions
+        bandwidth_by_level[level] = float(bench.results.bandwidth) / 1e9
+        total_insts = (int(bench.working_set_bytes) // bytes_per_inst) * bench.results.num_repetitions
         cycles = Cycles.from_time_and_frequency(bench.results.time_taken, frequency)
         ipc_by_level[level] = 0.0 if cycles.value == 0 else total_insts / cycles.value
 
@@ -208,12 +208,10 @@ def _pick_fp_for_combo(
         if bench.params.data_type != dt or bench.params.num_threads != nt:
             continue
         ops_per_inst = isa_instance.ops_per_inst(bench.params.data_type, bench.params.operation)
-        total_insts = (
-            (bench.params.num_ops.value // ops_per_inst) * bench.results.num_repetitions if ops_per_inst else 0
-        )
+        total_insts = (int(bench.params.num_ops) // ops_per_inst) * bench.results.num_repetitions if ops_per_inst else 0
         cycles = Cycles.from_time_and_frequency(bench.results.time_taken, frequency)
         ipc = 0.0 if cycles.value == 0 else total_insts / cycles.value
-        gflops = float(bench.results.performance.value) / 1e9
+        gflops = float(bench.results.performance) / 1e9
 
         if bench.params.operation == ArithmeticOperation.fma:
             fma_gflops = gflops

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/benchmark/suites/memory_sweep.py

@@ -94,14 +94,14 @@ class MemorySweepBenchmarkSuite(ISABenchmarkSuite):
             # Step 2 - Determine sweep range.
             # ------------------------------------------------------------------
             _, _, l1_avail, _ = level_table[0]
-            min_size_bytes: float = 0.1 * float(l1_avail.value)
+            min_size_bytes: float = 0.1 * float(l1_avail)
 
             if len(level_table) >= 2:
                 _, _, last_cache_avail, _ = level_table[-2]
             else:
                 _, _, last_cache_avail, _ = level_table[-1]
 
-            max_size_bytes: float = 32.0 * float(last_cache_avail.value)
+            max_size_bytes: float = 32.0 * float(last_cache_avail)
 
             if max_size_bytes <= min_size_bytes:
                 raise ValueError(
@@ -200,5 +200,5 @@ class MemorySweepBenchmarkSuite(ISABenchmarkSuite):
             level = bench.cache_level if bench.cache_level is not None else "UNKNOWN"
             rows.append((bench.working_set_bytes, level, bw))
 
-        rows.sort(key=lambda t: t[0].value)
+        rows.sort(key=lambda t: t[0])
         return rows

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/carm.py

@@ -126,7 +126,7 @@ SUBPARSERS = (
     ),
     SubParserInfo(
         name="profile",
-        help_short="Profile applications with PAPI",
+        help_short="Profile applications for CARM analysis",
         help_long="Profile instrumented applications to compute roofline metrics (AI, GFLOP/s, bandwidth). "
         "Supports MPI, threaded, and hybrid applications. "
         "Usage: carm profile [options] -- <command>",

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/carm_roofline.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-roofline
-Version: 1.0.2.dev0
+Version: 1.0.2.dev1
 Summary: CARM: Cache-Aware Roofline Model benchmarking and visualization toolkit
 Author: CHaMP Team
 License:                                  Apache License

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/gui/assets/style.css

@@ -214,10 +214,24 @@
     color: #555;
 }
 
-.apps-toggle {
-    transform: scale(0.8);
+
+
+.settings-toggle-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 12px;
+}
+
+.settings-toggle-label {
+    font-size: 13px;
+    font-weight: 600;
+    color: #555;
 }
 
+.normalize-toggle {
+    transform: scale(0.8);
+}
 
 /* ── Action buttons ────────────────────────────────────────────────────────── */
 .btn-add-roof {
@@ -238,46 +252,6 @@
     background: #0069d9;
 }
 
-/* ── Data selection panel ──────────────────────────────────────────────────── */
-.selection-actions {
-    display: flex;
-    gap: 6px;
-    padding: 0 12px 8px;
-}
-
-.btn-select-all,
-.btn-deselect-all {
-    flex: 1;
-    padding: 4px 8px;
-    background: #f0f0f0;
-    border: 1px solid #ccc;
-    border-radius: 3px;
-    font-size: 11px;
-    cursor: pointer;
-}
-
-.btn-select-all:hover,
-.btn-deselect-all:hover {
-    background: #e0e0e0;
-}
-
-.selection-roof-row {
-    padding: 4px 12px;
-}
-
-.selection-roof-header {
-    display: flex;
-    align-items: center;
-    gap: 6px;
-    padding: 4px 0;
-}
-
-.selection-roof-label {
-    font-size: 13px;
-    font-weight: 600;
-    color: #333;
-}
-
 
 /* ── Plot area ─────────────────────────────────────────────────────────────── */
 .plot-area {

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/gui/components.py

@@ -18,7 +18,6 @@ from gui.ids import (
     NavbarID,
     PlotAreaID,
     RoofCardID,
-    SelectionRowID,
     SettingsPanelID,
     SidebarID,
     StoreID,
@@ -260,11 +259,6 @@ def build_roof_card(
                                     className="apps-section-header",
                                     children=[
                                         html.Span("Applications", className="apps-section-title"),
-                                        dbc.Switch(
-                                            id=_make_id(RoofCardID.SWITCH_APPS, index=index),
-                                            value=roof.apps_enabled,
-                                            className="apps-toggle",
-                                        ),
                                     ],
                                 ),
                                 _multi_dropdown(
@@ -286,47 +280,21 @@ def build_roof_card(
 
 
 def build_settings_panel(store: RoofStore, options: FilterOptions | None = None) -> html.Div:
-    """Settings panel with roof/app visibility toggles."""
+    """Settings panel with the normalize-by-threads toggle."""
     return html.Div(
         className="settings-panel",
         style={"display": "block"} if store.active_panel == ActivePanel.SETTINGS else {"display": "none"},
         children=[
             html.H5("Settings", className="panel-header"),
             html.Div(
-                className="selection-actions",
+                className="settings-toggle-row",
                 children=[
-                    html.Button(
-                        "Select All",
-                        id=SettingsPanelID.BTN_SELECT_ALL,
-                        className="btn-select-all",
-                        n_clicks=0,
-                    ),
-                    html.Button(
-                        "Deselect All",
-                        id=SettingsPanelID.BTN_DESELECT_ALL,
-                        className="btn-deselect-all",
-                        n_clicks=0,
-                    ),
-                ],
-            ),
-            *[_selection_roof_row(r, i) for i, r in enumerate(store.roofs)],
-        ],
-    )
-
-
-def _selection_roof_row(roof: RoofConfig, roof_idx: int) -> html.Div:
-    """Roof row (checkbox + label) with app toggle."""
-    return html.Div(
-        className="selection-roof-row",
-        children=[
-            html.Div(
-                className="selection-roof-header",
-                children=[
-                    dbc.Checkbox(
-                        id=_make_id(SelectionRowID.CHECKBOX_ROOF_VIS, index=roof_idx),
-                        value=roof.apps_enabled,
+                    html.Span("Normalize performance by threads", className="settings-toggle-label"),
+                    dbc.Switch(
+                        id=SettingsPanelID.SWITCH_NORMALIZE,
+                        value=store.normalize_by_threads,
+                        className="normalize-toggle",
                     ),
-                    html.Span(roof.label, className="selection-roof-label"),
                 ],
             ),
         ],

{carm_roofline-1.0.2.dev0 → carm_roofline-1.0.2.dev1}/gui/data.py

@@ -52,7 +52,6 @@ class RoofConfig:
     load_store_ratio: str | None = "2:1"
     collapsed: bool = False
     app_ids: list[str] = field(default_factory=list)
-    apps_enabled: bool = True
 
     def __init__(
         self,
@@ -65,7 +64,6 @@ class RoofConfig:
         compute_insts: list[str] | None = None,
         load_store_ratio: str | None = "2:1",
         app_ids: list[str] | None = None,
-        apps_enabled: bool = True,
         collapsed: bool = False,
     ) -> None:
         self.id = roof_id or uuid.uuid4().hex
@@ -78,7 +76,6 @@ class RoofConfig:
         self.compute_insts = compute_insts or ["fma", "add"]
         self.load_store_ratio = load_store_ratio
         self.app_ids = app_ids or []
-        self.apps_enabled = apps_enabled
 
 
 def make_default_roof(opts: FilterOptions | None = None) -> RoofConfig:
@@ -106,6 +103,7 @@ class RoofStore:
     def __init__(self, roof_template: RoofConfig | None = None) -> None:
         self.roofs: list[RoofConfig] = [roof_template or RoofConfig()]
         self.active_panel: ActivePanel = ActivePanel.CARM_VIEW
+        self.normalize_by_threads: bool = False
 
     # Roof CRUD
     def add_roof(self, roof_template: RoofConfig | None = None) -> RoofConfig:
@@ -146,11 +144,11 @@ class RoofStore:
                     "load_store_ratio": r.load_store_ratio,
                     "collapsed": r.collapsed,
                     "app_ids": r.app_ids,
-                    "apps_enabled": r.apps_enabled,
                 }
                 for r in self.roofs
             ],
             "active_panel": self.active_panel,
+            "normalize_by_threads": self.normalize_by_threads,
         }
 
     @classmethod
@@ -168,11 +166,11 @@ class RoofStore:
                 load_store_ratio=r.get("load_store_ratio", "2:1"),
                 collapsed=r.get("collapsed", False),
                 app_ids=r.get("app_ids", []),
-                apps_enabled=r.get("apps_enabled", True),
             )
             for r in data.get("roofs", [])
         ]
         store.active_panel = ActivePanel(data.get("active_panel", "carm_view"))
+        store.normalize_by_threads = data.get("normalize_by_threads", False)
         return store
 
 
@@ -203,6 +201,7 @@ def build_roofline_figure(
     roofs: list[RoofConfig],
     records: list[BenchmarkRecord],
     applications_by_id: dict[str, ApplicationRecord] | None = None,
+    normalize_by_threads: bool = False,
 ) -> go.Figure:
     """Build a Plotly roofline figure from real benchmark records.
 
@@ -221,6 +220,7 @@ def build_roofline_figure(
     peak_perf_values: list[float] = []
 
     for roof in roofs:
+        roof_divisor = roof.threads if (normalize_by_threads and roof.threads and roof.threads > 0) else 1
         flt = RooflineFilter(
             machine=roof.machine if roof.machine else None,
             isa=roof.isa if roof.isa else None,
@@ -237,12 +237,12 @@ def build_roofline_figure(
             f"{len(model.source_timestamps)} run(s)"
         )
         if model.peak_performance_by_op:
-            peak_perf_values.append(max(p.value for p in model.peak_performance_by_op.values()))
+            peak_perf_values.append(max(p.value for p in model.peak_performance_by_op.values()) / roof_divisor)
         rp = model.ridge_points()
         for level, ai_obj in rp.items():
             bw = model.bandwidth_by_level.get(level)
             if bw is not None:
-                ridge_pairs.append((ai_obj.value, bw.value))
+                ridge_pairs.append((ai_obj.value, bw.value / roof_divisor))
 
     # Axis ranges, log10 coordinates (Plotly "log" axis convention).
     if ridge_pairs:
@@ -262,9 +262,10 @@ def build_roofline_figure(
 
     for idx, (roof, model) in enumerate(zip(roofs, models)):
         color = _COLORS[idx % len(_COLORS)]
+        roof_divisor = roof.threads if (normalize_by_threads and roof.threads and roof.threads > 0) else 1
 
         # ── Application points (drawn even when no ceiling data) ─────────
-        if applications_by_id and roof.apps_enabled:
+        if applications_by_id:
             for app_id in roof.app_ids:
                 rec = applications_by_id.get(app_id)
                 if rec is None or not rec.points:
@@ -272,15 +273,24 @@ def build_roofline_figure(
                 fig.add_trace(
                     go.Scatter(
                         x=[p.arithmetic_intensity for p in rec.points],
-                        y=[p.flops_per_second / 1e9 for p in rec.points],
+                        y=[
+                            p.flops_per_second
+                            / (p.num_threads if normalize_by_threads and p.num_threads and p.num_threads > 0 else 1)
+                            / 1e9
+                            for p in rec.points
+                        ],
                         mode="markers",
                         name=rec.label,
                         legendgroup=roof.id,
                         showlegend=True,
                         marker={"color": color, "symbol": "circle", "size": 7},
                         text=[p.label for p in rec.points],
+                        customdata=[[p.num_threads] for p in rec.points],
                         hovertemplate=(
-                            f"{rec.label}<br>%{{text}}<br>AI=%{{x:.3f}} OPS/Byte<br>Perf=%{{y:.1f}} GOPS/s"
+                            f"{rec.label}<br>%{{text}}<br>"
+                            f"AI=%{{x:.3f}} OPS/Byte<br>"
+                            f"Perf=%{{y:.1f}} GOPS/s<br>"
+                            f"Threads=%{{customdata[0]}}"
                             "<extra></extra>"
                         ),
                     )
@@ -306,24 +316,25 @@ def build_roofline_figure(
             )
             continue
 
-        peak_perf = max(p.value for p in model.peak_performance_by_op.values()) if has_perf else 0.0
+        peak_perf_raw = max(p.value for p in model.peak_performance_by_op.values()) if has_perf else 0.0
+        peak_perf = peak_perf_raw / roof_divisor
 
         _first = True
 
-        # ── Memory bandwidth ceilings (single segment: left edge → ridge point) ──
         for level in ("L1", "L2", "L3", "DRAM"):
             bw = model.bandwidth_by_level.get(level)
             if bw is None:
                 continue
+            bw_norm = bw / roof_divisor
             ai_left = 1e-6
-            y_left = bw.value * ai_left / 1e9
+            y_left = bw_norm.value * ai_left / 1e9
             if peak_perf > 0:
-                ridge_ai = peak_perf / bw.value
+                ridge_ai = peak_perf_raw / bw.value
                 ai_right = ridge_ai
                 y_right = peak_perf / 1e9
             else:
                 ai_right = 1e6
-                y_right = bw.value * ai_right / 1e9
+                y_right = bw_norm.value * ai_right / 1e9
 
             style = _BW_LINE_STYLES.get(level, {"dash": "solid", "width": 1})
             fig.add_trace(
@@ -331,7 +342,7 @@ def build_roofline_figure(
                     x=[ai_left, ai_right],
                     y=[y_left, y_right],
                     mode="lines",
-                    name=roof.label if _first else f"{roof.label} {level} ({bw!s})",
+                    name=roof.label if _first else f"{roof.label} {level} ({bw_norm!s})",
                     legendgroup=roof.id,
                     line={"color": color, **style},
                     hoverinfo="skip",
@@ -342,20 +353,21 @@ def build_roofline_figure(
 
         # ── Compute-performance ceilings (single segment: left-most ridge → right edge) ──
         for op_name, perf in model.peak_performance_by_op.items():
-            gops = perf.value / 1e9
+            perf_norm = perf / roof_divisor
+            gops = perf_norm.value / 1e9
             if model.bandwidth_by_level:
                 op_ridge_ai = min(perf.value / bw.value for bw in model.bandwidth_by_level.values())
                 compute_x_start = op_ridge_ai
             else:
                 compute_x_start = 1e-6
-            is_top = perf.value == peak_perf
+            is_top = perf.value == peak_perf_raw
             line_style = {"dash": "solid", "width": 1.5} if is_top else {"dash": "dot", "width": 2}
             fig.add_trace(
                 go.Scatter(
                     x=[compute_x_start, 1e6],
                     y=[gops, gops],
                     mode="lines",
-                    name=f"{roof.label} {op_name} ({perf!s})",
+                    name=f"{roof.label} {op_name} ({perf_norm!s})",
                     legendgroup=roof.id,
                     line={"color": color, **line_style},
                     hoverinfo="skip",
@@ -367,7 +379,7 @@ def build_roofline_figure(
         # ── Invisible ridge-point hover markers (one per op x cache level) ──
         if model.bandwidth_by_level and model.peak_performance_by_op:
             for op_name, perf in model.peak_performance_by_op.items():
-                gops = perf.value / 1e9
+                gops = (perf / roof_divisor).value / 1e9
                 for level, bw in model.bandwidth_by_level.items():
                     ridge_ai = perf.value / bw.value
                     fig.add_trace(
@@ -381,7 +393,7 @@ def build_roofline_figure(
                                 f"{roof.label} {op_name} x {level}<br>"
                                 f"AI = {ridge_ai:.2f} OPS/Byte<br>"
                                 f"Performance = {gops:.1f} GOPS/s<br>"
-                                f"BW = {bw!s}"
+                                f"BW = {bw / roof_divisor!s}"
                             ),
                             showlegend=False,
                         )