nvidia-gpu: add energy sensor
This commit introduces a energy sensor for the GPU.
Tested: Build an image for gb200nvl-obmc machine with the following
patches cherry picked. This patches are needed to enable the mctp stack.
https://gerrit.openbmc.org/c/openbmc/openbmc/+/79422
```
$ curl -s -k -u 'root:0penBmc' https://10.137.203.137/redfish/v1/Chassis/NVIDIA_GB200_1/Sensors/energy_NVIDIA_GB200_GPU_0_Energy_0
{
"@odata.id": "/redfish/v1/Chassis/NVIDIA_GB200_1/Sensors/energy_NVIDIA_GB200_GPU_0_Energy_0",
"@odata.type": "#Sensor.v1_2_0.Sensor",
"Id": "energy_NVIDIA_GB200_GPU_0_Energy_0",
"Name": "NVIDIA GB200 GPU 0 Energy 0",
"Reading": 269947.856,
"ReadingRangeMax": 1.8446744073709552e+16,
"ReadingRangeMin": 0.0,
"ReadingType": "EnergyJoules",
"ReadingUnits": "J",
"Status": {
"Health": "OK",
"State": "Enabled"
}
}%
```
Change-Id: I6f53ab2a83eedd54005bbdcd781dc8d320d7f26a
Signed-off-by: Harshit Aghera <haghera@nvidia.com>
diff --git a/src/nvidia-gpu/NvidiaGpuDevice.cpp b/src/nvidia-gpu/NvidiaGpuDevice.cpp
index dc30788..082fbbe 100644
--- a/src/nvidia-gpu/NvidiaGpuDevice.cpp
+++ b/src/nvidia-gpu/NvidiaGpuDevice.cpp
@@ -14,6 +14,7 @@
#include <bits/basic_string.h>
#include <MctpRequester.hpp>
+#include <NvidiaGpuEnergySensor.hpp>
#include <NvidiaGpuPowerSensor.hpp>
#include <NvidiaGpuThresholds.hpp>
#include <boost/asio/io_context.hpp>
@@ -61,6 +62,10 @@
conn, mctpRequester, name + "_Power_0", path, eid, gpuPowerSensorId,
objectServer, std::vector<thresholds::Threshold>{});
+ energySensor = std::make_shared<NvidiaGpuEnergySensor>(
+ conn, mctpRequester, name + "_Energy_0", path, eid, gpuEnergySensorId,
+ objectServer, std::vector<thresholds::Threshold>{});
+
lg2::info("Added GPU {NAME} Sensors with chassis path: {PATH}.", "NAME",
name, "PATH", path);
@@ -98,6 +103,7 @@
tLimitSensor->update();
}
powerSensor->update();
+ energySensor->update();
waitTimer.expires_after(std::chrono::milliseconds(sensorPollMs));
waitTimer.async_wait([this](const boost::system::error_code& ec) {
diff --git a/src/nvidia-gpu/NvidiaGpuDevice.hpp b/src/nvidia-gpu/NvidiaGpuDevice.hpp
index 9bcf64e..fc96719 100644
--- a/src/nvidia-gpu/NvidiaGpuDevice.hpp
+++ b/src/nvidia-gpu/NvidiaGpuDevice.hpp
@@ -11,6 +11,7 @@
#include "NvidiaGpuPowerSensor.hpp"
#include "NvidiaGpuSensor.hpp"
+#include <NvidiaGpuEnergySensor.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/steady_timer.hpp>
#include <sdbusplus/asio/connection.hpp>
@@ -60,6 +61,7 @@
std::shared_ptr<NvidiaGpuTempSensor> tempSensor;
std::shared_ptr<NvidiaGpuTempSensor> tLimitSensor;
std::shared_ptr<NvidiaGpuPowerSensor> powerSensor;
+ std::shared_ptr<NvidiaGpuEnergySensor> energySensor;
SensorConfigs configs;
diff --git a/src/nvidia-gpu/NvidiaGpuEnergySensor.cpp b/src/nvidia-gpu/NvidiaGpuEnergySensor.cpp
new file mode 100644
index 0000000..6d0fcd8
--- /dev/null
+++ b/src/nvidia-gpu/NvidiaGpuEnergySensor.cpp
@@ -0,0 +1,129 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "NvidiaGpuEnergySensor.hpp"
+
+#include "SensorPaths.hpp"
+#include "Thresholds.hpp"
+#include "Utils.hpp"
+#include "sensor.hpp"
+
+#include <bits/basic_string.h>
+
+#include <MctpRequester.hpp>
+#include <NvidiaDeviceDiscovery.hpp>
+#include <NvidiaGpuMctpVdm.hpp>
+#include <OcpMctpVdm.hpp>
+#include <phosphor-logging/lg2.hpp>
+#include <sdbusplus/asio/connection.hpp>
+#include <sdbusplus/asio/object_server.hpp>
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+using namespace std::literals;
+
+// Reading from the device is in millijoules and unit set on the dbus is Joules.
+static constexpr double gpuEnergySensorMaxReading =
+ std::numeric_limits<uint64_t>::max() / 1000.0;
+static constexpr double gpuEnergySensorMinReading = 0.0;
+
+NvidiaGpuEnergySensor::NvidiaGpuEnergySensor(
+ std::shared_ptr<sdbusplus::asio::connection>& conn,
+ mctp::MctpRequester& mctpRequester, const std::string& name,
+ const std::string& sensorConfiguration, const uint8_t eid, uint8_t sensorId,
+ sdbusplus::asio::object_server& objectServer,
+ std::vector<thresholds::Threshold>&& thresholdData) :
+ Sensor(escapeName(name), std::move(thresholdData), sensorConfiguration,
+ "energy", false, true, gpuEnergySensorMaxReading,
+ gpuEnergySensorMinReading, conn),
+ eid(eid), sensorId{sensorId}, mctpRequester(mctpRequester),
+ objectServer(objectServer)
+{
+ std::string dbusPath = sensorPathPrefix + "energy/"s + escapeName(name);
+
+ sensorInterface = objectServer.add_interface(
+ dbusPath, "xyz.openbmc_project.Sensor.Value");
+
+ for (const auto& threshold : thresholds)
+ {
+ std::string interface = thresholds::getInterface(threshold.level);
+ thresholdInterfaces[static_cast<size_t>(threshold.level)] =
+ objectServer.add_interface(dbusPath, interface);
+ }
+
+ association = objectServer.add_interface(dbusPath, association::interface);
+
+ setInitialProperties(sensor_paths::unitJoules);
+}
+
+NvidiaGpuEnergySensor::~NvidiaGpuEnergySensor()
+{
+ for (const auto& iface : thresholdInterfaces)
+ {
+ objectServer.remove_interface(iface);
+ }
+ objectServer.remove_interface(sensorInterface);
+ objectServer.remove_interface(association);
+}
+
+void NvidiaGpuEnergySensor::checkThresholds()
+{
+ thresholds::checkThresholds(this);
+}
+
+void NvidiaGpuEnergySensor::processResponse(int sendRecvMsgResult)
+{
+ if (sendRecvMsgResult != 0)
+ {
+ lg2::error(
+ "Error updating Energy Sensor for eid {EID} and sensor id {SID} : sending message over MCTP failed, rc={RC}",
+ "EID", eid, "SID", sensorId, "RC", sendRecvMsgResult);
+ return;
+ }
+
+ ocp::accelerator_management::CompletionCode cc{};
+ uint16_t reasonCode = 0;
+ uint64_t energyValue = 0;
+
+ auto rc = gpu::decodeGetCurrentEnergyCounterResponse(
+ response, cc, reasonCode, energyValue);
+
+ if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
+ {
+ lg2::error(
+ "Error updating Energy Sensor for eid {EID} and sensor id {SID} : decode failed, rc={RC}, cc={CC}, reasonCode={RESC}",
+ "EID", eid, "SID", sensorId, "RC", rc, "CC", cc, "RESC",
+ reasonCode);
+ return;
+ }
+
+ // Reading from the device is in millijoules and unit set on the dbus
+ // is Joules.
+ updateValue(energyValue / 1000.0);
+}
+
+void NvidiaGpuEnergySensor::update()
+{
+ auto rc = gpu::encodeGetCurrentEnergyCounterRequest(0, sensorId, request);
+
+ if (rc != 0)
+ {
+ lg2::error(
+ "Error updating Energy Sensor for eid {EID} and sensor id {SID} : encode failed, rc={RC}",
+ "EID", eid, "SID", sensorId, "RC", rc);
+ return;
+ }
+
+ mctpRequester.sendRecvMsg(
+ eid, request, response,
+ [this](int sendRecvMsgResult) { processResponse(sendRecvMsgResult); });
+}
diff --git a/src/nvidia-gpu/NvidiaGpuEnergySensor.hpp b/src/nvidia-gpu/NvidiaGpuEnergySensor.hpp
new file mode 100644
index 0000000..19bb982
--- /dev/null
+++ b/src/nvidia-gpu/NvidiaGpuEnergySensor.hpp
@@ -0,0 +1,58 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION &
+ * AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "MctpRequester.hpp"
+#include "Thresholds.hpp"
+#include "sensor.hpp"
+
+#include <NvidiaGpuMctpVdm.hpp>
+#include <sdbusplus/asio/connection.hpp>
+#include <sdbusplus/asio/object_server.hpp>
+
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+constexpr uint8_t gpuEnergySensorId{0};
+
+struct NvidiaGpuEnergySensor : public Sensor
+{
+ public:
+ NvidiaGpuEnergySensor(
+ std::shared_ptr<sdbusplus::asio::connection>& conn,
+ mctp::MctpRequester& mctpRequester, const std::string& name,
+ const std::string& sensorConfiguration, uint8_t eid, uint8_t sensorId,
+ sdbusplus::asio::object_server& objectServer,
+ std::vector<thresholds::Threshold>&& thresholdData);
+
+ ~NvidiaGpuEnergySensor() override;
+
+ void checkThresholds() override;
+
+ void update();
+
+ private:
+ void processResponse(int sendRecvMsgResult);
+
+ uint8_t eid{};
+
+ uint8_t sensorId;
+
+ std::shared_ptr<sdbusplus::asio::connection> conn;
+
+ mctp::MctpRequester& mctpRequester;
+
+ sdbusplus::asio::object_server& objectServer;
+
+ std::array<uint8_t, sizeof(gpu::GetCurrentEnergyCounterRequest)> request{};
+
+ std::array<uint8_t, sizeof(gpu::GetCurrentEnergyCounterResponse)>
+ response{};
+};
diff --git a/src/nvidia-gpu/NvidiaGpuMctpVdm.cpp b/src/nvidia-gpu/NvidiaGpuMctpVdm.cpp
index 2355bf9..b70e0c2 100644
--- a/src/nvidia-gpu/NvidiaGpuMctpVdm.cpp
+++ b/src/nvidia-gpu/NvidiaGpuMctpVdm.cpp
@@ -284,5 +284,70 @@
return 0;
}
+
+int encodeGetCurrentEnergyCounterRequest(uint8_t instanceId, uint8_t sensorId,
+ std::span<uint8_t> buf)
+{
+ if (buf.size() < sizeof(GetTemperatureReadingRequest))
+ {
+ return EINVAL;
+ }
+
+ auto* msg = reinterpret_cast<GetCurrentEnergyCounterRequest*>(buf.data());
+
+ ocp::accelerator_management::BindingPciVidInfo header{};
+ header.ocp_accelerator_management_msg_type =
+ static_cast<uint8_t>(ocp::accelerator_management::MessageType::REQUEST);
+ header.instance_id = instanceId &
+ ocp::accelerator_management::instanceIdBitMask;
+ header.msg_type = static_cast<uint8_t>(MessageType::PLATFORM_ENVIRONMENTAL);
+
+ auto rc = packHeader(header, msg->hdr.msgHdr.hdr);
+
+ if (rc != 0)
+ {
+ return rc;
+ }
+
+ msg->hdr.command = static_cast<uint8_t>(
+ PlatformEnvironmentalCommands::GET_CURRENT_ENERGY_COUNTER);
+ msg->hdr.data_size = sizeof(sensorId);
+ msg->sensor_id = sensorId;
+
+ return 0;
+}
+
+int decodeGetCurrentEnergyCounterResponse(
+ std::span<const uint8_t> buf,
+ ocp::accelerator_management::CompletionCode& cc, uint16_t& reasonCode,
+ uint64_t& energy)
+{
+ auto rc =
+ ocp::accelerator_management::decodeReasonCodeAndCC(buf, cc, reasonCode);
+
+ if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
+ {
+ return rc;
+ }
+
+ if (buf.size() < sizeof(GetCurrentPowerDrawResponse))
+ {
+ return EINVAL;
+ }
+
+ const auto* response =
+ reinterpret_cast<const GetCurrentEnergyCounterResponse*>(buf.data());
+
+ const uint16_t dataSize = le16toh(response->hdr.data_size);
+
+ if (dataSize != sizeof(uint64_t))
+ {
+ return EINVAL;
+ }
+
+ energy = le32toh(response->energy);
+
+ return 0;
+}
// NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast)
} // namespace gpu
diff --git a/src/nvidia-gpu/NvidiaGpuMctpVdm.hpp b/src/nvidia-gpu/NvidiaGpuMctpVdm.hpp
index c7f7511..10a3efc 100644
--- a/src/nvidia-gpu/NvidiaGpuMctpVdm.hpp
+++ b/src/nvidia-gpu/NvidiaGpuMctpVdm.hpp
@@ -32,6 +32,7 @@
GET_TEMPERATURE_READING = 0x00,
READ_THERMAL_PARAMETERS = 0x02,
GET_CURRENT_POWER_DRAW = 0x03,
+ GET_CURRENT_ENERGY_COUNTER = 0x06,
};
enum class DeviceIdentification : uint8_t
@@ -68,6 +69,8 @@
uint8_t averagingInterval;
} __attribute__((packed));
+using GetCurrentEnergyCounterRequest = GetNumericSensorReadingRequest;
+
struct GetTemperatureReadingResponse
{
ocp::accelerator_management::CommonResponse hdr;
@@ -86,6 +89,12 @@
uint32_t power;
} __attribute__((packed));
+struct GetCurrentEnergyCounterResponse
+{
+ ocp::accelerator_management::CommonResponse hdr;
+ uint64_t energy;
+} __attribute__((packed));
+
int packHeader(const ocp::accelerator_management::BindingPciVidInfo& hdr,
ocp::accelerator_management::BindingPciVid& msg);
@@ -121,4 +130,12 @@
std::span<const uint8_t> buf,
ocp::accelerator_management::CompletionCode& cc, uint16_t& reasonCode,
uint32_t& power);
+
+int encodeGetCurrentEnergyCounterRequest(uint8_t instanceId, uint8_t sensorId,
+ std::span<uint8_t> buf);
+
+int decodeGetCurrentEnergyCounterResponse(
+ std::span<const uint8_t> buf,
+ ocp::accelerator_management::CompletionCode& cc, uint16_t& reasonCode,
+ uint64_t& energy);
} // namespace gpu
diff --git a/src/nvidia-gpu/meson.build b/src/nvidia-gpu/meson.build
index 2e275fc..11aaab3 100644
--- a/src/nvidia-gpu/meson.build
+++ b/src/nvidia-gpu/meson.build
@@ -2,6 +2,7 @@
'MctpRequester.cpp',
'NvidiaDeviceDiscovery.cpp',
'NvidiaGpuDevice.cpp',
+ 'NvidiaGpuEnergySensor.cpp',
'NvidiaGpuMctpVdm.cpp',
'NvidiaGpuPowerSensor.cpp',
'NvidiaGpuSensor.cpp',
diff --git a/src/nvidia-gpu/tests/NvidiaGpuSensorTest.cpp b/src/nvidia-gpu/tests/NvidiaGpuSensorTest.cpp
index e319ebc..2c02d3b 100644
--- a/src/nvidia-gpu/tests/NvidiaGpuSensorTest.cpp
+++ b/src/nvidia-gpu/tests/NvidiaGpuSensorTest.cpp
@@ -795,6 +795,158 @@
EXPECT_EQ(result, EINVAL); // Should indicate error for invalid data size
}
+
+// Tests for GpuMctpVdm::encodeGetCurrentEnergyCounterRequest function
+TEST_F(GpuMctpVdmTests, EncodeGetCurrentEnergyCounterRequestSuccess)
+{
+ const uint8_t instanceId = 7;
+ const uint8_t sensorId = 3;
+ std::array<uint8_t, sizeof(gpu::GetCurrentEnergyCounterRequest)> buf{};
+
+ int result =
+ gpu::encodeGetCurrentEnergyCounterRequest(instanceId, sensorId, buf);
+
+ EXPECT_EQ(result, 0);
+
+ gpu::GetCurrentEnergyCounterRequest request{};
+ std::memcpy(&request, buf.data(), sizeof(request));
+
+ EXPECT_EQ(request.hdr.msgHdr.hdr.pci_vendor_id,
+ htobe16(gpu::nvidiaPciVendorId));
+ EXPECT_EQ(request.hdr.msgHdr.hdr.instance_id &
+ ocp::accelerator_management::instanceIdBitMask,
+ instanceId & ocp::accelerator_management::instanceIdBitMask);
+ EXPECT_NE(request.hdr.msgHdr.hdr.instance_id &
+ ocp::accelerator_management::requestBitMask,
+ 0);
+ EXPECT_EQ(request.hdr.msgHdr.hdr.ocp_accelerator_management_msg_type,
+ static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL));
+
+ // Verify request data
+ EXPECT_EQ(
+ request.hdr.command,
+ static_cast<uint8_t>(
+ gpu::PlatformEnvironmentalCommands::GET_CURRENT_ENERGY_COUNTER));
+ EXPECT_EQ(request.hdr.data_size, sizeof(sensorId));
+ EXPECT_EQ(request.sensor_id, sensorId);
+}
+
+// Tests for GpuMctpVdm::decodeGetCurrentEnergyCounterResponse function
+TEST_F(GpuMctpVdmTests, DecodeGetCurrentEnergyCounterResponseSuccess)
+{
+ // Create a mock successful response
+ std::array<uint8_t, sizeof(gpu::GetCurrentEnergyCounterResponse)> buf{};
+
+ gpu::GetCurrentEnergyCounterResponse response{};
+ ocp::accelerator_management::BindingPciVidInfo headerInfo{};
+ headerInfo.ocp_accelerator_management_msg_type = static_cast<uint8_t>(
+ ocp::accelerator_management::MessageType::RESPONSE);
+ headerInfo.instance_id = 7;
+ headerInfo.msg_type =
+ static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL);
+
+ gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
+
+ // Populate response data
+ response.hdr.command = static_cast<uint8_t>(
+ gpu::PlatformEnvironmentalCommands::GET_CURRENT_ENERGY_COUNTER);
+ response.hdr.completion_code = static_cast<uint8_t>(
+ ocp::accelerator_management::CompletionCode::SUCCESS);
+ response.hdr.reserved = 0;
+ response.hdr.data_size = htole16(sizeof(uint64_t));
+
+ // Set an energy value of 1000 Wh (1000 * 3600 = 3600000 Joules)
+ response.energy = htole64(3600000);
+
+ std::memcpy(buf.data(), &response, sizeof(response));
+
+ // Test decoding
+ ocp::accelerator_management::CompletionCode cc{};
+ uint16_t reasonCode{};
+ uint64_t energy{};
+
+ int result =
+ gpu::decodeGetCurrentEnergyCounterResponse(buf, cc, reasonCode, energy);
+
+ EXPECT_EQ(result, 0);
+ EXPECT_EQ(cc, ocp::accelerator_management::CompletionCode::SUCCESS);
+ EXPECT_EQ(reasonCode, 0);
+ EXPECT_EQ(energy, 3600000);
+}
+
+TEST_F(GpuMctpVdmTests, DecodeGetCurrentEnergyCounterResponseError)
+{
+ std::array<uint8_t,
+ sizeof(ocp::accelerator_management::CommonNonSuccessResponse)>
+ buf{};
+
+ // Populate error response data
+ ocp::accelerator_management::CommonNonSuccessResponse errorResponse{};
+ ocp::accelerator_management::BindingPciVidInfo headerInfo{};
+ headerInfo.ocp_accelerator_management_msg_type = static_cast<uint8_t>(
+ ocp::accelerator_management::MessageType::RESPONSE);
+ headerInfo.instance_id = 7;
+ headerInfo.msg_type =
+ static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL);
+
+ gpu::packHeader(headerInfo, errorResponse.msgHdr.hdr);
+
+ errorResponse.command = static_cast<uint8_t>(
+ gpu::PlatformEnvironmentalCommands::GET_CURRENT_ENERGY_COUNTER);
+ errorResponse.completion_code = static_cast<uint8_t>(
+ ocp::accelerator_management::CompletionCode::ERR_NOT_READY);
+ errorResponse.reason_code = htole16(0xDEF0);
+
+ std::memcpy(buf.data(), &errorResponse, sizeof(errorResponse));
+
+ // Test decoding
+ ocp::accelerator_management::CompletionCode cc{};
+ uint16_t reasonCode{};
+ uint64_t energy{};
+
+ int result =
+ gpu::decodeGetCurrentEnergyCounterResponse(buf, cc, reasonCode, energy);
+
+ EXPECT_EQ(result, 0);
+ EXPECT_EQ(cc, ocp::accelerator_management::CompletionCode::ERR_NOT_READY);
+ EXPECT_EQ(reasonCode, 0xDEF0);
+}
+
+TEST_F(GpuMctpVdmTests, DecodeGetCurrentEnergyCounterResponseInvalidSize)
+{
+ // Create a mock response with invalid data_size
+ std::array<uint8_t, sizeof(gpu::GetCurrentEnergyCounterResponse)> buf{};
+
+ gpu::GetCurrentEnergyCounterResponse response{};
+ ocp::accelerator_management::BindingPciVidInfo headerInfo{};
+ headerInfo.ocp_accelerator_management_msg_type = static_cast<uint8_t>(
+ ocp::accelerator_management::MessageType::RESPONSE);
+ headerInfo.instance_id = 7;
+ headerInfo.msg_type =
+ static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL);
+
+ gpu::packHeader(headerInfo, response.hdr.msgHdr.hdr);
+
+ response.hdr.command = static_cast<uint8_t>(
+ gpu::PlatformEnvironmentalCommands::GET_CURRENT_ENERGY_COUNTER);
+ response.hdr.completion_code = static_cast<uint8_t>(
+ ocp::accelerator_management::CompletionCode::SUCCESS);
+ response.hdr.reserved = 0;
+ response.hdr.data_size = htole16(4); // Invalid - should be sizeof(uint64_t)
+ response.energy = htole64(3600000);
+
+ std::memcpy(buf.data(), &response, sizeof(response));
+
+ // Test decoding
+ ocp::accelerator_management::CompletionCode cc{};
+ uint16_t reasonCode{};
+ uint64_t energy{};
+
+ int result =
+ gpu::decodeGetCurrentEnergyCounterResponse(buf, cc, reasonCode, energy);
+
+ EXPECT_EQ(result, EINVAL); // Should indicate error for invalid data size
+}
} // namespace gpu_mctp_tests
int main(int argc, char** argv)