carm-roofline 1.0.0.dev2__tar.gz → 1.0.0.dev4__tar.gz

{carm_roofline-1.0.0.dev2 → carm_roofline-1.0.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-roofline
-Version: 1.0.0.dev2
+Version: 1.0.0.dev4
 Summary: CARM: Cache-Aware Roofline Model benchmarking and visualization toolkit
 Author: CHaMP Team
 License:                   GNU LESSER GENERAL PUBLIC LICENSE
@@ -525,9 +525,10 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: rich>=14.3.2
 Requires-Dist: rich-argparse>=1.7.0
-Requires-Dist: numpy>=1.24.4
+Requires-Dist: numpy>=2.0.0
 Requires-Dist: matplotlib>=3.7.2
 Requires-Dist: tomli>=2.0.0
+Requires-Dist: platformdirs>=4.0.0
 Provides-Extra: gui
 Requires-Dist: dash[diskcache]; extra == "gui"
 Requires-Dist: dash-bootstrap-components; extra == "gui"
@@ -545,42 +546,45 @@ Requires-Dist: carm-roofline[dev,gui]; extra == "all"
 Dynamic: license-file
 
 
-# CARM Roofline
+# The CARM Tool
 
-CARM is a Cache-Aware Roofline Model toolkit for CPU benchmarking and visualization.
+
+Cache-Aware Roofline Model (CARM) toolkit - benchmark, visualize and profile Intel, AMD, ARM, RISC-V CPUs and NVIDIA, AMD GPUs.
 
 The package provides:
 
-- automatic microbenchmark generation for supported ISAs
+- automatic benchmarking for supported ISAs
 - arithmetic, memory, and roofline benchmark modes
-- CLI output in table, JSON, CSV, and plot formats
 - optional web GUI for interactive result visualization
 
+> [!WARNING]
+> The development branch and associated python package are still experimental, and do not include all features yet. For a stable release, please refer to the main branch.
+
 ## Installation
 
 Install from PyPI:
 
 ```bash
+# command-line interface only:
 pip install carm-roofline
+# with GUI extras:
+pip install carm-roofline[gui]
+# with all extras (GUI + development tools):
+pip install carm-roofline[all]
 ```
 
-Install with optional GUI dependencies:
-
-```bash
-pip install "carm-roofline[gui]"
-```
-
-Install all extras (GUI + development tools):
+To avoid conflicts with other packages, we recommend installing in a virtual environment:
 
 ```bash
-pip install "carm-roofline[all]"
+python -m venv carm-env
+source carm-env/bin/activate
+pip install carm-roofline[all]
 ```
 
 ## Requirements
 
-- Python 3.10+
-- Linux (POSIX)
-- GCC toolchain (for compiling benchmark binaries)
+- Python 3.9+
+- GCC (for compiling benchmark binaries)
 
 ## Command-Line Interface
 
@@ -594,7 +598,7 @@ Available subcommands:
 
 - `benchmark` - run benchmark suites
 - `gui` - launch the results dashboard
-- `profile` - reserved (not implemented yet)
+- `profile` - coming soon
 
 Show help:
 
@@ -627,12 +631,12 @@ carm benchmark --dry-run --test arithmetic --test-time 1 --verbose 4
 
 ## Output and Results
 
-By default, results are written under `carm_results`.
+By default, results are written under the platform user data directory for the `carm` app (via platformdirs). On linux, this is typically `~/.local/share/carm/`, on Windows, `%APPDATA%\carm\`, and on MacOS, `~/Library/Application Support/carm/`.
 
 Control output directory and format(s):
 
 ```bash
-carm benchmark --output-dir carm_results --output-fmt table json csv plot
+carm benchmark --output-dir ./carm_results --output-fmt table json csv plot
 ```
 
 Use `--name` to label result files:
@@ -652,12 +656,12 @@ carm gui
 Custom results location and port:
 
 ```bash
-carm gui --results-dir carm_results --gui-port 8050
+carm gui --results-dir ./carm_results --gui-port 8050
 ```
 
 ## Publications and Citation
 
-If you use CARM in papers or reports, please cite:
+If you use the CARM and the CARM Tool in papers or reports, please cite:
 
 <p>
   <a href="https://doi.org/10.1109/L-CA.2013.6" alt="Publication">

{carm_roofline-1.0.0.dev2 → carm_roofline-1.0.0.dev4}/README.md

@@ -1,40 +1,43 @@
 
-# CARM Roofline
+# The CARM Tool
 
-CARM is a Cache-Aware Roofline Model toolkit for CPU benchmarking and visualization.
+
+Cache-Aware Roofline Model (CARM) toolkit - benchmark, visualize and profile Intel, AMD, ARM, RISC-V CPUs and NVIDIA, AMD GPUs.
 
 The package provides:
 
-- automatic microbenchmark generation for supported ISAs
+- automatic benchmarking for supported ISAs
 - arithmetic, memory, and roofline benchmark modes
-- CLI output in table, JSON, CSV, and plot formats
 - optional web GUI for interactive result visualization
 
+> [!WARNING]
+> The development branch and associated python package are still experimental, and do not include all features yet. For a stable release, please refer to the main branch.
+
 ## Installation
 
 Install from PyPI:
 
 ```bash
+# command-line interface only:
 pip install carm-roofline
+# with GUI extras:
+pip install carm-roofline[gui]
+# with all extras (GUI + development tools):
+pip install carm-roofline[all]
 ```
 
-Install with optional GUI dependencies:
-
-```bash
-pip install "carm-roofline[gui]"
-```
-
-Install all extras (GUI + development tools):
+To avoid conflicts with other packages, we recommend installing in a virtual environment:
 
 ```bash
-pip install "carm-roofline[all]"
+python -m venv carm-env
+source carm-env/bin/activate
+pip install carm-roofline[all]
 ```
 
 ## Requirements
 
-- Python 3.10+
-- Linux (POSIX)
-- GCC toolchain (for compiling benchmark binaries)
+- Python 3.9+
+- GCC (for compiling benchmark binaries)
 
 ## Command-Line Interface
 
@@ -48,7 +51,7 @@ Available subcommands:
 
 - `benchmark` - run benchmark suites
 - `gui` - launch the results dashboard
-- `profile` - reserved (not implemented yet)
+- `profile` - coming soon
 
 Show help:
 
@@ -81,12 +84,12 @@ carm benchmark --dry-run --test arithmetic --test-time 1 --verbose 4
 
 ## Output and Results
 
-By default, results are written under `carm_results`.
+By default, results are written under the platform user data directory for the `carm` app (via platformdirs). On linux, this is typically `~/.local/share/carm/`, on Windows, `%APPDATA%\carm\`, and on MacOS, `~/Library/Application Support/carm/`.
 
 Control output directory and format(s):
 
 ```bash
-carm benchmark --output-dir carm_results --output-fmt table json csv plot
+carm benchmark --output-dir ./carm_results --output-fmt table json csv plot
 ```
 
 Use `--name` to label result files:
@@ -106,12 +109,12 @@ carm gui
 Custom results location and port:
 
 ```bash
-carm gui --results-dir carm_results --gui-port 8050
+carm gui --results-dir ./carm_results --gui-port 8050
 ```
 
 ## Publications and Citation
 
-If you use CARM in papers or reports, please cite:
+If you use the CARM and the CARM Tool in papers or reports, please cite:
 
 <p>
   <a href="https://doi.org/10.1109/L-CA.2013.6" alt="Publication">

{carm_roofline-1.0.0.dev2 → carm_roofline-1.0.0.dev4}/benchmark/benchmarking.py

@@ -102,7 +102,7 @@ class Benchmarking(InsertsArguments):
         self.data_type: DataType = args.data_type
         self.threads: int = args.threads
         self.interleaved: bool = args.interleaved
-        self.instruction: ArithmeticOperation = args.instruction
+        self.instructions: set[ArithmeticOperation] = set(args.instruction)
         self.num_ops: Operations = Operations(args.num_ops)
         self.ld_st_ratio: LoadStoreRatio = args.ld_st_ratio
         self.arith_mem_ratio: int = args.arith_mem_ratio
@@ -163,10 +163,10 @@ class Benchmarking(InsertsArguments):
         )
         parser.add_argument(
             "--instruction",
-            default=ArithmeticOperation.fma,
-            nargs="?",
+            default=[ArithmeticOperation.add, ArithmeticOperation.fma],
+            nargs="+",
             action=enum_action(ArithmeticOperation),
-            help="Arithmetic instruction benchmarked (Default: 'fma')",
+            help="Arithmetic instruction(s) to benchmark (Default: add fma)",
         )
         parser.add_argument(
             "--ld-st-ratio",

{carm_roofline-1.0.0.dev2 → carm_roofline-1.0.0.dev4}/benchmark/output/arithmetic.py

@@ -29,26 +29,19 @@ def _collect_gops_by_isa(isa_suites: dict[str, ISABenchmarkSuite]) -> dict[str,
     gops_by_isa: dict[str, float] = {}
 
     for isa, suite in sorted(isa_suites.items(), key=lambda kv: kv[0]):
-        benches: dict[str, Any]
-        if hasattr(suite, "get_arithmetic_benchmarks"):
-            benches = suite.get_arithmetic_benchmarks()
-        else:
-            benches = getattr(suite, "benchmarks", {})
-
         values: list[float] = []
-        for bench in benches.values():
-            res = getattr(bench, "results", None)
-            if not isinstance(res, ArithmeticBenchmarkResult):
+        for bench in suite.get_arithmetic_benchmarks().values():
+            if not isinstance(bench.results, ArithmeticBenchmarkResult):
                 continue
 
-            gops_value = float(res.performance.value) / 1e9
+            gops_value = float(bench.results.performance.value) / 1e9
             if not math.isfinite(gops_value):
                 warn(f"Skipping invalid GOPS value for ISA {isa}: {gops_value}")
                 continue
             values.append(gops_value)
 
         if values:
-            gops_by_isa[isa] = sum(values) / len(values)
+            gops_by_isa[isa] = max(values)
 
     return gops_by_isa
 
@@ -64,47 +57,53 @@ def _print_table(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite])
         isa_cls.name: isa_cls.from_architecture(context.architecture) for isa_cls in context.architecture.isa
     }
 
-    arithmetic_metrics: dict[str, dict[str, Any]] = {}
+    arithmetic_metrics: list[dict[str, Any]] = []
 
     for isa, suite in sorted(isa_suites.items(), key=lambda kv: kv[0]):
         frequency = context.architecture.get_frequency_for_isa(isa)
-        benches = suite.get_arithmetic_benchmarks()
-        assert len(benches) == 1, "Expected exactly one arithmetic benchmark per ISA for summary output"
-        benchmark_name, benchmark = next(iter(benches.items()))
-        res = benchmark.results
-        assert isinstance(res, ArithmeticBenchmarkResult), "Expected ArithmeticBenchmarkResult for arithmetic summary"
-
         isa_instance = isa_instances.get(isa)
         if isa_instance is None:
             warn(f"No ISA instance available for {isa}; skipping metrics")
             continue
 
-        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
-        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
-
-        arithmetic_metrics[isa] = {
-            "benchmark": benchmark_name,
-            "gops": float(res.performance.value) / 1e9,
-            "gops_display": str(res.performance),
-            "ipc": ipc,
-            "frequency_hz": float(frequency.value),
-            "frequency_display": str(frequency),
-            "ops_per_instruction": ops_per_inst,
-            "ops_per_cycle": ops_per_cycle,
-            "time_seconds": float(res.time_taken.value),
-            "time_display": str(res.time_taken),
-            "repetitions": int(res.num_repetitions),
-            "cycles": float(cycles.value),
-            "cycles_display": str(cycles),
-        }
+        benches = suite.get_arithmetic_benchmarks()
+        for benchmark_name, benchmark in benches.items():
+            res = benchmark.results
+            assert isinstance(res, ArithmeticBenchmarkResult), (
+                "Expected ArithmeticBenchmarkResult for arithmetic summary"
+            )
+
+            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
+            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
+
+            arithmetic_metrics.append(
+                {
+                    "isa": isa,
+                    "operation": benchmark.params.operation.name,
+                    "benchmark": benchmark_name,
+                    "gops": float(res.performance.value) / 1e9,
+                    "gops_display": str(res.performance),
+                    "ipc": ipc,
+                    "frequency_hz": float(frequency.value),
+                    "frequency_display": str(frequency),
+                    "ops_per_instruction": ops_per_inst,
+                    "ops_per_cycle": ops_per_cycle,
+                    "time_seconds": float(res.time_taken.value),
+                    "time_display": str(res.time_taken),
+                    "repetitions": int(res.num_repetitions),
+                    "cycles": float(cycles.value),
+                    "cycles_display": str(cycles),
+                }
+            )
 
     table = Table(title="Arithmetic Performance Summary")
 
     # normal output columns
     table.add_column("ISA", style="cyan")
+    table.add_column("Op", style="magenta")
     table.add_column("GOPS", justify="right")
     table.add_column("IPC", justify="right")
     table.add_column("Frequency", justify="right")
@@ -116,7 +115,8 @@ def _print_table(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite])
         table.add_column("Repetitions", justify="right")
         table.add_column("Cycles", justify="right")
 
-    for isa, metrics in sorted(arithmetic_metrics.items(), key=lambda kv: kv[0]):
+    # sort rows by ISA and operation
+    for metrics in sorted(arithmetic_metrics, key=lambda row: (row["isa"], row["operation"])):
         ipc = float(metrics["ipc"])
 
         if print_extra:
@@ -130,7 +130,8 @@ def _print_table(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite])
             extra_args = ()
 
         table.add_row(
-            isa,
+            metrics["isa"],
+            metrics["operation"],
             str(metrics["gops_display"]),
             f"{ipc:.2f}",
             str(metrics["frequency_display"]),
@@ -152,34 +153,36 @@ def _write_json(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite])
 
     for isa, suite in sorted(isa_suites.items(), key=lambda kv: kv[0]):
         frequency = context.architecture.get_frequency_for_isa(isa)
-        benches = suite.get_arithmetic_benchmarks()
-        assert len(benches) == 1, "Expected exactly one arithmetic benchmark per ISA for JSON output"
-        benchmark_name, benchmark = next(iter(benches.items()))
-        res = benchmark.results
-        assert isinstance(res, ArithmeticBenchmarkResult), "Expected ArithmeticBenchmarkResult for arithmetic JSON"
-
         isa_instance = isa_instances.get(isa)
         if isa_instance is None:
             warn(f"No ISA instance available for {isa}; skipping metrics")
             continue
 
-        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
-        cycles = Cycles.from_time_and_frequency(res.time_taken, frequency)
-        ipc = 0.0 if cycles.value == 0 else total_insts / cycles.value
-
-        results[isa] = {
-            "benchmark": benchmark_name,
-            "operation": benchmark.params.operation.name,
-            "gops": float(res.performance.value) / 1e9,
-            "ipc": ipc,
-            "frequency_hz": float(frequency.value),
-            "ops_per_instruction": ops_per_inst,
-            "ops_per_cycle": ops_per_inst * ipc,
-            "time_seconds": float(res.time_taken.value),
-            "repetitions": int(res.num_repetitions),
-            "cycles": float(cycles.value),
-        }
+        benches = suite.get_arithmetic_benchmarks()
+        isa_results: dict[str, object] = {}
+        for benchmark_name, benchmark in benches.items():
+            res = benchmark.results
+            assert isinstance(res, ArithmeticBenchmarkResult), "Expected ArithmeticBenchmarkResult for arithmetic JSON"
+
+            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
+            cycles = Cycles.from_time_and_frequency(res.time_taken, frequency)
+            ipc = 0.0 if cycles.value == 0 else total_insts / cycles.value
+
+            isa_results[benchmark.params.operation.name] = {
+                "benchmark": benchmark_name,
+                "operation": benchmark.params.operation.name,
+                "gops": float(res.performance.value) / 1e9,
+                "ipc": ipc,
+                "frequency_hz": float(frequency.value),
+                "ops_per_instruction": ops_per_inst,
+                "ops_per_cycle": ops_per_inst * ipc,
+                "time_seconds": float(res.time_taken.value),
+                "repetitions": int(res.num_repetitions),
+                "cycles": float(cycles.value),
+            }
+
+        results[isa] = isa_results
 
     out_dir = context.run_config.output_dir / "arithmetic"
     out_dir.mkdir(parents=True, exist_ok=True)

{carm_roofline-1.0.0.dev2 → carm_roofline-1.0.0.dev4}/benchmark/output/roofline.py

@@ -8,6 +8,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from benchmark.generation.code_gen.operation import ArithmeticOperation
 from output_utils import info, warn
 from units import Cycles
 
@@ -167,7 +168,12 @@ def _collect_memory_metrics(
     return bandwidth_by_level, ipc_by_level
 
 
-def _collect_fp_metrics(context: CARMContext, suite: ISABenchmarkSuite, isa_name: str) -> tuple[float, float]:
+def _collect_fp_metrics(
+    context: CARMContext,
+    suite: ISABenchmarkSuite,
+    isa_name: str,
+    operation: ArithmeticOperation | None = None,
+) -> tuple[float, float]:
     frequency = context.architecture.get_frequency_for_isa(isa_name)
     fp_gflops = 0.0
     fp_ipc = 0.0
@@ -179,6 +185,8 @@ def _collect_fp_metrics(context: CARMContext, suite: ISABenchmarkSuite, isa_name
     for bench in suite.get_arithmetic_benchmarks().values():
         if bench.results is None:
             continue
+        if operation is not None and bench.params.operation != operation:
+            continue
         fp_gflops = float(bench.results.performance.value) / 1e9
         ops_per_inst = isa_instance.ops_per_inst(bench.params.data_type, bench.params.operation)
         total_insts = (
@@ -214,8 +222,19 @@ def _write_csv(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite], o
 
         bandwidth_by_level, icycle_by_level = _collect_memory_metrics(context, suite, isa)
 
-        fp_inst = context.benchmarking.instruction.name
-        fp_gflops, fp_icycle = _collect_fp_metrics(context, suite, isa)
+        # Select primary instruction: prefer non-fma if available, else fall back to fma
+        primary_instruction = next(
+            (op for op in context.benchmarking.instructions if op != ArithmeticOperation.fma),
+            ArithmeticOperation.fma,
+        )
+
+        fp_inst = primary_instruction.name
+        fp_gflops, fp_icycle = _collect_fp_metrics(context, suite, isa, operation=primary_instruction)
+
+        fma_gflops = 0.0
+        fma_icycle = 0.0
+        if ArithmeticOperation.fma in context.benchmarking.instructions:
+            fma_gflops, fma_icycle = _collect_fp_metrics(context, suite, isa, operation=ArithmeticOperation.fma)
 
         def round_helper(x: float) -> str:
             return f"{x:.3g}" if x < 1 else f"{x:.3f}"
@@ -240,8 +259,8 @@ def _write_csv(context: CARMContext, isa_suites: dict[str, ISABenchmarkSuite], o
             round_helper(icycle_by_level["DRAM"]),
             round_helper(fp_gflops),
             round_helper(fp_icycle),
-            0,
-            0,
+            round_helper(fma_gflops),
+            round_helper(fma_icycle),
         ]
 
         secondary_headers = [

{carm_roofline-1.0.0.dev2 → carm_roofline-1.0.0.dev4}/benchmark/suites/arithmetic.py

@@ -5,8 +5,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from units import Performance
-
 from ..benchmark import ArithmeticBenchmark
 from ..generation import ArithmeticBenchmarkParams
 from .base import ISABenchmarkSuite
@@ -19,7 +17,7 @@ if TYPE_CHECKING:
 class ArithmeticBenchmarkSuite(ISABenchmarkSuite):
     """Suite for arithmetic-only benchmarks (TestType.ARITHMETIC).
 
-    Measures peak arithmetic performance for a specific operation.
+    Measures peak arithmetic performance across one or more operations.
     """
 
     @classmethod
@@ -61,29 +59,17 @@ class ArithmeticBenchmarkSuite(ISABenchmarkSuite):
         # This also helps us deal with SMT, ensuring threads are properly distributed across cores
         thread_affinity = architecture.memory_topology.plan_thread_affinity(benchmark.threads, 1)
 
-        # Generate arithmetic benchmark
-        params = ArithmeticBenchmarkParams(
-            data_type=benchmark.data_type,
-            thread_affinity=thread_affinity.cpu_ids,
-            operation=benchmark.instruction,
-            num_ops=benchmark.num_ops,
-        )
-        spec = isa.generate_arithmetic(params, context)
+        for operation in benchmark.instructions:
+            params = ArithmeticBenchmarkParams(
+                data_type=benchmark.data_type,
+                thread_affinity=thread_affinity.cpu_ids,
+                operation=operation,
+                num_ops=benchmark.num_ops,
+            )
+            spec = isa.generate_arithmetic(params, context)
 
-        # Add to ISA suite using the benchmark's authoritative name
-        arith_benchmark = ArithmeticBenchmark(params=params, spec=spec)
-        suite.add_benchmark(arith_benchmark.name, arith_benchmark)
+            # Add to ISA suite using the benchmark's authoritative name
+            arith_benchmark = ArithmeticBenchmark(params=params, spec=spec)
+            suite.add_benchmark(arith_benchmark.name, arith_benchmark)
 
         return suite
-
-    def get_peak_performance(self) -> Performance:
-        """Get peak GOPS from arithmetic portion of roofline suite.
-
-        Returns:
-            Peak GOPS from arithmetic benchmarks, or None if unavailable.
-        """
-        arith_benchmarks = self.get_arithmetic_benchmarks()
-        if len(arith_benchmarks) > 1:
-            raise ValueError("Expected exactly one arithmetic benchmark for peak performance calculation")
-
-        return super().get_peak_performance()

{carm_roofline-1.0.0.dev2 → carm_roofline-1.0.0.dev4}/benchmark/suites/memory_sweep.py

@@ -16,7 +16,7 @@ from output_utils import debug
 from units import Bandwidth, Bytes
 
 from ..benchmark import MemoryBenchmark
-from ..generation import MemoryBenchmarkParams
+from ..generation import MemoryBenchmarkParams, MemoryLayoutMode
 from .base import ISABenchmarkSuite
 
 if TYPE_CHECKING:
@@ -92,8 +92,7 @@ class MemorySweepBenchmarkSuite(ISABenchmarkSuite):
             (level_num, level_info.name)
             for level_num, level_info in zip(
                 topology.available_cache_levels(),
-                topology,
-                strict=True,
+                iter(topology),
             )
         ]
 
@@ -159,13 +158,15 @@ class MemorySweepBenchmarkSuite(ISABenchmarkSuite):
             size_per_thread = Bytes(int(size_bytes))
 
             # Classify: find the smallest cache level whose per-thread capacity
-            # is ≥ the sweep size.  Fall back to DRAM label if none matches.
+            # is >= the sweep size. Fall back to DRAM label if none matches.
             assigned_level_name: str = dram_level_name
             assigned_affinity: CacheAwareThreadAffinity = dram_affinity
             for _lvl_num, lvl_name, avail, aff in cache_levels_for_classification:
                 if size_per_thread <= avail:
                     assigned_level_name = lvl_name
                     assigned_affinity = aff
+                    # L1 can suffer from 4k aliasing - use single-array layout to prevent speculative forwarding issues
+                    mem_layout = MemoryLayoutMode.single if _lvl_num == 1 else MemoryLayoutMode.split
                     break
 
             # Use sweep{i:02d} as memory_level_name to guarantee unique C
@@ -178,6 +179,7 @@ class MemorySweepBenchmarkSuite(ISABenchmarkSuite):
                 load_store_ratio=benchmark.ld_st_ratio,
                 size_per_thread=size_per_thread,
                 memory_level_name=sweep_label,
+                layout_mode=mem_layout,
             )
 
             bench_spec = isa.generate_memory(params, context)

{carm_roofline-1.0.0.dev2 → carm_roofline-1.0.0.dev4}/benchmark/suites/roofline.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from units import ArithmeticIntensity, Bandwidth, Performance
+from units import ArithmeticIntensity, Bandwidth
 
 from .arithmetic import ArithmeticBenchmarkSuite
 from .base import ISABenchmarkSuite
@@ -53,22 +53,6 @@ class RooflineBenchmarkSuite(ISABenchmarkSuite):
 
         return suite
 
-    def get_peak_performance(self) -> Performance:
-        """Get peak GOPS from arithmetic portion of roofline suite.
-
-        Returns:
-            Peak GOPS from arithmetic benchmarks, or None if unavailable.
-        """
-        arith_benchmarks = self.get_arithmetic_benchmarks()
-        if len(arith_benchmarks) > 1:
-            raise ValueError("Expected exactly one arithmetic benchmark for peak performance calculation")
-
-        arith_benchmark = next(iter(arith_benchmarks.values()))
-        if arith_benchmark.results is None:
-            raise ValueError("Arithmetic benchmark missing performance result for roofline benchmarking")
-
-        return arith_benchmark.results.performance
-
     def get_bandwidth_by_level(self) -> dict[str, Bandwidth]:
         """Get peak bandwidth for each cache level from memory benchmarks.