Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add Subdevice support for sysman scheduler API 

Change-Id: I7b2222645d93346cfd3bfd3b6561dbe21154b61f
Signed-off-by: Jitendra Sharma <jitendra.sharma@intel.com>
This commit is contained in:
Jitendra Sharma 2020-09-23 07:08:48 +05:30 committed by sys_ocldev
parent 52b785552b
commit 77f88f9a96
15 changed files with 114 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
level_zero/tools/source/sysman/frequency/frequency.cpp
View File

@ -25,8 +25,8 @@ void FrequencyHandleContext::createHandle(ze_device_handle_t deviceHandle, zes_f
handleList.push_back(pFrequency); handleList.push_back(pFrequency);
} }
ze_result_t FrequencyHandleContext::init(std::vector<ze_device_handle_t> deviceHandles) { ze_result_t FrequencyHandleContext::init(std::vector<ze_device_handle_t> &deviceHandles) {
for (auto deviceHandle : deviceHandles) { for (const auto &deviceHandle : deviceHandles) {
auto totalDomains = OsFrequency::getNumberOfFreqDoainsSupported(pOsSysman); auto totalDomains = OsFrequency::getNumberOfFreqDoainsSupported(pOsSysman);
UNRECOVERABLE_IF(totalDomains > 2); UNRECOVERABLE_IF(totalDomains > 2);
for (uint32_t frequencyDomain = 0; frequencyDomain < totalDomains; frequencyDomain++) { for (uint32_t frequencyDomain = 0; frequencyDomain < totalDomains; frequencyDomain++) {

2
level_zero/tools/source/sysman/frequency/frequency.h
View File

@ -55,7 +55,7 @@ struct FrequencyHandleContext {
FrequencyHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){}; FrequencyHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
~FrequencyHandleContext(); ~FrequencyHandleContext();
ze_result_t init(std::vector<ze_device_handle_t> deviceHandles); ze_result_t init(std::vector<ze_device_handle_t> &deviceHandles);
ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency); ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency);

24
level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.cpp
View File

@ -20,7 +20,8 @@ const std::string LinuxSchedulerImp::defaultHeartbeatIntervalMilliSecs(".default
const std::string LinuxSchedulerImp::engineDir("engine"); const std::string LinuxSchedulerImp::engineDir("engine");
ze_result_t LinuxSchedulerImp::getProperties(zes_sched_properties_t &schedProperties) { ze_result_t LinuxSchedulerImp::getProperties(zes_sched_properties_t &schedProperties) {
schedProperties.onSubdevice = false; schedProperties.onSubdevice = onSubdevice;
schedProperties.subdeviceId = subdeviceId;
schedProperties.canControl = canControlScheduler(); schedProperties.canControl = canControlScheduler();
schedProperties.engines = this->engineType; schedProperties.engines = this->engineType;
schedProperties.supportedModes = (1 << ZES_SCHED_MODE_TIMEOUT) | (1 << ZES_SCHED_MODE_TIMESLICE) | (1 << ZES_SCHED_MODE_EXCLUSIVE); schedProperties.supportedModes = (1 << ZES_SCHED_MODE_TIMEOUT) | (1 << ZES_SCHED_MODE_TIMESLICE) | (1 << ZES_SCHED_MODE_EXCLUSIVE);
@ -175,9 +176,7 @@ static const std::multimap<zes_engine_type_flag_t, std::string> level0EngineType
{ZES_ENGINE_TYPE_FLAG_MEDIA, "vcs"}, {ZES_ENGINE_TYPE_FLAG_MEDIA, "vcs"},
{ZES_ENGINE_TYPE_FLAG_OTHER, "vecs"}}; {ZES_ENGINE_TYPE_FLAG_OTHER, "vecs"}};
ze_result_t OsScheduler::getNumEngineTypeAndInstances(std::map<zes_engine_type_flag_t, std::vector<std::string>> &mapOfEngines, OsSysman *pOsSysman) { static ze_result_t getNumEngineTypeAndInstancesForDevice(std::map<zes_engine_type_flag_t, std::vector<std::string>> &mapOfEngines, SysfsAccess *pSysfsAccess) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
auto pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
std::vector<std::string> localListOfAllEngines = {}; std::vector<std::string> localListOfAllEngines = {};
auto result = pSysfsAccess->scanDirEntries(LinuxSchedulerImp::engineDir, localListOfAllEngines); auto result = pSysfsAccess->scanDirEntries(LinuxSchedulerImp::engineDir, localListOfAllEngines);
if (ZE_RESULT_SUCCESS != result) { if (ZE_RESULT_SUCCESS != result) {
@ -206,15 +205,24 @@ ze_result_t OsScheduler::getNumEngineTypeAndInstances(std::map<zes_engine_type_f
return result; return result;
} }
LinuxSchedulerImp::LinuxSchedulerImp(OsSysman *pOsSysman, zes_engine_type_flag_t type, std::vector<std::string> &listOfEngines) { ze_result_t OsScheduler::getNumEngineTypeAndInstances(
std::map<zes_engine_type_flag_t, std::vector<std::string>> &mapOfEngines, OsSysman *pOsSysman, ze_device_handle_t subdeviceHandle) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
auto pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
return getNumEngineTypeAndInstancesForDevice(mapOfEngines, pSysfsAccess);
}
LinuxSchedulerImp::LinuxSchedulerImp(
OsSysman *pOsSysman, zes_engine_type_flag_t type, std::vector<std::string> &listOfEngines, ze_bool_t isSubdevice,
uint32_t subdeviceId) : engineType(type), onSubdevice(isSubdevice), subdeviceId(subdeviceId) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman); LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess(); pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
engineType = type;
this->listOfEngines = listOfEngines; this->listOfEngines = listOfEngines;
} }
OsScheduler *OsScheduler::create(OsSysman *pOsSysman, zes_engine_type_flag_t type, std::vector<std::string> &listOfEngines) { OsScheduler *OsScheduler::create(
LinuxSchedulerImp *pLinuxSchedulerImp = new LinuxSchedulerImp(pOsSysman, type, listOfEngines); OsSysman *pOsSysman, zes_engine_type_flag_t type, std::vector<std::string> &listOfEngines, ze_bool_t isSubdevice, uint32_t subdeviceId) {
LinuxSchedulerImp *pLinuxSchedulerImp = new LinuxSchedulerImp(pOsSysman, type, listOfEngines, isSubdevice, subdeviceId);
return static_cast<OsScheduler *>(pLinuxSchedulerImp); return static_cast<OsScheduler *>(pLinuxSchedulerImp);
} }

9
level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.h
View File

@ -6,12 +6,15 @@
*/ */
#pragma once #pragma once
#include "shared/source/os_interface/linux/drm_neo.h"
#include "sysman/scheduler/scheduler_imp.h" #include "sysman/scheduler/scheduler_imp.h"
#include <string> #include <string>
namespace L0 { namespace L0 {
class SysfsAccess; class SysfsAccess;
struct Device;
// Following below mappings of scheduler properties with sysfs nodes // Following below mappings of scheduler properties with sysfs nodes
// zes_sched_timeslice_properties_t.interval = timeslice_duration_ms // zes_sched_timeslice_properties_t.interval = timeslice_duration_ms
@ -28,13 +31,17 @@ class LinuxSchedulerImp : public OsScheduler, NEO::NonCopyableOrMovableClass {
ze_bool_t canControlScheduler() override; ze_bool_t canControlScheduler() override;
ze_result_t getProperties(zes_sched_properties_t &properties) override; ze_result_t getProperties(zes_sched_properties_t &properties) override;
LinuxSchedulerImp() = default; LinuxSchedulerImp() = default;
LinuxSchedulerImp(OsSysman *pOsSysman, zes_engine_type_flag_t type, std::vector<std::string> &listOfEngines); LinuxSchedulerImp(OsSysman *pOsSysman, zes_engine_type_flag_t type,
std::vector<std::string> &listOfEngines, ze_bool_t isSubdevice, uint32_t subdeviceId);
~LinuxSchedulerImp() override = default; ~LinuxSchedulerImp() override = default;
static const std::string engineDir; static const std::string engineDir;
protected: protected:
SysfsAccess *pSysfsAccess = nullptr; SysfsAccess *pSysfsAccess = nullptr;
Device *pDevice = nullptr;
zes_engine_type_flag_t engineType = ZES_ENGINE_TYPE_FLAG_OTHER; zes_engine_type_flag_t engineType = ZES_ENGINE_TYPE_FLAG_OTHER;
ze_bool_t onSubdevice = 0;
uint32_t subdeviceId = 0;
private: private:
static const std::string preemptTimeoutMilliSecs; static const std::string preemptTimeoutMilliSecs;

6
level_zero/tools/source/sysman/scheduler/os_scheduler.h
View File

@ -26,8 +26,10 @@ class OsScheduler {
virtual ze_result_t setHeartbeatInterval(uint64_t heartbeat) = 0; virtual ze_result_t setHeartbeatInterval(uint64_t heartbeat) = 0;
virtual ze_bool_t canControlScheduler() = 0; virtual ze_bool_t canControlScheduler() = 0;
virtual ze_result_t getProperties(zes_sched_properties_t &properties) = 0; virtual ze_result_t getProperties(zes_sched_properties_t &properties) = 0;
static OsScheduler *create(OsSysman *pOsSysman, zes_engine_type_flag_t engineType, std::vector<std::string> &listOfEngines); static OsScheduler *create(OsSysman *pOsSysman, zes_engine_type_flag_t engineType, std::vector<std::string> &listOfEngines,
static ze_result_t getNumEngineTypeAndInstances(std::map<zes_engine_type_flag_t, std::vector<std::string>> &listOfEngines, OsSysman *pOsSysman); ze_bool_t isSubdevice, uint32_t subdeviceId);
static ze_result_t getNumEngineTypeAndInstances(std::map<zes_engine_type_flag_t, std::vector<std::string>> &listOfEngines,
OsSysman *pOsSysman, ze_device_handle_t subdeviceHandle);
virtual ~OsScheduler() = default; virtual ~OsScheduler() = default;
}; };

16
level_zero/tools/source/sysman/scheduler/scheduler.cpp
View File

@ -23,16 +23,18 @@ SchedulerHandleContext::~SchedulerHandleContext() {
} }
handleList.clear(); handleList.clear();
} }
void SchedulerHandleContext::createHandle(zes_engine_type_flag_t engineType, std::vector<std::string> &listOfEngines) { void SchedulerHandleContext::createHandle(zes_engine_type_flag_t engineType, std::vector<std::string> &listOfEngines, ze_device_handle_t deviceHandle) {
Scheduler *pScheduler = new SchedulerImp(pOsSysman, engineType, listOfEngines); Scheduler *pScheduler = new SchedulerImp(pOsSysman, engineType, listOfEngines, deviceHandle);
handleList.push_back(pScheduler); handleList.push_back(pScheduler);
} }
void SchedulerHandleContext::init() { void SchedulerHandleContext::init(std::vector<ze_device_handle_t> &deviceHandles) {
std::map<zes_engine_type_flag_t, std::vector<std::string>> engineTypeInstance = {}; for (const auto &deviceHandle : deviceHandles) {
OsScheduler::getNumEngineTypeAndInstances(engineTypeInstance, pOsSysman); std::map<zes_engine_type_flag_t, std::vector<std::string>> engineTypeInstance = {};
for (auto itr = engineTypeInstance.begin(); itr != engineTypeInstance.end(); ++itr) { OsScheduler::getNumEngineTypeAndInstances(engineTypeInstance, pOsSysman, deviceHandle);
createHandle(itr->first, itr->second); for (auto itr = engineTypeInstance.begin(); itr != engineTypeInstance.end(); ++itr) {
createHandle(itr->first, itr->second, deviceHandle);
}
} }
} }

5
level_zero/tools/source/sysman/scheduler/scheduler.h
View File

@ -8,6 +8,7 @@
#pragma once #pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h" #include "shared/source/helpers/non_copyable_or_moveable.h"
#include "level_zero/core/source/device/device.h"
#include <level_zero/zes_api.h> #include <level_zero/zes_api.h>
#include <map> #include <map>
@ -41,7 +42,7 @@ class Scheduler : _zes_sched_handle_t {
struct SchedulerHandleContext : NEO::NonCopyableOrMovableClass { struct SchedulerHandleContext : NEO::NonCopyableOrMovableClass {
SchedulerHandleContext(OsSysman *pOsSysman); SchedulerHandleContext(OsSysman *pOsSysman);
~SchedulerHandleContext(); ~SchedulerHandleContext();
void init(); void init(std::vector<ze_device_handle_t> &deviceHandles);
ze_result_t schedulerGet(uint32_t *pCount, zes_sched_handle_t *phScheduler); ze_result_t schedulerGet(uint32_t *pCount, zes_sched_handle_t *phScheduler);
OsSysman *pOsSysman = nullptr; OsSysman *pOsSysman = nullptr;
@ -49,7 +50,7 @@ struct SchedulerHandleContext : NEO::NonCopyableOrMovableClass {
ze_device_handle_t hCoreDevice = nullptr; ze_device_handle_t hCoreDevice = nullptr;
private: private:
void createHandle(zes_engine_type_flag_t engineType, std::vector<std::string> &listOfEngines); void createHandle(zes_engine_type_flag_t engineType, std::vector<std::string> &listOfEngines, ze_device_handle_t deviceHandle);
}; };
} // namespace L0 } // namespace L0

7
level_zero/tools/source/sysman/scheduler/scheduler_imp.cpp
View File

@ -143,8 +143,11 @@ void SchedulerImp::init() {
pOsScheduler->getProperties(this->properties); pOsScheduler->getProperties(this->properties);
} }
SchedulerImp::SchedulerImp(OsSysman *pOsSysman, zes_engine_type_flag_t engineType, std::vector<std::string> &listOfEngines) { SchedulerImp::SchedulerImp(OsSysman *pOsSysman, zes_engine_type_flag_t engineType, std::vector<std::string> &listOfEngines, ze_device_handle_t deviceHandle) {
pOsScheduler = OsScheduler::create(pOsSysman, engineType, listOfEngines); ze_device_properties_t deviceProperties = {};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
pOsScheduler = OsScheduler::create(pOsSysman, engineType, listOfEngines,
deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, deviceProperties.subdeviceId);
UNRECOVERABLE_IF(nullptr == pOsScheduler); UNRECOVERABLE_IF(nullptr == pOsScheduler);
init(); init();
}; };

2
level_zero/tools/source/sysman/scheduler/scheduler_imp.h
View File

@ -29,7 +29,7 @@ class SchedulerImp : public Scheduler, NEO::NonCopyableOrMovableClass {
SchedulerImp() = default; SchedulerImp() = default;
OsScheduler *pOsScheduler = nullptr; OsScheduler *pOsScheduler = nullptr;
SchedulerImp(OsSysman *pOsSysman, zes_engine_type_flag_t type, std::vector<std::string> &listOfEngines); SchedulerImp(OsSysman *pOsSysman, zes_engine_type_flag_t type, std::vector<std::string> &listOfEngines, ze_device_handle_t deviceHandle);
~SchedulerImp() override; ~SchedulerImp() override;
zes_engine_type_flag_t engineType; zes_engine_type_flag_t engineType;

5
level_zero/tools/source/sysman/scheduler/windows/os_scheduler_imp.cpp
View File

@ -43,11 +43,12 @@ ze_result_t WddmSchedulerImp::getProperties(zes_sched_properties_t &properties)
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
} }
ze_result_t OsScheduler::getNumEngineTypeAndInstances(std::map<zes_engine_type_flag_t, std::vector<std::string>> &listOfEngines, OsSysman *pOsSysman) { ze_result_t OsScheduler::getNumEngineTypeAndInstances(std::map<zes_engine_type_flag_t, std::vector<std::string>> &listOfEngines, OsSysman *pOsSysman, ze_device_handle_t subdeviceHandle) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
} }
OsScheduler *OsScheduler::create(OsSysman *pOsSysman, zes_engine_type_flag_t type, std::vector<std::string> &listOfEngines) { OsScheduler *OsScheduler::create(
OsSysman *pOsSysman, zes_engine_type_flag_t type, std::vector<std::string> &listOfEngines, ze_bool_t isSubdevice, uint32_t subdeviceId) {
WddmSchedulerImp *pWddmSchedulerImp = new WddmSchedulerImp(); WddmSchedulerImp *pWddmSchedulerImp = new WddmSchedulerImp();
return static_cast<OsScheduler *>(pWddmSchedulerImp); return static_cast<OsScheduler *>(pWddmSchedulerImp);
} }

2
level_zero/tools/source/sysman/sysman_imp.cpp
View File

@ -88,7 +88,7 @@ void SysmanDeviceImp::init() {
pEngineHandleContext->init(); pEngineHandleContext->init();
} }
if (pSchedulerHandleContext) { if (pSchedulerHandleContext) {
pSchedulerHandleContext->init(); pSchedulerHandleContext->init(deviceHandles);
} }
if (pRasHandleContext) { if (pRasHandleContext) {
pRasHandleContext->init(); pRasHandleContext->init();

16
level_zero/tools/test/black_box_tests/zello_sysman.cpp
View File

@ -366,6 +366,9 @@ void testSysmanScheduler(ze_device_handle_t &device) {
std::cout << "Could not retrieve scheduler domains" << std::endl; std::cout << "Could not retrieve scheduler domains" << std::endl;
return; return;
} }
if (verbose) {
std::cout << "Number of scheduler domains = " << count << std::endl;
}
std::vector<zes_sched_handle_t> handles(count, nullptr); std::vector<zes_sched_handle_t> handles(count, nullptr);
VALIDATECALL(zesDeviceEnumSchedulers(device, &count, handles.data())); VALIDATECALL(zesDeviceEnumSchedulers(device, &count, handles.data()));
@ -375,6 +378,19 @@ void testSysmanScheduler(ze_device_handle_t &device) {
if (verbose) { if (verbose) {
std::cout << "Current Mode = " << getSchedulerModeName(currentMode) << std::endl; std::cout << "Current Mode = " << getSchedulerModeName(currentMode) << std::endl;
} }
zes_sched_properties_t schedProperties = {};
VALIDATECALL(zesSchedulerGetProperties(handle, &schedProperties));
if (verbose) {
std::cout << "Scheduler properties: onSubdevice = " << schedProperties.onSubdevice << std::endl;
if (schedProperties.onSubdevice) {
std::cout << "Scheduler properties: subdeviceId = " << schedProperties.subdeviceId << std::endl;
}
std::cout << "Scheduler properties: canControl = " << schedProperties.canControl << std::endl;
std::cout << "Scheduler properties: engines = " << schedProperties.engines << std::endl;
std::cout << "Scheduler properties: supportedModes = " << schedProperties.supportedModes << std::endl;
}
zes_sched_timeout_properties_t timeoutProperties = {}; zes_sched_timeout_properties_t timeoutProperties = {};
zes_sched_timeslice_properties_t timesliceProperties = {}; zes_sched_timeslice_properties_t timesliceProperties = {};

12
level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/test_zes_frequency.cpp
View File

@ -537,5 +537,17 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
} }
} }
TEST_F(SysmanMultiDeviceFixture, GivenValidDevicePointerWhenGettingFrequencyPropertiesThenValidSchedPropertiesRetrieved) {
zes_freq_properties_t properties = {};
ze_device_properties_t deviceProperties = {};
Device::fromHandle(device)->getProperties(&deviceProperties);
LinuxFrequencyImp *pLinuxFrequencyImp = new LinuxFrequencyImp(pOsSysman, deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
deviceProperties.subdeviceId, ZES_FREQ_DOMAIN_GPU);
EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxFrequencyImp->osFrequencyGetProperties(properties));
EXPECT_EQ(properties.subdeviceId, deviceProperties.subdeviceId);
EXPECT_EQ(properties.onSubdevice, deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE);
delete pLinuxFrequencyImp;
}
} // namespace ult } // namespace ult
} // namespace L0 } // namespace L0

