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

[Sysman] Update Scheduler module for zesInit

Browse Source 
Related-To: LOCI-4119

Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan
2023-03-20 11:49:01 +00:00
committed by Compute-Runtime-Automation
parent 77d70fd4a7
commit 0f280dbadf
26 changed files with 4131 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
level_zero/sysman/test/unit_tests/sources/scheduler/CMakeLists.txt Normal file
View File

@@ -0,0 +1,10 @@
#
# Copyright (C) 2020-2023 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
)
add_subdirectories()

29
level_zero/sysman/test/unit_tests/sources/scheduler/linux/CMakeLists.txt Normal file
View File

@@ -0,0 +1,29 @@
#
# Copyright (C) 2020-2023 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(L0_TESTS_TOOLS_SYSMAN_SCHEDULER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND L0_TESTS_TOOLS_SYSMAN_SCHEDULER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_scheduler_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_scheduler_prelim.h
)
else()
list(APPEND L0_TESTS_TOOLS_SYSMAN_SCHEDULER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_scheduler.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_scheduler.h
)
endif()
if(UNIX)
target_sources(${TARGET_NAME}
PRIVATE
${L0_TESTS_TOOLS_SYSMAN_SCHEDULER_LINUX}
)
endif()

301
level_zero/sysman/test/unit_tests/sources/scheduler/linux/mock_sysfs_scheduler.h Normal file
View File

@@ -0,0 +1,301 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/sysman/source/linux/fs_access.h"
#include "level_zero/sysman/source/scheduler/linux/os_scheduler_imp.h"
namespace L0 {
namespace ult {
const std::string preemptTimeoutMilliSecs("preempt_timeout_ms");
const std::string defaultPreemptTimeoutMilliSecs(".defaults/preempt_timeout_ms");
const std::string timesliceDurationMilliSecs("timeslice_duration_ms");
const std::string defaultTimesliceDurationMilliSecs(".defaults/timeslice_duration_ms");
const std::string heartbeatIntervalMilliSecs("heartbeat_interval_ms");
const std::string defaultHeartbeatIntervalMilliSecs(".defaults/heartbeat_interval_ms");
const std::string engineDir("engine");
const std::vector<std::string> listOfMockedEngines = {"rcs0", "bcs0", "vcs0", "vcs1", "vecs0"};
typedef struct SchedulerConfigValues {
uint64_t defaultVal;
uint64_t actualVal;
} SchedulerConfigValues_t;
typedef struct SchedulerConfig {
SchedulerConfigValues_t timeOut;
SchedulerConfigValues_t timeSclice;
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;
}
};
struct MockSchedulerSysfsAccess : public L0::Sysman::SysfsAccess {
ze_result_t mockReadFileFailureError = ZE_RESULT_SUCCESS;
ze_result_t mockWriteFileStatus = ZE_RESULT_SUCCESS;
ze_result_t mockGetScanDirEntryError = ZE_RESULT_SUCCESS;
std::vector<ze_result_t> mockReadReturnValues{ZE_RESULT_SUCCESS, ZE_RESULT_SUCCESS, ZE_RESULT_SUCCESS, ZE_RESULT_ERROR_NOT_AVAILABLE};
uint32_t mockReadCount = 0;
bool mockReadReturnStatus = false;
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;
}
ze_result_t getValForErrorWhileWrite(const std::string file, const uint64_t val) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
void cleanUpMap() {
for (std::string mappedEngine : listOfMockedEngines) {
auto it = engineSchedMap.find(mappedEngine);
if (it != engineSchedMap.end()) {
delete it->second;
}
}
}
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 read(const std::string file, uint64_t &val) override {
if (mockReadReturnStatus == true) {
if (mockReadCount < mockReadReturnValues.size()) {
ze_result_t returnValue = mockReadReturnValues[mockReadCount];
mockReadCount++;
return returnValue;
}
}
if (mockReadFileFailureError != ZE_RESULT_SUCCESS) {
return mockReadFileFailureError;
}
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;
}
auto it = engineSchedMap.find(mappedEngine);
if (it == engineSchedMap.end()) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
if (file.compare((file.length() - preemptTimeoutMilliSecs.length()),
preemptTimeoutMilliSecs.length(),
preemptTimeoutMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
val = it->second->timeOut.defaultVal;
} else {
val = it->second->timeOut.actualVal;
}
return ZE_RESULT_SUCCESS;
}
if (file.compare((file.length() - timesliceDurationMilliSecs.length()),
timesliceDurationMilliSecs.length(),
timesliceDurationMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
val = it->second->timeSclice.defaultVal;
} else {
val = it->second->timeSclice.actualVal;
}
return ZE_RESULT_SUCCESS;
}
if (file.compare((file.length() - heartbeatIntervalMilliSecs.length()),
heartbeatIntervalMilliSecs.length(),
heartbeatIntervalMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
val = it->second->heartBeat.defaultVal;
} else {
val = it->second->heartBeat.actualVal;
}
return ZE_RESULT_SUCCESS;
}
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t write(const std::string file, const uint64_t val) override {
if (mockWriteFileStatus != ZE_RESULT_SUCCESS) {
return mockWriteFileStatus;
}
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) { // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
if (file.find(mappedEngine) == std::string::npos) {
continue;
}
SchedulerConfig_t *schedConfig = new SchedulerConfig_t();
if (file.compare((file.length() - preemptTimeoutMilliSecs.length()),
preemptTimeoutMilliSecs.length(),
preemptTimeoutMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
schedConfig->timeOut.defaultVal = val;
} else {
schedConfig->timeOut.actualVal = val;
}
auto ret = engineSchedMap.emplace(mappedEngine, schedConfig);
if (ret.second == false) {
auto itr = engineSchedMap.find(mappedEngine);
if (file.find(".defaults") != std::string::npos) {
itr->second->timeOut.defaultVal = val;
} else {
itr->second->timeOut.actualVal = val;
}
delete schedConfig;
}
return ZE_RESULT_SUCCESS;
}
if (file.compare((file.length() - timesliceDurationMilliSecs.length()),
timesliceDurationMilliSecs.length(),
timesliceDurationMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
schedConfig->timeSclice.defaultVal = val;
} else {
schedConfig->timeSclice.actualVal = val;
}
auto ret = engineSchedMap.emplace(mappedEngine, schedConfig);
if (ret.second == false) {
auto itr = engineSchedMap.find(mappedEngine);
if (file.find(".defaults") != std::string::npos) {
itr->second->timeSclice.defaultVal = val;
} else {
itr->second->timeSclice.actualVal = val;
}
delete schedConfig;
}
return ZE_RESULT_SUCCESS;
}
if (file.compare((file.length() - heartbeatIntervalMilliSecs.length()),
heartbeatIntervalMilliSecs.length(),
heartbeatIntervalMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
schedConfig->heartBeat.defaultVal = val;
} else {
schedConfig->heartBeat.actualVal = val;
}
auto ret = engineSchedMap.emplace(mappedEngine, schedConfig);
if (ret.second == false) {
auto itr = engineSchedMap.find(mappedEngine);
if (file.find(".defaults") != std::string::npos) {
itr->second->heartBeat.defaultVal = val;
} else {
itr->second->heartBeat.actualVal = val;
}
delete schedConfig;
}
return ZE_RESULT_SUCCESS;
}
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t scanDirEntries(const std::string file, std::vector<std::string> &listOfEntries) override {
if (mockGetScanDirEntryError != ZE_RESULT_SUCCESS) {
return mockGetScanDirEntryError;
}
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;
}
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;
}
MockSchedulerSysfsAccess() = default;
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::Sysman::LinuxSchedulerImp {
public:
using LinuxSchedulerImp::pSysfsAccess;
};
} // namespace ult
} // namespace L0

