codegreen 0.4.9__tar.gz → 0.5.0__tar.gz

{codegreen-0.4.9 → codegreen-0.5.0}/CMakeLists.txt

@@ -46,15 +46,8 @@ include_directories(${CMAKE_SOURCE_DIR}/codegreen/measurement/include)
 add_subdirectory(codegreen/measurement)
 
 
-# Copy config to build dir
-if(EXISTS "${CMAKE_SOURCE_DIR}/config/codegreen.json")
-    file(MAKE_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/config)
-    configure_file(
-        ${CMAKE_SOURCE_DIR}/config/codegreen.json
-        ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/config/codegreen.json
-        COPYONLY
-    )
-endif()
+# NEMB finds its config at <library dir>/../config.json; place the bundled one there so the build tree works
+configure_file(${CMAKE_SOURCE_DIR}/codegreen/config.json ${CMAKE_BINARY_DIR}/config.json COPYONLY)
 
 # Dev-install: copy NEMB library to project root for pip editable installs
 add_custom_target(dev-install ALL
@@ -73,17 +66,13 @@ install(TARGETS codegreen-nemb
     RUNTIME DESTINATION lib
 )
 
+install(FILES ${CMAKE_SOURCE_DIR}/codegreen/config.json DESTINATION share/codegreen)  # <prefix>/lib/../share/codegreen
+
 install(FILES
     ${CMAKE_SOURCE_DIR}/codegreen/instrumentation/language_runtimes/python/codegreen_runtime.py
     DESTINATION bin/runtime
 )
 
-if(EXISTS "${CMAKE_SOURCE_DIR}/config/codegreen.json")
-    install(FILES ${CMAKE_SOURCE_DIR}/config/codegreen.json
-        DESTINATION bin/config
-    )
-endif()
-
 set(CPACK_PACKAGE_NAME "CodeGreen")
 set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Energy-aware software development tool")

{codegreen-0.4.9 → codegreen-0.5.0}/MANIFEST.in

@@ -1,5 +1,4 @@
 include README.md LICENSE requirements.txt pyproject.toml CMakeLists.txt setup.py
-include config/codegreen.json
 
 recursive-include codegreen/measurement CMakeLists.txt *.cpp *.c *.h *.hpp
 recursive-include codegreen/instrumentation/language_runtimes *.py *.h *.hpp *.java

{codegreen-0.4.9/codegreen.egg-info → codegreen-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegreen
-Version: 0.4.9
+Version: 0.5.0
 Summary: Know the true energy cost of your code
 Author-email: Saurabhsingh Rajput <saurabh@dal.ca>
 Maintainer-email: Saurabhsingh Rajput <saurabh@dal.ca>
@@ -637,7 +637,7 @@ See `codegreen/analysis/efg/README.md` for the module layout, a runnable example
 ```bash
 # Fail pipeline if energy exceeds budget
 codegreen run --budget 10.0 --json -- python tests/benchmark.py
-# Exit code 1 if mean energy > 10 Joules
+# Exit code 1 if mean energy > 10 Joules, 3 if the measurement is invalid (see validity.reasons)
 ```
 
 ## Upgrading

{codegreen-0.4.9 → codegreen-0.5.0}/README.md

@@ -192,7 +192,7 @@ See `codegreen/analysis/efg/README.md` for the module layout, a runnable example
 ```bash
 # Fail pipeline if energy exceeds budget
 codegreen run --budget 10.0 --json -- python tests/benchmark.py
-# Exit code 1 if mean energy > 10 Joules
+# Exit code 1 if mean energy > 10 Joules, 3 if the measurement is invalid (see validity.reasons)
 ```
 
 ## Upgrading

{codegreen-0.4.9 → codegreen-0.5.0}/benchmark/__main__.py

@@ -1,9 +1,9 @@
 """Entry point for `python3 -m benchmark`."""
 import argparse
-import sys
 from pathlib import Path
 from benchmark.config import BenchmarkConfig
 from benchmark.harness import BenchmarkHarness
+from benchmark.suites.benchmarksgame import BenchmarksgameSuite
 
 def main():
     parser = argparse.ArgumentParser(description="CodeGreen Energy Benchmark Suite")
@@ -18,27 +18,23 @@ def main():
     args = parser.parse_args()
 
     config = BenchmarkConfig.from_yaml(args.config) if args.config else BenchmarkConfig.default()
-    harness = BenchmarkHarness(config)
+    suite = BenchmarksgameSuite(Path(config.benchmarks_dir) if config.benchmarks_dir else None,
+                                languages=args.languages, problems=args.problems, sizes=args.sizes)
+    harness = BenchmarkHarness(suite, repetitions=args.repetitions, warmup_runs=config.warmup_runs,
+                               timeout_seconds=config.timeout_seconds, min_runtime_seconds=config.min_runtime_seconds)
 
     try:
-        collector = harness.run_suite(
-            problems=args.problems,
-            languages=args.languages,
-            sizes=args.sizes,
-            profilers=args.profilers,
-            repetitions=args.repetitions,
-        )
+        collector = harness.run_suite(profilers=args.profilers, repetitions=args.repetitions)
         summaries = collector.summarize_all()
         print(f"\n{'='*60}")
         print(f"Results: {len(collector.results)} runs")
         print(f"{'='*60}")
         for key, data in sorted(summaries.items()):
-            e = data.get("energy")
-            t = data.get("time")
-            valid = data.get("valid_runs", 0)
-            total = data.get("total_runs", 0)
+            e, t = data["energy"], data["time"]
             energy_str = f"{e.mean:.4f} +/- {e.std:.4f} J" if e else "N/A"
-            print(f"  {key}: energy={energy_str}  time={t.mean:.3f}s  valid={valid}/{total}")
+            time_str = f"{t.mean:.3f}s" if t else "N/A"
+            print(f"  {key}: energy={energy_str}  time={time_str}  valid={data['valid_runs']}/{data['total_runs']}"
+                  f"  invalid={data['invalid_reasons']}")
 
         if args.output:
             collector.to_json(args.output)

{codegreen-0.4.9 → codegreen-0.5.0}/benchmark/config.py

@@ -15,7 +15,7 @@ class SystemState:
     cpu_model: str = ""
     cpu_governor: str = ""
     kernel_version: str = ""
-    rapl_domains: List[str] = field(default_factory=list)
+    power_events: List[str] = field(default_factory=list)
 
     @classmethod
     def capture(cls) -> "SystemState":
@@ -34,17 +34,8 @@ class SystemState:
                 state.cpu_governor = f.read().strip()
         except (FileNotFoundError, OSError):
             pass
-        import os
-        for i in range(10):
-            path = f"/sys/class/powercap/intel-rapl:0:{i}/name"
-            if os.path.exists(path):
-                try:
-                    with open(path) as f:
-                        state.rapl_domains.append(f.read().strip())
-                except OSError:
-                    pass
-            else:
-                break
+        from benchmark.profilers import perf_power_events
+        state.power_events = perf_power_events()
         return state
 
 @dataclass
@@ -66,7 +57,7 @@ class RunResult:
     language: str
     size: str
     profiler: str
-    energy_joules: float
+    energy_joules: Optional[float]
     time_seconds: float
     output_valid: bool
     repetition: int = 0
@@ -74,6 +65,31 @@ class RunResult:
     suite: str = "benchmarksgame"
     timestamp: datetime = field(default_factory=datetime.now)
     checkpoints: List[Dict[str, Any]] = field(default_factory=list)
+    validity: Optional[Dict[str, Any]] = None
+
+    @property
+    def measurement_valid(self) -> bool:
+        """No fatal validity reason; profilers without a validity contract (perf, native) report None."""
+        return self.validity is None or self.validity["status"] == "valid"
+
+# perf power events summed as the CPU-scope truth, mirroring the RAPL adapters' top-level domain rule: the first set
+# whose first event the power PMU offers wins (psys supersedes package + dram), using the offered events of that set.
+PERF_CPU_EVENT_SETS = (("energy-psys",), ("energy-pkg", "energy-ram"))
+
+@dataclass
+class ValidityTolerances:
+    """Expectations of benchmark.validation.experiments.ValidityExperiment. Windows are in sampler intervals
+    (sampler.interval_ms of the run itself); a window below min_window_samples - 1 intervals must be flagged
+    TOTAL_BELOW_RESOLUTION, one at or above min_window_samples + 1 must not, the two intervals between are either (one
+    late reading costs the window a reading). A sampler allowed on fewer than min_affinity_cpus CPUs must raise the
+    AFFINITY_SINGLE_CPU warning and may be SAMPLER_STARVED, as may any run whose reading gaps exceed codegreen's gap policy.
+    cv_max_pct maps a minimum window (s) to the largest CV (%) of valid energies across repetitions."""
+    min_window_samples: int = 2
+    min_affinity_cpus: int = 2
+    exclusive_rel_tol: float = 0.01
+    run_vs_perf_rel_tol: float = 0.03
+    run_vs_perf_min_duration_s: float = 1.0
+    cv_max_pct: Dict[float, float] = field(default_factory=lambda: {1.0: 5.0, 0.1: 10.0})
 
 @dataclass
 class BenchmarkConfig:

{codegreen-0.4.9 → codegreen-0.5.0}/benchmark/harness.py

@@ -3,7 +3,6 @@ import math
 import subprocess
 import sys
 import time
-from pathlib import Path
 from typing import Callable, List, Optional
 
 from benchmark.config import RunResult
@@ -49,11 +48,13 @@ class BenchmarkHarness:
         """Run a single task with a single profiler."""
         reps = repetitions or self.repetitions
         profiler = get_profiler(profiler_name)
+        if not profiler.is_available():
+            self.progress_callback(f"  Skipping {task.name} [{profiler_name}]: {profiler.unavailable_reason()}")
+            return []
+        # Build the task (compile, construct run command); the build may name the source anew (Java public class)
+        task = self.suite.build(task)
         if hasattr(profiler, 'set_source') and task.source_file:
             profiler.set_source(task.source_file, task.language)
-
-        # Build the task (compile, construct run command)
-        task = self.suite.build(task)
         if not task.run_command:
             self.progress_callback(f"  No run command for {task.name}, skipping")
             return []
@@ -96,6 +97,7 @@ class BenchmarkHarness:
                     variant=task.variant,
                     suite=self.suite.name,
                     checkpoints=profile_result.checkpoints,
+                    validity=profile_result.validity,
                 )
                 results.append(result)
                 self.collector.add(result)
@@ -105,6 +107,22 @@ class BenchmarkHarness:
                 self.progress_callback(f"  Run {i+1} failed: {e}")
         return results
 
+    def tasks(self, problem: str, languages: List[str], sizes: Optional[List[str]] = None) -> List[Task]:
+        """Tasks of one problem at the given languages and sizes (suite defaults when None); the default suite is
+        benchmarksgame."""
+        if self.suite is None:
+            from benchmark.suites.benchmarksgame import BenchmarksgameSuite
+            self.suite = BenchmarksgameSuite()
+        found = self.suite.discover({"problems": [problem], "languages": languages, "sizes": sizes})
+        if not found:
+            raise ValueError(f"{self.suite.name} has no task for {problem} in {languages} at sizes {sizes}")
+        return found
+
+    def run_problem(self, problem: str, languages: List[str], sizes: List[str], profilers: List[str],
+                    repetitions: Optional[int] = None) -> List[RunResult]:
+        """Run one problem for every language, size and profiler; returns the results of all runs."""
+        return [r for t in self.tasks(problem, languages, sizes) for p in profilers for r in self.run_task(t, p, repetitions)]
+
     def run_suite(self, profilers: Optional[List[str]] = None,
                   repetitions: Optional[int] = None,
                   filters: Optional[dict] = None) -> ResultCollector:

{codegreen-0.4.9 → codegreen-0.5.0}/benchmark/profilers.py

@@ -1,21 +1,27 @@
 """Energy profiler interfaces for CodeGreen and perf RAPL."""
 import json
+import os
 import re
+import shlex
+import shutil
 import subprocess
 import tempfile
 import time
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
+
+from benchmark.config import PERF_CPU_EVENT_SETS
 
 @dataclass
 class ProfileResult:
-    energy_joules: float
+    energy_joules: Optional[float]
     time_seconds: float
     output: str
     checkpoints: List[Dict[str, Any]]
     raw_data: Dict[str, Any]
+    validity: Optional[Dict[str, Any]] = None
 
 class ProfilerInterface(ABC):
     @abstractmethod
@@ -26,11 +32,22 @@ class ProfilerInterface(ABC):
     def is_available(self) -> bool:
         pass
 
+    def unavailable_reason(self) -> str:
+        return f"{type(self).__name__} is not available on this host"
+
+def perf_power_events() -> List[str]:
+    """RAPL events the kernel power PMU offers through perf (empty without perf or without a power PMU)."""
+    if not shutil.which("perf"):
+        return []
+    out = subprocess.run(["perf", "list", "power"], capture_output=True, text=True, timeout=60).stdout
+    return sorted(set(re.findall(r"power/(energy-[\w-]+)/", out)))
+
 class CodeGreenProfiler(ProfilerInterface):
     """Uses codegreen measure CLI for energy measurement."""
     def __init__(self):
         self.source_path: Path | None = None
         self.language: str | None = None
+        self.extra_args: List[str] = []
 
     def set_source(self, source: Path, language: str = None):
         """Set source file and language for measurement."""
@@ -46,25 +63,31 @@ class CodeGreenProfiler(ProfilerInterface):
             if cmd[0] == "python3":
                 args = cmd[2:] if len(cmd) > 2 else []
             elif cmd[0] == "java":
-                args = cmd[3:] if len(cmd) > 3 else []  # java -cp dir class args
+                args = cmd[4:]  # java -cp dir class args
             else:
                 args = cmd[1:] if len(cmd) > 1 else []  # binary args
         else:
             # Fallback: detect from command
             lang, source, args = self._detect_from_cmd(cmd)
 
-        import os
-        full_cmd = ["codegreen", "measure", lang, source, "--json", "--timeout", str(timeout)] + args
+        full_cmd = ["codegreen", "measure", lang, source, "--json", "--timeout", str(timeout), *self.extra_args] + args
         env = {**os.environ, "PYTHONUNBUFFERED": "1"}
 
         start = time.perf_counter()
         result = subprocess.run(full_cmd, capture_output=True, text=True, timeout=timeout + 30, env=env)
         elapsed = time.perf_counter() - start
-
-        energy, checkpoints, raw, program_output = self._parse_output(result.stdout)
-        if energy <= 0.0 and checkpoints:
-            energy = 0.0
-        return ProfileResult(energy_joules=energy, time_seconds=elapsed, output=program_output, checkpoints=checkpoints, raw_data=raw)
+        # The JSON result is printed on every exit code (exit 3 = invalid measurement); signed energy is kept as reported.
+        try:
+            raw = json.loads(result.stdout)
+        except json.JSONDecodeError:
+            raise RuntimeError(f"codegreen measure exit {result.returncode} without a JSON result: {result.stderr[-500:]}")
+        validity = raw.get("validity")
+        if validity is None or result.returncode not in (0, 3):
+            detail = {**(validity or {}).get("detail", {}),
+                      "MEASURE_FAILED": raw.get("error") or f"codegreen measure exit {result.returncode}"}
+            validity = {**(validity or {"warnings": {}}), "status": "invalid", "reasons": list(detail), "detail": detail}
+        return ProfileResult((raw.get("summary") or {}).get("total_energy_j"), elapsed, "",
+                             raw.get("checkpoints") or [], raw, validity)
 
     def _detect_from_cmd(self, cmd: List[str]) -> tuple:
         """Fallback: detect language, source, args from command."""
@@ -72,118 +95,56 @@ class CodeGreenProfiler(ProfilerInterface):
             return "python", cmd[1] if len(cmd) > 1 else cmd[0], cmd[2:] if len(cmd) > 2 else []
         elif cmd[0] == "java":
             # java -cp dir class args -> need source from set_source
-            return "java", str(self.source_path) if self.source_path else "", cmd[3:] if len(cmd) > 3 else []
+            return "java", str(self.source_path) if self.source_path else "", cmd[4:]
         else:
             # Compiled binary
             source = str(self.source_path) if self.source_path else cmd[0]
             lang = "cpp" if (".gpp" in source or "cpp" in source) else "c"
             return lang, source, cmd[1:] if len(cmd) > 1 else []
 
-    def _parse_output(self, stdout: str) -> tuple:
-        energy, checkpoints, raw, program_output = 0.0, [], {}, ""
-        try:
-            raw = json.loads(stdout)
-        except (json.JSONDecodeError, ValueError):
-            return energy, checkpoints, raw, stdout
-
-        # Extract energy from summary (primary) or checkpoints (fallback)
-        summary = raw.get("summary", {})
-        if summary.get("total_energy_j", 0) > 0:
-            energy = summary["total_energy_j"]
-
-        checkpoints = raw.get("checkpoints", [])
-        if energy <= 0 and len(checkpoints) >= 2:
-            first_j = checkpoints[0].get("joules", 0)
-            last_j = checkpoints[-1].get("joules", 0)
-            energy = last_j - first_j
-            if energy < 0:
-                energy = 0.0
-
-        return energy, checkpoints, raw, program_output
-
     def is_available(self) -> bool:
-        try:
-            with open("/sys/class/powercap/intel-rapl:0/energy_uj") as f:
-                f.read()
-            return True
-        except (FileNotFoundError, PermissionError, OSError):
-            return False
+        return shutil.which("codegreen") is not None
 
 class PerfProfiler(ProfilerInterface):
+    """perf stat -a over the command: system-wide RAPL energy at the CPU domain set of PERF_CPU_EVENT_SETS, the
+    truth source for `codegreen run/measure --sensors rapl`."""
     def __init__(self):
-        self.perf_output_file: Path | None = None
-        self._events = self._detect_events()
+        offered = perf_power_events()
+        self.events = next(([e for e in s if e in offered] for s in PERF_CPU_EVENT_SETS if s[0] in offered), [])
         self.repeat_count: int = 1
 
-    def __del__(self):
-        self._cleanup()
-
-    def _detect_events(self) -> str:
-        try:
-            result = subprocess.run(["perf", "list", "power"], capture_output=True, text=True, timeout=5)
-            events = []
-            if "energy-pkg" in result.stdout:
-                events.append("power/energy-pkg/")
-            if "energy-ram" in result.stdout:
-                events.append("power/energy-ram/")
-            return ",".join(events) if events else "power/energy-pkg/"
-        except Exception:
-            return "power/energy-pkg/"
-
     def run(self, cmd: List[str], timeout: int = 300) -> ProfileResult:
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
-            self.perf_output_file = Path(f.name)
-        if self.repeat_count > 1:
-            shell_cmd = " ".join(f"'{c}'" for c in cmd)
-            loop_cmd = f"for i in $(seq 1 {self.repeat_count}); do {shell_cmd}; done"
-            full_cmd = ["perf", "stat", "-e", self._events, "-o",
-                        str(self.perf_output_file), "--", "bash", "-c", loop_cmd]
-        else:
-            full_cmd = ["perf", "stat", "-e", self._events, "-o",
-                        str(self.perf_output_file), "--"] + cmd
-        start = time.perf_counter()
-        result = subprocess.run(full_cmd, capture_output=True, text=True, timeout=timeout)
-        elapsed = time.perf_counter() - start
-        energy = self._parse_perf_output()
-        if self.repeat_count > 1:
-            energy /= self.repeat_count
-            elapsed /= self.repeat_count
-        return ProfileResult(
-            energy_joules=energy,
-            time_seconds=elapsed,
-            output=result.stdout,
-            checkpoints=[],
-            raw_data={"perf_output": self.perf_output_file.read_text() if self.perf_output_file.exists() else "",
-                       "repeat_count": self.repeat_count}
-        )
-
-    def _parse_perf_output(self) -> float:
-        if not self.perf_output_file or not self.perf_output_file.exists():
-            return 0.0
-        content = self.perf_output_file.read_text()
-        total = 0.0
-        pkg_match = re.search(r'([\d.,]+)\s+Joules\s+power/energy-pkg/', content)
-        if pkg_match:
-            total += float(pkg_match.group(1).replace(',', ''))
-        ram_match = re.search(r'([\d.,]+)\s+Joules\s+power/energy-ram/', content)
-        if ram_match:
-            total += float(ram_match.group(1).replace(',', ''))
-        return total
-
-    def _cleanup(self):
-        if self.perf_output_file and self.perf_output_file.exists():
-            try:
-                self.perf_output_file.unlink()
-            except OSError:
-                pass
-            self.perf_output_file = None
+        body = cmd if self.repeat_count == 1 else [
+            "bash", "-c", f"for i in $(seq {self.repeat_count}); do {shlex.join(cmd)}; done"]
+        with tempfile.NamedTemporaryFile(suffix=".csv", delete=False) as f:
+            out = Path(f.name)
+        try:
+            start = time.perf_counter()
+            result = subprocess.run(["perf", "stat", "-a", "-x,", "-e", ",".join(f"power/{e}/" for e in self.events),
+                                     "-o", str(out), "--", *body], capture_output=True, text=True, timeout=timeout)
+            elapsed = time.perf_counter() - start
+            text = out.read_text()
+        finally:
+            out.unlink()
+        if result.returncode:
+            raise RuntimeError(f"perf stat exit {result.returncode}: {result.stderr[-500:]}")
+        events = {}
+        for f in (line.split(",") for line in text.splitlines()):
+            if len(f) > 2 and f[2].startswith("power/"):
+                if not f[0][:1].isdigit():
+                    raise RuntimeError(f"perf could not count {f[2]}: {f[0]}")
+                events[f[2][6:-1]] = float(f[0]) / self.repeat_count
+        if sorted(events) != sorted(self.events):
+            raise RuntimeError(f"perf counted {sorted(events)}, expected {self.events}")
+        return ProfileResult(sum(events.values()), elapsed / self.repeat_count, result.stdout, [],
+                             {"events_j": events, "repeat_count": self.repeat_count})
 
     def is_available(self) -> bool:
-        try:
-            result = subprocess.run(["perf", "list", "power"], capture_output=True, text=True, timeout=5)
-            return "energy-pkg" in result.stdout
-        except (subprocess.TimeoutExpired, FileNotFoundError):
-            return False
+        return bool(self.events)
+
+    def unavailable_reason(self) -> str:
+        return (f"perf offers none of the power events {PERF_CPU_EVENT_SETS} (`perf list power`: "
+                f"{perf_power_events() or 'none'}); install perf on a host with a RAPL power PMU")
 
 class NativeProfiler(ProfilerInterface):
     """Runs without energy profiling - for baseline timing."""
@@ -192,7 +153,7 @@ class NativeProfiler(ProfilerInterface):
         result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
         elapsed = time.perf_counter() - start
         return ProfileResult(
-            energy_joules=0.0,
+            energy_joules=None,
             time_seconds=elapsed,
             output=result.stdout,
             checkpoints=[],
@@ -208,7 +169,7 @@ class CodeCarbonProfiler(ProfilerInterface):
         try:
             from codecarbon import EmissionsTracker
         except ImportError:
-            return ProfileResult(0.0, 0.0, "", [], {"error": "codecarbon not installed"})
+            raise RuntimeError("codecarbon not installed")
         tracker = EmissionsTracker(log_level="error", save_to_file=False)
         tracker.start()
         start = time.perf_counter()
@@ -220,11 +181,8 @@ class CodeCarbonProfiler(ProfilerInterface):
                              {"emissions_kg_co2": emissions, "energy_kwh": tracker._total_energy.kWh})
 
     def is_available(self) -> bool:
-        try:
-            import codecarbon
-            return True
-        except ImportError:
-            return False
+        import importlib.util
+        return importlib.util.find_spec("codecarbon") is not None
 
 
 class JoularJXProfiler(ProfilerInterface):
@@ -240,7 +198,7 @@ class JoularJXProfiler(ProfilerInterface):
 
     def run(self, cmd: List[str], timeout: int = 300) -> ProfileResult:
         if not self.agent_path:
-            return ProfileResult(0.0, 0.0, "", [], {"error": "JoularJX agent not found"})
+            raise RuntimeError("JoularJX agent not found")
         jx_cmd = cmd.copy()
         if cmd[0] == "java":
             jx_cmd.insert(1, f"-javaagent:{self.agent_path}")
@@ -253,7 +211,7 @@ class JoularJXProfiler(ProfilerInterface):
     def _parse_joularjx_output(self) -> float:
         csv_path = Path("joularJX-all-methods-energy.csv")
         if not csv_path.exists():
-            return 0.0
+            raise RuntimeError(f"JoularJX wrote no {csv_path}")
         total = 0.0
         for line in csv_path.read_text().splitlines()[1:]:
             parts = line.split(",")