components/power_metrics/energy_metrics_provider_win.cc

   1 // Copyright 2023 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/power_metrics/energy_metrics_provider_win.h"
   6
   7 #include <windows.h>
   8 #include <devioctl.h>
   9
  10 #include <initguid.h>  // This has to be before emi.h
  11
  12 #include <emi.h>
  13 #include <setupapi.h>
  14
  15 #include "base/logging.h"
  16 #include "base/memory/free_deleter.h"
  17 #include "base/memory/ptr_util.h"
  18 #include "base/threading/scoped_blocking_call.h"
  19 #include "base/win/scoped_devinfo.h"
  20 #include "base/win/scoped_handle.h"
  21
  22 namespace power_metrics {
  23
  24 namespace {
  25
  26 // Windows EMI interface provides energy data in units of picowatt-hour.
  27 constexpr double kNanojoulesPerPicowattHour = 3.6;
  28
  29 // These metrics are hardware dependent. "RAPL" metrics are from Intel
  30 // Running Average Power Limit (RAPL) interface, and the rest are from AMD.
  31 // Here, we only consider single-socket system, where "Package0" means that the
  32 // metered hardware are in the same package 0, "PP0" usually stands for cores,
  33 // and "PP1" usually stands for integrated GPU. There should also be "Package1"
  34 // or more packages for more than one socket system, which needs more tests to
  35 // find out.
  36 void SetEnergyMetric(const std::wstring& metric_type,
  37                      EnergyMetricsProvider::EnergyMetrics& energy_metrics,
  38                      uint64_t absolute_energy) {
  39   if (metric_type == L"RAPL_Package0_PKG") {
  40     energy_metrics.package_nanojoules = absolute_energy;
  41   } else if (metric_type == L"RAPL_Package0_PP0") {
  42     energy_metrics.cpu_nanojoules = absolute_energy;
  43   } else if (metric_type == L"RAPL_Package0_PP1") {
  44     energy_metrics.gpu_nanojoules = absolute_energy;
  45   } else if (metric_type == L"RAPL_Package0_DRAM") {
  46     energy_metrics.dram_nanojoules = absolute_energy;
  47   } else if (metric_type == L"VDDCR_VDD Energy") {
  48     energy_metrics.vdd_nanojoules = absolute_energy;
  49   } else if (metric_type == L"VDDCR_SOC Energy") {
  50     energy_metrics.soc_nanojoules = absolute_energy;
  51   } else if (metric_type == L"Current Socket Energy") {
  52     energy_metrics.socket_nanojoules = absolute_energy;
  53   } else if (metric_type == L"Apu Energy") {
  54     energy_metrics.apu_nanojoules = absolute_energy;
  55   }
  56 }
  57
  58 }  // namespace
  59
  60 EnergyMetricsProviderWin::EnergyMetricsProviderWin() = default;
  61 EnergyMetricsProviderWin::~EnergyMetricsProviderWin() = default;
  62
  63 // static
  64 std::unique_ptr<EnergyMetricsProviderWin> EnergyMetricsProviderWin::Create() {
  65   return base::WrapUnique(new EnergyMetricsProviderWin());
  66 }
  67
  68 absl::optional<EnergyMetricsProvider::EnergyMetrics>
  69 EnergyMetricsProviderWin::CaptureMetrics() {
  70   if (!Initialize()) {
  71     handle_.Close();
  72     return absl::nullopt;
  73   }
  74
  75   base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
  76                                                 base::BlockingType::MAY_BLOCK);
  77
  78   DWORD bytes_returned = 0;
  79   std::vector<EMI_CHANNEL_MEASUREMENT_DATA> measurement_data(
  80       metric_types_.size());
  81   const size_t measurement_data_size_bytes =
  82       sizeof(EMI_CHANNEL_MEASUREMENT_DATA) * metric_types_.size();
  83   // Get the EMI measurement data.
  84   if (!DeviceIoControl(handle_.get(), IOCTL_EMI_GET_MEASUREMENT, nullptr, 0,
  85                        measurement_data.data(), measurement_data_size_bytes,
  86                        &bytes_returned, nullptr)) {
  87     PLOG(ERROR) << "IOCTL_EMI_GET_MEASUREMENT failed";
  88     return absl::nullopt;
  89   }
  90   CHECK_EQ(bytes_returned, measurement_data_size_bytes);
  91
  92   EnergyMetrics energy_metrics = {0};
  93   for (size_t i = 0; i < metric_types_.size(); ++i) {
  94     EMI_CHANNEL_MEASUREMENT_DATA* channel_data = &measurement_data[i];
  95     uint64_t absolute_energy = static_cast<uint64_t>(
  96         kNanojoulesPerPicowattHour * channel_data->AbsoluteEnergy);
  97     SetEnergyMetric(metric_types_[i], energy_metrics, absolute_energy);
  98   }
  99   return energy_metrics;
 100 }
 101
 102 bool EnergyMetricsProviderWin::Initialize() {
 103   if (is_initialized_) {
 104     if (metric_types_.empty()) {
 105       return false;
 106     }
 107     return true;
 108   }
 109
 110   is_initialized_ = true;
 111   base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
 112                                                 base::BlockingType::MAY_BLOCK);
 113
 114   // Energy Meter Interface
 115   // {45BD8344-7ED6-49cf-A440-C276C933B053}
 116   // https://learn.microsoft.com/en-us/windows-hardware/drivers/powermeter/energy-meter-interface
 117   //
 118   // Get device information set for the Energy Meter Interface.
 119   base::win::ScopedDevInfo dev_info(
 120       SetupDiGetClassDevs(&GUID_DEVICE_ENERGY_METER, nullptr, nullptr,
 121                           DIGCF_PRESENT | DIGCF_DEVICEINTERFACE));
 122   if (!dev_info.is_valid()) {
 123     PLOG(WARNING) << "SetupDiGetClassDevs";
 124     return false;
 125   }
 126
 127   // Pick the first device interface in the returned device information set.
 128   //
 129   // TODO(crbug.com/1385251): Determine if the first device interface is always
 130   // the desired one.
 131   SP_DEVICE_INTERFACE_DATA dev_data = {0};
 132   dev_data.cbSize = sizeof(dev_data);
 133   if (!SetupDiEnumDeviceInterfaces(dev_info.get(), nullptr,
 134                                    &GUID_DEVICE_ENERGY_METER, 0, &dev_data)) {
 135     PLOG(WARNING) << "SetupDiEnumDeviceInterfaces";
 136     return false;
 137   }
 138
 139   // Get the required size of device interface detail data.
 140   DWORD required_size = 0;
 141   if (SetupDiGetDeviceInterfaceDetail(dev_info.get(), &dev_data, nullptr, 0,
 142                                       &required_size, nullptr) ||
 143       ::GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
 144     return false;
 145   }
 146
 147   // Get the pointer to an SP_DEVICE_INTERFACE_DETAIL_DATA structure to
 148   // receive information.
 149   std::unique_ptr<SP_DEVICE_INTERFACE_DETAIL_DATA, base::FreeDeleter>
 150       dev_detail_data(
 151           static_cast<SP_DEVICE_INTERFACE_DETAIL_DATA*>(malloc(required_size)));
 152   dev_detail_data->cbSize = sizeof(*dev_detail_data);
 153   if (!SetupDiGetDeviceInterfaceDetail(dev_info.get(), &dev_data,
 154                                        dev_detail_data.get(), required_size,
 155                                        nullptr, nullptr)) {
 156     PLOG(WARNING) << "SetupDiGetDeviceInterfaceDetail";
 157     return false;
 158   }
 159
 160   // Get the handle to access Energy Meter Interface.
 161   handle_.Set(::CreateFile(dev_detail_data->DevicePath, GENERIC_READ,
 162                            FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
 163                            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
 164   if (!handle_.is_valid()) {
 165     LOG(WARNING) << "Failed to set up handle";
 166     return false;
 167   }
 168
 169   DWORD bytes_returned = 0;
 170
 171   // Verify the EMI interface version.
 172   EMI_VERSION emi_version = {0};
 173   if (!DeviceIoControl(handle_.get(), IOCTL_EMI_GET_VERSION, nullptr, 0,
 174                        &emi_version, sizeof(emi_version), &bytes_returned,
 175                        nullptr)) {
 176     PLOG(WARNING) << "EMI interface not available";
 177     return false;
 178   }
 179   CHECK_EQ(bytes_returned, sizeof(emi_version));
 180
 181   if (emi_version.EmiVersion != EMI_VERSION_V2 &&
 182       emi_version.EmiVersion != EMI_VERSION_V1) {
 183     LOG(WARNING) << "EMI version not supported, EMI version = "
 184                  << emi_version.EmiVersion;
 185     return false;
 186   }
 187
 188   // Get the size of the EMI metadata.
 189   EMI_METADATA_SIZE metadata_size = {0};
 190   if (!DeviceIoControl(handle_.get(), IOCTL_EMI_GET_METADATA_SIZE, nullptr, 0,
 191                        &metadata_size, sizeof(metadata_size), &bytes_returned,
 192                        nullptr)) {
 193     PLOG(ERROR) << "IOCTL_EMI_GET_METADATA_SIZE";
 194     return false;
 195   }
 196   CHECK_EQ(bytes_returned, sizeof(metadata_size));
 197
 198   if (!metadata_size.MetadataSize) {
 199     LOG(ERROR) << "MetadataSize == 0";
 200     return false;
 201   }
 202
 203   // Get the EMI metadata.
 204   std::vector<char> metadata_buf(metadata_size.MetadataSize);
 205   if (!DeviceIoControl(handle_.get(), IOCTL_EMI_GET_METADATA, nullptr, 0,
 206                        metadata_buf.data(), metadata_size.MetadataSize,
 207                        &bytes_returned, nullptr)) {
 208     PLOG(ERROR) << "IOCTL_EMI_GET_METADATA";
 209     return false;
 210   }
 211   CHECK_EQ(static_cast<DWORD>(bytes_returned), metadata_buf.size());
 212
 213   // For different EMI versions, get the types of available metrics
 214   // respectively.
 215   if (emi_version.EmiVersion == EMI_VERSION_V1) {
 216     EMI_METADATA_V1* metadata_v1 =
 217         reinterpret_cast<EMI_METADATA_V1*>(metadata_buf.data());
 218     metric_types_.push_back(metadata_v1->MeteredHardwareName);
 219   } else if (emi_version.EmiVersion == EMI_VERSION_V2) {
 220     EMI_METADATA_V2* metadata_v2 =
 221         reinterpret_cast<EMI_METADATA_V2*>(metadata_buf.data());
 222     EMI_CHANNEL_V2* channel = &metadata_v2->Channels[0];
 223     // EMI v2 has a different channel for each metric.
 224     for (int i = 0; i < metadata_v2->ChannelCount; ++i) {
 225       metric_types_.push_back(channel->ChannelName);
 226       channel = EMI_CHANNEL_V2_NEXT_CHANNEL(channel);
 227     }
 228   }
 229
 230   if (metric_types_.empty()) {
 231     LOG(WARNING) << "No available energy metric";
 232     return false;
 233   }
 234   return true;
 235 }
 236
 237 }  // namespace power_metrics