carm-roofline 1.0.2.dev2__tar.gz → 1.0.3.dev1__tar.gz

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

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

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/architecture/architecture.py

@@ -5,13 +5,12 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from arguments import InsertsArguments, positive_int
-from benchmark import generation as bench_gen
-from error import UserError
+from core import Frequency, UserError
+from isa import INCOMPATIBLE_ISAS, ISA_NAME_TO_CLASS
 from output_utils import configure_verbosity, debug, detail, format_if_container, warn
-from units import Frequency
 
 if TYPE_CHECKING:
-    from benchmark.generation import BaseISA
+    from isa import BaseISA
 
 from .config import load_memory_topology_from_toml
 from .detect import DetectedArchitecture, detect_for_isa, native_detect
@@ -32,7 +31,7 @@ def check_isa_compatibility(selected_isas: list[type[BaseISA]]) -> None:
 
     # Check for special incompatibilities within the same family
     isa_set = set(selected_isas)
-    for incompatible_pair in bench_gen.INCOMPATIBLE_ISAS:
+    for incompatible_pair in INCOMPATIBLE_ISAS:
         if incompatible_pair.issubset(isa_set):
             pair_names = ", ".join(isa.name for isa in incompatible_pair)
             raise UserError(f"Incompatible ISAs selected: {pair_names}")
@@ -245,10 +244,8 @@ class Architecture(InsertsArguments):
             detected = native_detect(threads=num_threads)
             isa_strs = detected.isa or []
 
-            self.isa: list[type[BaseISA]] = [bench_gen.ISA_NAME_TO_CLASS[isa_str] for isa_str in isa_strs]
+            self.isa: list[type[BaseISA]] = [ISA_NAME_TO_CLASS[isa_str] for isa_str in isa_strs]
         else:
-            from benchmark.generation import ISA_NAME_TO_CLASS
-
             self.isa = [ISA_NAME_TO_CLASS[isa_name] for isa_name in args.isa]
             # Verify that the selected ISAs are compatible
             check_isa_compatibility(self.isa)
@@ -279,7 +276,7 @@ class Architecture(InsertsArguments):
 
     @staticmethod
     def insert_arguments(parser: argparse.ArgumentParser) -> None:
