codegreen 0.3.0__tar.gz → 0.3.2__tar.gz

codegreen-0.3.2/CMakeLists.txt

@@ -0,0 +1,113 @@
+cmake_minimum_required(VERSION 3.16)
+project(CodeGreen VERSION 0.3.0 LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif()
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+
+find_package(PkgConfig)
+find_package(Threads REQUIRED)
+
+# Optional GPU library detection
+find_library(NVML_LIBRARY nvidia-ml PATHS /usr/local/cuda/lib64 /usr/lib/x86_64-linux-gnu)
+find_path(NVML_INCLUDE_DIR nvml.h PATHS /usr/local/cuda/include /usr/include/nvidia/gdk)
+find_library(ROCM_SMI_LIBRARY rocm_smi64 PATHS /opt/rocm/lib)
+find_path(ROCM_SMI_INCLUDE_DIR rocm_smi.h PATHS /opt/rocm/include/rocm_smi)
+
+if(NVML_LIBRARY AND NVML_INCLUDE_DIR)
+    message(STATUS "NVML found: ${NVML_LIBRARY}")
+    set(HAVE_NVML ON)
+else()
+    set(HAVE_NVML OFF)
+endif()
+
+if(ROCM_SMI_LIBRARY AND ROCM_SMI_INCLUDE_DIR)
+    message(STATUS "ROCm SMI found: ${ROCM_SMI_LIBRARY}")
+    set(HAVE_ROCM_SMI ON)
+else()
+    set(HAVE_ROCM_SMI OFF)
+endif()
+
+# Global include directories
+include_directories(${CMAKE_SOURCE_DIR}/codegreen/measurement/include)
+
+# Tree-sitter (for C++ instrumentation runtime, if submodules present)
+if(EXISTS "${CMAKE_SOURCE_DIR}/third_party/tree-sitter/lib/CMakeLists.txt")
+    include_directories(${CMAKE_SOURCE_DIR}/third_party/tree-sitter/lib/include)
+    add_subdirectory(third_party/tree-sitter/lib)
+    if(EXISTS "${CMAKE_SOURCE_DIR}/third_party/tree-sitter-python/CMakeLists.txt")
+        add_subdirectory(third_party/tree-sitter-python EXCLUDE_FROM_ALL)
+    endif()
+endif()
+
+# NEMB -- the only native component
+add_subdirectory(codegreen/measurement)
+
+# Sync instrumentation files to build dir (for C/C++/Java runtime headers)
+file(MAKE_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/runtime)
+file(MAKE_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/python/instrumentation)
+
+add_custom_target(sync_instrumentation
+    COMMAND ${CMAKE_COMMAND} -E copy
+        ${CMAKE_SOURCE_DIR}/codegreen/instrumentation/language_runtimes/python/codegreen_runtime.py
+        ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/runtime/codegreen_runtime.py
+    COMMAND ${CMAKE_COMMAND} -E copy_directory
+        ${CMAKE_SOURCE_DIR}/codegreen/instrumentation/language_runtimes
+        ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/python/instrumentation/language_runtimes
+    COMMAND ${CMAKE_COMMAND} -E copy_directory
+        ${CMAKE_SOURCE_DIR}/codegreen/instrumentation/configs
+        ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/python/instrumentation/configs
+    COMMENT "Syncing instrumentation files to build directory"
+)
+
+add_dependencies(codegreen-nemb sync_instrumentation)
+
+# 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()
+
+# Dev-install: copy NEMB library to project root for pip editable installs
+add_custom_target(dev-install ALL
+    DEPENDS codegreen-nemb
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_SOURCE_DIR}/lib
+    COMMAND ${CMAKE_COMMAND} -E copy
+        $<TARGET_FILE:codegreen-nemb>
+        ${CMAKE_SOURCE_DIR}/lib/
+    COMMENT "Dev-install: copying NEMB to ${CMAKE_SOURCE_DIR}/lib/"
+)
+
+# Install
+install(TARGETS codegreen-nemb
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib
+    RUNTIME DESTINATION bin
+)
+
+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")
+include(CPack)

