Better RAPL handling

Author: benoit-cty

codecarbon/core/cpu.py

@@ -443,17 +443,23 @@ def _fetch_rapl_files(self) -> None:
                     except Exception as e:
                         if isinstance(e, PermissionError):
                             logger.warning(
-                                "Permission denied listing %s: %s", entry_path, e
+                                "\tRAPL - Permission denied listing %s: %s",
+                                entry_path,
+                                e,
                             )
                         else:
-                            logger.debug("Cannot list %s: %s", entry_path, e)
+                            logger.debug("\tRAPL - Cannot list %s: %s", entry_path, e)
             except Exception as e:
                 if isinstance(e, PermissionError):
                     logger.warning(
-                        "Permission denied scanning %s for RAPL domains: %s", base, e
+                        "\tRAPL - Permission denied scanning %s for RAPL domains: %s",
+                        base,
+                        e,
                     )
                 else:
-                    logger.debug("Cannot scan %s for RAPL domains: %s", base, e)
+                    logger.debug(
+                        "\tRAPL - Cannot scan %s for RAPL domains: %s", base, e
+                    )
 
         # Fallback: if none found and the configured path looks like it directly
         # contains domain entries, try listing it (preserves backward compatibility).
@@ -473,6 +479,12 @@ def _fetch_rapl_files(self) -> None:
         # Remove duplicates
         domain_dirs = list(dict.fromkeys(domain_dirs))
 
+        # Build a list of successfully readable domains with their metadata
+        # We'll deduplicate at the end, after we know which ones are readable
+        readable_domains = (
+            []
+        )  # List of (name, domain_dir, is_mmio, rapl_file, rapl_file_max)
+
         i = 0
         for domain_dir in domain_dirs:
             try:
@@ -485,13 +497,13 @@ def _fetch_rapl_files(self) -> None:
                     except Exception as e:
                         if isinstance(e, PermissionError):
                             logger.warning(
-                                "Permission denied reading name file %s: %s",
+                                "\tRAPL - Permission denied reading name file %s: %s",
                                 name_path,
                                 e,
                             )
                         else:
                             logger.debug(
-                                "Unable to read name file %s: %s", name_path, e
+                                "\tRAPL - Unable to read name file %s: %s", name_path, e
                             )
                 if not name:
                     # Use the domain directory basename as a fallback
@@ -519,40 +531,127 @@ def _fetch_rapl_files(self) -> None:
                     if is_required_main:
                         found_main_readable = True
                 except PermissionError:
-                    msg = f"Permission denied reading RAPL file {rapl_file}."
+                    msg = f"\tRAPL - Permission denied reading RAPL file {rapl_file}."
                     suggestion = "You can grant read permission with: sudo chmod -R a+r /sys/class/powercap/*"
                     logger.warning("%s %s; skipping.", msg, suggestion)
                     # do not raise; skip this domain
                     continue
                 except Exception as e:
                     logger.debug(
-                        "Skipping non-numeric or unreadable RAPL file %s: %s",
+                        "\tRAPL - Skipping non-numeric or unreadable RAPL file %s: %s",
                         rapl_file,
                         e,
                     )
                     continue
 
-                try:
-                    self._rapl_files.append(
-                        RAPLFile(name=name, path=rapl_file, max_path=rapl_file_max)
-                    )
-                    logger.debug("We will read Intel RAPL files at %s", rapl_file)
-                except PermissionError as e:
-                    logger.warning(
-                        "Permission denied while initializing RAPL file %s: %s",
-                        rapl_file,
-                        e,
-                    )
-                    continue
-                except Exception as e:
-                    logger.debug(
-                        "Unable to initialize RAPLFile for %s: %s", rapl_file, e
-                    )
-                    continue
+                # This domain is readable, add it to our list
+                is_mmio = "intel-rapl-mmio" in domain_dir
+                readable_domains.append(
+                    (name, domain_dir, is_mmio, rapl_file, rapl_file_max)
+                )
             except Exception as e:
                 # Log and continue on any per-domain failure; availability is
                 # determined from whether a main/package counter was readable.