-        from benchmark.generation import ISA_NAME_TO_CLASS
+        from isa import ISA_NAME_TO_CLASS
 
         parser.add_argument(
             "-i",

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/architecture/arm.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from architecture.detect import DetectedArchitecture, TestContext, run_generic_tests
-from benchmark.generation import ArmNeon, ArmScalar, ArmSVE
+from isa import ArmNeon, ArmScalar, ArmSVE
 
 
 def detect(threads: int = 1) -> DetectedArchitecture:

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/architecture/config.py

@@ -18,8 +18,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import cast
 
-from error import UserError
-from units import Bytes
+from core import Bytes, UserError
 
 from .memory import SimpleMemoryTopology
 

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/architecture/detect.py

@@ -15,12 +15,11 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from error import UserError
+from core import Frequency, UserError
 from output_utils import debug, detail, warn
-from units import Frequency
 
 if TYPE_CHECKING:
-    from benchmark.generation import BaseISA
+    from isa import BaseISA
 
 from .memory import MemoryTopology
 

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/architecture/memory.py

@@ -9,9 +9,8 @@ from enum import Enum
 from pathlib import Path
 from typing import Protocol, runtime_checkable
 
-from error import UserError
+from core import Bytes, UserError
 from output_utils import debug, format_if_container
-from units import Bytes
 
 _CPU_ROOT = Path("/sys/devices/system/cpu")
 

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/architecture/riscv.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 import tempfile
 from pathlib import Path
 
-from benchmark import generation as bench_gen
 from exec_interface import ExecutionInterface
+from isa import RISCV_RVV, RISCV_RVV_071, RISCVScalar
 
 from .detect import ROOT, DetectedArchitecture, TestContext, run_generic_tests
 
@@ -24,7 +24,7 @@ def detect(threads: int = 1) -> DetectedArchitecture:
     detected = run_generic_tests(ctx, threads=threads)
 
     # Build ISA list with scalar as base
-    isa_list = [bench_gen.RISCVScalar.name]
+    isa_list = [RISCVScalar.name]
 
     # Detect RVV version using RISC-V specific test
     exec_iface = _get_execution_interface()
@@ -33,9 +33,9 @@ def detect(threads: int = 1) -> DetectedArchitecture:
     if rvv_version_probe_path.exists():
         # Try compiling with RVV 1.0 flag first (most common)
         if _can_compile_rvv(exec_iface, rvv_version_probe_path, "RISCV_RVV"):
-            isa_list.append(bench_gen.RISCV_RVV.name)
+            isa_list.append(RISCV_RVV.name)
         elif _can_compile_rvv(exec_iface, rvv_version_probe_path, "RISCV_RVV_0_7_1"):
-            isa_list.append(bench_gen.RISCV_RVV_071.name)
+            isa_list.append(RISCV_RVV_071.name)
 
     detected.isa = isa_list
 

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/architecture/x86.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from architecture.detect import ROOT, DetectedArchitecture, TestContext, run_generic_tests, run_test
-from units import Frequency
+from core import Frequency
 
 
 def detect(threads: int = 1) -> DetectedArchitecture:

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/benchmark/__init__.py

@@ -11,7 +11,6 @@ from .benchmark import (
     MixedBenchmarkResult,
 )
 from .benchmarking import Benchmarking, TestType
-from .generation import ALL_ISAS, BaseISA
 from .interface import generate_microbenchmarks, run_full_benchmark
 from .result import OutputFormat
 from .suites import (
@@ -23,13 +22,11 @@ from .suites import (
 )
 
 __all__ = [
-    "ALL_ISAS",
     "ArithmeticBenchmark",
     "ArithmeticBenchmarkResult",
     "ArithmeticBenchmarkSuite",
     "BaseBenchmark",
     "BaseBenchmarkResult",
-    "BaseISA",
     "Benchmarking",
     "ISABenchmarkSuite",
     "MemoryBenchmark",

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/benchmark/benchmark.py

@@ -8,9 +8,9 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 
+from core import ArithmeticIntensity, Bandwidth, Bytes, Performance, Seconds
 from output_utils import debug
 from test_bench.builder import MicrobenchmarkFunctionSpec
-from units import ArithmeticIntensity, Bandwidth, Bytes, Performance, Seconds
 
 from .generation import ArithmeticBenchmarkParams, BenchmarkParams, MemoryBenchmarkParams
 

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/benchmark/benchmarking.py

@@ -10,11 +10,8 @@ from enum import Enum
 from typing import TypeVar
 
 from arguments import InsertsArguments, enum_action, positive_float, positive_int
-from benchmark.generation.code_gen.operation import ArithmeticOperation
+from core import ArithmeticOperation, Bytes, DataType, Operations
 from output_utils import warn
-from units import Bytes, Operations
-
-from .generation import DataType
 
 
 class TestType(Enum):

carm_roofline-1.0.3.dev1/benchmark/generation/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from .parameters import ArithmeticBenchmarkParams, BenchmarkParams, MemoryBenchmarkParams, MemoryLayoutMode
+
+__all__ = [
+    "ArithmeticBenchmarkParams",
+    "BenchmarkParams",
+    "MemoryBenchmarkParams",
+    "MemoryLayoutMode",
+]

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/benchmark/generation/code_gen/__init__.py

@@ -1,17 +1,13 @@
 from __future__ import annotations
 
 from . import instruction
-from .data_type import DataType
 from .instruction import ControlInstructions, TypedInstructions, escape_for_inline_asm
-from .operation import Operation
 from .register import CyclicRegisterSet, HelperRegisterSet, TypedRegisterSets
 
 __all__ = [
     "ControlInstructions",
     "CyclicRegisterSet",
-    "DataType",
     "HelperRegisterSet",
-    "Operation",
     "TypedInstructions",
     "TypedRegisterSets",
     "escape_for_inline_asm",

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/benchmark/generation/code_gen/instruction.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 from enum import Enum, auto
 from typing import Union, overload
 
-from .data_type import DataType
-from .operation import ArithmeticOperation, MemoryOperation, Operation
+from core import ArithmeticOperation, DataType, MemoryOperation, Operation
+
 from .register import CyclicRegisterSet
 
 # Type alias for objects that can be converted to string

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/benchmark/generation/code_gen/register.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections.abc import Iterable, Iterator
 from typing import Union
 
-from .data_type import DataType
+from core import DataType
 
 __all__ = [
     "CyclicRegisterSet",

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/benchmark/generation/parameters.py

@@ -4,14 +4,12 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import TYPE_CHECKING
 
-import units
-from benchmark.generation.code_gen.operation import ArithmeticOperation
-from units import Bytes, Operations
+from core import ArithmeticOperation, Bytes, Operations
 
 if TYPE_CHECKING:
     from benchmark.benchmarking import LoadStoreRatio
 
-from .code_gen import DataType
+from core import DataType
 
 
 class BenchParamError(Exception):
@@ -52,14 +50,14 @@ class ArithmeticBenchmarkParams(BenchmarkParams):
         params = ArithmeticBenchmarkParams(
             data_type=DataType.f32,
             operation=ArithmeticOperation.fma,
-            num_ops=units.Operations(1000),
+            num_ops=Operations(1000),
             thread_affinity=[0, 1, 2, 3],
         )
         spec = isa.generate_arithmetic(params)
     """
 
     operation: ArithmeticOperation
-    num_ops: units.Operations
+    num_ops: Operations
 
     def __post_init__(self) -> None:
         super().__post_init__()

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

@@ -8,8 +8,8 @@ from typing import TYPE_CHECKING, Any
 
 from rich.table import Table
 
+from core import Cycles
 from output_utils import error, get_console, warn
-from units import Cycles
 
 from .base import NON_ROOFLINE_CSV_ERROR_MSG, OutputHandler
 from .common import (
@@ -47,7 +47,7 @@ def _collect_gops_by_isa(isa_suites: dict[str, ISABenchmarkSuite]) -> dict[str,
 
 def _print_table(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite]) -> None:
     from benchmark.benchmark import ArithmeticBenchmarkResult
-    from benchmark.generation.isa import BaseISA
+    from isa import BaseISA
 
     print_extra = context.run_config.verbose >= 3
 

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/benchmark/output/common.py

@@ -11,7 +11,7 @@ from typing import TYPE_CHECKING, Any
 from output_utils import error, info, warn
 
 if TYPE_CHECKING:
-    from benchmark.generation.code_gen import DataType
+    from core import DataType
 
 
 def format_precision_label(data_type: DataType) -> str:

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

@@ -13,16 +13,16 @@ from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from core import Cycles
 from output_utils import info, warn
 from roofline_assembly import RecordType
-from units import Cycles
 
 if TYPE_CHECKING:
     from benchmark.benchmark import ArithmeticBenchmark, MemoryBenchmark
-    from benchmark.generation.isa import BaseISA
     from benchmark.suites.base import ISABenchmarkSuite
     from context import CARMContext
-    from units import Frequency
+    from core import Frequency
+    from isa import BaseISA
 
 
 def _serialize_arithmetic(

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

@@ -9,9 +9,9 @@ from typing import TYPE_CHECKING, Any
 from rich.table import Table
 
 from benchmark.benchmark import MemoryBenchmarkResult
-from benchmark.generation.isa import BaseISA
+from core import Cycles
+from isa import BaseISA
 from output_utils import error, warn
-from units import Cycles
 
 from .base import NON_ROOFLINE_CSV_ERROR_MSG, OutputHandler
 from .common import (

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

@@ -9,10 +9,10 @@ from typing import TYPE_CHECKING, Any
 from rich.table import Table
 
 from benchmark.benchmark import MemoryBenchmarkResult
-from benchmark.generation.isa import BaseISA
 from benchmark.suites import MemorySweepBenchmarkSuite
+from core import Cycles
+from isa import BaseISA
 from output_utils import error, warn
-from units import Cycles
 
 from .base import NON_ROOFLINE_CSV_ERROR_MSG, OutputHandler
 from .common import safe_matplotlib_import, save_or_show_plot

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

@@ -8,83 +8,204 @@ from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from benchmark.generation.code_gen.operation import ArithmeticOperation
-from output_utils import info, warn
-from units import Cycles
+from rich.table import Table
+
+from core import ArithmeticIntensity, ArithmeticOperation, Bandwidth, Cycles, Performance
+from output_utils import error, get_console, info, warn
 
 from .base import OutputHandler
-from .common import format_precision_label
+from .common import format_precision_label, safe_matplotlib_import, save_or_show_plot
 
 if TYPE_CHECKING:
     from benchmark.benchmark import ISABenchmarkSuite
-    from benchmark.generation.isa import BaseISA
     from context import CARMContext
+    from isa import BaseISA
 
 
-def _gather_roofline_points(suite: ISABenchmarkSuite) -> dict[str, tuple[float, float]]:
-    """Gather roofline points (intensity, performance) from a benchmark suite.
-
-    Roofline analysis requires both arithmetic intensity and GOPS,
-    which are only available from MixedBenchmarkResult.
+def _print_table(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite]) -> None:
+    """Print a merged roofline summary table.
 
-    Note:
-        Skips invalid values (NaN, inf, or non-positive) with warning.
+    One row per ISA x (data_type, threads, loads, stores) combo, showing peak
+    intensity. Values are displayed via their unit class __str__ methods
+    (e.g., "8.95 GOPS/s", "380.00 GB/s", "0.02 FLOP/B").
+    At verbose >= 3, also prints the arithmetic and memory detail tables.
     """
-    # Basic implementation used by tests and future consumers.
-    # Collect intensity/performance pairs from MixedBenchmarkResult-like objects.
-    points: dict[str, tuple[float, float]] = {}
-
-    for name, bench in suite.benchmarks.items():
-        res = getattr(bench, "results", None)
-        if res is None:
-            continue
-        # we expect attributes 'arithmetic_intensity' and 'performance'
-        ai = getattr(res, "arithmetic_intensity", None)
-        perf = getattr(res, "performance", None)
-        if ai is None or perf is None:
-            # nothing to record for this benchmark
-            continue
-        try:
-            ai_val = float(ai)
-            perf_val = float(perf)
-        except Exception:
-            warn(f"Skipping invalid roofline point for {name} (non-numeric)")
-            continue
+    table = Table(title="Roofline Summary")
+    table.add_column("ISA", style="cyan")
+    table.add_column("Prec.", justify="left")
+    table.add_column("Thr.", style="magenta", justify="right")
+    table.add_column("Peak", justify="right")
+    for level in _CACHE_LEVELS:
+        table.add_column(level, justify="right")
+        table.add_column(f"{level} AI", justify="right")
 
-        if ai_val <= 0 or perf_val <= 0:
-            warn(f"Skipping invalid roofline point for {name} (non-positive values)")
-            continue
+    for isa, suite in sorted(isa_suites.items(), key=lambda kv: kv[0]):
+        mem_benches = suite.get_memory_benchmarks()
+        arith_benches = suite.get_arithmetic_benchmarks()
+
+        for (dt, nt, _ld, _st), group in sorted(_group_combos(mem_benches).items()):
+            # Collect Bandwidth per cache level from this combo's memory benchmarks
+            bw_by_level: dict[str, Bandwidth | None] = dict.fromkeys(_CACHE_LEVELS)
+            for bench in group:
+                if bench.results is not None and bench.cache_level in bw_by_level:
+                    bw_by_level[bench.cache_level] = bench.results.bandwidth
+
+            # Find peak Performance from arithmetic benchmarks matching this combo
+            peak_perf: Performance | None = None
+            for bench in arith_benches.values():
+                if bench.results is None:
+                    continue
+                if bench.params.data_type != dt or bench.params.num_threads != nt:
+                    continue
+                if peak_perf is None or bench.results.performance > peak_perf:
+                    peak_perf = bench.results.performance
+
+            row: list[str] = [isa, format_precision_label(dt), str(nt)]
+            if peak_perf is not None:
+                row.append(str(peak_perf))
+            else:
+                row.append("-")
+
+            for level in _CACHE_LEVELS:
+                bw = bw_by_level[level]
+                if bw is not None and bw.value > 0 and peak_perf is not None:
+                    ridge = ArithmeticIntensity(peak_perf.value / bw.value)
+                    row.append(str(bw))
+                    row.append(str(ridge))
+                else:
+                    row.append("-")
+                    row.append("-")
+            table.add_row(*row)
+
+    get_console().print(table)
+
+    if context.run_config.verbose >= 3:
+        from . import arithmetic, memory
+
+        arithmetic._print_table(context, isa_suites)
+        memory._print_table(context, isa_suites)
+
+
+_ROOFLINE_COLORS = [
+    "#1f77b4",
+    "#ff7f0e",
+    "#2ca02c",
+    "#d62728",
+    "#9467bd",
+    "#8c564b",
+    "#e377c2",
+    "#7f7f7f",
+    "#bcbd22",
+    "#17becf",
+]
+_LINE_STYLES = {"L1": "-", "L2": "--", "L3": "-.", "DRAM": ":"}
+_CACHE_LEVELS = ("L1", "L2", "L3", "DRAM")
+
+
+def _plot_roofline_to_axis(
+    roofline_data: dict[str, tuple[float, dict[str, float]]],
+    ax: Any,
+    np: Any,
+) -> None:
+    """Draw roofline curves on a matplotlib log-log axis.
+
+    For each ISA: horizontal ceiling at peak Gflop/s, and one bandwidth slope
+    per cache level (y = bandwidth x AI, clipped at the ceiling).
+    """
+    all_ridges: list[float] = []
+    for peak_gflops, bw_gbps in roofline_data.values():
+        for bw in bw_gbps.values():
+            if bw > 0:
+                all_ridges.append(peak_gflops / bw)
+
+    if not all_ridges:
+        warn("No valid roofline ridge points to plot")
+        return
 
-        points[name] = (ai_val, perf_val)
-    return points
+    ai_min = min(all_ridges) / 10
+    ai_max = max(all_ridges) * 10
+    ai_values = np.logspace(np.log10(ai_min), np.log10(ai_max), 200)
+    if not isinstance(ai_values, list):
+        ai_values = list(ai_values)
 
+    for idx, (isa, (peak_gflops, bw_gbps)) in enumerate(sorted(roofline_data.items())):
+        color = _ROOFLINE_COLORS[idx % len(_ROOFLINE_COLORS)]
 
-def _print_table(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite]) -> None:
-    info("Roofline summary per ISA:")
+        # Compute ridge points for this ISA to clip the ceiling
+        isa_ridges = [peak_gflops / bw for level in _CACHE_LEVELS if (bw := bw_gbps.get(level, 0)) > 0]
+        if isa_ridges:
+            min_ridge = min(isa_ridges)
+            ceiling_ai = [ai for ai in ai_values if ai >= min_ridge]
+        else:
+            ceiling_ai = []
+        if ceiling_ai:
+            ax.plot(
+                ceiling_ai,
+                [peak_gflops] * len(ceiling_ai),
+                color=color,
+                linestyle="-",
+                linewidth=1.5,
+                label=f"{isa} ceiling",
+            )
+        for level in _CACHE_LEVELS:
+            bw = bw_gbps.get(level, 0)
+            if bw <= 0:
+                continue
+            perf = [min(bw * ai, peak_gflops) for ai in ai_values]
+            ax.plot(
+                ai_values,
+                perf,
+                color=color,
+                linestyle=_LINE_STYLES[level],
+                linewidth=1,
+                alpha=1,
+            )
+
+    ax.set_xscale("log")
+    ax.set_yscale("log")
+    ax.set_xlabel("Arithmetic Intensity (FLOP/byte)")
+    ax.set_ylabel("Performance (Gflop/s)")
+    ax.set_title("Roofline Model")
+    ax.legend(fontsize=8)
 
 
 def _write_plot(isa_suites: dict[str, ISABenchmarkSuite], output_path: Path | None = None) -> None:
-    """Generate roofline plots or warn when no data.
+    """Generate and save roofline plot.
 
-    This minimal implementation is sufficient for unit tests and avoids
-    raising exceptions during missing-data scenarios.  Full plotting logic
-    may be added later.
+    Draws log-log roofline curves (bandwidth slopes + compute ceiling) per ISA.
+    Gracefully handles missing data, invalid values, and I/O errors.
     """
-    # gather all points across ISAs; warn if none found
-    any_points = False
-    for _isa, suite in isa_suites.items():
-        pts = _gather_roofline_points(suite)
-        if pts:
-            any_points = True
-            break
-
-    if not any_points:
+    roofline_data: dict[str, tuple[float, dict[str, float]]] = {}
+    for isa, suite in sorted(isa_suites.items(), key=lambda kv: kv[0]):
+        try:
+            peak = suite.get_peak_performance()
+            bw_by_level = suite.get_bandwidth_by_level()
+        except ValueError:
+            warn(f"Skipping {isa} in roofline plot: missing or incomplete benchmark results")
+            continue
+        peak_gflops = float(peak) / 1e9
+        bw_gbps = {level: float(bw) / 1e9 for level, bw in bw_by_level.items()}
+        roofline_data[isa] = (peak_gflops, bw_gbps)
+
+    if not roofline_data:
         warn("No roofline data found")
         return
 
-    # Placeholder: in a complete implementation we would import matplotlib
-    # and numpy and draw the curves. For now just silently succeed.
-    return
+    plt, np = safe_matplotlib_import()
+    if plt is None:
+        return
+
+    fig = None
+    try:
+        fig, ax = plt.subplots(figsize=(10, 7))
+        _plot_roofline_to_axis(roofline_data, ax, np)
+        plt.tight_layout()
+        save_or_show_plot(output_path, "roofline.png", plt=plt)
+    except Exception as e:
+        error(f"Failed to generate roofline plot: {e}")
+    finally:
+        if fig is not None:
+            plt.close(fig)
 
 
 def _to_isa_label(isa_name: str, context: CARMContext) -> str:

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/benchmark/result.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 from enum import Enum
 from typing import TYPE_CHECKING
 
-from units import Seconds
+from core import Seconds
 
 if TYPE_CHECKING:
     from .benchmark import BaseBenchmark

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/benchmark/suites/arithmetic.py

@@ -37,7 +37,7 @@ class ArithmeticBenchmarkSuite(ISABenchmarkSuite):
         Raises:
             ValueError: Unsupported precision or unknown ISA name.
         """
-        from benchmark.generation.isa import BaseISA
+        from isa import BaseISA
 
         benchmark = context.benchmarking
         architecture = context.architecture

{carm_roofline-1.0.2.dev2 → carm_roofline-1.0.3.dev1}/benchmark/suites/base.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
-from units import Bandwidth, Performance
+from core import Bandwidth, Performance
 
 if TYPE_CHECKING:
     from context import CARMContext