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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-roofline
-Version: 1.0.2.dev1
+Version: 1.0.2.dev2
 Summary: CARM: Cache-Aware Roofline Model benchmarking and visualization toolkit
 Author: CHaMP Team
 License:                                  Apache License
@@ -246,7 +246,6 @@ Dynamic: license-file
 
 # The CARM Tool
 
-
 Cache-Aware Roofline Model (CARM) toolkit - benchmark, visualize and profile Intel, AMD, ARM, RISC-V CPUs and NVIDIA, AMD GPUs.
 
 The package provides:
@@ -258,6 +257,10 @@ The package provides:
 > [!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.
 
+## Documentation
+
+You can find the full documentation at [https://champ-hub.github.io/carm-roofline](https://champ-hub.github.io/carm-roofline/).
+
 ## Installation
 
 Install from PyPI:
@@ -279,10 +282,17 @@ source carm-env/bin/activate
 pip install carm-roofline[all]
 ```
 
+If cloning the repository directly (e.g. for development or access to example applications), use `--recurse-submodules` to also fetch the examples:
+
+```bash
+git clone --recurse-submodules https://github.com/champ-hub/carm-roofline
+```
+
 ## Requirements
 
 - Python 3.9+
-- GCC (for compiling benchmark binaries)
+- C compiler (e.g. gcc, clang)
+- Optional: [PAPI](https://github.com/icl-utk-edu/papi) headers and binaries for profiling
 
 ## Command-Line Interface
 
@@ -296,7 +306,7 @@ Available subcommands:
 
 - `benchmark` - run benchmark suites
 - `gui` - launch the results dashboard
-- `profile` - coming soon
+- `profile` - profile an application with PAPI or perf
 
 Show help:
 
@@ -304,6 +314,7 @@ Show help:
 carm --help
 carm benchmark --help
 carm gui --help
+carm profile --help
 ```
 
 ## Basic Usage

{carm_roofline-1.0.2.dev1 → carm_roofline-1.0.2.dev2}/README.md

@@ -1,7 +1,6 @@
 
 # The CARM Tool
 
-
 Cache-Aware Roofline Model (CARM) toolkit - benchmark, visualize and profile Intel, AMD, ARM, RISC-V CPUs and NVIDIA, AMD GPUs.
 
 The package provides:
@@ -13,6 +12,10 @@ The package provides:
 > [!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.
 
+## Documentation
+
+You can find the full documentation at [https://champ-hub.github.io/carm-roofline](https://champ-hub.github.io/carm-roofline/).
+
 ## Installation
 
 Install from PyPI:
@@ -34,10 +37,17 @@ source carm-env/bin/activate
 pip install carm-roofline[all]
 ```
 
+If cloning the repository directly (e.g. for development or access to example applications), use `--recurse-submodules` to also fetch the examples:
+
+```bash
+git clone --recurse-submodules https://github.com/champ-hub/carm-roofline
+```
+
 ## Requirements
 
 - Python 3.9+
-- GCC (for compiling benchmark binaries)
+- C compiler (e.g. gcc, clang)
+- Optional: [PAPI](https://github.com/icl-utk-edu/papi) headers and binaries for profiling
 
 ## Command-Line Interface
 
@@ -51,7 +61,7 @@ Available subcommands:
 
 - `benchmark` - run benchmark suites
 - `gui` - launch the results dashboard
-- `profile` - coming soon
+- `profile` - profile an application with PAPI or perf
 
 Show help:
 
@@ -59,6 +69,7 @@ Show help:
 carm --help
 carm benchmark --help
 carm gui --help
+carm profile --help
 ```
 
 ## Basic Usage

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

@@ -5,7 +5,13 @@ import contextvars
 from exec_interface import ExecutionInterface
 
 from .architecture import Architecture
-from .identity import MachineSignature, detect_machine_signature, generate_run_name, signature_from_architecture
+from .identity import (
+    MachineSignature,
+    detect_machine_signature,
+    generate_run_name,
+    signature_from_architecture,
+    write_machine_json,
+)
 from .memory import SimpleMemoryTopology
 
 # Context variable to hold the execution interface, for compatibility with simulation and native execution
@@ -31,4 +37,5 @@ __all__ = [
     "get_execution_interface",
     "set_execution_interface",
     "signature_from_architecture",
+    "write_machine_json",
 ]

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

@@ -11,6 +11,8 @@ machine yields the same name across runs.
 from __future__ import annotations
 
 import hashlib
+import json
+import os
 import platform
 import re
 from dataclasses import dataclass
@@ -22,6 +24,8 @@ from .memory import MemoryLevelInfo, MemoryTopology, MemoryTopologyLike
 if TYPE_CHECKING:
     from .architecture import Architecture
 
+_BYTES_PER_GIB = 1024**3
+
 
 @dataclass(frozen=True)
 class CpuInfo:
@@ -55,17 +59,52 @@ class MachineSignature:
     vendor: str
     memory_levels: tuple[MemoryLevelSignature, ...]
 
+    def _canonical_hash_string(self) -> str:
+        """Canonical string fed to SHA-256 for the config hash.
+
+        Format: ``arch=<arch>;vendor=<vendor>;levels=<levels>`` where
+        ``<levels>`` is a ``|``-separated list of
+        ``<name>:<size_bytes>:<instances>:<num_sharing_threads>``.
+        """
+        levels_str = "|".join(
+            f"{lvl.name}:{lvl.size_bytes}:{lvl.instances}:{lvl.num_sharing_threads}" for lvl in self.memory_levels
+        )
+        return f"arch={self.arch};vendor={self.vendor};levels={levels_str}"
+
     @property
     def config_hash(self) -> str:
         """Deterministic 8-char hex SHA256 of non-model-name fields.
 
         Hash inputs: arch, vendor, memory_levels (name, size, instances, sharing).
+
+        .. note::
+            DRAM ``size_bytes`` comes from ``/proc/zoneinfo`` ``present`` pages
+            (physical capacity, stable across reboots).  Falls back to a
+            rounded-``MemTotal`` value when zoneinfo is unavailable.
+            ``num_sharing_threads`` is set to 0 for DRAM (not a hardware
+            property; CPU online count may vary).  Cache-level fields are
+            used verbatim.
         """
-        levels_str = "|".join(
-            f"{lvl.name}:{lvl.size_bytes}:{lvl.instances}:{lvl.num_sharing_threads}" for lvl in self.memory_levels
-        )
-        canonical = f"arch={self.arch};vendor={self.vendor};levels={levels_str}"
-        return hashlib.sha256(canonical.encode("utf-8")).hexdigest()[:8]
+        return hashlib.sha256(self._canonical_hash_string().encode("utf-8")).hexdigest()[:8]
+
+    def to_dict(self) -> dict[str, object]:
+        """Serialize all fields for machine.json debugging output."""
+        return {
+            "model_name": self.model_name,
+            "arch": self.arch,
+            "vendor": self.vendor,
+            "config_hash": self.config_hash,
+            "hash_input": self._canonical_hash_string(),
+            "memory_levels": [
+                {
+                    "name": lvl.name,
+                    "size_bytes": lvl.size_bytes,
+                    "instances": lvl.instances,
+                    "num_sharing_threads": lvl.num_sharing_threads,
+                }
+                for lvl in self.memory_levels
+            ],
+        }
 
 
 def read_cpuinfo() -> CpuInfo:
@@ -102,21 +141,69 @@ def read_cpuinfo() -> CpuInfo:
     return CpuInfo(model_name=model_name, vendor=vendor)
 
 
+def _get_physical_ram_bytes() -> int | None:
+    """Total physical RAM (bytes) from ``/proc/zoneinfo``, or ``None``.
+
+    Sums the ``present`` field across all zones — this is the number of
+    physical pages present, derived from the firmware's e820/device-tree
+    memory map at boot.  It reflects hardware capacity and is stable across
+    reboots, unlike ``MemTotal`` which subtracts kernel runtime reservations.
+    """
+    try:
+        with open("/proc/zoneinfo") as f:
+            total_present = 0
+            for line in f:
+                parts = line.strip().split()
+                if len(parts) == 2 and parts[0] == "present":
+                    total_present += int(parts[1])
+        return total_present * os.sysconf("SC_PAGE_SIZE")
+    except (OSError, ValueError):
+        return None
+
+
 def _levels_from_topology(topology: MemoryTopologyLike | None) -> tuple[MemoryLevelSignature, ...]:
-    """Convert a memory topology to a tuple of deterministic level signatures."""
+    """Convert a memory topology to a tuple of deterministic level signatures.
+
+    DRAM levels use the ``present`` page count from ``/proc/zoneinfo`` (a
+    hardware-capacity value stable across reboots).  Falls back to rounding
+    the topology's ``MemTotal``-based size to the nearest GiB when zoneinfo
+    is unavailable (containers, odd kernels).
+
+    ``num_sharing_threads`` is set to 0 for DRAM (not a hardware property;
+    ``shared_cpu_list`` varies with CPU online count).
+
+    Cache levels (L1/L2/L3) are passed through unchanged.
+    """
+    # Read physical RAM once — stable firmware value
+    physical_ram = _get_physical_ram_bytes()
+
     if topology is None:
         return ()
     levels: list[MemoryLevelSignature] = []
     for lvl in topology:
         if isinstance(lvl, MemoryLevelInfo):
-            levels.append(
-                MemoryLevelSignature(
-                    name=lvl.name,
-                    size_bytes=int(lvl.size),
-                    instances=lvl.instances,
-                    num_sharing_threads=lvl.num_sharing_threads,
+            if lvl.name == "DRAM":
+                if physical_ram is not None:
+                    size_bytes = physical_ram
+                else:
+                    size_bytes = round(int(lvl.size) / _BYTES_PER_GIB) * _BYTES_PER_GIB
+                levels.append(
+                    MemoryLevelSignature(
+                        name=lvl.name,
+                        size_bytes=size_bytes,
+                        instances=lvl.instances,
+                        num_sharing_threads=0,
+                    )
+                )
+            else:
+                levels.append(
+                    MemoryLevelSignature(
+                        name=lvl.name,
+                        size_bytes=int(lvl.size),
+                        instances=lvl.instances,
+                        num_sharing_threads=lvl.num_sharing_threads,
+                    )
                 )
-            )
     return tuple(levels)
 
 
@@ -206,3 +293,18 @@ def _short_model_name(name: str) -> str:
 def generate_run_name(signature: MachineSignature) -> str:
     """Generate ``"<short_model>_<config_hash>"`` (e.g. ``"Ryzen-7-7735HS_59486dd1"``)."""
     return f"{_short_model_name(signature.model_name)}_{signature.config_hash}"
+
+
+def write_machine_json(signature: MachineSignature, directory: Path) -> None:
+    """Write machine.json to *directory* if it does not already exist.
+
+    The file contains the full MachineSignature serialized as JSON, including
+    all hash inputs and the computed hash, so future runs can debug why a
+    machine hash changed.
+    """
+    path = directory / "machine.json"
+    if path.exists():
+        return
+    directory.mkdir(parents=True, exist_ok=True)
+    with open(path, "x", encoding="utf-8") as f:
+        json.dump(signature.to_dict(), f, indent=2, sort_keys=True)

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

@@ -17,6 +17,7 @@ from architecture import (
     generate_run_name,
     set_execution_interface,
     signature_from_architecture,
+    write_machine_json,
 )
 from arguments import InsertsArguments, TopLevelHelpFormatter
 from benchmark.interface import run_full_benchmark
@@ -58,8 +59,9 @@ def _handle_benchmark(args: argparse.Namespace) -> int:
     # Make exec_iface globally available for architecture feature detection
     set_execution_interface(exec_iface)
     architecture = Architecture(args)
+    signature = signature_from_architecture(architecture)
     if args.name is None:
-        args.name = generate_run_name(signature_from_architecture(architecture))
+        args.name = generate_run_name(signature)
     benchmarking = Benchmarking(args)
     run_config = RunConfig(args)
 
@@ -73,6 +75,7 @@ def _handle_benchmark(args: argparse.Namespace) -> int:
         detail("Dry run finished: benchmark code generated successfully.")
         return 0
 
+    write_machine_json(signature, run_config.output_dir / run_config.name)
     output_benchmark_results(context, benchmark_suites)
     return 0
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-roofline
-Version: 1.0.2.dev1
+Version: 1.0.2.dev2
 Summary: CARM: Cache-Aware Roofline Model benchmarking and visualization toolkit
 Author: CHaMP Team
 License:                                  Apache License
@@ -246,7 +246,6 @@ Dynamic: license-file
 
 # The CARM Tool
 
-
 Cache-Aware Roofline Model (CARM) toolkit - benchmark, visualize and profile Intel, AMD, ARM, RISC-V CPUs and NVIDIA, AMD GPUs.
 
 The package provides:
@@ -258,6 +257,10 @@ The package provides:
 > [!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.
 
+## Documentation
+
+You can find the full documentation at [https://champ-hub.github.io/carm-roofline](https://champ-hub.github.io/carm-roofline/).
+
 ## Installation
 
 Install from PyPI:
@@ -279,10 +282,17 @@ source carm-env/bin/activate
 pip install carm-roofline[all]
 ```
 
+If cloning the repository directly (e.g. for development or access to example applications), use `--recurse-submodules` to also fetch the examples:
+
+```bash
+git clone --recurse-submodules https://github.com/champ-hub/carm-roofline
+```
+
 ## Requirements
 
 - Python 3.9+
-- GCC (for compiling benchmark binaries)
+- C compiler (e.g. gcc, clang)
+- Optional: [PAPI](https://github.com/icl-utk-edu/papi) headers and binaries for profiling
 
 ## Command-Line Interface
 
@@ -296,7 +306,7 @@ Available subcommands:
 
 - `benchmark` - run benchmark suites
 - `gui` - launch the results dashboard
-- `profile` - coming soon
+- `profile` - profile an application with PAPI or perf
 
 Show help:
 
@@ -304,6 +314,7 @@ Show help:
 carm --help
 carm benchmark --help
 carm gui --help
+carm profile --help
 ```
 
 ## Basic Usage

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

@@ -28,6 +28,7 @@ from .shared import (
     MetricDefinition,
     MetricResolutionConfig,
     MetricType,
+    RooflinePoint,
     compute_region_point,
     sum_roofline_points,
 )
@@ -43,6 +44,7 @@ __all__ = [
     "ProfilerBackend",
     "RankMetrics",
     "RegionMetrics",
+    "RooflinePoint",
     "RunMetadata",
     "RunResults",
     "ThreadMetrics",

{carm_roofline-1.0.2.dev1 → carm_roofline-1.0.2.dev2}/profiling/aggregation.py

@@ -25,6 +25,7 @@ from .shared import (
     MetricContext,
     MetricDefinition,
     MetricType,
+    RooflinePoint,
     compute_region_point,
     sum_roofline_points,
 )
@@ -59,7 +60,7 @@ def _region_points(
     regions: list[RegionMetrics],
     resolved: dict[MetricType, MetricDefinition],
     metric_ctx: MetricContext,
-) -> list[dict[str, float]]:
+) -> list[RooflinePoint]:
     """Compute (flops, bytes, time_s) for each region in a list."""
     return [compute_region_point(r.counters, r.time_nsec, resolved, metric_ctx) for r in regions]
 
@@ -75,17 +76,16 @@ def aggregate_global(
     total time (regions within a thread execute sequentially, threads within
     a rank run in parallel).
     """
-    thread_totals: list[dict[str, float]] = []
+    thread_totals: list[RooflinePoint] = []
     num_regions = 0
     for rank in run.ranks:
         for thread in rank.threads:
             thread_points = _region_points(thread.regions, resolved, metric_ctx)
             thread_totals.append(sum_roofline_points(thread_points))
             num_regions += len(thread_points)
-
-    total_flops = sum(p["flops"] for p in thread_totals)
-    total_bytes = sum(p["bytes"] for p in thread_totals)
-    total_time = max((p["time_s"] for p in thread_totals), default=0.0)
+    total_flops = sum(p.flops for p in thread_totals)
+    total_bytes = sum(p.bytes for p in thread_totals)
+    total_time = max((p.time_s for p in thread_totals), default=0.0)
     num_threads = sum(len(r.threads) for r in run.ranks)
     return AggregatedPoint(
         label=run.metadata.name or "global",
@@ -110,16 +110,16 @@ def aggregate_per_rank(
     """
     points: list[AggregatedPoint] = []
     for rank in run.ranks:
-        thread_totals: list[dict[str, float]] = []
+        thread_totals: list[RooflinePoint] = []
         num_regions = 0
         for thread in rank.threads:
             thread_points = _region_points(thread.regions, resolved, metric_ctx)
             thread_totals.append(sum_roofline_points(thread_points))
             num_regions += len(thread_points)
 
-        total_flops = sum(p["flops"] for p in thread_totals)
-        total_bytes = sum(p["bytes"] for p in thread_totals)
-        total_time = max((p["time_s"] for p in thread_totals), default=0.0)
+        total_flops = sum(p.flops for p in thread_totals)
+        total_bytes = sum(p.bytes for p in thread_totals)
+        total_time = max((p.time_s for p in thread_totals), default=0.0)
         label = f"{run.metadata.name}_rank{rank.rank_id}" if run.metadata.name else f"rank{rank.rank_id}"
         points.append(
             AggregatedPoint(
@@ -154,9 +154,9 @@ def aggregate_per_thread(
             points.append(
                 AggregatedPoint(
                     label=label,
-                    total_flops=total["flops"],
-                    total_bytes=total["bytes"],
-                    runtime_s=total["time_s"],
+                    total_flops=total.flops,
+                    total_bytes=total.bytes,
+                    runtime_s=total.time_s,
                     num_ranks=1,
                     num_threads=1,
                     num_regions=len(thread_points),
@@ -177,7 +177,7 @@ def aggregate_per_region_merged(
     (parallel execution).
     """
     # by_region[region_name][(rank_id, thread_id)] = [point, point, ...]
-    by_region: dict[str, dict[tuple[int, int], list[dict[str, float]]]] = {}
+    by_region: dict[str, dict[tuple[int, int], list[RooflinePoint]]] = {}
 
     for rank in run.ranks:
         for thread in rank.threads:
@@ -192,9 +192,9 @@ def aggregate_per_region_merged(
         # Sum within each thread (sequential calls)
         per_thread_sums = {key: sum_roofline_points(pt_list) for key, pt_list in thread_groups.items()}
 
-        total_flops = sum(p["flops"] for p in per_thread_sums.values())
-        total_bytes = sum(p["bytes"] for p in per_thread_sums.values())
-        total_time = max((p["time_s"] for p in per_thread_sums.values()), default=0.0)
+        total_flops = sum(p.flops for p in per_thread_sums.values())
+        total_bytes = sum(p.bytes for p in per_thread_sums.values())
+        total_time = max((p.time_s for p in per_thread_sums.values()), default=0.0)
 
         rank_ids: set[int] = {rk for (rk, _) in thread_groups}
         label = f"{run.metadata.name}_{name}" if run.metadata.name else name
@@ -235,9 +235,9 @@ def aggregate_per_region_per_thread(
                 points.append(
                     AggregatedPoint(
                         label=label,
-                        total_flops=region_point["flops"],
-                        total_bytes=region_point["bytes"],
-                        runtime_s=region_point["time_s"],
+                        total_flops=region_point.flops,
+                        total_bytes=region_point.bytes,
+                        runtime_s=region_point.time_s,
                         num_ranks=1,
                         num_threads=1,
                         num_regions=1,

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

@@ -6,7 +6,7 @@ import argparse
 from enum import Enum
 from pathlib import Path
 
-from architecture import detect_machine_signature, generate_run_name
+from architecture import MachineSignature, detect_machine_signature, generate_run_name
 from arguments import InsertsArguments, add_verbose_argument, enum_action
 from benchmark.generation import ISA_NAME_TO_CLASS, DataType
 from results_paths import default_results_root
@@ -55,7 +55,6 @@ class ProfileConfig(InsertsArguments):
         verbose: Verbosity level (0-4).
         machine_name: Name for the results directory (each machine gets its own subdirectory).
         app_name: Application name recorded in the output metadata.
-        results_dir: Directory to scan for existing profiling result files.
         keep_artifacts: Whether to keep raw profiling output files.
         papi_events: Optional comma-separated PAPI event override.
         perf_events: Optional comma-separated perf event override.
@@ -71,11 +70,11 @@ class ProfileConfig(InsertsArguments):
         self.aggregation: AggregationMode = args.aggregation
         self.verbose: int = args.verbose
         self.output_dir: Path = args.output_dir
+        self.machine_signature: MachineSignature = detect_machine_signature()
         self.machine_name: str = (
-            args.machine_name if args.machine_name is not None else generate_run_name(detect_machine_signature())
+            args.machine_name if args.machine_name is not None else generate_run_name(self.machine_signature)
         )
         self.app_name: str = args.app_name if args.app_name is not None else _default_app_name(args.command)
-        self.results_dir: Path = args.results_dir
         self.keep_artifacts: bool = args.keep_artifacts
         self.papi_events: str | None = args.papi_events
         self.perf_events: str | None = args.perf_events
@@ -121,12 +120,6 @@ class ProfileConfig(InsertsArguments):
             type=Path,
             help="Directory to write result files (default: platform user data dir for app 'carm')",
         )
-        parser.add_argument(
-            "--results-dir",
-            default=default_results_root() / "profile",
-            type=Path,
-            help="Directory to scan for existing profiling result files (default: <output-dir>/profile)",
-        )
         parser.add_argument(
             "--keep-artifacts",
             action="store_true",

{carm_roofline-1.0.2.dev1 → carm_roofline-1.0.2.dev2}/profiling/output.py

@@ -10,6 +10,7 @@ import csv
 import json
 from datetime import datetime
 
+from architecture import write_machine_json
 from output_utils import detail, info
 
 from .aggregation import AggregatedPoint
@@ -28,7 +29,12 @@ def write_profile_results(
     (GUI-compatible legacy format).  JSONL is written to
     ``<output_dir>/<machine_name>/applications.jsonl`` (one appended line per run,
     embedding run metadata and the aggregated points).
+
+    A ``machine.json`` debugging file is also written to
+    ``<output_dir>/<machine_name>/machine.json`` on the first run.
     """
+    machine_dir = config.output_dir / config.machine_name
+    write_machine_json(config.machine_signature, machine_dir)
     write_applications_csv(points, config, run)
     write_profile_jsonl(run, config, points)
 

{carm_roofline-1.0.2.dev1 → carm_roofline-1.0.2.dev2}/profiling/shared.py

@@ -108,6 +108,22 @@ class MetricDefinition:
     warning: str | None = None
 
 
+@dataclass(frozen=True)
+class RooflinePoint:
+    """Computed roofline metrics for a single region or aggregated set."""
+
+    flops: float = 0.0
+    bytes: float = 0.0
+    time_s: float = 0.0
+
+    def __add__(self, other: RooflinePoint) -> RooflinePoint:
+        return RooflinePoint(
+            flops=self.flops + other.flops,
+            bytes=self.bytes + other.bytes,
+            time_s=self.time_s + other.time_s,
+        )
+
+
 # ---------------------------------------------------------------------------
 # Computing roofline point data from raw counters
 # ---------------------------------------------------------------------------
@@ -118,7 +134,7 @@ def compute_region_point(
     time_nsec: int,
     resolved: dict[MetricType, MetricDefinition],
     metric_ctx: MetricContext,
-) -> dict[str, float]:
+) -> RooflinePoint:
     """Compute (flops, bytes, time_s) for a single region from raw counters.
 
     Only metrics whose required events are all present in *counters* are
@@ -129,8 +145,7 @@ def compute_region_point(
         time_nsec: Wall-clock time in nanoseconds for the region.
         resolved: Resolved metric implementations from ``resolve_metrics()``.
 
-    Returns:
-        A dict with keys ``flops``, ``bytes``, and ``time_s``.
+        A `RooflinePoint` with flops, bytes, and time_s.
     """
     float_counters = {k: float(v) for k, v in counters.items()}
     available_set = frozenset(counters)
@@ -147,23 +162,16 @@ def compute_region_point(
         if impl.required_events <= available_set:
             bytes_val = impl.compute(float_counters, metric_ctx)
 
-    return {
-        "flops": flops,
-        "bytes": bytes_val,
-        "time_s": time_nsec / 1e9,
-    }
+    return RooflinePoint(flops=flops, bytes=bytes_val, time_s=time_nsec / 1e9)
 
 
-def sum_roofline_points(points: list[dict[str, float]]) -> dict[str, float]:
-    """Sum a list of (flops, bytes, time_s) dicts.
+def sum_roofline_points(points: list[RooflinePoint]) -> RooflinePoint:
+    """Sum a list of (flops, bytes, time_s) RooflinePoints.
 
     Flops, bytes, and time are all summed, all points in the list represent
     sequential execution within a single thread.
     """
-    flops = sum(p["flops"] for p in points)
-    bytes_val = sum(p["bytes"] for p in points)
-    time_s = sum(p["time_s"] for p in points)
-    return {"flops": flops, "bytes": bytes_val, "time_s": time_s}
+    return sum(points, start=RooflinePoint())
 
 
 def resolve_metrics(

{carm_roofline-1.0.2.dev1 → carm_roofline-1.0.2.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "carm-roofline"
-version = "1.0.2.dev1"
+version = "1.0.2.dev2"
 description = "CARM: Cache-Aware Roofline Model benchmarking and visualization toolkit"
 readme = "README.md"
 requires-python = ">=3.9"

{carm_roofline-1.0.2.dev1 → carm_roofline-1.0.2.dev2}/test_bench/test_bench.c

@@ -170,6 +170,8 @@ measure_benchmark(const benchmark_metadata_t *metadata, wrapper_fn_t wrapper_fn,
         tdata[i].read_ptr = (void *) ((char *) combined_data + thread_offset);
         tdata[i].write_ptr = (void *) ((char *) combined_data + thread_offset + aligned_read);
         tdata[i].freq = freq;
+        tdata[i].read_size = aligned_read;
+        tdata[i].write_size = aligned_write;
 
 #if VERBOSITY >= 4
         if (tdata[i].read_ptr != NULL) {

{carm_roofline-1.0.2.dev1 → carm_roofline-1.0.2.dev2}/test_bench/test_bench.h

@@ -47,6 +47,8 @@ typedef struct {
     void *read_ptr;  /* Per-thread slice of the read (load) buffer */
     void *write_ptr; /* Per-thread slice of the write (store) buffer */
     float freq;
+    size_t read_size;  /* Per-thread read buffer size (aligned, bytes) */
+    size_t write_size; /* Per-thread write buffer size (aligned, bytes) */
     /* Timing results per thread (nanoseconds) */
     uint64_t *elapsed_ns; /* Elapsed time in nanoseconds */
 } thread_wrapper_data_t;

{carm_roofline-1.0.2.dev1 → carm_roofline-1.0.2.dev2}/test_bench/wrapper.inl

@@ -19,6 +19,13 @@ static void *_WRAPPER_EXPAND(UBENCH_NAME)(void *arg)
     void *read_ptr = tdata->read_ptr;
     void *write_ptr = tdata->write_ptr;
 
+    /* Force COW: write one byte per page so the kernel allocates real physical pages (not the shared zero page). This
+     * ensures NUMA-correct first-touch placement and prevents load-only benchmarks from measuring L1 bandwidth
+     * regardless of working set size. */
+    for (size_t off = 0; off < tdata->read_size; off += 4096)
+        ((volatile char *) read_ptr)[off] = 0;
+    for (size_t off = 0; off < tdata->write_size; off += 4096)
+        ((volatile char *) write_ptr)[off] = 0;
     barrier_sync();
 
     uint64_t reps = CARM_BENCH_START_REPS;