{codegreen-0.3.0/codegreen.egg-info → codegreen-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegreen
-Version: 0.3.0
+Version: 0.3.2
 Summary: Energy-aware software development tool for measuring and optimizing code energy consumption
 Author-email: Saurabhsingh Rajput <saurabh@dal.ca>
 Maintainer-email: Saurabhsingh Rajput <saurabh@dal.ca>
@@ -400,6 +400,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: C++
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
 Classifier: Environment :: Console
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
@@ -468,9 +469,13 @@ sudo codegreen run -- python script.py
 
 | Platform | pip install | Energy measurement | Backend |
 |----------|------------|-------------------|---------|
-| Linux x86_64 (Intel/AMD) | Pre-built wheel | Full | RAPL via NEMB |
-| macOS ARM64 (Apple Silicon) | Pre-built wheel | Full | IOReport + kpc via NEMB |
+| Linux x86_64 (Intel) | Pre-built wheel | Full (PKG, core, iGPU, DRAM) | RAPL via NEMB |
+| Linux x86_64 (AMD) | Pre-built wheel | Full (PKG, no DRAM counter) | RAPL via NEMB |
+| macOS ARM64 (Apple Silicon) | Pre-built wheel | Full (CPU, GPU, ANE, DRAM) | IOReport + kpc via NEMB |
 | macOS Intel | From source | Full | IOReport via NEMB |
+| Windows 11 (Intel) | From source | Full (PKG, core, iGPU, DRAM) | EMI via intelpep.sys |
+| Windows 11 (AMD) | From source | Unverified | EMI may not expose AMD RAPL |
+| NVIDIA GPU (any OS) | Automatic | Full (cumulative mJ) | NVML |
 | Other | From source | Time-only | Fallback |
 
 ### Requirements
@@ -478,6 +483,7 @@ sudo codegreen run -- python script.py
 - Python 3.9+
 - Linux: kernel 5.0+, Intel/AMD CPU with RAPL support
 - macOS: Apple Silicon (M1-M5) or Intel, sudo for energy measurement
+- Windows 11: Intel/AMD CPU (EMI via inbox intelpep.sys driver, zero install)
 - Source builds: CMake 3.16+, C++17 compiler
 
 ## Usage
@@ -555,7 +561,7 @@ Features: Ball & Larus branch heuristics, SCC-based hot path computation, three-
 
 ## Architecture
 
-- **C++ NEMB backend**: platform-aware energy measurement (RAPL on Linux, IOReport on macOS), sub-microsecond timestamping, background polling with lock-free ring buffers
+- **C++ NEMB backend**: platform-aware energy measurement (RAPL on Linux, IOReport on macOS, EMI on Windows), sub-microsecond timestamping, background polling with lock-free ring buffers
 - **Python instrumentation**: tree-sitter AST analysis, config-driven checkpoint insertion
 - **Energy Flow Graph**: CFG + energy annotation for path-dependent analysis
 - **Benchmark harness**: multi-suite support (benchmarksgame, PerfOpt), statistical analysis with t-distribution CI, IQR outlier detection, profiler comparison

{codegreen-0.3.0 → codegreen-0.3.2}/README.md

@@ -37,9 +37,13 @@ sudo codegreen run -- python script.py
 
 | Platform | pip install | Energy measurement | Backend |
 |----------|------------|-------------------|---------|
-| Linux x86_64 (Intel/AMD) | Pre-built wheel | Full | RAPL via NEMB |
-| macOS ARM64 (Apple Silicon) | Pre-built wheel | Full | IOReport + kpc via NEMB |
+| Linux x86_64 (Intel) | Pre-built wheel | Full (PKG, core, iGPU, DRAM) | RAPL via NEMB |
+| Linux x86_64 (AMD) | Pre-built wheel | Full (PKG, no DRAM counter) | RAPL via NEMB |
+| macOS ARM64 (Apple Silicon) | Pre-built wheel | Full (CPU, GPU, ANE, DRAM) | IOReport + kpc via NEMB |
 | macOS Intel | From source | Full | IOReport via NEMB |
+| Windows 11 (Intel) | From source | Full (PKG, core, iGPU, DRAM) | EMI via intelpep.sys |
+| Windows 11 (AMD) | From source | Unverified | EMI may not expose AMD RAPL |
+| NVIDIA GPU (any OS) | Automatic | Full (cumulative mJ) | NVML |
 | Other | From source | Time-only | Fallback |
 
 ### Requirements
@@ -47,6 +51,7 @@ sudo codegreen run -- python script.py
 - Python 3.9+
 - Linux: kernel 5.0+, Intel/AMD CPU with RAPL support
 - macOS: Apple Silicon (M1-M5) or Intel, sudo for energy measurement
+- Windows 11: Intel/AMD CPU (EMI via inbox intelpep.sys driver, zero install)
 - Source builds: CMake 3.16+, C++17 compiler
 
 ## Usage
@@ -124,7 +129,7 @@ Features: Ball & Larus branch heuristics, SCC-based hot path computation, three-
 
 ## Architecture
 
-- **C++ NEMB backend**: platform-aware energy measurement (RAPL on Linux, IOReport on macOS), sub-microsecond timestamping, background polling with lock-free ring buffers
+- **C++ NEMB backend**: platform-aware energy measurement (RAPL on Linux, IOReport on macOS, EMI on Windows), sub-microsecond timestamping, background polling with lock-free ring buffers
 - **Python instrumentation**: tree-sitter AST analysis, config-driven checkpoint insertion
 - **Energy Flow Graph**: CFG + energy annotation for path-dependent analysis
 - **Benchmark harness**: multi-suite support (benchmarksgame, PerfOpt), statistical analysis with t-distribution CI, IQR outlier detection, profiler comparison

{codegreen-0.3.0 → codegreen-0.3.2}/benchmark/profilers.py

@@ -202,11 +202,79 @@ class NativeProfiler(ProfilerInterface):
     def is_available(self) -> bool:
         return True
 
+class CodeCarbonProfiler(ProfilerInterface):
+    """Wraps CodeCarbon for energy measurement (requires: pip install codecarbon)."""
+    def run(self, cmd: List[str], timeout: int = 300) -> ProfileResult:
+        try:
+            from codecarbon import EmissionsTracker
+        except ImportError:
+            return ProfileResult(0.0, 0.0, "", [], {"error": "codecarbon not installed"})
+        tracker = EmissionsTracker(log_level="error", save_to_file=False)
+        tracker.start()
+        start = time.perf_counter()
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+        elapsed = time.perf_counter() - start
+        emissions = tracker.stop()
+        energy = tracker._total_energy.kWh * 3_600_000  # kWh -> J
+        return ProfileResult(energy, elapsed, result.stdout, [],
+                             {"emissions_kg_co2": emissions, "energy_kwh": tracker._total_energy.kWh})
+
+    def is_available(self) -> bool:
+        try:
+            import codecarbon
+            return True
+        except ImportError:
+            return False
+
+
+class JoularJXProfiler(ProfilerInterface):
+    """Wraps JoularJX for Java energy measurement (requires JoularJX agent jar)."""
+    def __init__(self, agent_path: str = ""):
+        self.agent_path = agent_path or self._find_agent()
+
+    def _find_agent(self) -> str:
+        for p in [Path("joularjx-agent.jar"), Path.home() / ".joularjx" / "joularjx-agent.jar"]:
+            if p.exists():
+                return str(p)
+        return ""
+
+    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"})
+        jx_cmd = cmd.copy()
+        if cmd[0] == "java":
+            jx_cmd.insert(1, f"-javaagent:{self.agent_path}")
+        start = time.perf_counter()
+        result = subprocess.run(jx_cmd, capture_output=True, text=True, timeout=timeout)
+        elapsed = time.perf_counter() - start
+        energy = self._parse_joularjx_output()
+        return ProfileResult(energy, elapsed, result.stdout, [], {"agent": self.agent_path})
+
+    def _parse_joularjx_output(self) -> float:
+        csv_path = Path("joularJX-all-methods-energy.csv")
+        if not csv_path.exists():
+            return 0.0
+        total = 0.0
+        for line in csv_path.read_text().splitlines()[1:]:
+            parts = line.split(",")
+            if len(parts) >= 2:
+                try:
+                    total += float(parts[-1])
+                except ValueError:
+                    pass
+        return total
+
+    def is_available(self) -> bool:
+        return bool(self.agent_path) and Path(self.agent_path).exists()
+
+
 def get_profiler(name: str) -> ProfilerInterface:
     profilers = {
         "codegreen": CodeGreenProfiler,
         "perf": PerfProfiler,
         "native": NativeProfiler,
+        "codecarbon": CodeCarbonProfiler,
+        "joularjx": JoularJXProfiler,
     }
     if name not in profilers:
         raise ValueError(f"Unknown profiler: {name}. Available: {list(profilers.keys())}")

{codegreen-0.3.0 → codegreen-0.3.2}/benchmark/suites/__init__.py

@@ -2,10 +2,14 @@
 from benchmark.suites.base import Suite, Task
 from benchmark.suites.benchmarksgame import BenchmarksgameSuite
 from benchmark.suites.perfopt import PerfOptSuite
+from benchmark.suites.dacapo import DaCapoSuite
+from benchmark.suites.renaissance import RenaissanceSuite
 
 SUITES = {
     "benchmarksgame": BenchmarksgameSuite,
     "perfopt": PerfOptSuite,
+    "dacapo": DaCapoSuite,
+    "renaissance": RenaissanceSuite,
 }
 
 def get_suite(name: str, **kwargs) -> Suite:

codegreen-0.3.2/benchmark/suites/dacapo.py

@@ -0,0 +1,45 @@
+"""DaCapo benchmark suite for Java workloads.
+Requires: DaCapo jar downloaded from https://dacapobench.org/
+Usage: codegreen benchmark --suite dacapo --dataset-dir /path/to/dacapo.jar
+"""
+from pathlib import Path
+from typing import List, Optional
+from benchmark.suites.base import Suite, Task
+
+DACAPO_BENCHMARKS = [
+    "avrora", "batik", "biojava", "cassandra", "eclipse", "fop",
+    "graphchi", "h2", "h2o", "jme", "jython", "kafka",
+    "luindex", "lusearch", "pmd", "spring", "sunflow",
+    "tomcat", "tradebeans", "tradesoap", "xalan", "zxing",
+]
+
+
+class DaCapoSuite(Suite):
+    def __init__(self, dataset_dir: str = "", benchmarks: List[str] = None):
+        self.jar_path = Path(dataset_dir) if dataset_dir else None
+        self.benchmarks = benchmarks or DACAPO_BENCHMARKS
+
+    @property
+    def name(self) -> str:
+        return "dacapo"
+
+    def discover(self, filters: Optional[dict] = None) -> List[Task]:
+        if not self.jar_path or not self.jar_path.exists():
+            raise FileNotFoundError(f"DaCapo jar not found at {self.jar_path}. "
+                                    "Download from https://dacapobench.org/")
+        selected = self.benchmarks
+        if filters and "benchmarks" in filters:
+            selected = [b for b in selected if b in filters["benchmarks"]]
+        return [Task(
+            name=b, language="java",
+            run_command=["java", "-jar", str(self.jar_path), b],
+            variant="default",
+            metadata={"suite": "dacapo", "benchmark": b}
+        ) for b in selected]
+
+    def build(self, task: Task) -> Task:
+        return task  # DaCapo is pre-built
+
+    @property
+    def default_timeout(self) -> int:
+        return 600

codegreen-0.3.2/benchmark/suites/renaissance.py

@@ -0,0 +1,48 @@
+"""Renaissance benchmark suite for modern JVM workloads.
+Requires: Renaissance jar downloaded from https://renaissance.dev/
+Usage: codegreen benchmark --suite renaissance --dataset-dir /path/to/renaissance.jar
+"""
+from pathlib import Path
+from typing import List, Optional
+from benchmark.suites.base import Suite, Task
+
+RENAISSANCE_BENCHMARKS = [
+    "akka-uct", "als", "chi-square", "db-shootout", "dec-tree",
+    "dotty", "finagle-chirper", "finagle-http", "fj-kmeans",
+    "future-genetic", "gauss-mix", "log-regression", "mnemonics",
+    "movie-lens", "naive-bayes", "neo4j-analytics", "page-rank",
+    "par-mnemonics", "philosophers", "reactors", "rx-scrabble",
+    "scala-doku", "scala-kmeans", "scala-stm-bench7", "scrabble",
+]
+
+
+class RenaissanceSuite(Suite):
+    def __init__(self, dataset_dir: str = "", benchmarks: List[str] = None, repetitions: int = 1):
+        self.jar_path = Path(dataset_dir) if dataset_dir else None
+        self.benchmarks = benchmarks or RENAISSANCE_BENCHMARKS
+        self.repetitions = repetitions
+
+    @property
+    def name(self) -> str:
+        return "renaissance"
+
+    def discover(self, filters: Optional[dict] = None) -> List[Task]:
+        if not self.jar_path or not self.jar_path.exists():
+            raise FileNotFoundError(f"Renaissance jar not found at {self.jar_path}. "
+                                    "Download from https://renaissance.dev/")
+        selected = self.benchmarks
+        if filters and "benchmarks" in filters:
+            selected = [b for b in selected if b in filters["benchmarks"]]
+        return [Task(
+            name=b, language="java",
+            run_command=["java", "-jar", str(self.jar_path), b, "-r", str(self.repetitions)],
+            variant="default",
+            metadata={"suite": "renaissance", "benchmark": b, "repetitions": self.repetitions}
+        ) for b in selected]
+
+    def build(self, task: Task) -> Task:
+        return task
+
+    @property
+    def default_timeout(self) -> int:
+        return 900

{codegreen-0.3.0 → codegreen-0.3.2}/codegreen/__init__.py

@@ -5,7 +5,7 @@ A comprehensive energy measurement and code optimization tool for developers
 and researchers who need precise, fine-grained energy consumption analysis.
 """
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 __author__ = "Saurabhsingh Rajput"
 __email__ = "saurabh@dal.ca"
 __description__ = "Energy-aware software development tool"

{codegreen-0.3.0 → codegreen-0.3.2}/codegreen/cli/cli.py

@@ -990,8 +990,8 @@ def _build_comprehensive_json(
 def _should_run_actual_measurement(sensors: Optional[List[SensorType]]) -> bool:
     """Check if actual energy measurement should be performed"""
     # For now, check if binary exists for actual measurement
-    binary_path = get_binary_path()
-    return binary_path is not None and binary_path.exists()
+    backend = _get_energy_backend()
+    return not isinstance(backend, _TimeOnlyBackend)
 
 
 def _parse_runtime_measurements(output: str) -> List[Dict[str, Any]]:
@@ -2126,22 +2126,26 @@ def run_measure_workload(
     console.print(f"[blue]Duration:[/blue] {duration} seconds")
     console.print(f"[blue]Workload:[/blue] {workload}")
     
-    binary_path = get_binary_path()
-    if not binary_path:
-        console.print("[red]CodeGreen binary not found[/red]")
+    backend = _get_energy_backend()
+    if isinstance(backend, _TimeOnlyBackend):
+        console.print("[red]No energy measurement backend available[/red]")
         raise typer.Exit(1)
-    
+
+    # Generate workload command
+    if workload == "cpu_stress":
+        cmd = ["python3", "-c", f"import time;t=time.time();[sum(range(10**6)) for _ in iter(lambda:time.time()-t<{duration},True)]"]
+    elif workload == "memory_stress":
+        cmd = ["python3", "-c", f"import time;t=time.time();exec('x=[]\\nwhile time.time()-t<{duration}:\\n x.append(bytearray(10**6))\\n if len(x)>100: x.clear()')"]
+    else:
+        cmd = ["python3", "-c", f"import time;time.sleep({duration})"]
+
     try:
-        result = subprocess.run(
-            [binary_path, "--measure-workload", f"--duration={duration}", f"--workload={workload}"],
-            capture_output=True,
-            text=True,
-            timeout=duration + 30  # Add buffer time
-        )
-        
-        if result.returncode == 0:
+        energy_j, elapsed = backend.measure(cmd, timeout=duration + 30)
+        if energy_j and energy_j > 0:
             console.print("[green]Workload measurement completed successfully[/green]")
-            console.print(result.stdout)
+            console.print(f"Energy: {energy_j:.4f} J")
+            console.print(f"Power:  {energy_j/elapsed:.2f} W")
+            console.print(f"Duration: {elapsed:.2f} s")
         else:
             console.print("[red]Workload measurement failed[/red]")
             console.print(result.stderr)
@@ -2321,11 +2325,30 @@ def run_command(
             "budget_exceeded": budget is not None and e_stats.mean > budget
         }, indent=2))
     else:
+        # Coefficient of variation: signal-to-noise indicator
+        cv = (e_stats.std / e_stats.mean * 100) if e_stats.mean > 0 else 0
+        ci_width = e_stats.ci95_upper - e_stats.ci95_lower
+        ci_pct = (ci_width / e_stats.mean * 100) if e_stats.mean > 0 else 0
+
+        # Color-code by measurement quality
+        if cv < 5:
+            quality, color = "excellent", "green"
+        elif cv < 15:
+            quality, color = "good", "yellow"
+        elif cv < 30:
+            quality, color = "moderate", "bright_yellow"
+        else:
+            quality, color = "high noise", "red"
+
         console.print(f"\n[bold]Energy:[/bold] {e_stats.mean:.4f} J +/- {e_stats.std:.4f} J")
-        console.print(f"  Range: [{e_stats.min:.4f} .. {e_stats.max:.4f}] J, "
-                       f"CI95: [{e_stats.ci95_lower:.4f}, {e_stats.ci95_upper:.4f}] J")
+        console.print(f"  Range: [{e_stats.min:.4f} .. {e_stats.max:.4f}] J")
+        console.print(f"  CI95:  [{e_stats.ci95_lower:.4f}, {e_stats.ci95_upper:.4f}] J ({ci_pct:.1f}% width)")
+        console.print(f"  CV:    [{color}]{cv:.1f}% ({quality})[/{color}]")
         console.print(f"[bold]Time:[/bold]   {t_stats.mean:.4f} s +/- {t_stats.std:.4f} s")
+        console.print(f"[bold]Power:[/bold]  {e_stats.mean / t_stats.mean:.2f} W (avg)")
         console.print(f"  Runs: {len(energies)}, Outliers removed: {e_stats.outliers_removed}")
+        if cv > 20:
+            console.print(f"[yellow]  Tip: high variance -- try --repeat 30 or reduce background load[/yellow]")
         if budget is not None:
             if e_stats.mean > budget:
                 console.print(f"[red]BUDGET EXCEEDED: {e_stats.mean:.4f}J > {budget}J[/red]")
@@ -2405,10 +2428,8 @@ class _NEMBBackend(_EnergyBackend):
         return (energy.value if ok and energy.value > 0 else None, elapsed)
 
     def wrap_command(self, cmd_str: str, energy_file: str, checkpoint_file: str) -> str:
-        # NEMB wraps via the codegreen binary which handles measurement internally
-        binary = get_binary_path()
-        if binary:
-            return f"{binary} measure-workload --output {energy_file} -- bash -c '{cmd_str} 2>{checkpoint_file}'"
+        # NEMB measures in-process; for project mode, just run the command and
+        # let the coordinator's background thread capture energy during execution
         return f"bash -c '{cmd_str} 2>{checkpoint_file}'"
 
     def parse_energy(self, energy_file: str) -> float:

{codegreen-0.3.0 → codegreen-0.3.2/codegreen.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegreen
-Version: 0.3.0
+Version: 0.3.2
 Summary: Energy-aware software development tool for measuring and optimizing code energy consumption
 Author-email: Saurabhsingh Rajput <saurabh@dal.ca>
 Maintainer-email: Saurabhsingh Rajput <saurabh@dal.ca>
@@ -400,6 +400,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: C++
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
 Classifier: Environment :: Console
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
@@ -468,9 +469,13 @@ sudo codegreen run -- python script.py
 
 | Platform | pip install | Energy measurement | Backend |
 |----------|------------|-------------------|---------|
-| Linux x86_64 (Intel/AMD) | Pre-built wheel | Full | RAPL via NEMB |
-| macOS ARM64 (Apple Silicon) | Pre-built wheel | Full | IOReport + kpc via NEMB |
+| Linux x86_64 (Intel) | Pre-built wheel | Full (PKG, core, iGPU, DRAM) | RAPL via NEMB |
+| Linux x86_64 (AMD) | Pre-built wheel | Full (PKG, no DRAM counter) | RAPL via NEMB |
+| macOS ARM64 (Apple Silicon) | Pre-built wheel | Full (CPU, GPU, ANE, DRAM) | IOReport + kpc via NEMB |
 | macOS Intel | From source | Full | IOReport via NEMB |
+| Windows 11 (Intel) | From source | Full (PKG, core, iGPU, DRAM) | EMI via intelpep.sys |
+| Windows 11 (AMD) | From source | Unverified | EMI may not expose AMD RAPL |
+| NVIDIA GPU (any OS) | Automatic | Full (cumulative mJ) | NVML |
 | Other | From source | Time-only | Fallback |
 
 ### Requirements
@@ -478,6 +483,7 @@ sudo codegreen run -- python script.py
 - Python 3.9+
 - Linux: kernel 5.0+, Intel/AMD CPU with RAPL support
 - macOS: Apple Silicon (M1-M5) or Intel, sudo for energy measurement
+- Windows 11: Intel/AMD CPU (EMI via inbox intelpep.sys driver, zero install)
 - Source builds: CMake 3.16+, C++17 compiler
 
 ## Usage
@@ -555,7 +561,7 @@ Features: Ball & Larus branch heuristics, SCC-based hot path computation, three-
 
 ## Architecture
 
-- **C++ NEMB backend**: platform-aware energy measurement (RAPL on Linux, IOReport on macOS), sub-microsecond timestamping, background polling with lock-free ring buffers
+- **C++ NEMB backend**: platform-aware energy measurement (RAPL on Linux, IOReport on macOS, EMI on Windows), sub-microsecond timestamping, background polling with lock-free ring buffers
 - **Python instrumentation**: tree-sitter AST analysis, config-driven checkpoint insertion
 - **Energy Flow Graph**: CFG + energy annotation for path-dependent analysis
 - **Benchmark harness**: multi-suite support (benchmarksgame, PerfOpt), statistical analysis with t-distribution CI, IQR outlier detection, profiler comparison

{codegreen-0.3.0 → codegreen-0.3.2}/codegreen.egg-info/SOURCES.txt

@@ -15,7 +15,9 @@ benchmark/results.py
 benchmark/suites/__init__.py
 benchmark/suites/base.py
 benchmark/suites/benchmarksgame.py
+benchmark/suites/dacapo.py
 benchmark/suites/perfopt.py
+benchmark/suites/renaissance.py
 benchmark/validation/__init__.py
 benchmark/validation/analysis.py
 benchmark/validation/experiments.py

{codegreen-0.3.0 → codegreen-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codegreen"
-version = "0.3.0"
+version = "0.3.2"
 description = "Energy-aware software development tool for measuring and optimizing code energy consumption"
 readme = "README.md"
 license = {file = "LICENSE"}
@@ -36,6 +36,7 @@ classifiers = [
     "Programming Language :: C++",
     "Operating System :: POSIX :: Linux",
     "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows :: Windows 11",
     "Environment :: Console"
 ]
 requires-python = ">=3.8"
@@ -107,8 +108,10 @@ find = {where = ["."], include = [
     "config.json",
     "lib/*.so",
     "lib/*.dylib",
+    "lib/*.dll",
     "lib/runtime/**/*.h",
     "bin/codegreen",
+    "bin/codegreen.exe",
 ]
 
 [tool.setuptools.exclude-package-data]

{codegreen-0.3.0 → codegreen-0.3.2}/setup.py

@@ -1,6 +1,8 @@
 #!/usr/bin/env python3
 """CodeGreen setup with C++ backend compilation for wheel builds."""
 
+from __future__ import annotations
+
 import os
 import platform
 import shutil
@@ -14,6 +16,7 @@ _EXCLUDE_DIRS = {"ide", "measurement", "optimizer"}
 _NATIVE_LIB = {
     "Darwin": "libcodegreen-nemb.dylib",
     "Linux": "libcodegreen-nemb.so",
+    "Windows": "codegreen-nemb.dll",
 }
 
 
@@ -116,8 +119,10 @@ setup(
         "codegreen": [
             "lib/*.so",
             "lib/*.dylib",
+            "lib/*.dll",
             "lib/runtime/**/*.h",
             "bin/codegreen",
+            "bin/codegreen.exe",
             "config.json",
         ],
     },

{codegreen-0.3.0 → codegreen-0.3.2}/tests/test_instrumentation.py

@@ -184,7 +184,7 @@ SAMPLES = {
     "java": (".java", JAVA_SAMPLE, 3),
     "c": (".c", C_SAMPLE, 3),
     "cpp": (".cpp", CPP_SAMPLE, 3),
-    "javascript": (".js", JS_SAMPLE, 2),
+    "javascript": (".js", JS_SAMPLE, 4),
 }
 
 
@@ -215,8 +215,7 @@ class TestInstrumentationPoints:
         ("java", ".java", JAVA_SAMPLE, 3),
         ("c", ".c", C_SAMPLE, 3),
         ("cpp", ".cpp", CPP_SAMPLE, 3),
-        pytest.param("javascript", ".js", JS_SAMPLE, 2,
-                     marks=pytest.mark.xfail(reason="JavaScript instrumentation incomplete")),
+        pytest.param("javascript", ".js", JS_SAMPLE, 4),
     ])
     def test_finds_instrumentation_points(self, lang, ext, code, min_points):
         path = _write_sample(lang, code, ext)