carm-roofline 1.0.0.dev4__tar.gz → 1.0.1.dev0__tar.gz

{carm_roofline-1.0.0.dev4 → carm_roofline-1.0.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-roofline
-Version: 1.0.0.dev4
+Version: 1.0.1.dev0
 Summary: CARM: Cache-Aware Roofline Model benchmarking and visualization toolkit
 Author: CHaMP Team
 License:                   GNU LESSER GENERAL PUBLIC LICENSE
@@ -518,7 +518,7 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: System :: Benchmark
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Operating System :: POSIX :: Linux
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -529,6 +529,7 @@ Requires-Dist: numpy>=2.0.0
 Requires-Dist: matplotlib>=3.7.2
 Requires-Dist: tomli>=2.0.0
 Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: argcomplete>=3.0.0
 Provides-Extra: gui
 Requires-Dist: dash[diskcache]; extra == "gui"
 Requires-Dist: dash-bootstrap-components; extra == "gui"
@@ -622,7 +623,7 @@ Other usage examples:
 # Short roofline benchmark (1 second per micro-bench)
 carm benchmark --test roofline --test-time 1
 # Arithmetic-only
-carm benchmark --test arithmetic --instruction add --data-type f32
+carm benchmark --test arithmetic --instruction add mul fma --data-type f32
 # Memory-only
 carm benchmark --test memory --mem-target L2 --ld-st-ratio 2:1
 # Dry run (generate benchmark code, skip compile/execute):
@@ -631,7 +632,7 @@ carm benchmark --dry-run --test arithmetic --test-time 1 --verbose 4
 
 ## Output and 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/`.
+By default, results are written to the user data directory (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):
 

{carm_roofline-1.0.0.dev4 → carm_roofline-1.0.1.dev0}/README.md

@@ -75,7 +75,7 @@ Other usage examples:
 # Short roofline benchmark (1 second per micro-bench)
 carm benchmark --test roofline --test-time 1
 # Arithmetic-only
-carm benchmark --test arithmetic --instruction add --data-type f32
+carm benchmark --test arithmetic --instruction add mul fma --data-type f32
 # Memory-only
 carm benchmark --test memory --mem-target L2 --ld-st-ratio 2:1
 # Dry run (generate benchmark code, skip compile/execute):
@@ -84,7 +84,7 @@ carm benchmark --dry-run --test arithmetic --test-time 1 --verbose 4
 
 ## Output and 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/`.
+By default, results are written to the user data directory (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):
 

{carm_roofline-1.0.0.dev4 → carm_roofline-1.0.1.dev0}/architecture/architecture.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any
 
 from arguments import InsertsArguments, positive_int
 from benchmark import generation as bench_gen
-from error import ConfigurationError
+from error import UserError
 from output_utils import configure_verbosity, debug, detail, format_if_container, warn
 from units import Frequency
 
@@ -28,14 +28,14 @@ def check_isa_compatibility(selected_isas: list[type[BaseISA]]) -> None:
             families.add(family)
 
     if len(families) > 1:
-        raise ConfigurationError(f"Incompatible ISA families selected: {', '.join(families)}")
+        raise UserError(f"Incompatible ISA families selected: {', '.join(families)}")
 
     # Check for special incompatibilities within the same family
     isa_set = set(selected_isas)
     for incompatible_pair in bench_gen.INCOMPATIBLE_ISAS:
         if incompatible_pair.issubset(isa_set):
             pair_names = ", ".join(isa.name for isa in incompatible_pair)
-            raise ConfigurationError(f"Incompatible ISAs selected: {pair_names}")
+            raise UserError(f"Incompatible ISAs selected: {pair_names}")
 
 
 def positive_po2_int(arg: str) -> int:
@@ -103,6 +103,36 @@ class ISAFrequencies:
             base_frequency = Frequency(base_frequency)
         return ISAFrequencies({isa.name: base_frequency for isa in isas})
 
+    @staticmethod
+    def from_detected(detected: DetectedArchitecture, isa_list: list[type[BaseISA]]) -> ISAFrequencies:
+        """Create ISAFrequencies from auto-detected architecture data.
+
+        Initializes all ISAs to the base frequency, then overrides with any per-ISA
+        specific frequencies that were detected.
+
+        Args:
+            detected: DetectedArchitecture object from probing
+            isa_list: List of ISA classes for this architecture
+
+        Returns:
+            ISAFrequencies with appropriate frequencies from detected data
+
+        Raises:
+            ValueError: If no frequency information is available
+        """
+        base_freq = detected.frequency
+        if not base_freq:
+            raise ValueError("Frequency could not be auto-detected, specify it using --frequency <freq>")
+
+        # Start with all ISAs at base frequency
+        isa_freqs_dict = {isa.name: base_freq for isa in isa_list}
+
+        # Override with any specific ISA frequencies that were detected
+        if detected.isa_frequencies:
+            isa_freqs_dict.update(detected.isa_frequencies)
+
+        return ISAFrequencies(isa_freqs_dict)
+
     def __getitem__(self, isa_name: str) -> Frequency:
         """Get frequency for a specific ISA.
 
@@ -111,6 +141,9 @@ class ISAFrequencies:
 
         Returns:
             Frequency wrapper for that ISA
+
+        Raises:
+            KeyError: If ISA not found
         """
         return self._isa_frequencies[isa_name]
 
@@ -177,7 +210,7 @@ class Architecture(InsertsArguments):
                 "Specify them using a TOML config file with --topology-config <path>"
             )
 
