Implement EnergyMetricsProvider in //components

EnergyMetricsProvider provides system-wide energy consumption metrics.
It currently only works on Windows 11, and we will add implementations
for other supported operating systems.

Bug: 1385251
Change-Id: I8474ea042535f42a92bece364264c68e88e2c9fc
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4317885
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Reviewed-by: Francois Pierre Doray <fdoray@chromium.org>
Commit-Queue: Francois Pierre Doray <fdoray@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1130446}

components/BUILD.gn

@@ -189,6 +189,7 @@ test("components_unittests") {
     "//components/policy/core/common:unit_tests",
     "//components/power_bookmarks/core:unit_tests",
     "//components/power_bookmarks/storage:unit_tests",
+    "//components/power_metrics:unit_tests",
     "//components/power_scheduler:unit_tests",
     "//components/prefs:unit_tests",
     "//components/profile_metrics:unit_tests",
@@ -610,10 +611,6 @@ test("components_unittests") {
     ]
   }
 
-  if (is_mac) {
-    deps += [ "//components/power_metrics:unit_tests" ]
-  }
-
   if (toolkit_views) {
     deps += [ "//components/constrained_window:unit_tests" ]
   }

components/power_metrics/BUILD.gn

@@ -2,9 +2,19 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-if (is_mac) {
-  static_library("power_metrics") {
-    sources = [
+static_library("power_metrics") {
+  sources = [
+    "energy_metrics_provider.cc",
+    "energy_metrics_provider.h",
+  ]
+
+  deps = [
+    "//base",
+    "//third_party/abseil-cpp:absl",
+  ]
+
+  if (is_mac) {
+    sources += [
       "energy_impact_mac.h",
       "energy_impact_mac.mm",
       "m1_sensors_internal_types_mac.h",
@@ -19,13 +29,23 @@ if (is_mac) {
       "smc_mac.h",
       "smc_mac.mm",
     ]
-
-    deps = [ "//base" ]
   }
 
-  source_set("unit_tests") {
-    testonly = true
+  if (is_win) {
+    sources += [
+      "energy_metrics_provider_win.cc",
+      "energy_metrics_provider_win.h",
+    ]
 
+    libs = [ "Setupapi.lib" ]
+    ldflags = [ "/DELAYLOAD:setupapi.dll" ]
+  }
+}
+
+source_set("unit_tests") {
+  testonly = true
+
+  if (is_mac) {
     sources = [
       "energy_impact_mac_unittest.mm",
       "resource_coalition_mac_unittest.mm",
@@ -39,4 +59,13 @@ if (is_mac) {
       "//testing/gtest",
     ]
   }
+
+  if (is_win) {
+    sources = [ "energy_metrics_provider_win_unittest.cc" ]
+
+    deps = [
+      ":power_metrics",
+      "//testing/gtest",
+    ]
+  }
 }

components/power_metrics/energy_metrics_provider.cc

@@ -0,0 +1,26 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/power_metrics/energy_metrics_provider.h"
+
+#include "build/build_config.h"
+#if BUILDFLAG(IS_WIN)
+#include "components/power_metrics/energy_metrics_provider_win.h"
+#endif  // BUILDFLAG(IS_WIN)
+
+namespace power_metrics {
+
+EnergyMetricsProvider::EnergyMetricsProvider() = default;
+EnergyMetricsProvider::~EnergyMetricsProvider() = default;
+
+// static
+std::unique_ptr<EnergyMetricsProvider> EnergyMetricsProvider::Create() {
+#if BUILDFLAG(IS_WIN)
+  return EnergyMetricsProviderWin::Create();
+#else
+  return nullptr;
+#endif  // BUILDFLAG(IS_WIN)
+}
+
+}  // namespace power_metrics

components/power_metrics/energy_metrics_provider.h

@@ -0,0 +1,56 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_POWER_METRICS_ENERGY_METRICS_PROVIDER_H_
+#define COMPONENTS_POWER_METRICS_ENERGY_METRICS_PROVIDER_H_
+
+#include <cstdint>
+#include <memory>
+
+#include "third_party/abseil-cpp/absl/types/optional.h"
+
+namespace power_metrics {
+
+// EnergyMetricsProvider provides system-wide energy consumption metrics.
+class EnergyMetricsProvider {
+ public:
+  struct EnergyMetrics {
+    // The absolute energy of the whole processor package.
+    uint64_t package_nanojoules;
+    // The absolute energy of all of the cores.
+    uint64_t cpu_nanojoules;
+    // The absolute energy of the uncore (usually the integrated GPU, only
+    // available in client CPUs).
+    uint64_t gpu_nanojoules;
+    // The absolute energy of the DRAM (only available in server CPUs).
+    uint64_t dram_nanojoules;
+    // The following metrics are emitted by AMD processors.
+    // We don't know what they measure exactly.
+    uint64_t vdd_nanojoules;
+    uint64_t soc_nanojoules;
+    uint64_t socket_nanojoules;
+    uint64_t apu_nanojoules;
+  };
+
+  // Returns nullptr if no suitable implementation exists.
+  static std::unique_ptr<EnergyMetricsProvider> Create();
+
+  EnergyMetricsProvider(const EnergyMetricsProvider&) = delete;
+  EnergyMetricsProvider& operator=(const EnergyMetricsProvider&) = delete;
+
+  virtual ~EnergyMetricsProvider();
+
+  // Used to capture energy consumption metrics. It returns nullopt if not
+  // available on the current platform.
+  virtual absl::optional<EnergyMetrics> CaptureMetrics() = 0;
+
+ protected:
+  // The constructor is intentionally only exposed to subclasses. Production
+  // code must use the Create() factory method.
+  EnergyMetricsProvider();
+};
+
+}  // namespace power_metrics
+
+#endif  // COMPONENTS_POWER_METRICS_ENERGY_METRICS_PROVIDER_H_

components/power_metrics/energy_metrics_provider_win.cc

@@ -0,0 +1,237 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/power_metrics/energy_metrics_provider_win.h"
+
+#include <windows.h>
+#include <devioctl.h>
+
+#include <initguid.h>  // This has to be before emi.h
+
+#include <emi.h>
+#include <setupapi.h>
+
+#include "base/logging.h"
+#include "base/memory/free_deleter.h"
+#include "base/memory/ptr_util.h"
+#include "base/threading/scoped_blocking_call.h"
+#include "base/win/scoped_devinfo.h"
+#include "base/win/scoped_handle.h"
+
+namespace power_metrics {
+
+namespace {
+
+// Windows EMI interface provides energy data in units of picowatt-hour.
+constexpr double kNanojoulesPerPicowattHour = 3.6;
+
+// These metrics are hardware dependent. "RAPL" metrics are from Intel
+// Running Average Power Limit (RAPL) interface, and the rest are from AMD.
+// Here, we only consider single-socket system, where "Package0" means that the
+// metered hardware are in the same package 0, "PP0" usually stands for cores,
+// and "PP1" usually stands for integrated GPU. There should also be "Package1"
+// or more packages for more than one socket system, which needs more tests to
+// find out.
+void SetEnergyMetric(const std::wstring& metric_type,
+                     EnergyMetricsProvider::EnergyMetrics& energy_metrics,
+                     uint64_t absolute_energy) {
+  if (metric_type == L"RAPL_Package0_PKG") {
+    energy_metrics.package_nanojoules = absolute_energy;
+  } else if (metric_type == L"RAPL_Package0_PP0") {
+    energy_metrics.cpu_nanojoules = absolute_energy;
+  } else if (metric_type == L"RAPL_Package0_PP1") {
+    energy_metrics.gpu_nanojoules = absolute_energy;
+  } else if (metric_type == L"RAPL_Package0_DRAM") {
+    energy_metrics.dram_nanojoules = absolute_energy;
+  } else if (metric_type == L"VDDCR_VDD Energy") {
+    energy_metrics.vdd_nanojoules = absolute_energy;
+  } else if (metric_type == L"VDDCR_SOC Energy") {
+    energy_metrics.soc_nanojoules = absolute_energy;
+  } else if (metric_type == L"Current Socket Energy") {
+    energy_metrics.socket_nanojoules = absolute_energy;
+  } else if (metric_type == L"Apu Energy") {
+    energy_metrics.apu_nanojoules = absolute_energy;
+  }
+}
+
+}  // namespace
+
+EnergyMetricsProviderWin::EnergyMetricsProviderWin() = default;
+EnergyMetricsProviderWin::~EnergyMetricsProviderWin() = default;
+
+// static
+std::unique_ptr<EnergyMetricsProviderWin> EnergyMetricsProviderWin::Create() {
+  return base::WrapUnique(new EnergyMetricsProviderWin());
+}
+
+absl::optional<EnergyMetricsProvider::EnergyMetrics>
+EnergyMetricsProviderWin::CaptureMetrics() {
+  if (!Initialize()) {
+    handle_.Close();
+    return absl::nullopt;
+  }
+
+  base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
+                                                base::BlockingType::MAY_BLOCK);
+
+  DWORD bytes_returned = 0;
+  std::vector<EMI_CHANNEL_MEASUREMENT_DATA> measurement_data(
+      metric_types_.size());
+  const size_t measurement_data_size_bytes =
+      sizeof(EMI_CHANNEL_MEASUREMENT_DATA) * metric_types_.size();
+  // Get the EMI measurement data.
+  if (!DeviceIoControl(handle_.get(), IOCTL_EMI_GET_MEASUREMENT, nullptr, 0,
+                       measurement_data.data(), measurement_data_size_bytes,
+                       &bytes_returned, nullptr)) {
+    PLOG(ERROR) << "IOCTL_EMI_GET_MEASUREMENT failed";
+    return absl::nullopt;
+  }
+  CHECK_EQ(bytes_returned, measurement_data_size_bytes);
+
+  EnergyMetrics energy_metrics = {0};
+  for (size_t i = 0; i < metric_types_.size(); ++i) {
+    EMI_CHANNEL_MEASUREMENT_DATA* channel_data = &measurement_data[i];
+    uint64_t absolute_energy = static_cast<uint64_t>(
+        kNanojoulesPerPicowattHour * channel_data->AbsoluteEnergy);
+    SetEnergyMetric(metric_types_[i], energy_metrics, absolute_energy);
+  }
+  return energy_metrics;
+}
+
+bool EnergyMetricsProviderWin::Initialize() {
+  if (is_initialized_) {
+    if (metric_types_.empty()) {
+      return false;
+    }
+    return true;
+  }
+
+  is_initialized_ = true;
+  base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
+                                                base::BlockingType::MAY_BLOCK);
+
+  // Energy Meter Interface
+  // {45BD8344-7ED6-49cf-A440-C276C933B053}
+  // https://learn.microsoft.com/en-us/windows-hardware/drivers/powermeter/energy-meter-interface
+  //
+  // Get device information set for the Energy Meter Interface.
+  base::win::ScopedDevInfo dev_info(
+      SetupDiGetClassDevs(&GUID_DEVICE_ENERGY_METER, nullptr, nullptr,
+                          DIGCF_PRESENT | DIGCF_DEVICEINTERFACE));
+  if (!dev_info.is_valid()) {
+    PLOG(WARNING) << "SetupDiGetClassDevs";
+    return false;
+  }
+
+  // Pick the first device interface in the returned device information set.
+  //
+  // TODO(crbug.com/1385251): Determine if the first device interface is always
+  // the desired one.
+  SP_DEVICE_INTERFACE_DATA dev_data = {0};
+  dev_data.cbSize = sizeof(dev_data);
+  if (!SetupDiEnumDeviceInterfaces(dev_info.get(), nullptr,
+                                   &GUID_DEVICE_ENERGY_METER, 0, &dev_data)) {
+    PLOG(WARNING) << "SetupDiEnumDeviceInterfaces";
+    return false;
+  }
+
+  // Get the required size of device interface detail data.
+  DWORD required_size = 0;
+  if (SetupDiGetDeviceInterfaceDetail(dev_info.get(), &dev_data, nullptr, 0,
+                                      &required_size, nullptr) ||
+      ::GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+    return false;
+  }
+
+  // Get the pointer to an SP_DEVICE_INTERFACE_DETAIL_DATA structure to
+  // receive information.
+  std::unique_ptr<SP_DEVICE_INTERFACE_DETAIL_DATA, base::FreeDeleter>
+      dev_detail_data(
+          static_cast<SP_DEVICE_INTERFACE_DETAIL_DATA*>(malloc(required_size)));
+  dev_detail_data->cbSize = sizeof(*dev_detail_data);
+  if (!SetupDiGetDeviceInterfaceDetail(dev_info.get(), &dev_data,
+                                       dev_detail_data.get(), required_size,
+                                       nullptr, nullptr)) {
+    PLOG(WARNING) << "SetupDiGetDeviceInterfaceDetail";
+    return false;
+  }
+
+  // Get the handle to access Energy Meter Interface.
+  handle_.Set(::CreateFile(dev_detail_data->DevicePath, GENERIC_READ,
+                           FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
+                           OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
+  if (!handle_.is_valid()) {
+    LOG(WARNING) << "Failed to set up handle";
+    return false;
+  }
+
+  DWORD bytes_returned = 0;
+
+  // Verify the EMI interface version.
+  EMI_VERSION emi_version = {0};
+  if (!DeviceIoControl(handle_.get(), IOCTL_EMI_GET_VERSION, nullptr, 0,
+                       &emi_version, sizeof(emi_version), &bytes_returned,
+                       nullptr)) {
+    PLOG(WARNING) << "EMI interface not available";
+    return false;
+  }
+  CHECK_EQ(bytes_returned, sizeof(emi_version));
+
+  if (emi_version.EmiVersion != EMI_VERSION_V2 &&
+      emi_version.EmiVersion != EMI_VERSION_V1) {
+    LOG(WARNING) << "EMI version not supported, EMI version = "
+                 << emi_version.EmiVersion;
+    return false;
+  }
+
+  // Get the size of the EMI metadata.
+  EMI_METADATA_SIZE metadata_size = {0};
+  if (!DeviceIoControl(handle_.get(), IOCTL_EMI_GET_METADATA_SIZE, nullptr, 0,
+                       &metadata_size, sizeof(metadata_size), &bytes_returned,
+                       nullptr)) {
+    PLOG(ERROR) << "IOCTL_EMI_GET_METADATA_SIZE";
+    return false;
+  }
+  CHECK_EQ(bytes_returned, sizeof(metadata_size));
+
+  if (!metadata_size.MetadataSize) {
+    LOG(ERROR) << "MetadataSize == 0";
+    return false;
+  }
+
+  // Get the EMI metadata.
+  std::vector<char> metadata_buf(metadata_size.MetadataSize);
+  if (!DeviceIoControl(handle_.get(), IOCTL_EMI_GET_METADATA, nullptr, 0,
+                       metadata_buf.data(), metadata_size.MetadataSize,
+                       &bytes_returned, nullptr)) {
+    PLOG(ERROR) << "IOCTL_EMI_GET_METADATA";
+    return false;
+  }
+  CHECK_EQ(static_cast<DWORD>(bytes_returned), metadata_buf.size());
+
+  // For different EMI versions, get the types of available metrics
+  // respectively.
+  if (emi_version.EmiVersion == EMI_VERSION_V1) {
+    EMI_METADATA_V1* metadata_v1 =
+        reinterpret_cast<EMI_METADATA_V1*>(metadata_buf.data());
+    metric_types_.push_back(metadata_v1->MeteredHardwareName);
+  } else if (emi_version.EmiVersion == EMI_VERSION_V2) {
+    EMI_METADATA_V2* metadata_v2 =
+        reinterpret_cast<EMI_METADATA_V2*>(metadata_buf.data());
+    EMI_CHANNEL_V2* channel = &metadata_v2->Channels[0];
+    // EMI v2 has a different channel for each metric.
+    for (int i = 0; i < metadata_v2->ChannelCount; ++i) {
+      metric_types_.push_back(channel->ChannelName);
+      channel = EMI_CHANNEL_V2_NEXT_CHANNEL(channel);
+    }
+  }
+
+  if (metric_types_.empty()) {
+    LOG(WARNING) << "No available energy metric";
+    return false;
+  }
+  return true;
+}
+
+}  // namespace power_metrics

components/power_metrics/energy_metrics_provider_win.h

@@ -0,0 +1,45 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_POWER_METRICS_ENERGY_METRICS_PROVIDER_WIN_H_
+#define COMPONENTS_POWER_METRICS_ENERGY_METRICS_PROVIDER_WIN_H_
+
+#include <memory>
+#include <string>
+
+#include "base/win/scoped_handle.h"
+#include "components/power_metrics/energy_metrics_provider.h"
+
+namespace power_metrics {
+
+// EnergyMetricsProviderWin obtains energy metrics via Energy Meter Interface
+// (EMI) consisting of a set of IOCTLs, which is only supported in Win11.
+class EnergyMetricsProviderWin : public EnergyMetricsProvider {
+ public:
+  // Factory method for production instances.
+  static std::unique_ptr<EnergyMetricsProviderWin> Create();
+
+  EnergyMetricsProviderWin(const EnergyMetricsProviderWin&) = delete;
+  EnergyMetricsProviderWin& operator=(const EnergyMetricsProviderWin&) = delete;
+
+  ~EnergyMetricsProviderWin() override;
+
+  // EnergyMetricsProvider implementation.
+  absl::optional<EnergyMetrics> CaptureMetrics() override;
+
+ private:
+  EnergyMetricsProviderWin();
+
+  bool Initialize();
+
+  // Available metric types, derived from EMI metadata.
+  std::vector<std::wstring> metric_types_;
+  // Used to derive energy consumption data via EMI interface.
+  base::win::ScopedHandle handle_;
+  bool is_initialized_ = false;
+};
+
+}  // namespace power_metrics
+
+#endif  // COMPONENTS_POWER_METRICS_ENERGY_METRICS_PROVIDER_WIN_H_

components/power_metrics/energy_metrics_provider_win_unittest.cc

@@ -0,0 +1,17 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/power_metrics/energy_metrics_provider_win.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace power_metrics {
+
+TEST(EnergyMetricsProviderWinTest, CaptureMetrics) {
+  auto provider = EnergyMetricsProviderWin::Create();
+  ASSERT_NE(provider, nullptr);
+  provider->CaptureMetrics();
+}
+
+}  // namespace power_metrics