-                logger.warning("Error processing RAPL domain %s: %s", domain_dir, e)
+                logger.warning(
+                    "\tRAPL - Error processing RAPL domain %s: %s", domain_dir, e
+                )
+                continue
+
+        # Deduplicate readable domains with same name, preferring MMIO over MSR-based
+        # This prevents double-counting when same domain appears in both
+        # intel-rapl and intel-rapl-mmio (e.g., package-0)
+
+        # First, check if we have a psys (platform/system) domain
+        # psys provides total platform power and already includes package, core, uncore, etc.
+        # Using psys alone is the best way to avoid double-counting on modern Intel systems
+        psys_domain = None
+        for domain_tuple in readable_domains:
+            name, domain_dir, is_mmio, rapl_file, rapl_file_max = domain_tuple
+
+            # Check if this is a psys domain
+            try:
+                name_path = os.path.join(domain_dir, "name")
+                if os.path.exists(name_path):
+                    with open(name_path) as f:
+                        domain_name = f.read().strip().lower()
+                        if domain_name == "psys":
+                            psys_domain = domain_tuple
+                            logger.info(
+                                "\tRAPL - Found psys (platform/system) domain - this provides "
+                                "total platform power and avoids double-counting"
+                            )
+                            break
+            except Exception:
+                pass
+
+        # If psys is available, use ONLY psys to avoid all double-counting
+        if psys_domain:
+            logger.info(
+                "\tRAPL - Using only psys domain for power measurement to ensure accuracy. "
+                "Other domains (package, core, uncore) are subsets of psys."
+            )
+            domain_map = {"psys": psys_domain}
+        else:
+            # No psys available, fall back to deduplicating package/core/uncore domains
+            logger.warning(
+                "\tRAPL - No psys domain found, using individual domains (package, core, uncore)"
+            )
+            domain_map = (
+                {}
+            )  # name -> (name, domain_dir, is_mmio, rapl_file, rapl_file_max)
+            for domain_tuple in readable_domains:
+                name, domain_dir, is_mmio, rapl_file, rapl_file_max = domain_tuple
+
+                # Extract the base name (without "Processor Energy Delta_X" numbering)
+                # to properly identify duplicates
+                base_name = name
+                if "Processor Energy" in name:
+                    # This is a package domain, use the original domain name for deduplication
+                    try:
+                        name_path = os.path.join(domain_dir, "name")
+                        if os.path.exists(name_path):
+                            with open(name_path) as f:
+                                base_name = f.read().strip()
+                    except Exception:
+                        base_name = os.path.basename(domain_dir)
+
+                # If we haven't seen this base name, or we're replacing MSR with MMIO, keep it
+                if base_name not in domain_map or (
+                    is_mmio and not domain_map[base_name][2]
+                ):
+                    domain_map[base_name] = domain_tuple
+
+        logger.debug(
+            "\tRAPL - Found %d unique RAPL domains after deduplication (from %d readable domains)",
+            len(domain_map),
+            len(readable_domains),
+        )
+
+        # Now create RAPLFile objects for deduplicated domains
+        for name, _, is_mmio, rapl_file, rapl_file_max in domain_map.values():
+            try:
+                # Determine interface type for logging
+                interface_type = "MMIO" if is_mmio else "MSR"
+                self._rapl_files.append(
+                    RAPLFile(name=name, path=rapl_file, max_path=rapl_file_max)
+                )
+                logger.debug(
+                    "\tRAPL - Reading RAPL domain '%s' via %s interface at %s",
+                    name,
+                    interface_type,
+                    rapl_file,
+                )
+            except PermissionError as e:
+                logger.warning(
+                    "\tRAPL - Permission denied while initializing RAPL file %s: %s",
+                    rapl_file,
+                    e,
+                )
+                continue
+            except Exception as e:
+                logger.debug(
+                    "\tRAPL - Unable to initialize RAPLFile for %s: %s", rapl_file, e
+                )
                 continue
 
         # Save whether we found a readable main/package energy counter so