-        # Handle frequency: user arg (Frequency wrapper) overrides all, otherwise use detected per-ISA frequencies
+        # Handle frequency: user arg (Frequency wrapper) overrides all, otherwise use detected
         if args.frequency is not None:
             # args.frequency is already a Frequency wrapper from frequency_type()
             self.frequency = ISAFrequencies.from_base_frequency(args.frequency, self.isa)
@@ -185,14 +218,7 @@ class Architecture(InsertsArguments):
                 d_freq = detected.frequency if detected.isa_frequencies is None else detected.isa_frequencies
                 _override_warn("frequency", args.frequency, d_freq)
         else:
-            isa_freqs = detected.isa_frequencies
-            # if there are isa-specific frequencies, use them; otherwise fall back to base frequency if available
-            if isa_freqs:
-                self.frequency = ISAFrequencies(isa_freqs)
-            elif base_freq := detected.frequency:
-                self.frequency = ISAFrequencies.from_base_frequency(base_freq, self.isa)
-            else:
-                raise ValueError("Frequency could not be auto-detected, specify it using --frequency <freq>")
+            self.frequency = ISAFrequencies.from_detected(detected, self.isa)
 
         self.nominal_frequency: Frequency | None = detected.frequency_nominal
 
@@ -252,20 +278,18 @@ class Architecture(InsertsArguments):
         parser.add_argument(
             "-i",
             "--isa",
-            nargs="*",
+            nargs="+",
             choices=list(ISA_NAME_TO_CLASS.keys()),
             help="Set of ISAs to test. (Default: automatically detects all available ISAs)",
         )
         parser.add_argument(
             "-l",
             "--vector-length",
-            nargs="?",
             type=positive_po2_int,
             help="Vector register length in bytes. (Default: automatically detected)",
         )
         parser.add_argument(
             "--vector-lmul",
-            nargs="?",
             type=int,
             choices=(1, 2, 4, 8),
             help="Vector register group modifier (LMUL). RISC-V specific.",
@@ -283,12 +307,13 @@ class Architecture(InsertsArguments):
             "--emit-config",
             type=str,
             metavar="PATH",
+            nargs="?",
+            const="topology.toml",
             help="Generate a template TOML configuration file at the specified path and exit. "
             "Edit the template and pass it back with --topology-config.",
         )
         parser.add_argument(
             "--frequency",
-            nargs="?",
             type=Frequency.from_argparse,
             help="Processor frequency, e.g. '2GHz', '3200mhz' (Default: automatically detected if possible)",
         )