600
level_zero/sysman/test/unit_tests/sources/scheduler/linux/mock_sysfs_scheduler_prelim.h Normal file
View File

@@ -0,0 +1,600 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/os_interface/linux/engine_info.h"
#include "shared/source/os_interface/linux/i915_prelim.h"
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "level_zero/sysman/source/linux/fs_access.h"
#include "level_zero/sysman/source/scheduler/linux/os_scheduler_imp.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_hw_device_id.h"
namespace L0 {
namespace ult {
const std::string preemptTimeoutMilliSecs("preempt_timeout_ms");
const std::string defaultPreemptTimeoutMilliSecs(".defaults/preempt_timeout_ms");
const std::string timesliceDurationMilliSecs("timeslice_duration_ms");
const std::string defaultTimesliceDurationMilliSecs(".defaults/timeslice_duration_ms");
const std::string heartbeatIntervalMilliSecs("heartbeat_interval_ms");
const std::string defaultHeartbeatIntervalMilliSecs(".defaults/heartbeat_interval_ms");
const std::string enableEuDebug("prelim_enable_eu_debug");
const std::string engineDir("engine");
const std::vector<std::string> listOfMockedEngines = {"rcs0", "bcs0", "vcs0", "vcs1", "vecs0", "ccs0"};
uint32_t tileCount = 2u;
uint32_t numberOfEnginesInSched = 34u;
struct MockSchedulerNeoDrm : public Drm {
using Drm::getEngineInfo;
using Drm::setupIoctlHelper;
const int mockFd = 0;
MockSchedulerNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<MockSysmanHwDeviceIdDrm>(mockFd, ""), rootDeviceEnvironment) {}
bool sysmanQueryEngineInfo() override {
uint16_t engineClassCopy = ioctlHelper->getDrmParamValue(DrmParam::EngineClassCopy);
uint16_t engineClassCompute = ioctlHelper->getDrmParamValue(DrmParam::EngineClassCompute);
uint16_t engineClassVideo = ioctlHelper->getDrmParamValue(DrmParam::EngineClassVideo);
uint16_t engineClassVideoEnhance = ioctlHelper->getDrmParamValue(DrmParam::EngineClassVideoEnhance);
uint16_t engineClassInvalid = ioctlHelper->getDrmParamValue(DrmParam::EngineClassInvalid);
// Fill distanceInfos vector with dummy values
std::vector<NEO::DistanceInfo> distanceInfos = {
{{1, 0}, {engineClassCopy, 0}, 0},
{{1, 0}, {engineClassCopy, 1}, 1000},
{{1, 0}, {engineClassCompute, 0}, 0},
{{1, 0}, {engineClassCompute, 1}, 0},
{{1, 0}, {engineClassCompute, 2}, 0},
{{1, 0}, {engineClassCompute, 3}, 0},
{{1, 0}, {engineClassCompute, 4}, 1000},
{{1, 0}, {engineClassCompute, 5}, 1000},
{{1, 0}, {engineClassCompute, 6}, 1000},
{{1, 0}, {engineClassCompute, 7}, 1000},
{{1, 1}, {engineClassCopy, 0}, 1000},
{{1, 1}, {engineClassCopy, 1}, 0},
{{1, 1}, {engineClassCompute, 0}, 1000},
{{1, 1}, {engineClassCompute, 1}, 1000},
{{1, 1}, {engineClassCompute, 2}, 1000},
{{1, 1}, {engineClassCompute, 3}, 1000},
{{1, 1}, {engineClassCompute, 4}, 0},
{{1, 1}, {engineClassCompute, 5}, 0},
{{1, 1}, {engineClassCompute, 6}, 0},
{{1, 1}, {engineClassCompute, 7}, 0},
{{1, 1}, {engineClassInvalid, 7}, 0},
};
std::vector<QueryItem> queryItems{distanceInfos.size()};
for (auto i = 0u; i < distanceInfos.size(); i++) {
queryItems[i].queryId = PRELIM_DRM_I915_QUERY_DISTANCE_INFO;
queryItems[i].length = sizeof(NEO::PrelimI915::prelim_drm_i915_query_distance_info);
queryItems[i].flags = 0u;
queryItems[i].dataPtr = reinterpret_cast<uint64_t>(&distanceInfos[i]);
}
// Fill i915QueryEngineInfo with dummy values
std::vector<NEO::EngineCapabilities> i915QueryEngineInfo(numberOfEnginesInSched);
i915QueryEngineInfo[0].engine.engineClass = engineClassCopy;
i915QueryEngineInfo[0].engine.engineInstance = 0;
i915QueryEngineInfo[1].engine.engineClass = engineClassCopy;
i915QueryEngineInfo[1].engine.engineInstance = 1;
i915QueryEngineInfo[2].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[2].engine.engineInstance = 0;
i915QueryEngineInfo[3].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[3].engine.engineInstance = 1;
i915QueryEngineInfo[4].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[4].engine.engineInstance = 2;
i915QueryEngineInfo[5].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[5].engine.engineInstance = 3;
i915QueryEngineInfo[6].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[6].engine.engineInstance = 4;
i915QueryEngineInfo[7].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[7].engine.engineInstance = 5;
i915QueryEngineInfo[8].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[8].engine.engineInstance = 6;
i915QueryEngineInfo[9].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[9].engine.engineInstance = 7;
i915QueryEngineInfo[10].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[10].engine.engineInstance = 8;
i915QueryEngineInfo[11].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[11].engine.engineInstance = 9;
i915QueryEngineInfo[12].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[12].engine.engineInstance = 10;
i915QueryEngineInfo[13].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[13].engine.engineInstance = 11;
i915QueryEngineInfo[14].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[14].engine.engineInstance = 12;
i915QueryEngineInfo[15].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[15].engine.engineInstance = 13;
i915QueryEngineInfo[16].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[16].engine.engineInstance = 14;
i915QueryEngineInfo[17].engine.engineClass = engineClassVideo;
i915QueryEngineInfo[17].engine.engineInstance = 15;
i915QueryEngineInfo[18].engine.engineClass = engineClassVideoEnhance;
i915QueryEngineInfo[18].engine.engineInstance = 0;
i915QueryEngineInfo[19].engine.engineClass = engineClassVideoEnhance;
i915QueryEngineInfo[19].engine.engineInstance = 1;
i915QueryEngineInfo[20].engine.engineClass = engineClassVideoEnhance;
i915QueryEngineInfo[20].engine.engineInstance = 2;
i915QueryEngineInfo[21].engine.engineClass = engineClassVideoEnhance;
i915QueryEngineInfo[21].engine.engineInstance = 3;
i915QueryEngineInfo[22].engine.engineClass = engineClassVideoEnhance;
i915QueryEngineInfo[22].engine.engineInstance = 4;
i915QueryEngineInfo[23].engine.engineClass = engineClassVideoEnhance;
i915QueryEngineInfo[23].engine.engineInstance = 5;
i915QueryEngineInfo[24].engine.engineClass = engineClassVideoEnhance;
i915QueryEngineInfo[24].engine.engineInstance = 6;
i915QueryEngineInfo[25].engine.engineClass = engineClassVideoEnhance;
i915QueryEngineInfo[25].engine.engineInstance = 7;
i915QueryEngineInfo[26].engine.engineClass = engineClassCompute;
i915QueryEngineInfo[26].engine.engineInstance = 0;
i915QueryEngineInfo[27].engine.engineClass = engineClassCompute;
i915QueryEngineInfo[27].engine.engineInstance = 1;
i915QueryEngineInfo[28].engine.engineClass = engineClassCompute;
i915QueryEngineInfo[28].engine.engineInstance = 2;
i915QueryEngineInfo[29].engine.engineClass = engineClassCompute;
i915QueryEngineInfo[29].engine.engineInstance = 3;
i915QueryEngineInfo[30].engine.engineClass = engineClassCompute;
i915QueryEngineInfo[30].engine.engineInstance = 4;
i915QueryEngineInfo[31].engine.engineClass = engineClassCompute;
i915QueryEngineInfo[31].engine.engineInstance = 5;
i915QueryEngineInfo[32].engine.engineClass = engineClassCompute;
i915QueryEngineInfo[32].engine.engineInstance = 6;
i915QueryEngineInfo[33].engine.engineClass = engineClassCompute;
i915QueryEngineInfo[33].engine.engineInstance = 7;
this->engineInfo.reset(new EngineInfo(this, tileCount, distanceInfos, queryItems, i915QueryEngineInfo));
return true;
}
bool queryEngineInfoMockReturnFalse() {
return false;
}
void resetEngineInfo() {
engineInfo.reset();
}
};
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;
}
};
class MockSchedulerProcfsAccess : public L0::Sysman::ProcfsAccess {
public:
MockSchedulerProcfsAccess() = default;
const pid_t pid1 = 1234;
const pid_t pid2 = 1235;
const pid_t pid3 = 1236;
const pid_t pid4 = 1237;
ze_result_t listProcessesResult = ZE_RESULT_SUCCESS;
ze_result_t listProcesses(std::vector<::pid_t> &list) override {
if (listProcessesResult != ZE_RESULT_SUCCESS) {
return listProcessesResult;
}
list.push_back(pid1);
list.push_back(pid2);
list.push_back(pid3);
list.push_back(pid4);
return ZE_RESULT_SUCCESS;
}
ze_result_t getFileDescriptorsResult;
ze_result_t getFileDescriptors(const ::pid_t pid, std::vector<int> &list) override {
// push dummy fd numbers in list vector
if (pid == pid1) {
list.push_back(1);
list.push_back(2);
} else if (pid == pid2) {
list.push_back(1);
list.push_back(2);
} else if (pid == pid3) {
list.push_back(1);
list.push_back(2);
} else if (pid == pid4) {
list.push_back(1);
list.push_back(3);
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getFileName(const ::pid_t pid, const int fd, std::string &val) override {
if (fd == 1) {
val = "/dev/null"; // assuming after opening /dev/null fd received is 1
return ZE_RESULT_SUCCESS;
}
if (fd == 2) {
val = "/dev/dri/renderD128"; // assuming after opening /dev/dri/renderD128 fd received is 2
return ZE_RESULT_SUCCESS;
}
if (fd == 3) {
val = "/dev/dummy"; // assuming after opening /dev/dummy fd received is 3
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
::pid_t myProcessId() override {
return pid2;
}
ADDMETHOD_NOBASE_VOIDRETURN(kill, (const ::pid_t pid));
};
typedef struct SchedulerConfigValues {
uint64_t defaultVal;
uint64_t actualVal;
} SchedulerConfigValues_t;
typedef struct SchedulerConfig {
SchedulerConfigValues_t timeOut;
SchedulerConfigValues_t timeSclice;
SchedulerConfigValues_t heartBeat;
uint64_t euDebugEnable;
} SchedulerConfig_t;
class CalledTimesUpdate {
public:
CalledTimesUpdate(int &calledTimes) : calledTimesVar(calledTimes) {}
~CalledTimesUpdate() {
calledTimesVar++;
}
private:
int &calledTimesVar;
};
struct MockSchedulerSysfsAccess : public L0::Sysman::SysfsAccess {
using SysfsAccess::deviceNames;
ze_result_t mockReadFileFailureError = ZE_RESULT_SUCCESS;
ze_result_t mockGetScanDirEntryError = ZE_RESULT_SUCCESS;
std::vector<ze_result_t> mockReadReturnValues{ZE_RESULT_SUCCESS, ZE_RESULT_SUCCESS, ZE_RESULT_SUCCESS, ZE_RESULT_ERROR_NOT_AVAILABLE};
uint32_t mockReadCount = 0;
bool mockReadReturnStatus = false;
bool mockGetValueForError = false;
bool mockGetValueForErrorWhileWrite = false;
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;
}
ze_result_t getValForErrorWhileWrite(const std::string file, const uint64_t val) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
void cleanUpMap() {
for (std::string mappedEngine : listOfMockedEngines) {
auto it = engineSchedMap.find(mappedEngine);
if (it != engineSchedMap.end()) {
delete it->second;
}
}
}
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;
}
if (engine.empty()) {
engineSchedFilePropertiesMap[file] = SchedulerFileProperties(isAvailable, mode);
}
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t canWrite(const std::string file) override {
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;
}
return result;
}
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t read(const std::string file, uint64_t &val) override {
if (mockReadReturnStatus == true) {
if (mockReadCount < mockReadReturnValues.size()) {
ze_result_t returnValue = mockReadReturnValues[mockReadCount];
mockReadCount++;
return returnValue;
}
}
if (mockReadFileFailureError != ZE_RESULT_SUCCESS) {
return mockReadFileFailureError;
}
if (mockGetValueForError == true) {
return getValForError(file, 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;
}
// listOfMockedEngines is as below:
// [0]: "rcs0"
// [1]: "bcs0"
// [2]: "vcs0"
// [3]: "vcs1"
// [4]: "vecs0"
// [5]: "ccs0"
for (std::string mappedEngine : listOfMockedEngines) {
if (file.compare(file.length() - enableEuDebug.length(),
enableEuDebug.length(),
enableEuDebug) == 0) {
// "prelim_enable_eu_debug" sysfs node is common node across one drm client
// This node is not engine specific. Hence it needs to be handled separately.
// All other engine specific nodes are handled outside of this if block
// As "prelim_enable_eu_debug" node is common across system, hence below we could find
// using any engine node. Lets use rcs0 here.
auto it = engineSchedMap.find("rcs0");
val = it->second->euDebugEnable;
return ZE_RESULT_SUCCESS;
}
if (file.find(mappedEngine) == std::string::npos) {
continue;
}
auto it = engineSchedMap.find(mappedEngine);
if (it == engineSchedMap.end()) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
if (file.compare(file.length() - enableEuDebug.length(),
enableEuDebug.length(),
enableEuDebug) == 0) {
val = it->second->euDebugEnable;
}
if (file.compare((file.length() - preemptTimeoutMilliSecs.length()),
preemptTimeoutMilliSecs.length(),
preemptTimeoutMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
val = it->second->timeOut.defaultVal;
} else {
val = it->second->timeOut.actualVal;
}
return ZE_RESULT_SUCCESS;
}
if (file.compare((file.length() - timesliceDurationMilliSecs.length()),
timesliceDurationMilliSecs.length(),
timesliceDurationMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
val = it->second->timeSclice.defaultVal;
} else {
val = it->second->timeSclice.actualVal;
}
return ZE_RESULT_SUCCESS;
}
if (file.compare((file.length() - heartbeatIntervalMilliSecs.length()),
heartbeatIntervalMilliSecs.length(),
heartbeatIntervalMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
val = it->second->heartBeat.defaultVal;
} else {
val = it->second->heartBeat.actualVal;
}
return ZE_RESULT_SUCCESS;
}
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
int writeCalled = 0;
std::vector<ze_result_t> writeResult{ZE_RESULT_SUCCESS};
ze_result_t write(const std::string file, const uint64_t val) override {
CalledTimesUpdate update(writeCalled); // increment this method's call count while exiting this method
if (writeCalled < static_cast<int>(writeResult.size())) {
if (writeResult[writeCalled] != ZE_RESULT_SUCCESS) {
// If we are here, it means test simply wants to validate failure values from this method
return writeResult[writeCalled];
}
}
if (mockGetValueForErrorWhileWrite == true) {
return getValForErrorWhileWrite(file, 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;
}
if (file.compare(file.length() - enableEuDebug.length(), enableEuDebug.length(), enableEuDebug) == 0) {
// "prelim_enable_eu_debug" sysfs node is common node across one drm client
// This node is not engine specific. Hence it needs to be handled separately.
// All other engine specific nodes are handled outside of this if block inside for loop
for (auto &mappedEngine : listOfMockedEngines) {
SchedulerConfig_t *schedConfig = new SchedulerConfig_t();
schedConfig->euDebugEnable = val;
auto ret = engineSchedMap.emplace(mappedEngine, schedConfig);
if (ret.second == false) {
auto itr = engineSchedMap.find(mappedEngine);
itr->second->euDebugEnable = val;
delete schedConfig;
}
}
return ZE_RESULT_SUCCESS;
}
for (std::string mappedEngine : listOfMockedEngines) { // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
if (file.find(mappedEngine) == std::string::npos) {
continue;
}
SchedulerConfig_t *schedConfig = new SchedulerConfig_t();
if (file.compare((file.length() - preemptTimeoutMilliSecs.length()),
preemptTimeoutMilliSecs.length(),
preemptTimeoutMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
schedConfig->timeOut.defaultVal = val;
} else {
schedConfig->timeOut.actualVal = val;
}
auto ret = engineSchedMap.emplace(mappedEngine, schedConfig);
if (ret.second == false) {
auto itr = engineSchedMap.find(mappedEngine);
if (file.find(".defaults") != std::string::npos) {
itr->second->timeOut.defaultVal = val;
} else {
itr->second->timeOut.actualVal = val;
}
delete schedConfig;
}
return ZE_RESULT_SUCCESS;
}
if (file.compare((file.length() - timesliceDurationMilliSecs.length()),
timesliceDurationMilliSecs.length(),
timesliceDurationMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
schedConfig->timeSclice.defaultVal = val;
} else {
schedConfig->timeSclice.actualVal = val;
}
auto ret = engineSchedMap.emplace(mappedEngine, schedConfig);
if (ret.second == false) {
auto itr = engineSchedMap.find(mappedEngine);
if (file.find(".defaults") != std::string::npos) {
itr->second->timeSclice.defaultVal = val;
} else {
itr->second->timeSclice.actualVal = val;
}
delete schedConfig;
}
return ZE_RESULT_SUCCESS;
}
if (file.compare((file.length() - heartbeatIntervalMilliSecs.length()),
heartbeatIntervalMilliSecs.length(),
heartbeatIntervalMilliSecs) == 0) {
if (file.find(".defaults") != std::string::npos) {
schedConfig->heartBeat.defaultVal = val;
} else {
schedConfig->heartBeat.actualVal = val;
}
auto ret = engineSchedMap.emplace(mappedEngine, schedConfig);
if (ret.second == false) {
auto itr = engineSchedMap.find(mappedEngine);
if (file.find(".defaults") != std::string::npos) {
itr->second->heartBeat.defaultVal = val;
} else {
itr->second->heartBeat.actualVal = val;
}
delete schedConfig;
}
return ZE_RESULT_SUCCESS;
}
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t scanDirEntries(const std::string file, std::vector<std::string> &listOfEntries) override {
if (mockGetScanDirEntryError != ZE_RESULT_SUCCESS) {
return mockGetScanDirEntryError;
}
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;
}
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;
}
MockSchedulerSysfsAccess() = default;
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::Sysman::LinuxSchedulerImp {
public:
using LinuxSchedulerImp::isComputeUnitDebugModeEnabled;
using LinuxSchedulerImp::pSysfsAccess;
using LinuxSchedulerImp::setExclusiveModeImp;
using LinuxSchedulerImp::setHeartbeatInterval;
using LinuxSchedulerImp::setPreemptTimeout;
using LinuxSchedulerImp::setTimesliceDuration;
using LinuxSchedulerImp::subdeviceId;
};
} // namespace ult
} // namespace L0

645
level_zero/sysman/test/unit_tests/sources/scheduler/linux/test_zes_scheduler.cpp Normal file
View File

@@ -0,0 +1,645 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/sysman_const.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include "level_zero/sysman/test/unit_tests/sources/scheduler/linux/mock_sysfs_scheduler.h"
namespace L0 {
namespace ult {
constexpr uint32_t handleComponentCount = 4u;
constexpr uint64_t convertMilliToMicro = 1000u;
constexpr uint64_t defaultTimeoutMilliSecs = 650u;
constexpr uint64_t defaultTimesliceMilliSecs = 1u;
constexpr uint64_t defaultHeartbeatMilliSecs = 3000u;
constexpr uint64_t timeoutMilliSecs = 640u;
constexpr uint64_t timesliceMilliSecs = 1u;
constexpr uint64_t heartbeatMilliSecs = 2500u;
constexpr uint64_t expectedDefaultHeartbeatTimeoutMicroSecs = defaultHeartbeatMilliSecs * convertMilliToMicro;
constexpr uint64_t expectedDefaultTimeoutMicroSecs = defaultTimeoutMilliSecs * convertMilliToMicro;
constexpr uint64_t expectedDefaultTimesliceMicroSecs = defaultTimesliceMilliSecs * convertMilliToMicro;
constexpr uint64_t expectedHeartbeatTimeoutMicroSecs = heartbeatMilliSecs * convertMilliToMicro;
constexpr uint64_t expectedTimeoutMicroSecs = timeoutMilliSecs * convertMilliToMicro;
constexpr uint64_t expectedTimesliceMicroSecs = timesliceMilliSecs * convertMilliToMicro;
class SysmanDeviceSchedulerFixture : public SysmanDeviceFixture {
protected:
std::unique_ptr<MockSchedulerSysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockSchedulerSysfsAccess>();
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->write(engineDir + "/" + engineName + "/" + defaultPreemptTimeoutMilliSecs, defaultTimeoutMilliSecs);
pSysfsAccess->write(engineDir + "/" + engineName + "/" + defaultTimesliceDurationMilliSecs, defaultTimesliceMilliSecs);
pSysfsAccess->write(engineDir + "/" + engineName + "/" + defaultHeartbeatIntervalMilliSecs, defaultHeartbeatMilliSecs);
pSysfsAccess->write(engineDir + "/" + engineName + "/" + preemptTimeoutMilliSecs, timeoutMilliSecs);
pSysfsAccess->write(engineDir + "/" + engineName + "/" + timesliceDurationMilliSecs, timesliceMilliSecs);
pSysfsAccess->write(engineDir + "/" + engineName + "/" + heartbeatIntervalMilliSecs, heartbeatMilliSecs);
});
// delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pSchedulerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pSchedulerHandleContext->handleList.clear();
device = pSysmanDevice;
getSchedHandles(0);
}
void TearDown() override {
pSysfsAccess->cleanUpMap();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
SysmanDeviceFixture::TearDown();
}
std::vector<zes_sched_handle_t> getSchedHandles(uint32_t count) {
std::vector<zes_sched_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumSchedulers(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
return handles;
}
zes_sched_mode_t fixtureGetCurrentMode(zes_sched_handle_t hScheduler) {
zes_sched_mode_t mode;
ze_result_t result = zesSchedulerGetCurrentMode(hScheduler, &mode);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
return mode;
}
zes_sched_timeout_properties_t fixtureGetTimeoutModeProperties(zes_sched_handle_t hScheduler, ze_bool_t getDefaults) {
zes_sched_timeout_properties_t config;
ze_result_t result = zesSchedulerGetTimeoutModeProperties(hScheduler, getDefaults, &config);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
return config;
}
zes_sched_timeslice_properties_t fixtureGetTimesliceModeProperties(zes_sched_handle_t hScheduler, ze_bool_t getDefaults) {
zes_sched_timeslice_properties_t config;
ze_result_t result = zesSchedulerGetTimesliceModeProperties(hScheduler, getDefaults, &config);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
return config;
}
};
TEST_F(SysmanDeviceSchedulerFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumSchedulersAndSysfsCanReadReturnsErrorThenZeroCountIsReturned) {
pSysfsAccess->mockGetScanDirEntryError = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto pSchedulerHandleContextTest = std::make_unique<L0::Sysman::SchedulerHandleContext>(pOsSysman);
pSchedulerHandleContextTest->init(pOsSysman->getSubDeviceCount());
EXPECT_EQ(0u, static_cast<uint32_t>(pSchedulerHandleContextTest->handleList.size()));
}
TEST_F(SysmanDeviceSchedulerFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumSchedulersAndSysfsCanReadReturnsIncorrectPermissionThenZeroCountIsReturned) {
pSysfsAccess->setEngineDirectoryPermission(0);
auto pSchedulerHandleContextTest = std::make_unique<L0::Sysman::SchedulerHandleContext>(pOsSysman);
pSchedulerHandleContextTest->init(pOsSysman->getSubDeviceCount());
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));
EXPECT_EQ(count, handleComponentCount);
uint32_t testcount = count + 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumSchedulers(device->toHandle(), &testcount, NULL));
EXPECT_EQ(testcount, count);
count = 0;
std::vector<zes_sched_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumSchedulers(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, handleComponentCount);
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeThenVerifyzesSchedulerGetCurrentModeCallSucceeds) {
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
auto mode = fixtureGetCurrentMode(handle);
EXPECT_EQ(mode, ZES_SCHED_MODE_TIMESLICE);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesThenVerifyzesSchedulerGetTimeoutModePropertiesCallSucceeds) {
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
auto config = fixtureGetTimeoutModeProperties(handle, false);
EXPECT_EQ(config.watchdogTimeout, expectedHeartbeatTimeoutMicroSecs);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesThenVerifyzesSchedulerGetTimeoutModePropertiesForDifferingValues) {
auto handles = getSchedHandles(handleComponentCount);
pSysfsAccess->write(engineDir + "/" + "vcs1" + "/" + heartbeatIntervalMilliSecs, (heartbeatMilliSecs + 5));
for (auto handle : handles) {
zes_sched_properties_t properties = {};
zes_sched_timeout_properties_t config;
ze_result_t result = zesSchedulerGetProperties(handle, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
ze_result_t result = zesSchedulerGetTimeoutModeProperties(handle, false, &config);
EXPECT_NE(ZE_RESULT_SUCCESS, result);
}
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesWithDefaultsThenVerifyzesSchedulerGetTimeoutModePropertiesCallSucceeds) {
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
auto config = fixtureGetTimeoutModeProperties(handle, true);
EXPECT_EQ(config.watchdogTimeout, expectedDefaultHeartbeatTimeoutMicroSecs);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimesliceModePropertiesThenVerifyzesSchedulerGetTimesliceModePropertiesCallSucceeds) {
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
auto config = fixtureGetTimesliceModeProperties(handle, false);
EXPECT_EQ(config.interval, expectedTimesliceMicroSecs);
EXPECT_EQ(config.yieldTimeout, expectedTimeoutMicroSecs);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimescliceModePropertiesThenVerifyzesSchedulerGetTimescliceModePropertiesForDifferingPreemptTimeoutValues) {
auto handles = getSchedHandles(handleComponentCount);
pSysfsAccess->write(engineDir + "/" + "vcs1" + "/" + preemptTimeoutMilliSecs, (timeoutMilliSecs + 5));
for (auto handle : handles) {
zes_sched_properties_t properties = {};
zes_sched_timeslice_properties_t config;
ze_result_t result = zesSchedulerGetProperties(handle, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
ze_result_t result = zesSchedulerGetTimesliceModeProperties(handle, false, &config);
EXPECT_NE(ZE_RESULT_SUCCESS, result);
}
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimescliceModePropertiesThenVerifyzesSchedulerGetTimescliceModePropertiesForDifferingTimesliceDurationValues) {
auto handles = getSchedHandles(handleComponentCount);
pSysfsAccess->write(engineDir + "/" + "vcs1" + "/" + timesliceDurationMilliSecs, (timesliceMilliSecs + 5));
for (auto handle : handles) {
zes_sched_properties_t properties = {};
zes_sched_timeslice_properties_t config;
ze_result_t result = zesSchedulerGetProperties(handle, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
ze_result_t result = zesSchedulerGetTimesliceModeProperties(handle, false, &config);
EXPECT_NE(ZE_RESULT_SUCCESS, result);
}
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesThenVerifyzesSchedulerGetTimeoutModePropertiesForReadFileFailureFileUnavailable) {
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
zes_sched_properties_t properties = {};
zes_sched_timeout_properties_t config;
ze_result_t result = zesSchedulerGetProperties(handle, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
pSysfsAccess->mockReadFileFailureError = ZE_RESULT_ERROR_NOT_AVAILABLE;
ze_result_t result = zesSchedulerGetTimeoutModeProperties(handle, false, &config);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesThenVerifyzesSchedulerGetTimeoutModePropertiesForReadFileFailureInsufficientPermissions) {
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
zes_sched_properties_t properties = {};
zes_sched_timeout_properties_t config;
ze_result_t result = zesSchedulerGetProperties(handle, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
pSysfsAccess->mockReadFileFailureError = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
ze_result_t result = zesSchedulerGetTimeoutModeProperties(handle, false, &config);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
}
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimescliceModePropertiesThenVerifyzesSchedulerGetTimescliceModePropertiesForReadFileFailureDueToUnavailable) {
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
zes_sched_timeslice_properties_t config;
zes_sched_properties_t properties = {};
ze_result_t result = zesSchedulerGetProperties(handle, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
/* The flag mockReadReturnStatus enables the call to read call where
* the read call returns ZE_RESULT_SUCCESS for the first 3 invocations
* and the 4th invocation returns the ZE_RESULT_ERROR_NOT_AVAILABLE
*/
pSysfsAccess->mockReadReturnStatus = true;
result = zesSchedulerGetTimesliceModeProperties(handle, false, &config);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimescliceModePropertiesThenVerifyzesSchedulerGetTimescliceModePropertiesForReadFileFailureDueToInsufficientPermissions) {
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
zes_sched_timeslice_properties_t config;
zes_sched_properties_t properties = {};
ze_result_t result = zesSchedulerGetProperties(handle, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
pSysfsAccess->mockReadFileFailureError = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
result = zesSchedulerGetTimesliceModeProperties(handle, false, &config);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
}
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimesliceModePropertiesWithDefaultsThenVerifyzesSchedulerGetTimesliceModePropertiesCallSucceeds) {
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
auto config = fixtureGetTimesliceModeProperties(handle, true);
EXPECT_EQ(config.interval, expectedDefaultTimesliceMicroSecs);
EXPECT_EQ(config.yieldTimeout, expectedDefaultTimeoutMicroSecs);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeThenVerifyzesSchedulerSetTimeoutModeCallSucceeds) {
auto handles = getSchedHandles(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_SUCCESS, result);
EXPECT_FALSE(needReboot);
auto getConfig = fixtureGetTimeoutModeProperties(handle, false);
EXPECT_EQ(getConfig.watchdogTimeout, setConfig.watchdogTimeout);
auto mode = fixtureGetCurrentMode(handle);
EXPECT_EQ(mode, ZES_SCHED_MODE_TIMEOUT);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenTimeoutLessThanMinimumThenVerifyzesSchedulerSetTimeoutModeCallFails) {
auto handles = getSchedHandles(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 = getSchedHandles(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 = getSchedHandles(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 = getSchedHandles(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 = getSchedHandles(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 = getSchedHandles(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 = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeslice_properties_t setConfig;
setConfig.interval = 1000u;
setConfig.yieldTimeout = 1000u;
ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_FALSE(needReboot);
auto getConfig = fixtureGetTimesliceModeProperties(handle, false);
EXPECT_EQ(getConfig.interval, setConfig.interval);
EXPECT_EQ(getConfig.yieldTimeout, setConfig.yieldTimeout);
auto mode = fixtureGetCurrentMode(handle);
EXPECT_EQ(mode, ZES_SCHED_MODE_TIMESLICE);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenIntervalIsLessThanMinimumThenVerifyzesSchedulerSetTimesliceModeCallFails) {
auto handles = getSchedHandles(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 = getSchedHandles(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 = getSchedHandles(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 = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_FALSE(needReboot);
auto mode = fixtureGetCurrentMode(handle);
EXPECT_EQ(mode, ZES_SCHED_MODE_EXCLUSIVE);
}
}
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 = getSchedHandles(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 = getSchedHandles(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 = getSchedHandles(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 = getSchedHandles(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, 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 = getSchedHandles(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 = getSchedHandles(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) {
pSysfsAccess->mockWriteFileStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto handles = getSchedHandles(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) {
pSysfsAccess->mockReadFileFailureError = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
zes_sched_timeout_properties_t config;
ze_result_t result = zesSchedulerGetTimeoutModeProperties(handle, true, &config);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimesliceModePropertiesWithDefaultsWhenSysfsNodeIsAbsentThenFailureIsReturned) {
pSysfsAccess->mockReadFileFailureError = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
zes_sched_timeslice_properties_t config;
ze_result_t result = zesSchedulerGetTimesliceModeProperties(handle, true, &config);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenSysfsNodeIsAbsentThenFailureIsReturned) {
pSysfsAccess->mockWriteFileStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeslice_properties_t setConfig;
setConfig.interval = 1000u;
setConfig.yieldTimeout = 1000u;
ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenSysfsNodeWithoutPermissionsThenFailureIsReturned) {
pSysfsAccess->mockWriteFileStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
ze_bool_t needReboot;
zes_sched_timeslice_properties_t setConfig;
setConfig.interval = 1000u;
setConfig.yieldTimeout = 1000u;
pSysfsAccess->mockWriteFileStatus = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result);
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetPropertiesThenVerifyzesSchedulerGetPropertiesCallSucceeds) {
auto handles = getSchedHandles(handleComponentCount);
for (auto handle : handles) {
zes_sched_properties_t properties = {};
ze_result_t result = zesSchedulerGetProperties(handle, &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_TRUE(properties.canControl);
EXPECT_LE(properties.engines, ZES_ENGINE_TYPE_FLAG_RENDER);
EXPECT_EQ(properties.supportedModes, static_cast<uint32_t>((1 << ZES_SCHED_MODE_TIMEOUT) | (1 << ZES_SCHED_MODE_TIMESLICE) | (1 << ZES_SCHED_MODE_EXCLUSIVE)));
}
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidObjectsOfClassSchedulerImpAndSchedulerHandleContextThenDuringObjectReleaseCheckDestructorBranches) {
for (auto &handle : pSysmanDeviceImp->pSchedulerHandleContext->handleList) {
auto pSchedulerImp = static_cast<L0::Sysman::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;
L0::Sysman::LinuxSchedulerImp *pLinuxSchedulerImp = new L0::Sysman::LinuxSchedulerImp(pOsSysman, ZES_ENGINE_TYPE_FLAG_RENDER, listOfEngines,
true, 3);
EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxSchedulerImp->getProperties(properties));
EXPECT_EQ(properties.subdeviceId, 3u);
EXPECT_EQ(properties.onSubdevice, true);
delete pLinuxSchedulerImp;
}
} // namespace ult
} // namespace L0

1051
level_zero/sysman/test/unit_tests/sources/scheduler/linux/test_zes_scheduler_prelim.cpp Normal file
View File

File diff suppressed because it is too large Load Diff