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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-roofline
-Version: 1.0.0.dev3
+Version: 1.0.0.dev4
 Summary: CARM: Cache-Aware Roofline Model benchmarking and visualization toolkit
 Author: CHaMP Team
 License:                   GNU LESSER GENERAL PUBLIC LICENSE

{carm_roofline-1.0.0.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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.dev3 → 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.
 

{carm_roofline-1.0.0.dev3 → carm_roofline-1.0.0.dev4}/carm_roofline.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-roofline
-Version: 1.0.0.dev3
+Version: 1.0.0.dev4
 Summary: CARM: Cache-Aware Roofline Model benchmarking and visualization toolkit
 Author: CHaMP Team
 License:                   GNU LESSER GENERAL PUBLIC LICENSE

{carm_roofline-1.0.0.dev3 → carm_roofline-1.0.0.dev4}/pyproject.toml

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

{carm_roofline-1.0.0.dev3 → carm_roofline-1.0.0.dev4}/carm.py

@@ -1,6 +1,6 @@
+#!/usr/bin/env python3
 from __future__ import annotations
 
-#!/usr/bin/env python3
 import argparse
 import sys
 import traceback