{carm_roofline-1.0.0.dev4 → carm_roofline-1.0.1.dev0}/architecture/config.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import cast
 
-from error import ConfigurationError
+from error import UserError
 from units import Bytes
 
 from .memory import SimpleMemoryTopology
@@ -81,13 +81,13 @@ def load_memory_topology_from_toml(config_path: Path | str) -> SimpleMemoryTopol
     """
     config_path = Path(config_path)
     if not config_path.exists():
-        raise ConfigurationError(f"Config file not found: {config_path}")
+        raise UserError(f"Config file not found: {config_path}")
 
     try:
         with open(config_path, "rb") as f:
             config = tomllib.load(f)
     except Exception as e:
-        raise ConfigurationError(f"Failed to parse TOML file '{config_path}': {e}") from e
+        raise UserError(f"Failed to parse TOML file '{config_path}': {e}") from e
 
     total_cpus = _read_optional_int(config, "total_cpus")
     smt_degree = cast(int, _read_optional_int(config, "smt_degree", 1))
@@ -96,7 +96,7 @@ def load_memory_topology_from_toml(config_path: Path | str) -> SimpleMemoryTopol
     # Extract cache levels
     cache_levels_data = config.get("cache_levels", [])
     if not isinstance(cache_levels_data, list) or not cache_levels_data:
-        raise ConfigurationError("Configuration must contain at least one [[cache_levels]] section")
+        raise UserError("Configuration must contain at least one [[cache_levels]] section")
 
     # Parse and validate each cache level (processed in document order; order determines level numbers)
     level_sizes: list[Bytes] = []
@@ -104,17 +104,17 @@ def load_memory_topology_from_toml(config_path: Path | str) -> SimpleMemoryTopol
 
     for level_dict in cache_levels_data:
         if not isinstance(level_dict, dict):
-            raise ConfigurationError(f"Each [[cache_levels]] entry must be a table, got: {type(level_dict).__name__}")
+            raise UserError(f"Each [[cache_levels]] entry must be a table, got: {type(level_dict).__name__}")
         try:
             instances = level_dict["instances"]
             size_str = level_dict["size"]
         except KeyError as e:
-            raise ConfigurationError(f"Cache level section missing required field: {e}") from e
+            raise UserError(f"Cache level section missing required field: {e}") from e
 
         if not isinstance(instances, int):
-            raise ConfigurationError(f"'instances' must be an integer, got: {instances!r}")
+            raise UserError(f"'instances' must be an integer, got: {instances!r}")
         if not isinstance(size_str, str):
-            raise ConfigurationError(f"'size' must be a string, got: {size_str!r}")
+            raise UserError(f"'size' must be a string, got: {size_str!r}")
 
         size = Bytes.from_string(size_str)
         level_sizes.append(size)

{carm_roofline-1.0.0.dev4 → carm_roofline-1.0.1.dev0}/architecture/detect.py

@@ -15,7 +15,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from error import ConfigurationError
+from error import UserError
 from output_utils import debug, detail, warn
 from units import Frequency
 
@@ -244,7 +244,7 @@ def detect_cache(ctx: TestContext) -> dict[str, Any]:
             else:
                 raise ValueError("MemoryTopology parsed but contains no CPU data")
         except Exception as e:
-            raise ConfigurationError(
+            raise UserError(
                 f"Failed to parse native system memory topology from /sys: {e}. "
                 "For non-native execution or when sysfs is unavailable, "
                 "please provide cache hierarchy explicitly with --topology-config."
@@ -424,7 +424,7 @@ def native_detect(threads: int = 1) -> DetectedArchitecture:
     """
     machine = platform.machine().lower()
     if machine == "":
