Debian Codegraph @

level_zero/tools/test/unit_tests/sources/sysman/windows/test_sysman_manager.cpp

raw
1 /*
2 * Copyright (C) 2020-2025 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
9 #include "level_zero/tools/source/sysman/sysman_const.h"
10 #include "level_zero/tools/source/sysman/sysman_imp.h"
11 #include "level_zero/tools/source/sysman/windows/os_sysman_imp.h"
12 #include "level_zero/tools/test/unit_tests/sources/sysman/windows/mock_kmd_sys_manager.h"
13
14 #include "gtest/gtest.h"
15
16 extern bool sysmanUltsEnable;
17
18 namespace L0 {
19 namespace ult {
20
21 uint64_t convertTStoMicroSec(uint64_t ts, uint32_t freq) {
22 double timeFactor = 1.0 / static_cast<double>(freq);
23 timeFactor = static_cast<double>(ts) * timeFactor;
24 timeFactor *= static_cast<double>(microFacor);
25 return static_cast<uint64_t>(timeFactor);
26 }
27
28 class SysmanKmdManagerFixture : public ::testing::Test {
29
30 protected:
31 Mock<MockKmdSysManager> *pKmdSysManager = nullptr;
32
33 void SetUp() override {
34 if (!sysmanUltsEnable) {
35 GTEST_SKIP();
36 }
37 pKmdSysManager = new Mock<MockKmdSysManager>;
38 }
39 void TearDown() override {
40 if (!sysmanUltsEnable) {
41 GTEST_SKIP();
42 }
43 if (pKmdSysManager != nullptr) {
44 delete pKmdSysManager;
45 pKmdSysManager = nullptr;
46 }
47 }
48 };
49
50 TEST_F(SysmanKmdManagerFixture, GivenAllowSetCallsFalseWhenRequestingSingleThenPowerValueIsCorrect) {
51 pKmdSysManager->allowSetCalls = false;
52
53 ze_result_t result = ZE_RESULT_SUCCESS;
54 KmdSysman::RequestProperty request;
55 KmdSysman::ResponseProperty response;
56
57 request.commandId = KmdSysman::Command::Get;
58 request.componentId = KmdSysman::Component::PowerComponent;
59 request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit1;
60
61 result = pKmdSysManager->requestSingle(request, response);
62
63 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
64
65 uint32_t value = 0;
66 memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
67 value = static_cast<uint32_t>(value);
68
69 EXPECT_EQ(value, pKmdSysManager->mockPowerLimit1);
70 }
71
72 TEST_F(SysmanKmdManagerFixture, GivenAllowSetCallsTrueWhenRequestingSingleThenPowerValueIsCorrect) {
73 pKmdSysManager->allowSetCalls = true;
74
75 ze_result_t result = ZE_RESULT_SUCCESS;
76 KmdSysman::RequestProperty request;
77 KmdSysman::ResponseProperty response;
78
79 constexpr uint32_t increase = 500;
80 uint32_t iniitialPl1 = pKmdSysManager->mockPowerLimit1;
81
82 request.commandId = KmdSysman::Command::Get;
83 request.componentId = KmdSysman::Component::PowerComponent;
84 request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit1;
85 request.dataSize = 0;
86
87 result = pKmdSysManager->requestSingle(request, response);
88
89 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
90
91 uint32_t value = 0;
92 memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
93 value = static_cast<uint32_t>(value);
94
95 EXPECT_EQ(value, iniitialPl1);
96
97 value += increase;
98
99 request.commandId = KmdSysman::Command::Set;
100 request.componentId = KmdSysman::Component::PowerComponent;
101 request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit1;
102 request.dataSize = sizeof(uint32_t);
103
104 memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
105
106 result = pKmdSysManager->requestSingle(request, response);
107
108 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
109
110 request.commandId = KmdSysman::Command::Get;
111 request.componentId = KmdSysman::Component::PowerComponent;
112 request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit1;
113 request.dataSize = 0;
114
115 result = pKmdSysManager->requestSingle(request, response);
116
117 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
118
119 value = 0;
120 memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
121 value = static_cast<uint32_t>(value);
122
123 EXPECT_EQ(value, (iniitialPl1 + increase));
124 }
125
126 TEST_F(SysmanKmdManagerFixture, GivenAllowSetCallsFalseAndCorruptedDataWhenRequestingSingleThenCallFails) {
127 pKmdSysManager->allowSetCalls = false;
128
129 ze_result_t result = ZE_RESULT_SUCCESS;
130 KmdSysman::RequestProperty request;
131 KmdSysman::ResponseProperty response;
132
133 request.commandId = KmdSysman::Command::Get;
134 request.componentId = KmdSysman::Component::PowerComponent;
135 request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit1;
136 request.dataSize = sizeof(uint64_t);
137
138 result = pKmdSysManager->requestSingle(request, response);
139
140 EXPECT_NE(ZE_RESULT_SUCCESS, result);
141
142 request.commandId = KmdSysman::Command::MaxCommands;
143 request.componentId = KmdSysman::Component::PowerComponent;
144 request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit1;
145 request.dataSize = 0;
146
147 result = pKmdSysManager->requestSingle(request, response);
148
149 EXPECT_NE(ZE_RESULT_SUCCESS, result);
150
151 request.commandId = KmdSysman::Command::Get;
152 request.componentId = KmdSysman::Component::MaxComponents;
153 request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit1;
154 request.dataSize = 0;
155
156 result = pKmdSysManager->requestSingle(request, response);
157
158 EXPECT_NE(ZE_RESULT_SUCCESS, result);
159
160 request.commandId = KmdSysman::Command::Get;
161 request.componentId = KmdSysman::Component::PowerComponent;
162 request.requestId = KmdSysman::Requests::Power::MaxPowerRequests;
163 request.dataSize = 0;
164
165 result = pKmdSysManager->requestSingle(request, response);
166
167 EXPECT_NE(ZE_RESULT_SUCCESS, result);
168 }
169
170 TEST_F(SysmanKmdManagerFixture, GivenAllowSetCallsTrueAndCorruptedDataWhenRequestingSingleThenCallFails) {
171 pKmdSysManager->allowSetCalls = true;
172
173 ze_result_t result = ZE_RESULT_SUCCESS;
174 KmdSysman::RequestProperty request;
175 KmdSysman::ResponseProperty response;
176 uint32_t value = 0;
177
178 request.commandId = KmdSysman::Command::Set;
179 request.componentId = KmdSysman::Component::PowerComponent;
180 request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit1;
181 request.dataSize = 0;
182 memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
183
184 result = pKmdSysManager->requestSingle(request, response);
185
186 EXPECT_NE(ZE_RESULT_SUCCESS, result);
187
188 request.commandId = KmdSysman::Command::MaxCommands;
189 request.componentId = KmdSysman::Component::PowerComponent;
190 request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit1;
191 request.dataSize = sizeof(uint32_t);
192
193 result = pKmdSysManager->requestSingle(request, response);
194
195 EXPECT_NE(ZE_RESULT_SUCCESS, result);
196
197 request.commandId = KmdSysman::Command::Get;
198 request.componentId = KmdSysman::Component::MaxComponents;
199 request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit1;
200
201 result = pKmdSysManager->requestSingle(request, response);
202
203 EXPECT_NE(ZE_RESULT_SUCCESS, result);
204
205 request.commandId = KmdSysman::Command::Get;
206 request.componentId = KmdSysman::Component::PowerComponent;
207 request.requestId = KmdSysman::Requests::Power::MaxPowerRequests;
208
209 result = pKmdSysManager->requestSingle(request, response);
210
211 EXPECT_NE(ZE_RESULT_SUCCESS, result);
212 }
213
214 TEST_F(SysmanKmdManagerFixture, GivenAllowSetCallsFalseAndTDROccurredWhenRequestSingleIsCalledThenErrorDeviceLostIsReturned) {
215 pKmdSysManager->allowSetCalls = false;
216 pKmdSysManager->mockEscapeResult = STATUS_DEVICE_REMOVED;
217
218 ze_result_t result = ZE_RESULT_SUCCESS;
219 KmdSysman::RequestProperty request;
220 KmdSysman::ResponseProperty response;
221 uint32_t value = 0;
222
223 request.commandId = KmdSysman::Command::Set;
224 request.componentId = KmdSysman::Component::PowerComponent;
225 request.requestId = KmdSysman::Requests::Power::CurrentPowerLimit1;
226 request.dataSize = 0;
227 memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
228
229 result = pKmdSysManager->requestSingle(request, response);
230
231 EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, result);
232 }
233
234 TEST_F(SysmanKmdManagerFixture, GivenAllowSetCallsFalseAndTDROccurredWhenRequestMultipleIsCalledThenErrorDeviceLostIsReturned) {
235 pKmdSysManager->allowSetCalls = false;
236 pKmdSysManager->mockEscapeResult = STATUS_DEVICE_REMOVED;
237
238 ze_result_t result = ZE_RESULT_SUCCESS;
239 std::vector<KmdSysman::RequestProperty> vRequests = {};
240 std::vector<KmdSysman::ResponseProperty> vResponses = {};
241 KmdSysman::RequestProperty request = {};
242
243 request.commandId = KmdSysman::Command::Get;
244 request.componentId = KmdSysman::Component::MemoryComponent;
245
246 request.requestId = KmdSysman::Requests::Memory::MaxBandwidth;
247 vRequests.push_back(request);
248
249 request.requestId = KmdSysman::Requests::Memory::CurrentBandwidthRead;
250 vRequests.push_back(request);
251
252 request.requestId = KmdSysman::Requests::Memory::CurrentBandwidthWrite;
253 vRequests.push_back(request);
254
255 result = pKmdSysManager->requestMultiple(vRequests, vResponses);
256 EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, result);
257 }
258
259 } // namespace ult
260 } // namespace L0