| /* |
| * SPDX-FileCopyrightText: Copyright OpenBMC Authors |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include "MctpMockTestBase.hpp" |
| #include "MessagePackUnpackUtils.hpp" |
| #include "MockMctpRequester.hpp" |
| #include "NvidiaGpuMctpVdm.hpp" |
| #include "NvidiaGpuViolationDuration.hpp" |
| #include "NvidiaLongRunningHandler.hpp" |
| #include "OcpMctpVdm.hpp" |
| #include "SerialQueue.hpp" |
| #include "TestUtils.hpp" |
| |
| #include <cstdint> |
| #include <memory> |
| #include <span> |
| #include <string> |
| #include <system_error> |
| #include <vector> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| namespace |
| { |
| |
| constexpr const char* metricIface = "xyz.openbmc_project.Metric.Value"; |
| |
| // Build a GET_VIOLATION_DURATION response with the given completion code: |
| // common response header + 4 x uint64_t (hw, globalSw, power, thermal) in ns |
| std::vector<uint8_t> buildViolationResponse( |
| ocp::accelerator_management::CompletionCode cc, uint64_t hw, |
| uint64_t globalSw, uint64_t power, uint64_t thermal) |
| { |
| const uint16_t dataSize = sizeof(uint64_t) * 4; |
| std::vector<uint8_t> buf( |
| ocp::accelerator_management::commonResponseSize + dataSize, 0); |
| PackBuffer pack(buf); |
| ocp::accelerator_management::packHeader( |
| pack, gpu::nvidiaPciVendorId, |
| ocp::accelerator_management::MessageType::RESPONSE, 0, |
| static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL)); |
| pack.pack(static_cast<uint8_t>( |
| gpu::PlatformEnvironmentalCommands::GET_VIOLATION_DURATION)); |
| pack.pack(static_cast<uint8_t>(cc)); |
| pack.pack(static_cast<uint16_t>(0)); // reasonCode |
| pack.pack(dataSize); |
| pack.pack(hw); |
| pack.pack(globalSw); |
| pack.pack(power); |
| pack.pack(thermal); |
| EXPECT_EQ(pack.getError(), 0); |
| return buf; |
| } |
| |
| // The long-running response event carries the command payload on its own: |
| // 4 x uint64_t (hw, globalSw, power, thermal) in ns, with no response header. |
| std::vector<uint8_t> buildViolationPayload(uint64_t hw, uint64_t globalSw, |
| uint64_t power, uint64_t thermal) |
| { |
| std::vector<uint8_t> buf(sizeof(uint64_t) * 4, 0); |
| PackBuffer pack(buf); |
| pack.pack(hw); |
| pack.pack(globalSw); |
| pack.pack(power); |
| pack.pack(thermal); |
| EXPECT_EQ(pack.getError(), 0); |
| return buf; |
| } |
| |
| std::vector<uint8_t> buildErrorResponse() |
| { |
| return test_utils::buildPlatformEnvErrorResponse( |
| gpu::PlatformEnvironmentalCommands::GET_VIOLATION_DURATION, |
| static_cast<uint8_t>( |
| ocp::accelerator_management::CompletionCode::ERROR), |
| 0x1234); |
| } |
| |
| class NvidiaGpuViolationDurationTest : public MctpMockTestBase |
| { |
| protected: |
| std::shared_ptr<NvidiaGpuViolationDuration> createViolation( |
| const std::string& name = "GPU_VIOL", |
| uint8_t eid = test_utils::defaultEid) |
| { |
| auto queue = std::make_shared<SerialQueue>(ioContext()); |
| return std::make_shared<NvidiaGpuViolationDuration>( |
| requester(), objects(), name, eid, queue, lrHandler); |
| } |
| |
| static std::string powerPath(const std::string& name) |
| { |
| return "/xyz/openbmc_project/metric/gpu_" + name + |
| "/power_limit_throttle_duration"; |
| } |
| |
| static std::string thermalPath(const std::string& name) |
| { |
| return "/xyz/openbmc_project/metric/gpu_" + name + |
| "/thermal_limit_throttle_duration"; |
| } |
| |
| // Held by the fixture so a test can feed the deferred long-running |
| // response event that follows an ACCEPTED reply. |
| std::shared_ptr<NvidiaLongRunningResponseHandler> lrHandler = |
| std::make_shared<NvidiaLongRunningResponseHandler>(ioContext()); |
| }; |
| |
| TEST_F(NvidiaGpuViolationDurationTest, ConstructorDoesNotCrash) |
| { |
| auto viol = createViolation("viol_ctor"); |
| ASSERT_NE(viol, nullptr); |
| } |
| |
| TEST_F(NvidiaGpuViolationDurationTest, UpdateImmediateSuccessSetsValues) |
| { |
| // power = 2e9 ns -> 2.0 s; thermal = 5e8 ns -> 0.5 s |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce(mock_mctp::respondWith( |
| {}, buildViolationResponse( |
| ocp::accelerator_management::CompletionCode::SUCCESS, 100, |
| 200, 2'000'000'000ULL, 500'000'000ULL))); |
| |
| auto viol = createViolation("viol_succ"); |
| viol->update(); |
| |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(powerPath("viol_succ"), metricIface, "Value"), 2.0); |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(thermalPath("viol_succ"), metricIface, "Value"), |
| 0.5); |
| } |
| |
| TEST_F(NvidiaGpuViolationDurationTest, UpdateSendsRequest) |
| { |
| // WillOnce cardinality asserts the request was actually sent. |
| EXPECT_CALL(mctpMock, sendRecvMsg).WillOnce(mock_mctp::respondWith({}, {})); |
| |
| auto viol = createViolation("viol_sends"); |
| viol->update(); |
| } |
| |
| TEST_F(NvidiaGpuViolationDurationTest, UpdateRequestContainsCorrectEid) |
| { |
| constexpr uint8_t testEid = 42; |
| EXPECT_CALL(mctpMock, sendRecvMsg(testEid, testing::_, testing::_)) |
| .WillOnce(mock_mctp::respondWith({}, {})); |
| |
| auto viol = createViolation("viol_eid", testEid); |
| viol->update(); |
| } |
| |
| TEST_F(NvidiaGpuViolationDurationTest, UpdateVerifiesRequestEncoding) |
| { |
| // Copy the request bytes before completing the call: the reqMsg span is |
| // a view into caller-owned memory, valid only during the call. |
| std::vector<uint8_t> lastRequest; |
| const std::vector<uint8_t> response; |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce([&](uint8_t /*eid*/, std::span<const uint8_t> reqMsg, |
| auto callback) { |
| lastRequest.assign(reqMsg.begin(), reqMsg.end()); |
| callback(std::error_code{}, response); |
| }); |
| |
| auto viol = createViolation("viol_enc"); |
| viol->update(); |
| |
| ASSERT_FALSE(lastRequest.empty()); |
| |
| UnpackBuffer unpack(lastRequest); |
| ocp::accelerator_management::MessageType ocpMsgType{}; |
| uint8_t instanceId = 0; |
| uint8_t msgType = 0; |
| EXPECT_EQ(ocp::accelerator_management::unpackHeader( |
| unpack, gpu::nvidiaPciVendorId, ocpMsgType, instanceId, |
| msgType), |
| 0); |
| EXPECT_EQ(msgType, |
| static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL)); |
| |
| uint8_t command = 0; |
| unpack.unpack(command); |
| EXPECT_EQ(command, |
| static_cast<uint8_t>( |
| gpu::PlatformEnvironmentalCommands::GET_VIOLATION_DURATION)); |
| EXPECT_EQ(unpack.getError(), 0); |
| } |
| |
| TEST_F(NvidiaGpuViolationDurationTest, |
| UpdateAcceptedThenLongRunningEventSetsValues) |
| { |
| // WillOnce cardinality asserts the request was actually sent. |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce(mock_mctp::respondWith( |
| {}, buildViolationResponse( |
| ocp::accelerator_management::CompletionCode::ACCEPTED, 0, 0, |
| 0, 0))); |
| |
| auto viol = createViolation("viol_accepted"); |
| ASSERT_NO_THROW(viol->update()); |
| |
| // ACCEPTED only registers the response handler; the values stay at their |
| // defaults until the long-running response event arrives. |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(powerPath("viol_accepted"), metricIface, "Value"), |
| 0.0); |
| |
| // The event payload carries the command data only, with no response |
| // header, and the ACCEPTED reply above was built with instance id 0. |
| // power = 2e9 ns -> 2.0 s; thermal = 5e8 ns -> 0.5 s |
| lrHandler->handler( |
| test_utils::makeEventInfo( |
| test_utils::longRunningResponseEventClass, |
| static_cast<uint8_t>(gpu::MessageType::PLATFORM_ENVIRONMENTAL), |
| static_cast<uint8_t>( |
| gpu::PlatformEnvironmentalCommands::GET_VIOLATION_DURATION)), |
| test_utils::buildLongRunningEventData( |
| 0, |
| static_cast<uint8_t>( |
| ocp::accelerator_management::CompletionCode::SUCCESS), |
| 0, |
| buildViolationPayload(100, 200, 2'000'000'000ULL, 500'000'000ULL))); |
| |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(powerPath("viol_accepted"), metricIface, "Value"), |
| 2.0); |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(thermalPath("viol_accepted"), metricIface, "Value"), |
| 0.5); |
| } |
| |
| TEST_F(NvidiaGpuViolationDurationTest, UpdateMctpTransportErrorNoCrash) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce(mock_mctp::respondWith( |
| std::make_error_code(std::errc::timed_out), {})); |
| |
| auto viol = createViolation("viol_mctp_err"); |
| EXPECT_NO_THROW(viol->update()); |
| } |
| |
| TEST_F(NvidiaGpuViolationDurationTest, UpdateDecodeErrorNoCrash) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce(mock_mctp::respondWith({}, buildErrorResponse())); |
| |
| auto viol = createViolation("viol_dec_err"); |
| EXPECT_NO_THROW(viol->update()); |
| } |
| |
| TEST_F(NvidiaGpuViolationDurationTest, UpdateEmptyBufferNoCrash) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg).WillOnce(mock_mctp::respondWith({}, {})); |
| |
| auto viol = createViolation("viol_empty"); |
| EXPECT_NO_THROW(viol->update()); |
| } |
| |
| TEST_F(NvidiaGpuViolationDurationTest, UpdateTinyBufferNoCrash) |
| { |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce(mock_mctp::respondWith({}, {0x00, 0x01})); |
| |
| auto viol = createViolation("viol_tiny"); |
| EXPECT_NO_THROW(viol->update()); |
| } |
| |
| TEST_F(NvidiaGpuViolationDurationTest, UpdateSuccessThenErrorKeepsPreviousValue) |
| { |
| // power = 2e9 ns -> 2.0 s; thermal = 5e8 ns -> 0.5 s |
| EXPECT_CALL(mctpMock, sendRecvMsg) |
| .WillOnce(mock_mctp::respondWith( |
| {}, buildViolationResponse( |
| ocp::accelerator_management::CompletionCode::SUCCESS, 100, |
| 200, 2'000'000'000ULL, 500'000'000ULL))) |
| .WillOnce(mock_mctp::respondWith({}, buildErrorResponse())); |
| |
| auto viol = createViolation("viol_keep"); |
| |
| viol->update(); |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(powerPath("viol_keep"), metricIface, "Value"), 2.0); |
| |
| // A subsequent error response must not overwrite the last good values. |
| viol->update(); |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(powerPath("viol_keep"), metricIface, "Value"), 2.0); |
| EXPECT_DOUBLE_EQ( |
| getProperty<double>(thermalPath("viol_keep"), metricIface, "Value"), |
| 0.5); |
| } |
| |
| } // namespace |