4
level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/CMakeLists.txt
View File

@ -8,7 +8,7 @@ if(UNIX)
target_sources(${TARGET_NAME} target_sources(${TARGET_NAME}
PRIVATE PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_scheduler.cpp ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/test_zes_scheduler.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_scheduler.h ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/mock_sysfs_scheduler.h
) )
endif() endif()

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

@ -34,6 +34,7 @@ class SysmanDeviceSchedulerFixture : public SysmanDeviceFixture {
protected: protected:
std::unique_ptr<Mock<SchedulerSysfsAccess>> pSysfsAccess; std::unique_ptr<Mock<SchedulerSysfsAccess>> pSysfsAccess;
SysfsAccess *pSysfsAccessOld = nullptr; SysfsAccess *pSysfsAccessOld = nullptr;
std::vector<ze_device_handle_t> deviceHandles;
void SetUp() override { void SetUp() override {
SysmanDeviceFixture::SetUp(); SysmanDeviceFixture::SetUp();
@ -56,7 +57,22 @@ class SysmanDeviceSchedulerFixture : public SysmanDeviceFixture {
ON_CALL(*pSysfsAccess.get(), scanDirEntries(_, _)) ON_CALL(*pSysfsAccess.get(), scanDirEntries(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<SchedulerSysfsAccess>::getscanDirEntries)); .WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<SchedulerSysfsAccess>::getscanDirEntries));
pSysmanDeviceImp->pSchedulerHandleContext->init(); // delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pSchedulerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pSchedulerHandleContext->handleList.clear();
uint32_t subDeviceCount = 0;
// We received a device handle. Check for subdevices in this device
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, nullptr);
if (subDeviceCount == 0) {
deviceHandles.resize(1, device->toHandle());
} else {
deviceHandles.resize(subDeviceCount, nullptr);
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
}
pSysmanDeviceImp->pSchedulerHandleContext->init(deviceHandles);
} }
void TearDown() override { void TearDown() override {
@ -98,7 +114,7 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenComponentCountZeroWhenCallingzesDevice
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<SchedulerSysfsAccess>::getscanDirEntriesStatusReturnError)); .WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<SchedulerSysfsAccess>::getscanDirEntriesStatusReturnError));
auto pSchedulerHandleContextTest = std::make_unique<SchedulerHandleContext>(pOsSysman); auto pSchedulerHandleContextTest = std::make_unique<SchedulerHandleContext>(pOsSysman);
pSchedulerHandleContextTest->init(); pSchedulerHandleContextTest->init(deviceHandles);
EXPECT_EQ(0u, static_cast<uint32_t>(pSchedulerHandleContextTest->handleList.size())); EXPECT_EQ(0u, static_cast<uint32_t>(pSchedulerHandleContextTest->handleList.size()));
} }
@ -431,5 +447,18 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
} }
} }
TEST_F(SysmanMultiDeviceFixture, GivenValidDevicePointerWhenGettingSchedPropertiesThenValidSchedPropertiesRetrieved) {
zes_sched_properties_t properties = {};
std::vector<std::string> listOfEngines;
ze_device_properties_t deviceProperties = {};
Device::fromHandle(device)->getProperties(&deviceProperties);
LinuxSchedulerImp *pLinuxSchedulerImp = new LinuxSchedulerImp(pOsSysman, ZES_ENGINE_TYPE_FLAG_COMPUTE, listOfEngines,
deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, deviceProperties.subdeviceId);
EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxSchedulerImp->getProperties(properties));
EXPECT_EQ(properties.subdeviceId, deviceProperties.subdeviceId);
EXPECT_EQ(properties.onSubdevice, deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE);
delete pLinuxSchedulerImp;
}
} // namespace ult } // namespace ult
} // namespace L0 } // namespace L0