@@ -580,7 +679,7 @@ def get_cpu_details(self, duration: Time) -> Dict:
                     )
         except Exception as e:
             logger.info(
-                "Unable to read Intel RAPL files at %s\n \
+                "\tRAPL - Unable to read Intel RAPL files at %s\n \
                 Exception occurred %s",
                 self._rapl_files,
                 e,

examples/intel_rapl_show.py

@@ -3,6 +3,50 @@
 # The script can be used to monitor power consumption over time for a specific power domain
 # The power consumption is read from the energy counter in microjoules and converted to watts
 
+"""
+
+Sample output for Intel(R) Core(TM) Ultra 7 265H
+https://www.intel.com/content/www/us/en/products/sku/241750/intel-core-ultra-7-processor-265h-24m-cache-up-to-5-30-ghz/specifications.html
+- Processor Base Power 28 W
+- Maximum Turbo Power 115 W
+- Minimum Assured Power 20 W
+
+
+
+Available Power Domains:
+[{'path': 'intel-rapl:1', 'name': 'psys', 'is_mmio': False}, {'path': 'intel-rapl:0:0', 'name': 'core', 'is_mmio': False}, {'path': 'intel-rapl-mmio:0', 'name': 'package-0', 'is_mmio': True}, {'path': 'intel-rapl:0:1', 'name': 'uncore', 'is_mmio': False}]
+Starting Power Monitoring (deduplication: True):
+
+Monitoring domains:
+  - psys (intel-rapl:1) via MSR
+  - core (intel-rapl:0:0) via MSR
+  - package-0 (intel-rapl-mmio:0) via MMIO
+  - uncore (intel-rapl:0:1) via MSR
+
+
+Idle :
+ - Domain 'psys' (MSR): 8.03 Watts
+ - Domain 'core' (MSR): 1.51 Watts
+ - Domain 'package-0' (MMIO): 4.61 Watts
+ - Domain 'uncore' (MSR): 0.57 Watts
+ - Total Power Consumption: 14.72 Watts
+
+With `7z b` to load the CPU:
+
+ - Domain 'psys' (MSR): 22.89 Watts
+ - Domain 'core' (MSR): 14.49 Watts
+ - Domain 'package-0' (MMIO): 18.51 Watts
+ - Domain 'uncore' (MSR): 0.19 Watts
+ - Total Power Consumption: 56.07 Watts
+
+ psys (9.61W) ← Most comprehensive
+├── package-0 (3.78W)
+│   ├── core (0.84W) ← CPU cores only
+│   └── uncore (0.21W) ← Memory controller, cache, iGPU
+└── Other platform components (~5.8W)
+    └── Chipset, PCIe, etc.
+
+"""
 import json
 import os
 import time
@@ -22,7 +66,10 @@ def inspect_rapl_domains(self):
             # Iterate through all RAPL domains
             for domain_dir in os.listdir(self.rapl_base_path):
                 print(domain_dir)
-                if not domain_dir.startswith("intel-rapl:"):
+                if not (
+                    domain_dir.startswith("intel-rapl:")
+                    or domain_dir.startswith("intel-rapl-mmio:")
+                ):
                     continue
 
                 domain_path = os.path.join(self.rapl_base_path, domain_dir)
@@ -134,17 +181,23 @@ def __init__(self):
         # Base path for RAPL power readings in sysfs
         self.rapl_base_path = "/sys/class/powercap/intel-rapl/subsystem"
 
-    def list_power_domains(self):
+    def list_power_domains(self, deduplicate=True):
         """
-        List available RAPL power domains
+        List available RAPL power domains (including intel-rapl and intel-rapl-mmio)
+
+        :param deduplicate: If True, avoid duplicate domains with same name, preferring MMIO
+        :return: List of domain info dictionaries
         """
-        self.domains = []
+        all_domains = []
         try:
             for domain in os.listdir(self.rapl_base_path):
-                if domain.startswith("intel-rapl:"):
+                if domain.startswith("intel-rapl:") or domain.startswith(
+                    "intel-rapl-mmio:"
+                ):
                     domain_info = {
                         "path": domain,
                         "name": "",
+                        "is_mmio": domain.startswith("intel-rapl-mmio:"),
                     }
                     if os.path.exists(
                         os.path.join(self.rapl_base_path, domain, "name")
@@ -153,12 +206,39 @@ def list_power_domains(self):
                             os.path.join(self.rapl_base_path, domain, "name"), "r"
                         ) as f:
                             domain_info["name"] = f.read().strip()
-                    self.domains.append(domain_info)
+                    all_domains.append(domain_info)
+
+            # Deduplicate if requested
+            if deduplicate:
+                self.domains = self._deduplicate_domains(all_domains)
+            else:
+                self.domains = all_domains
+
             return self.domains
         except Exception as e:
             print(f"Error listing power domains: {e}")
             return []
 
+    def _deduplicate_domains(self, domains):
+        """
+        Remove duplicate domains with the same name, preferring MMIO over MSR-based
+
+        :param domains: List of domain info dictionaries
+        :return: Deduplicated list
+        """
+        domain_map = {}
+
+        for domain in domains:
+            name = domain["name"]
+
+            # If we haven't seen this name, or we're replacing MSR with MMIO
+            if name not in domain_map or (
+                domain["is_mmio"] and not domain_map[name]["is_mmio"]
+            ):
+                domain_map[name] = domain
+
+        return list(domain_map.values())
+
     def read_power_consumption(self, domain=None, interval=1):
         """
         Read power consumption for a specific RAPL domain
@@ -201,28 +281,38 @@ def read_power_consumption(self, domain=None, interval=1):
             print(f"Error reading power for {domain}: {e}")
             return None
 
-    def monitor_power(self, interval=1, duration=10):
+    def monitor_power(self, interval=1, duration=10, deduplicate=True):
         """
         Monitor power consumption over time
 
         :param interval: Sampling interval in seconds
         :param duration: Total monitoring duration in seconds
+        :param deduplicate: If True, avoid counting duplicate domains (e.g., same package via MSR and MMIO)
         """
-        print("Starting Power Monitoring:")
+        print(f"Starting Power Monitoring (deduplication: {deduplicate}):")
         if not self.domains:
-            self.domains = self.list_power_domains()
+            self.domains = self.list_power_domains(deduplicate=deduplicate)
+
+        # Show which domains are being monitored
+        print("\nMonitoring domains:")
+        for domain in self.domains:
+            interface = "MMIO" if domain.get("is_mmio") else "MSR"
+            print(f"  - {domain.get('name')} ({domain.get('path')}) via {interface}")
+        print()
+
         start_time = time.time()
 
         while time.time() - start_time < duration:
             total_power = 0
             for domain in self.domains:
                 power = self.read_power_consumption(domain)
                 if power is not None:
+                    interface = "MMIO" if domain.get("is_mmio") else "MSR"
                     print(
-                        f"Domain '{domain.get('path').split('/')[-1]}/{domain.get('name')}' as a power consumption of {power:.2f} Watts"
+                        f"Domain '{domain.get('name')}' ({interface}): {power:.2f} Watts"
                     )
                     total_power += power
-            print(f"Total Power Consumption: {total_power:.2f} Watts")
+            print(f"Total Power Consumption: {total_power:.2f} Watts\n")
 
             time.sleep(interval)