intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-08 22:12:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add tests for sysman schedulder

Browse Source 
Adding unit tests for scheduler module


Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan
2021-07-14 17:01:58 +00:00
committed by Compute-Runtime-Automation
parent e836f994f6
commit 229ab9e30c
2 changed files with 319 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/mock_sysfs_scheduler.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -34,9 +34,27 @@ typedef struct SchedulerConfig {
SchedulerConfigValues_t heartBeat;
} SchedulerConfig_t;
class SchedulerFileProperties {
bool isAvailable = false;
::mode_t mode = 0;
public:
SchedulerFileProperties() = default;
SchedulerFileProperties(bool isAvailable, ::mode_t mode) : isAvailable(isAvailable), mode(mode) {}
bool getAvailability() {
return isAvailable;
}
bool hasMode(::mode_t mode) {
return mode & this->mode;
}
};
template <>
struct Mock<SchedulerSysfsAccess> : public SysfsAccess {
std::map<std::string, SchedulerConfig_t *> engineSchedMap;
std::map<std::string, SchedulerFileProperties> engineSchedFilePropertiesMap;
ze_result_t getValForError(const std::string file, uint64_t &val) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
@@ -54,7 +72,39 @@ struct Mock<SchedulerSysfsAccess> : public SysfsAccess {
}
}
}
ze_result_t getFileProperties(const std::string file, SchedulerFileProperties &fileProps) {
auto iterator = engineSchedFilePropertiesMap.find(file);
if (iterator != engineSchedFilePropertiesMap.end()) {
fileProps = static_cast<SchedulerFileProperties>(iterator->second);
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t setFileProperties(const std::string &engine, const std::string file, bool isAvailable, ::mode_t mode) {
auto iterator = std::find(listOfMockedEngines.begin(), listOfMockedEngines.end(), engine);
if (iterator != listOfMockedEngines.end()) {
engineSchedFilePropertiesMap[engineDir + "/" + engine + "/" + file] = SchedulerFileProperties(isAvailable, mode);
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t getVal(const std::string file, uint64_t &val) {
SchedulerFileProperties fileProperties;
ze_result_t result = getFileProperties(file, fileProperties);
if (ZE_RESULT_SUCCESS == result) {
if (!fileProperties.getAvailability()) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
if (!fileProperties.hasMode(S_IRUSR)) {
return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
}
} else {
return ZE_RESULT_ERROR_UNKNOWN;
}
for (std::string mappedEngine : listOfMockedEngines) {
if (file.find(mappedEngine) == std::string::npos) {
continue;
@@ -96,7 +146,21 @@ struct Mock<SchedulerSysfsAccess> : public SysfsAccess {
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t setVal(const std::string file, const uint64_t val) {
SchedulerFileProperties fileProperties;
ze_result_t result = getFileProperties(file, fileProperties);
if (ZE_RESULT_SUCCESS == result) {
if (!fileProperties.getAvailability()) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
if (!fileProperties.hasMode(S_IWUSR)) {
return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
}
} else {
return ZE_RESULT_ERROR_UNKNOWN;
}
for (std::string mappedEngine : listOfMockedEngines) {
if (file.find(mappedEngine) == std::string::npos) {
continue;
@@ -166,21 +230,38 @@ struct Mock<SchedulerSysfsAccess> : public SysfsAccess {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t getscanDirEntries(const std::string file, std::vector<std::string> &listOfEntries) {
if (file.compare(engineDir) == 0) {
if (!isDirectoryAccessible(engineDir)) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
if (!(engineDirectoryPermissions & S_IRUSR)) {
return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
}
listOfEntries = listOfMockedEngines;
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t getscanDirEntriesStatusReturnError(const std::string file, std::vector<std::string> &listOfEntries) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
void setEngineDirectoryPermission(::mode_t permission) {
engineDirectoryPermissions = permission;
}
Mock<SchedulerSysfsAccess>() = default;
MOCK_METHOD(ze_result_t, read, (const std::string file, uint64_t &val), (override));
MOCK_METHOD(ze_result_t, write, (const std::string file, const uint64_t val), (override));
MOCK_METHOD(ze_result_t, scanDirEntries, (const std::string file, std::vector<std::string> &listOfEntries), (override));
private:
::mode_t engineDirectoryPermissions = S_IRUSR | S_IWUSR;
bool isDirectoryAccessible(const std::string dir) {
if (dir.compare(engineDir) == 0) {
return true;
}
return false;
}
};
class PublicLinuxSchedulerImp : public L0::LinuxSchedulerImp {

264
level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/test_zes_scheduler.cpp
View File

@@ -43,6 +43,13 @@ class SysmanDeviceSchedulerFixture : public SysmanDeviceFixture {
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, defaultPreemptTimeoutMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
pSysfsAccess->setFileProperties(engineName, defaultTimesliceDurationMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
pSysfsAccess->setFileProperties(engineName, defaultHeartbeatIntervalMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
pSysfsAccess->setFileProperties(engineName, preemptTimeoutMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
pSysfsAccess->setFileProperties(engineName, heartbeatIntervalMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
pSysfsAccess->setVal(engineDir + "/" + engineName + "/" + defaultPreemptTimeoutMilliSecs, defaultTimeoutMilliSecs);
pSysfsAccess->setVal(engineDir + "/" + engineName + "/" + defaultTimesliceDurationMilliSecs, defaultTimesliceMilliSecs);
pSysfsAccess->setVal(engineDir + "/" + engineName + "/" + defaultHeartbeatIntervalMilliSecs, defaultHeartbeatMilliSecs);
@@ -118,6 +125,13 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenComponentCountZeroWhenCallingzesDevice
EXPECT_EQ(0u, static_cast<uint32_t>(pSchedulerHandleContextTest->handleList.size()));
}
TEST_F(SysmanDeviceSchedulerFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumSchedulersAndSysfsCanReadReturnsIncorrectPermissionThenZeroCountIsReturned) {
pSysfsAccess->setEngineDirectoryPermission(0);
auto pSchedulerHandleContextTest = std::make_unique<SchedulerHandleContext>(pOsSysman);
pSchedulerHandleContextTest->init(deviceHandles);
EXPECT_EQ(0u, static_cast<uint32_t>(pSchedulerHandleContextTest->handleList.size()));
}
TEST_F(SysmanDeviceSchedulerFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumSchedulersThenNonZeroCountIsReturnedAndVerifyCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumSchedulers(device->toHandle(), &count, NULL));
@@ -312,6 +326,91 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenTimeoutLessThanMinimumThenVerifyzesSchedulerSetTimeoutModeCallFails) {
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeout_properties_t setConfig;
setConfig.watchdogTimeout = minTimeoutModeHeartbeat - 1;
ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenCurrentModeIsTimeoutModeThenVerifyzesSchedulerSetTimeoutModeCallSucceeds) {
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeout_properties_t setTimeOutConfig;
setTimeOutConfig.watchdogTimeout = 10000u;
ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setTimeOutConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = zesSchedulerSetTimeoutMode(handle, &setTimeOutConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenHeartBeatSettingFailsThenVerifyzesSchedulerSetTimeoutModeCallFails) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, heartbeatIntervalMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeout_properties_t setTimeOutConfig;
setTimeOutConfig.watchdogTimeout = 10000u;
ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setTimeOutConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenGetCurrentModeFailsThenVerifyzesSchedulerSetTimeoutModeCallFails) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, preemptTimeoutMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeout_properties_t setConfig;
setConfig.watchdogTimeout = minTimeoutModeHeartbeat;
ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenPreEmptTimeoutNoPermissionThenVerifyzesSchedulerSetTimeoutModeCallFails) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, preemptTimeoutMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeout_properties_t setConfig;
setConfig.watchdogTimeout = minTimeoutModeHeartbeat;
ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenTimeSliceDurationNoPermissionThenVerifyzesSchedulerSetTimeoutModeCallFails) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeout_properties_t setConfig;
setConfig.watchdogTimeout = minTimeoutModeHeartbeat;
ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeThenVerifyzesSchedulerSetTimesliceModeCallSucceeds) {
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
@@ -330,6 +429,50 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenIntervalIsLessThanMinimumThenVerifyzesSchedulerSetTimesliceModeCallFails) {
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeslice_properties_t setConfig;
setConfig.interval = minTimeoutInMicroSeconds - 1;
setConfig.yieldTimeout = 1000u;
ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenNoAccessToTimeSliceDurationThenVerifyzesSchedulerSetTimesliceModeCallFails) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeslice_properties_t setConfig;
setConfig.interval = minTimeoutInMicroSeconds;
setConfig.yieldTimeout = 1000u;
ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenNoAccessToHeartBeatIntervalThenVerifyzesSchedulerSetTimesliceModeCallFails) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, heartbeatIntervalMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeslice_properties_t setConfig;
setConfig.interval = minTimeoutInMicroSeconds;
setConfig.yieldTimeout = 1000u;
ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeThenVerifyzesSchedulerSetExclusiveModeCallSucceeds) {
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
@@ -342,9 +485,50 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeWhenSysfsNodeIsAbsentThenFailureIsReturned) {
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<SchedulerSysfsAccess>::getValForError));
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeWhenPreEmptTimeoutNotAvailableThenVerifyzesSchedulerSetExclusiveModeCallFails) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, preemptTimeoutMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeWhenTimeSliceDurationNotAvailableThenVerifyzesSchedulerSetExclusiveModeCallFails) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeWhenTimeSliceDurationHasNoPermissionsThenVerifyzesSchedulerSetExclusiveModeCallFails) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeWhenPreEmptTimeOutNotAvailableThenFailureIsReturned) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, preemptTimeoutMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
zes_sched_mode_t mode;
@@ -353,6 +537,41 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeWhenTimeSliceDurationNotAvailableThenFailureIsReturned) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
zes_sched_mode_t mode;
ze_result_t result = zesSchedulerGetCurrentMode(handle, &mode);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeWhenTimeSliceDurationHasNoPermissionThenFailureIsReturned) {
for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(),
[=](std::string engineName) {
pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, true, S_IRGRP | S_IROTH | S_IWUSR);
});
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
zes_sched_mode_t mode;
ze_result_t result = zesSchedulerGetCurrentMode(handle, &mode);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetComputeUnitDebugModeThenUnsupportedFeatureIsReturned) {
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReload;
ze_result_t result = zesSchedulerSetComputeUnitDebugMode(handle, &needReload);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesWithDefaultsWhenSysfsNodeIsAbsentThenFailureIsReturned) {
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<SchedulerSysfsAccess>::getValForError));
@@ -375,35 +594,6 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenSysfsNodeIsAbsentThenFailureIsReturned) {
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<SchedulerSysfsAccess>::getValForErrorWhileWrite));
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeout_properties_t setConfig;
setConfig.watchdogTimeout = 10000u;
ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenSysfsNodeWithoutPermissionsThenFailureIsReturned) {
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<SchedulerSysfsAccess>::getValForErrorWhileWrite));
auto handles = get_sched_handles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeout_properties_t setConfig;
setConfig.watchdogTimeout = 10000u;
EXPECT_CALL(*pSysfsAccess.get(), write(_, _))
.WillOnce(Return(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS))
.WillRepeatedly(DoDefault());
ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenSysfsNodeIsAbsentThenFailureIsReturned) {
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<SchedulerSysfsAccess>::getValForErrorWhileWrite));
@@ -447,6 +637,16 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidObjectsOfClassSchedulerImpAndSchedulerHandleContextThenDuringObjectReleaseCheckDestructorBranches) {
for (auto &handle : pSysmanDeviceImp->pSchedulerHandleContext->handleList) {
auto pSchedulerImp = static_cast<SchedulerImp *>(handle);
delete pSchedulerImp->pOsScheduler;
pSchedulerImp->pOsScheduler = nullptr;
delete handle;
handle = nullptr;
}
}
TEST_F(SysmanMultiDeviceFixture, GivenValidDevicePointerWhenGettingSchedPropertiesThenValidSchedPropertiesRetrieved) {
zes_sched_properties_t properties = {};
std::vector<std::string> listOfEngines;