-        raise ConfigurationError(
+        raise UserError(
             "Unable to detect machine architecture (platform.machine() returned empty string). Please specify the "
             "architecture manually (--isa <arch>)."
         )

{carm_roofline-1.0.0.dev4 → carm_roofline-1.0.1.dev0}/architecture/memory.py

@@ -9,7 +9,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Protocol, runtime_checkable
 
-from error import ConfigurationError
+from error import UserError
 from output_utils import debug, format_if_container
 from units import Bytes
 
@@ -168,26 +168,26 @@ class SimpleMemoryTopology:
         """
 
         if len(level_sizes) != len(instances_per_level):
-            raise ConfigurationError(
+            raise UserError(
                 "Level sizes and instances_per_level must have same length: "
                 f"{len(level_sizes)} vs {len(instances_per_level)}"
             )
         if not level_sizes:
-            raise ConfigurationError("At least one cache level must be provided")
+            raise UserError("At least one cache level must be provided")
 
         if any(inst <= 0 for inst in instances_per_level):
-            raise ConfigurationError("All values in instances_per_level must be positive integers")
+            raise UserError("All values in instances_per_level must be positive integers")
 
         if total_cpus is not None and total_cpus <= 0:
-            raise ConfigurationError(f"total_cpus must be positive when provided, got {total_cpus}")
+            raise UserError(f"total_cpus must be positive when provided, got {total_cpus}")
 
         if cpu_offset < 0:
-            raise ConfigurationError(f"cpu_offset must be >= 0, got {cpu_offset}")
+            raise UserError(f"cpu_offset must be >= 0, got {cpu_offset}")
 
         if total_cpus is not None:
             for idx, instances in enumerate(instances_per_level, 1):
                 if instances > total_cpus:
-                    raise ConfigurationError(
+                    raise UserError(
                         f"Cache level {idx}: instances ({instances}) cannot exceed total_cpus ({total_cpus})"
                     )
 

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

@@ -11,7 +11,7 @@ from enum import Enum
 from arguments import InsertsArguments, enum_action, positive_float, positive_int
 from benchmark.generation.code_gen.operation import ArithmeticOperation
 from output_utils import warn
-from units import Operations
+from units import Bytes, Operations
 
 from .generation import DataType
 
@@ -66,27 +66,29 @@ def ld_st_ratio_type(arg: str) -> LoadStoreRatio:
     return LoadStoreRatio(ld, st)
 
 
-def mem_test_size_type(arg: str) -> int | str:
+def mem_test_size_type(arg: str) -> Bytes | None:
     """Parse a memory test size specifier.
 
     Accepts either:
-      - A positive integer (KiB)
+      - A quantity with a binary unit (e.g. "16 KiB", "2 MiB", "8 GiB")
       - The string "auto" (case-insensitive) for automatic sizing
 
     Returns:
-        int (KiB value) or str (literal "auto")
+        Bytes or None (for "auto")
 
     Raises:
         argparse.ArgumentTypeError on invalid input.
     """
     s = str(arg).strip().lower()
     if s == "auto":
-        return "auto"
+        return None
     try:
-        return positive_int(arg)
-    except (ValueError, argparse.ArgumentTypeError) as e:
+        return Bytes.from_argparse(arg)
+    except argparse.ArgumentTypeError:
+        raise
+    except Exception as e:
         raise argparse.ArgumentTypeError(
-            f"invalid memory test size: {arg!r}. Must be a positive integer or 'auto'"
+            f"invalid memory test size: {arg!r}. Expected a binary unit string like '16 KiB', '2 MiB', or 'auto'. ({e})"
         ) from e
 
 
@@ -106,7 +108,7 @@ class Benchmarking(InsertsArguments):
         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
-        self.mem_test_sizes: list[int | str] | None = args.mem_test_sizes
+        self.mem_test_sizes: list[Bytes | None] | None = args.mem_test_sizes
         self.verbose: int = args.verbose
         self.test_time: float = args.test_time
         if self.test_time < 10.0:
@@ -132,7 +134,6 @@ class Benchmarking(InsertsArguments):
             "-m",
             "--mem-target",
             default="all",
-            nargs="?",
             choices=["L1", "L2", "L3", "DRAM", "all"],
             help="Target memory level for 'memory' and 'mixed' tests (Default: all)",
         )
@@ -140,7 +141,6 @@ class Benchmarking(InsertsArguments):
             "-o",
             "--num-ops",
             default=32 * 1024,
-            nargs="?",
             type=positive_int,
             help="Number of arithmetic operations to perform in the arithmetic test (Default: 32768)",
         )
@@ -148,7 +148,6 @@ class Benchmarking(InsertsArguments):
             "-d",
             "--data-type",
             default=DataType.f32,
-            nargs="?",
             action=enum_action(DataType),
             help="Data type for benchmark operations (Default: f32)",
         )
@@ -171,7 +170,6 @@ class Benchmarking(InsertsArguments):
         parser.add_argument(
             "--ld-st-ratio",
             default=LoadStoreRatio(2, 1),
-            nargs="?",
             type=ld_st_ratio_type,
             help="Load-to-store ratio for memory access patterns. Format: 'LD:ST' (e.g., '2:1') or a single "
             "integer for 'N:1' ratio. Use '1:0' for load-only or '0:1' for store-only tests. (Default: 2:1)",
@@ -179,22 +177,22 @@ class Benchmarking(InsertsArguments):
         parser.add_argument(
             "--arith-mem-ratio",
             default=2,
-            nargs="?",
             type=positive_int,
             help="Ratio between arithmetic and memory operations for 'mixed' test (Default: 2)",
         )
         parser.add_argument(
             "--mem-test-sizes",
-            nargs="*",
+            nargs="+",
             type=mem_test_size_type,
-            help="Size of the test arrays for each memory level in KiB. 'auto' can be used to automatically determine "
-            "sizes based on the cache sizes, e.g. '--mem-test-sizes 32 256 2048 65536' / '--mem-test-sizes auto auto "
-            "2048 auto' for L1, L2, L3, DRAM tests respectively. (Default: auto for all levels)",
+            help="Size of the test arrays for each memory level. Accepts binary unit strings like '16KiB', '2MiB', "
+            "'8GiB', or 'auto' to automatically size based on detected caches. "
+            "e.g. '--mem-test-sizes 16KiB 256KiB 2MiB 64GiB' / "
+            "'--mem-test-sizes auto auto 2MiB auto' for L1, L2, L3, DRAM respectively. "
+            "(Default: auto for all levels)",
         )
         parser.add_argument(
             "--test-time",
             default=25.0,
-            nargs="?",
             type=positive_float,
             help="Target runtime for each individual microbenchmark, in seconds. Low runtime may lead to inaccurate "
             "results. (Default: 25.0)",

{carm_roofline-1.0.0.dev4 → carm_roofline-1.0.1.dev0}/benchmark/generation/x86.py

@@ -172,7 +172,7 @@ class X86AVX2(X86AVX):
         super().__init__(**kwargs)
 
 
-class X86AVX512(X86Scalar):
+class X86AVX512(X86SSE):
     name = "x86_avx512"
     BITS = 512
 

{carm_roofline-1.0.0.dev4 → carm_roofline-1.0.1.dev0}/benchmark/interface.py

@@ -9,7 +9,6 @@ This module coordinates the entire benchmark pipeline:
 
 from __future__ import annotations
 
-import tempfile
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -20,6 +19,7 @@ from test_bench.builder import (
     create_microbenchmark_header,
     run_microbenchmarks,
 )
+from workspace import workspace_context
 
 from .benchmark import BaseBenchmark
 from .result import parse_benchmark_output
@@ -120,9 +120,13 @@ def run_full_benchmark(
 
     debug(f"Flattened benchmarks for compilation: {list(flat_benchmarks.keys())}")
 
-    with tempfile.TemporaryDirectory(prefix="carm-test-bench-") as workspace_dir:
+    keep_workspace = context.run_config.dry_run or context.run_config.keep_artifacts
+    with workspace_context(keep=keep_workspace, prefix="carm-benchmark-") as workspace_dir:
         workspace = Path(workspace_dir)
 
+        if keep_workspace:
+            detail(f"Artifacts will be kept in: {workspace}")
+
         # Keep generated artifacts in a writable temporary workspace.
         # Static C sources remain in-package and are included explicitly at compile time.
         generated_header = workspace / "microbenchmarks.h"

{carm_roofline-1.0.0.dev4 → carm_roofline-1.0.1.dev0}/benchmark/suites/memory.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from collections.abc import Iterator
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
@@ -68,6 +69,11 @@ class MemoryBenchmarkSuite(ISABenchmarkSuite):
 
         previous_size_per_thread: Bytes | None = None
 
+        # Iterator over user-provided per-level sizes (if any)
+        user_sizes: Iterator[Bytes | None] | None = None
+        if benchmark.mem_test_sizes is not None:
+            user_sizes = iter(benchmark.mem_test_sizes)
+
         mem_level_indices = architecture.memory_topology.available_cache_levels()
         # Generate memory benchmarks for each memory level
         for mem_level_idx, mem_level_info in zip(mem_level_indices, architecture.memory_topology):
@@ -76,7 +82,7 @@ class MemoryBenchmarkSuite(ISABenchmarkSuite):
             # Plan thread affinity for this memory level
             thread_affinity = architecture.memory_topology.plan_thread_affinity(benchmark.threads, mem_level_idx)
             avail_size_per_thread: Bytes = thread_affinity.total_cache_bytes // thread_affinity.num_threads
-            is_first_target = mem_level_idx == mem_level_indices[0]
+            _is_first_target = mem_level_idx == mem_level_indices[0]
             is_final_target = mem_level_idx == mem_level_indices[-1]
 
             if is_final_target and previous_size_per_thread is not None:
@@ -84,6 +90,13 @@ class MemoryBenchmarkSuite(ISABenchmarkSuite):
             else:
                 target_size_per_thread = avail_size_per_thread * _CACHE_COVERAGE
 
+            # Override with user-provided size (if any) for this cache level.
+            # A None entry in the list (from "auto") keeps the computed value.
+            if user_sizes is not None:
+                user_size = next(user_sizes, None)
+                if user_size is not None:
+                    target_size_per_thread = user_size
+
             # Warn if the per-thread dataset also fits in a smaller (closer-to-CPU) cache level.
             # E.g. targeting L3 with 16 threads, but per-thread data fits in each thread's L2:
             # the hardware will serve requests from L2, not L3, skewing the bandwidth result.
@@ -99,7 +112,8 @@ class MemoryBenchmarkSuite(ISABenchmarkSuite):
                     )
 
             # Generate memory benchmark for this level
-            layout_mode = MemoryLayoutMode.single if is_first_target else MemoryLayoutMode.split
+            # Use split layout only for the DRAM
+            layout_mode = MemoryLayoutMode.split if is_final_target else MemoryLayoutMode.single
             params = MemoryBenchmarkParams(
                 data_type=data_type,
                 thread_affinity=thread_affinity.cpu_ids,

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

@@ -65,7 +65,7 @@ class RooflineBenchmarkSuite(ISABenchmarkSuite):
         for bench in self.get_memory_benchmarks().values():
             if bench.cache_level is None:
                 raise ValueError(
-                    f"Memory benchmark {bench.name} missing cache level annotation for roofline benchmarking"
+                    f"Memory benchmark {bench.name} missing cache level annotation for roofline benchmarki>ng"
                 )
             if bench.results is None:
                 raise ValueError(f"Memory benchmark {bench.name} missing bandwidth result for roofline benchmarking")