Debian Codegraph @

level_zero/sysman/test/unit_tests/sources/scheduler/linux/test_zes_scheduler.cpp

raw
1 /*
2 * Copyright (C) 2020-2024 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
9 #include "level_zero/sysman/source/sysman_const.h"
10 #include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
11 #include "level_zero/sysman/test/unit_tests/sources/scheduler/linux/mock_sysfs_scheduler.h"
12
13 namespace L0 {
14 namespace Sysman {
15 namespace ult {
16
17 constexpr uint32_t handleComponentCount = 5u;
18 constexpr uint64_t convertMilliToMicro = 1000u;
19
20 class SysmanDeviceSchedulerFixture : public SysmanDeviceFixture {
21
22 protected:
23 L0::Sysman::SysmanDevice *device = nullptr;
24
25 std::vector<zes_sched_handle_t> getSchedHandles(uint32_t count) {
26 std::vector<zes_sched_handle_t> handles(count, nullptr);
27 EXPECT_EQ(zesDeviceEnumSchedulers(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
28 return handles;
29 }
30
31 zes_sched_mode_t fixtureGetCurrentMode(zes_sched_handle_t hScheduler) {
32 zes_sched_mode_t mode;
33 ze_result_t result = zesSchedulerGetCurrentMode(hScheduler, &mode);
34 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
35 return mode;
36 }
37
38 zes_sched_timeout_properties_t fixtureGetTimeoutModeProperties(zes_sched_handle_t hScheduler, ze_bool_t getDefaults) {
39 zes_sched_timeout_properties_t config;
40 ze_result_t result = zesSchedulerGetTimeoutModeProperties(hScheduler, getDefaults, &config);
41 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
42 return config;
43 }
44
45 zes_sched_timeslice_properties_t fixtureGetTimesliceModeProperties(zes_sched_handle_t hScheduler, ze_bool_t getDefaults) {
46 zes_sched_timeslice_properties_t config;
47 ze_result_t result = zesSchedulerGetTimesliceModeProperties(hScheduler, getDefaults, &config);
48 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
49 return config;
50 }
51
52 SysmanDeviceSchedulerFixture() = default;
53 };
54
55 class SysmanDeviceSchedulerFixtureI915 : public SysmanDeviceSchedulerFixture {
56
57 protected:
58 std::unique_ptr<MockSchedulerSysfsAccessI915> pSysfsAccess;
59 L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
60
61 uint64_t defaultTimeout = 650u;
62 uint64_t defaultTimeslice = 1u;
63 uint64_t defaultHeartbeat = 3000u;
64 uint64_t timeout = 640u;
65 uint64_t timeslice = 1u;
66 uint64_t heartbeat = 2500u;
67 uint64_t expectedDefaultHeartbeatTimeoutMicroSecs = defaultHeartbeat * convertMilliToMicro;
68 uint64_t expectedDefaultTimeoutMicroSecs = defaultTimeout * convertMilliToMicro;
69 uint64_t expectedDefaultTimesliceMicroSecs = defaultTimeslice * convertMilliToMicro;
70 uint64_t expectedHeartbeatTimeoutMicroSecs = heartbeat * convertMilliToMicro;
71 uint64_t expectedTimeoutMicroSecs = timeout * convertMilliToMicro;
72 uint64_t expectedTimesliceMicroSecs = timeslice * convertMilliToMicro;
73
74 void SetUp() override {
75 SysmanDeviceFixture::SetUp();
76 pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
77 pSysfsAccess = std::make_unique<MockSchedulerSysfsAccessI915>();
78 pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
79 pSysfsAccess->engineSchedFilePropertiesMap.clear();
80 pSysfsAccess->cleanUpMap();
81 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
82 [=](std::string engineName) {
83 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->defaultpreemptTimeout, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
84 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->defaulttimesliceDuration, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
85 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->defaultheartbeatInterval, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
86 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->preemptTimeout, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
87 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->timesliceDuration, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
88 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->heartbeatInterval, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
89
90 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->defaultpreemptTimeout, defaultTimeout);
91 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->defaulttimesliceDuration, defaultTimeslice);
92 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->defaultheartbeatInterval, defaultHeartbeat);
93 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->preemptTimeout, timeout);
94 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->timesliceDuration, timeslice);
95 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->heartbeatInterval, heartbeat);
96 });
97 pSysmanDeviceImp->pSchedulerHandleContext->handleList.clear();
98 device = pSysmanDevice;
99 getSchedHandles(0);
100 }
101
102 void TearDown() override {
103 pSysfsAccess->cleanUpMap();
104 pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
105 SysmanDeviceFixture::TearDown();
106 }
107 };
108
109 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenComponentCountZeroWhenCallingzesDeviceEnumSchedulersAndSysfsCanReadReturnsErrorThenZeroCountIsReturned) {
110 pSysfsAccess->mockGetScanDirEntryError = ZE_RESULT_ERROR_NOT_AVAILABLE;
111
112 auto pSchedulerHandleContextTest = std::make_unique<L0::Sysman::SchedulerHandleContext>(pOsSysman);
113 pSchedulerHandleContextTest->init(pOsSysman->getSubDeviceCount());
114 EXPECT_EQ(0u, static_cast<uint32_t>(pSchedulerHandleContextTest->handleList.size()));
115 }
116
117 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenComponentCountZeroWhenCallingzesDeviceEnumSchedulersAndSysfsCanReadReturnsIncorrectPermissionThenZeroCountIsReturned) {
118 pSysfsAccess->setEngineDirectoryPermission(0);
119 auto pSchedulerHandleContextTest = std::make_unique<L0::Sysman::SchedulerHandleContext>(pOsSysman);
120 pSchedulerHandleContextTest->init(pOsSysman->getSubDeviceCount());
121 EXPECT_EQ(0u, static_cast<uint32_t>(pSchedulerHandleContextTest->handleList.size()));
122 }
123
124 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenComponentCountZeroWhenCallingzesDeviceEnumSchedulersThenNonZeroCountIsReturnedAndVerifyCallSucceeds) {
125 uint32_t count = 0;
126 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumSchedulers(device->toHandle(), &count, NULL));
127 EXPECT_EQ(count, handleComponentCount);
128
129 uint32_t testcount = count + 1;
130 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumSchedulers(device->toHandle(), &testcount, NULL));
131 EXPECT_EQ(testcount, count);
132
133 count = 0;
134 std::vector<zes_sched_handle_t> handles(count, nullptr);
135 EXPECT_EQ(zesDeviceEnumSchedulers(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
136 EXPECT_EQ(count, handleComponentCount);
137 }
138
139 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenComponentCountZeroAndKMDVersionIsPrelimWhenCallingzesDeviceEnumSchedulersThenNonZeroCountIsReturnedAndVerifyCallSucceeds) {
140
141 pLinuxSysmanImp->pSysmanKmdInterface.reset();
142 pLinuxSysmanImp->pSysmanKmdInterface = std::make_unique<SysmanKmdInterfaceI915Prelim>(pLinuxSysmanImp->getSysmanProductHelper());
143
144 auto pSchedulerHandleContextTest = std::make_unique<L0::Sysman::SchedulerHandleContext>(pOsSysman);
145 pSchedulerHandleContextTest->init(pOsSysman->getSubDeviceCount());
146
147 uint32_t count = 0;
148 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumSchedulers(device->toHandle(), &count, NULL));
149 EXPECT_EQ(count, handleComponentCount);
150
151 uint32_t testcount = count + 1;
152 EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumSchedulers(device->toHandle(), &testcount, NULL));
153 EXPECT_EQ(testcount, count);
154
155 count = 0;
156 std::vector<zes_sched_handle_t> handles(count, nullptr);
157 EXPECT_EQ(zesDeviceEnumSchedulers(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
158 EXPECT_EQ(count, handleComponentCount);
159 }
160
161 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeThenVerifyzesSchedulerGetCurrentModeCallSucceeds) {
162 auto handles = getSchedHandles(handleComponentCount);
163 for (auto handle : handles) {
164 auto mode = fixtureGetCurrentMode(handle);
165 EXPECT_EQ(mode, ZES_SCHED_MODE_TIMESLICE);
166 }
167 }
168
169 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesThenVerifyzesSchedulerGetTimeoutModePropertiesCallSucceeds) {
170 auto handles = getSchedHandles(handleComponentCount);
171 for (auto handle : handles) {
172 auto config = fixtureGetTimeoutModeProperties(handle, false);
173 EXPECT_EQ(config.watchdogTimeout, expectedHeartbeatTimeoutMicroSecs);
174 }
175 }
176
177 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesThenVerifyzesSchedulerGetTimeoutModePropertiesForDifferingValues) {
178 auto handles = getSchedHandles(handleComponentCount);
179 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + "vcs1" + "/" + pSysfsAccess->heartbeatInterval, (heartbeat + 5));
180
181 for (auto handle : handles) {
182 zes_sched_properties_t properties = {};
183 zes_sched_timeout_properties_t config;
184 ze_result_t result = zesSchedulerGetProperties(handle, &properties);
185 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
186 if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
187 ze_result_t result = zesSchedulerGetTimeoutModeProperties(handle, false, &config);
188 EXPECT_NE(ZE_RESULT_SUCCESS, result);
189 }
190 }
191 }
192
193 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesWithDefaultsThenVerifyzesSchedulerGetTimeoutModePropertiesCallSucceeds) {
194 auto handles = getSchedHandles(handleComponentCount);
195 for (auto handle : handles) {
196 auto config = fixtureGetTimeoutModeProperties(handle, true);
197 EXPECT_EQ(config.watchdogTimeout, expectedDefaultHeartbeatTimeoutMicroSecs);
198 }
199 }
200
201 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimesliceModePropertiesThenVerifyzesSchedulerGetTimesliceModePropertiesCallSucceeds) {
202 auto handles = getSchedHandles(handleComponentCount);
203 for (auto handle : handles) {
204 auto config = fixtureGetTimesliceModeProperties(handle, false);
205 EXPECT_EQ(config.interval, expectedTimesliceMicroSecs);
206 EXPECT_EQ(config.yieldTimeout, expectedTimeoutMicroSecs);
207 }
208 }
209
210 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimescliceModePropertiesThenVerifyzesSchedulerGetTimescliceModePropertiesForDifferingPreemptTimeoutValues) {
211 auto handles = getSchedHandles(handleComponentCount);
212 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + "vcs1" + "/" + pSysfsAccess->preemptTimeout, (timeout + 5));
213
214 for (auto handle : handles) {
215 zes_sched_properties_t properties = {};
216 zes_sched_timeslice_properties_t config;
217 ze_result_t result = zesSchedulerGetProperties(handle, &properties);
218 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
219 if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
220 ze_result_t result = zesSchedulerGetTimesliceModeProperties(handle, false, &config);
221 EXPECT_NE(ZE_RESULT_SUCCESS, result);
222 }
223 }
224 }
225
226 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimescliceModePropertiesThenVerifyzesSchedulerGetTimescliceModePropertiesForDifferingTimesliceDurationValues) {
227 auto handles = getSchedHandles(handleComponentCount);
228 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + "vcs1" + "/" + pSysfsAccess->timesliceDuration, (timeslice + 5));
229
230 for (auto handle : handles) {
231 zes_sched_properties_t properties = {};
232 zes_sched_timeslice_properties_t config;
233 ze_result_t result = zesSchedulerGetProperties(handle, &properties);
234 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
235 if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
236 ze_result_t result = zesSchedulerGetTimesliceModeProperties(handle, false, &config);
237 EXPECT_NE(ZE_RESULT_SUCCESS, result);
238 }
239 }
240 }
241
242 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesThenVerifyzesSchedulerGetTimeoutModePropertiesForReadFileFailureFileUnavailable) {
243 auto handles = getSchedHandles(handleComponentCount);
244
245 for (auto handle : handles) {
246 zes_sched_properties_t properties = {};
247 zes_sched_timeout_properties_t config;
248 ze_result_t result = zesSchedulerGetProperties(handle, &properties);
249 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
250 if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
251
252 pSysfsAccess->mockReadFileFailureError = ZE_RESULT_ERROR_NOT_AVAILABLE;
253
254 ze_result_t result = zesSchedulerGetTimeoutModeProperties(handle, false, &config);
255 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
256 }
257 }
258 }
259
260 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesThenVerifyzesSchedulerGetTimeoutModePropertiesForReadFileFailureInsufficientPermissions) {
261 auto handles = getSchedHandles(handleComponentCount);
262
263 for (auto handle : handles) {
264 zes_sched_properties_t properties = {};
265 zes_sched_timeout_properties_t config;
266 ze_result_t result = zesSchedulerGetProperties(handle, &properties);
267 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
268 if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
269
270 pSysfsAccess->mockReadFileFailureError = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
271
272 ze_result_t result = zesSchedulerGetTimeoutModeProperties(handle, false, &config);
273 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
274 }
275 }
276 }
277
278 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimescliceModePropertiesThenVerifyzesSchedulerGetTimescliceModePropertiesForReadFileFailureDueToUnavailable) {
279 auto handles = getSchedHandles(handleComponentCount);
280 for (auto handle : handles) {
281 zes_sched_timeslice_properties_t config;
282 zes_sched_properties_t properties = {};
283 ze_result_t result = zesSchedulerGetProperties(handle, &properties);
284 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
285 if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
286
287 /* The flag mockReadReturnStatus enables the call to read call where
288 * the read call returns ZE_RESULT_SUCCESS for the first 3 invocations
289 * and the 4th invocation returns the ZE_RESULT_ERROR_NOT_AVAILABLE
290 */
291
292 pSysfsAccess->mockReadReturnStatus = true;
293
294 result = zesSchedulerGetTimesliceModeProperties(handle, false, &config);
295 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
296 }
297 }
298 }
299
300 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimescliceModePropertiesThenVerifyzesSchedulerGetTimescliceModePropertiesForReadFileFailureDueToInsufficientPermissions) {
301 auto handles = getSchedHandles(handleComponentCount);
302 for (auto handle : handles) {
303 zes_sched_timeslice_properties_t config;
304 zes_sched_properties_t properties = {};
305 ze_result_t result = zesSchedulerGetProperties(handle, &properties);
306 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
307 if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
308
309 pSysfsAccess->mockReadFileFailureError = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
310
311 result = zesSchedulerGetTimesliceModeProperties(handle, false, &config);
312 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
313 }
314 }
315 }
316
317 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimesliceModePropertiesWithDefaultsThenVerifyzesSchedulerGetTimesliceModePropertiesCallSucceeds) {
318 auto handles = getSchedHandles(handleComponentCount);
319 for (auto handle : handles) {
320 auto config = fixtureGetTimesliceModeProperties(handle, true);
321 EXPECT_EQ(config.interval, expectedDefaultTimesliceMicroSecs);
322 EXPECT_EQ(config.yieldTimeout, expectedDefaultTimeoutMicroSecs);
323 }
324 }
325
326 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeThenVerifyzesSchedulerSetTimeoutModeCallSucceeds) {
327 auto handles = getSchedHandles(handleComponentCount);
328 for (auto handle : handles) {
329 ze_bool_t needReboot;
330 zes_sched_timeout_properties_t setConfig;
331 setConfig.watchdogTimeout = 10000u;
332 ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
333 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
334 EXPECT_FALSE(needReboot);
335 auto getConfig = fixtureGetTimeoutModeProperties(handle, false);
336 EXPECT_EQ(getConfig.watchdogTimeout, setConfig.watchdogTimeout);
337 auto mode = fixtureGetCurrentMode(handle);
338 EXPECT_EQ(mode, ZES_SCHED_MODE_TIMEOUT);
339 }
340 }
341
342 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenTimeoutLessThanMinimumThenVerifyzesSchedulerSetTimeoutModeCallFails) {
343 auto handles = getSchedHandles(handleComponentCount);
344 for (auto handle : handles) {
345 ze_bool_t needReboot;
346 zes_sched_timeout_properties_t setConfig;
347 setConfig.watchdogTimeout = minTimeoutModeHeartbeat - 1;
348 ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
349 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
350 }
351 }
352
353 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenCurrentModeIsTimeoutModeThenVerifyzesSchedulerSetTimeoutModeCallSucceeds) {
354 auto handles = getSchedHandles(handleComponentCount);
355 for (auto handle : handles) {
356 ze_bool_t needReboot;
357 zes_sched_timeout_properties_t setTimeOutConfig;
358 setTimeOutConfig.watchdogTimeout = 10000u;
359 ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setTimeOutConfig, &needReboot);
360 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
361
362 result = zesSchedulerSetTimeoutMode(handle, &setTimeOutConfig, &needReboot);
363 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
364 }
365 }
366
367 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenHeartBeatSettingFailsThenVerifyzesSchedulerSetTimeoutModeCallFails) {
368 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
369 [=](std::string engineName) {
370 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->heartbeatInterval, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
371 });
372 auto handles = getSchedHandles(handleComponentCount);
373 for (auto handle : handles) {
374 ze_bool_t needReboot;
375 zes_sched_timeout_properties_t setTimeOutConfig;
376 setTimeOutConfig.watchdogTimeout = 10000u;
377 ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setTimeOutConfig, &needReboot);
378 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
379 }
380 }
381
382 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenGetCurrentModeFailsThenVerifyzesSchedulerSetTimeoutModeCallFails) {
383 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
384 [=](std::string engineName) {
385 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->preemptTimeout, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
386 });
387 auto handles = getSchedHandles(handleComponentCount);
388 for (auto handle : handles) {
389 ze_bool_t needReboot;
390 zes_sched_timeout_properties_t setConfig;
391 setConfig.watchdogTimeout = minTimeoutModeHeartbeat;
392 ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
393 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
394 }
395 }
396
397 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenPreEmptTimeoutNoPermissionThenVerifyzesSchedulerSetTimeoutModeCallFails) {
398 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
399 [=](std::string engineName) {
400 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->preemptTimeout, true, S_IRUSR | S_IRGRP | S_IROTH);
401 });
402 auto handles = getSchedHandles(handleComponentCount);
403 for (auto handle : handles) {
404 ze_bool_t needReboot;
405 zes_sched_timeout_properties_t setConfig;
406 setConfig.watchdogTimeout = minTimeoutModeHeartbeat;
407 ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
408 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
409 }
410 }
411
412 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenTimeSliceDurationNoPermissionThenVerifyzesSchedulerSetTimeoutModeCallFails) {
413 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
414 [=](std::string engineName) {
415 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->timesliceDuration, true, S_IRUSR | S_IRGRP | S_IROTH);
416 });
417 auto handles = getSchedHandles(handleComponentCount);
418 for (auto handle : handles) {
419 ze_bool_t needReboot;
420 zes_sched_timeout_properties_t setConfig;
421 setConfig.watchdogTimeout = minTimeoutModeHeartbeat;
422 ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
423 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
424 }
425 }
426
427 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeThenVerifyzesSchedulerSetTimesliceModeCallSucceeds) {
428 auto handles = getSchedHandles(handleComponentCount);
429 for (auto handle : handles) {
430 ze_bool_t needReboot;
431 zes_sched_timeslice_properties_t setConfig;
432 setConfig.interval = 1000u;
433 setConfig.yieldTimeout = 1000u;
434 ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
435 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
436 EXPECT_FALSE(needReboot);
437 auto getConfig = fixtureGetTimesliceModeProperties(handle, false);
438 EXPECT_EQ(getConfig.interval, setConfig.interval);
439 EXPECT_EQ(getConfig.yieldTimeout, setConfig.yieldTimeout);
440 auto mode = fixtureGetCurrentMode(handle);
441 EXPECT_EQ(mode, ZES_SCHED_MODE_TIMESLICE);
442 }
443 }
444
445 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenIntervalIsLessThanMinimumThenVerifyzesSchedulerSetTimesliceModeCallFails) {
446 auto handles = getSchedHandles(handleComponentCount);
447 for (auto handle : handles) {
448 ze_bool_t needReboot;
449 zes_sched_timeslice_properties_t setConfig;
450 setConfig.interval = minTimeoutInMicroSeconds - 1;
451 setConfig.yieldTimeout = 1000u;
452 ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
453 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
454 }
455 }
456
457 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenNoAccessToTimeSliceDurationThenVerifyzesSchedulerSetTimesliceModeCallFails) {
458 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
459 [=](std::string engineName) {
460 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->timesliceDuration, true, S_IRUSR | S_IRGRP | S_IROTH);
461 });
462 auto handles = getSchedHandles(handleComponentCount);
463 for (auto handle : handles) {
464 ze_bool_t needReboot;
465 zes_sched_timeslice_properties_t setConfig;
466 setConfig.interval = minTimeoutInMicroSeconds;
467 setConfig.yieldTimeout = 1000u;
468 ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
469 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
470 }
471 }
472
473 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenNoAccessToHeartBeatIntervalThenVerifyzesSchedulerSetTimesliceModeCallFails) {
474 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
475 [=](std::string engineName) {
476 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->heartbeatInterval, true, S_IRUSR | S_IRGRP | S_IROTH);
477 });
478 auto handles = getSchedHandles(handleComponentCount);
479 for (auto handle : handles) {
480 ze_bool_t needReboot;
481 zes_sched_timeslice_properties_t setConfig;
482 setConfig.interval = minTimeoutInMicroSeconds;
483 setConfig.yieldTimeout = 1000u;
484 ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
485 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
486 }
487 }
488
489 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeThenVerifyzesSchedulerSetExclusiveModeCallSucceeds) {
490 auto handles = getSchedHandles(handleComponentCount);
491 for (auto handle : handles) {
492 ze_bool_t needReboot;
493 ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot);
494 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
495 EXPECT_FALSE(needReboot);
496 auto mode = fixtureGetCurrentMode(handle);
497 EXPECT_EQ(mode, ZES_SCHED_MODE_EXCLUSIVE);
498 }
499 }
500
501 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeWhenPreEmptTimeoutNotAvailableThenVerifyzesSchedulerSetExclusiveModeCallFails) {
502 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
503 [=](std::string engineName) {
504 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->preemptTimeout, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
505 });
506 auto handles = getSchedHandles(handleComponentCount);
507 for (auto handle : handles) {
508 ze_bool_t needReboot;
509 ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot);
510 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
511 }
512 }
513
514 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeWhenTimeSliceDurationNotAvailableThenVerifyzesSchedulerSetExclusiveModeCallFails) {
515 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
516 [=](std::string engineName) {
517 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->timesliceDuration, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
518 });
519 auto handles = getSchedHandles(handleComponentCount);
520 for (auto handle : handles) {
521 ze_bool_t needReboot;
522 ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot);
523 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
524 }
525 }
526
527 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeWhenTimeSliceDurationHasNoPermissionsThenVerifyzesSchedulerSetExclusiveModeCallFails) {
528 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
529 [=](std::string engineName) {
530 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->timesliceDuration, true, S_IRUSR | S_IRGRP | S_IROTH);
531 });
532 auto handles = getSchedHandles(handleComponentCount);
533 for (auto handle : handles) {
534 ze_bool_t needReboot;
535 ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot);
536 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
537 }
538 }
539
540 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeWhenPreEmptTimeOutNotAvailableThenFailureIsReturned) {
541 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
542 [=](std::string engineName) {
543 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->preemptTimeout, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
544 });
545 auto handles = getSchedHandles(handleComponentCount);
546 for (auto handle : handles) {
547 zes_sched_mode_t mode;
548 ze_result_t result = zesSchedulerGetCurrentMode(handle, &mode);
549 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
550 }
551 }
552
553 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeWhenTimeSliceDurationNotAvailableThenFailureIsReturned) {
554 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
555 [=](std::string engineName) {
556 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->timesliceDuration, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
557 });
558 auto handles = getSchedHandles(handleComponentCount);
559 for (auto handle : handles) {
560 zes_sched_mode_t mode;
561 ze_result_t result = zesSchedulerGetCurrentMode(handle, &mode);
562 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
563 }
564 }
565
566 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeWhenTimeSliceDurationHasNoPermissionThenFailureIsReturned) {
567 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
568 [=](std::string engineName) {
569 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->timesliceDuration, true, S_IRGRP | S_IROTH | S_IWUSR);
570 });
571 auto handles = getSchedHandles(handleComponentCount);
572 for (auto handle : handles) {
573 zes_sched_mode_t mode;
574 ze_result_t result = zesSchedulerGetCurrentMode(handle, &mode);
575 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
576 }
577 }
578
579 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetComputeUnitDebugModeThenUnsupportedFeatureIsReturned) {
580 auto handles = getSchedHandles(handleComponentCount);
581 for (auto handle : handles) {
582 ze_bool_t needReload;
583 ze_result_t result = zesSchedulerSetComputeUnitDebugMode(handle, &needReload);
584 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
585 }
586 }
587
588 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesWithDefaultsWhenSysfsNodeIsAbsentThenFailureIsReturned) {
589 pSysfsAccess->mockReadFileFailureError = ZE_RESULT_ERROR_NOT_AVAILABLE;
590
591 auto handles = getSchedHandles(handleComponentCount);
592 for (auto handle : handles) {
593 zes_sched_timeout_properties_t config;
594 ze_result_t result = zesSchedulerGetTimeoutModeProperties(handle, true, &config);
595 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
596 }
597 }
598
599 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimesliceModePropertiesWithDefaultsWhenSysfsNodeIsAbsentThenFailureIsReturned) {
600 pSysfsAccess->mockReadFileFailureError = ZE_RESULT_ERROR_NOT_AVAILABLE;
601
602 auto handles = getSchedHandles(handleComponentCount);
603 for (auto handle : handles) {
604 zes_sched_timeslice_properties_t config;
605 ze_result_t result = zesSchedulerGetTimesliceModeProperties(handle, true, &config);
606 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
607 }
608 }
609
610 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenSysfsNodeIsAbsentThenFailureIsReturned) {
611 pSysfsAccess->mockWriteFileStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
612
613 auto handles = getSchedHandles(handleComponentCount);
614 for (auto handle : handles) {
615 ze_bool_t needReboot;
616 zes_sched_timeslice_properties_t setConfig;
617 setConfig.interval = 1000u;
618 setConfig.yieldTimeout = 1000u;
619 ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
620 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
621 }
622 }
623
624 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenSysfsNodeWithoutPermissionsThenFailureIsReturned) {
625 pSysfsAccess->mockWriteFileStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
626
627 auto handles = getSchedHandles(handleComponentCount);
628 for (auto handle : handles) {
629 ze_bool_t needReboot;
630 zes_sched_timeslice_properties_t setConfig;
631 setConfig.interval = 1000u;
632 setConfig.yieldTimeout = 1000u;
633
634 pSysfsAccess->mockWriteFileStatus = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
635 ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
636 EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
637 }
638 }
639
640 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidDeviceHandleWhenCallingzesSchedulerGetPropertiesThenVerifyzesSchedulerGetPropertiesCallSucceeds) {
641 auto handles = getSchedHandles(handleComponentCount);
642 for (auto handle : handles) {
643 zes_sched_properties_t properties = {};
644 ze_result_t result = zesSchedulerGetProperties(handle, &properties);
645 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
646 EXPECT_TRUE(properties.canControl);
647 EXPECT_LE(properties.engines, ZES_ENGINE_TYPE_FLAG_RENDER);
648 EXPECT_EQ(properties.supportedModes, static_cast<uint32_t>((1 << ZES_SCHED_MODE_TIMEOUT) | (1 << ZES_SCHED_MODE_TIMESLICE) | (1 << ZES_SCHED_MODE_EXCLUSIVE)));
649 }
650 }
651
652 TEST_F(SysmanDeviceSchedulerFixtureI915, GivenValidObjectsOfClassSchedulerImpAndSchedulerHandleContextThenDuringObjectReleaseCheckDestructorBranches) {
653 for (auto &handle : pSysmanDeviceImp->pSchedulerHandleContext->handleList) {
654 auto pSchedulerImp = static_cast<L0::Sysman::SchedulerImp *>(handle.get());
655 pSchedulerImp->pOsScheduler = nullptr;
656 handle = nullptr;
657 }
658 }
659
660 class SysmanDeviceSchedulerFixtureXe : public SysmanDeviceSchedulerFixture {
661
662 protected:
663 std::unique_ptr<MockSchedulerSysfsAccessXe> pSysfsAccess;
664 L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
665
666 uint64_t defaultTimeout = 650u;
667 uint64_t defaultTimeslice = 1u;
668 uint64_t defaultHeartbeat = 3000u;
669 uint64_t defaultMaximumJobTimeout = 4000u;
670 uint64_t timeout = 640u;
671 uint64_t timeslice = 1u;
672 uint64_t heartbeat = 2500u;
673 uint64_t expectedDefaultHeartbeatTimeoutMicroSecs = defaultHeartbeat * convertMilliToMicro;
674 uint64_t expectedHeartbeatTimeoutMicroSecs = heartbeat * convertMilliToMicro;
675 uint64_t expectedDefaultTimeoutMicroSecs = defaultTimeout;
676 uint64_t expectedDefaultTimesliceMicroSecs = defaultTimeslice;
677 uint64_t expectedTimeoutMicroSecs = timeout;
678 uint64_t expectedTimesliceMicroSecs = timeslice;
679
680 void SetUp() override {
681 SysmanDeviceFixture::SetUp();
682 pLinuxSysmanImp->pSysmanKmdInterface.reset();
683 pLinuxSysmanImp->pSysmanKmdInterface = std::make_unique<SysmanKmdInterfaceXe>(pLinuxSysmanImp->getSysmanProductHelper());
684 pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
685 pSysfsAccess = std::make_unique<MockSchedulerSysfsAccessXe>();
686 pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
687 for_each(pSysfsAccess->listOfMockedEngines.begin(), pSysfsAccess->listOfMockedEngines.end(),
688 [=](std::string engineName) {
689 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->defaultpreemptTimeout, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
690 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->defaulttimesliceDuration, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
691 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->defaultheartbeatInterval, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
692 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->preemptTimeout, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
693 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->timesliceDuration, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
694 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->heartbeatInterval, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
695 pSysfsAccess->setFileProperties(engineName, pSysfsAccess->defaultMaximumJobTimeout, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
696
697 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->defaultpreemptTimeout, defaultTimeout);
698 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->defaulttimesliceDuration, defaultTimeslice);
699 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->defaultheartbeatInterval, defaultHeartbeat);
700 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->preemptTimeout, timeout);
701 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->timesliceDuration, timeslice);
702 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->heartbeatInterval, heartbeat);
703 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + engineName + "/" + pSysfsAccess->defaultMaximumJobTimeout, heartbeat);
704 });
705 pSysmanDeviceImp->pSchedulerHandleContext->handleList.clear();
706 device = pSysmanDevice;
707 getSchedHandles(0);
708 }
709
710 void TearDown() override {
711 pSysfsAccess->engineSchedFilePropertiesMap.clear();
712 pSysfsAccess->cleanUpMap();
713 pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
714 SysmanDeviceFixture::TearDown();
715 }
716 };
717
718 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeThenVerifyzesSchedulerGetCurrentModeCallSucceeds) {
719 auto handles = getSchedHandles(handleComponentCount);
720 for (auto handle : handles) {
721 auto mode = fixtureGetCurrentMode(handle);
722 EXPECT_EQ(mode, ZES_SCHED_MODE_TIMESLICE);
723 }
724 }
725
726 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesThenVerifyzesSchedulerGetTimeoutModePropertiesCallSucceeds) {
727 auto handles = getSchedHandles(handleComponentCount);
728 for (auto handle : handles) {
729 auto config = fixtureGetTimeoutModeProperties(handle, false);
730 EXPECT_EQ(config.watchdogTimeout, expectedHeartbeatTimeoutMicroSecs);
731 }
732 }
733
734 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesThenVerifyzesSchedulerGetTimeoutModePropertiesForDifferingValues) {
735 auto handles = getSchedHandles(handleComponentCount);
736 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + "vcs1" + "/" + pSysfsAccess->heartbeatInterval, (heartbeat + 5));
737
738 for (auto handle : handles) {
739 zes_sched_properties_t properties = {};
740 zes_sched_timeout_properties_t config;
741 ze_result_t result = zesSchedulerGetProperties(handle, &properties);
742 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
743 if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
744 ze_result_t result = zesSchedulerGetTimeoutModeProperties(handle, false, &config);
745 EXPECT_NE(ZE_RESULT_SUCCESS, result);
746 }
747 }
748 }
749
750 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesWithDefaultsThenVerifyzesSchedulerGetTimeoutModePropertiesCallSucceeds) {
751 auto handles = getSchedHandles(handleComponentCount);
752 for (auto handle : handles) {
753 auto config = fixtureGetTimeoutModeProperties(handle, true);
754 EXPECT_EQ(config.watchdogTimeout, expectedDefaultHeartbeatTimeoutMicroSecs);
755 }
756 }
757
758 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimescliceModePropertiesThenVerifyzesSchedulerGetTimescliceModePropertiesForDifferingPreemptTimeoutValues) {
759 auto handles = getSchedHandles(handleComponentCount);
760 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + "vcs1" + "/" + pSysfsAccess->preemptTimeout, (timeout + 5));
761
762 for (auto handle : handles) {
763 zes_sched_properties_t properties = {};
764 zes_sched_timeslice_properties_t config;
765 ze_result_t result = zesSchedulerGetProperties(handle, &properties);
766 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
767 if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
768 ze_result_t result = zesSchedulerGetTimesliceModeProperties(handle, false, &config);
769 EXPECT_NE(ZE_RESULT_SUCCESS, result);
770 }
771 }
772 }
773
774 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimescliceModePropertiesThenVerifyzesSchedulerGetTimescliceModePropertiesForDifferingTimesliceDurationValues) {
775 auto handles = getSchedHandles(handleComponentCount);
776 pSysfsAccess->write(pSysfsAccess->engineDir + "/" + "vcs1" + "/" + pSysfsAccess->timesliceDuration, (timeslice + 5));
777
778 for (auto handle : handles) {
779 zes_sched_properties_t properties = {};
780 zes_sched_timeslice_properties_t config;
781 ze_result_t result = zesSchedulerGetProperties(handle, &properties);
782 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
783 if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
784 ze_result_t result = zesSchedulerGetTimesliceModeProperties(handle, false, &config);
785 EXPECT_NE(ZE_RESULT_SUCCESS, result);
786 }
787 }
788 }
789
790 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimesliceModePropertiesThenVerifyzesSchedulerGetTimesliceModePropertiesCallSucceeds) {
791 auto handles = getSchedHandles(handleComponentCount);
792 for (auto handle : handles) {
793 auto config = fixtureGetTimesliceModeProperties(handle, false);
794 EXPECT_EQ(config.interval, expectedTimesliceMicroSecs);
795 EXPECT_EQ(config.yieldTimeout, expectedTimeoutMicroSecs);
796 }
797 }
798
799 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimesliceModePropertiesWithDefaultsThenVerifyzesSchedulerGetTimesliceModePropertiesCallSucceeds) {
800 auto handles = getSchedHandles(handleComponentCount);
801 for (auto handle : handles) {
802 auto config = fixtureGetTimesliceModeProperties(handle, true);
803 EXPECT_EQ(config.interval, expectedDefaultTimesliceMicroSecs);
804 EXPECT_EQ(config.yieldTimeout, expectedDefaultTimeoutMicroSecs);
805 }
806 }
807
808 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeThenVerifyzesSchedulerSetTimeoutModeCallReturnsError) {
809 auto handles = getSchedHandles(handleComponentCount);
810 for (auto handle : handles) {
811 ze_bool_t needReboot;
812 zes_sched_timeout_properties_t setConfig;
813 setConfig.watchdogTimeout = 10000u;
814 ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
815 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
816 }
817 }
818
819 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeThenVerifyzesSchedulerSetTimesliceModeCallSucceeds) {
820 auto handles = getSchedHandles(handleComponentCount);
821 for (auto handle : handles) {
822 ze_bool_t needReboot;
823 zes_sched_timeslice_properties_t setConfig;
824 setConfig.interval = 1000u;
825 setConfig.yieldTimeout = 1000u;
826 ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
827 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
828 EXPECT_FALSE(needReboot);
829 auto getConfig = fixtureGetTimesliceModeProperties(handle, false);
830 EXPECT_EQ(getConfig.interval, setConfig.interval);
831 EXPECT_EQ(getConfig.yieldTimeout, setConfig.yieldTimeout);
832 auto mode = fixtureGetCurrentMode(handle);
833 EXPECT_EQ(mode, ZES_SCHED_MODE_TIMESLICE);
834 }
835 }
836
837 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeThenVerifyzesSchedulerSetExclusiveModeCallReturnsError) {
838 auto handles = getSchedHandles(handleComponentCount);
839 for (auto handle : handles) {
840 ze_bool_t needReboot;
841 ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot);
842 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
843 }
844 }
845
846 TEST_F(SysmanDeviceSchedulerFixtureXe, GivenDestinationOrSourceUnitsAreNotSupportedWhenConvertSysfsValueUnitIsCalledThenNoConversionIsDone) {
847
848 uint64_t sourceValue = 100;
849 uint64_t dstValue = 0;
850 pLinuxSysmanImp->pSysmanKmdInterface->convertSysfsValueUnit(SysfsValueUnit::unAvailable, SysfsValueUnit::milli, sourceValue, dstValue);
851 EXPECT_EQ(sourceValue, dstValue);
852 }
853
854 TEST_F(SysmanMultiDeviceFixture, GivenValidDevicePointerWhenGettingSchedPropertiesThenValidSchedPropertiesRetrieved) {
855 zes_sched_properties_t properties = {};
856 std::vector<std::string> listOfEngines;
857 L0::Sysman::LinuxSchedulerImp *pLinuxSchedulerImp = new L0::Sysman::LinuxSchedulerImp(pOsSysman, ZES_ENGINE_TYPE_FLAG_RENDER, listOfEngines,
858 true, 3);
859 EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxSchedulerImp->getProperties(properties));
860 EXPECT_EQ(properties.subdeviceId, 3u);
861 EXPECT_EQ(properties.onSubdevice, true);
862 delete pLinuxSchedulerImp;
863 }
864
865 class SysmanMultiDeviceSchedulerFixtureXe : public SysmanMultiDeviceFixture {
866
867 protected:
868 MockSchedulerNeoDrm *pMockSchedulerDrm = nullptr;
869 Drm *pOriginalDrm = nullptr;
870 L0::Sysman::SysmanDevice *device = nullptr;
871
872 void SetUp() override {
873 SysmanMultiDeviceFixture::SetUp();
874 pLinuxSysmanImp->pSysmanKmdInterface.reset();
875 pLinuxSysmanImp->pSysmanKmdInterface = std::make_unique<SysmanKmdInterfaceXe>(pLinuxSysmanImp->getSysmanProductHelper());
876 MockSchedulerNeoDrm *pDrm = new MockSchedulerNeoDrm(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()));
877 pDrm->setupIoctlHelper(pSysmanDeviceImp->getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily);
878 auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface;
879 osInterface->setDriverModel(std::unique_ptr<MockSchedulerNeoDrm>(pDrm));
880
881 pSysmanDeviceImp->pSchedulerHandleContext->handleList.clear();
882 device = pSysmanDevice;
883 auto drm = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface->getDriverModel()->as<NEO::Drm>();
884 pMockSchedulerDrm = static_cast<MockSchedulerNeoDrm *>(drm);
885 pMockSchedulerDrm->sysmanQueryEngineInfo();
886 }
887
888 void TearDown() override {
889 SysmanMultiDeviceFixture::TearDown();
890 }
891
892 std::vector<zes_sched_handle_t> getSchedHandles(uint32_t count) {
893 std::vector<zes_sched_handle_t> handles(count, nullptr);
894 EXPECT_EQ(zesDeviceEnumSchedulers(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
895 handles.resize(count);
896 return handles;
897 }
898 };
899
900 TEST_F(SysmanMultiDeviceSchedulerFixtureXe, WhenSchedulerHandlesAreEnumeratedCorrectEnginesAreDetected) {
901 auto schedHandles = getSchedHandles(1024);
902 const uint64_t enabledEngines = ZES_ENGINE_TYPE_FLAG_RENDER | ZES_ENGINE_TYPE_FLAG_DMA |
903 ZES_ENGINE_TYPE_FLAG_MEDIA | ZES_ENGINE_TYPE_FLAG_COMPUTE |
904 ZES_ENGINE_TYPE_FLAG_OTHER;
905
906 for (const auto &handle : schedHandles) {
907 zes_sched_properties_t properties{};
908 EXPECT_EQ(zesSchedulerGetProperties(handle, &properties), ZE_RESULT_SUCCESS);
909 EXPECT_TRUE(properties.canControl);
910 EXPECT_TRUE(properties.onSubdevice);
911 EXPECT_LT(properties.subdeviceId, 2u);
912 EXPECT_NE(properties.engines & enabledEngines, 0u);
913 }
914 }
915
916 } // namespace ult
917 } // namespace Sysman
918 } // namespace L0