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

Remove legacy affinity mask format

Browse Source 
Change-Id: I17e9ad131c888bdaceb7d14dd7b5aa9b5aec14d7
Signed-off: Jaime Arteaga <jaime.a.arteaga.molina@intel.com>
This commit is contained in:
Jaime Arteaga
2020-09-14 21:44:47 -07:00
committed by sys_ocldev
parent c5b214e554
commit 57e462d8ee
4 changed files with 1 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
level_zero/core/test/unit_tests/sources/driver/test_driver.cpp
View File

@@ -259,139 +259,6 @@ TEST_F(DriverTestMultipleFamilyNoSupport, whenInitializingDriverWithArrayOfNotSu
EXPECT_EQ(nullptr, driverHandle);
}
struct LegacyMaskArray {
const std::string masks[16] = {"0", "1", "2", "3", "4", "5", "6", "7",
"8", "9", "A", "B", "C", "D", "E", "F"};
};
struct DriverTestMultipleDeviceWithLegacyAffinityMask : public ::testing::WithParamInterface<std::tuple<std::string, std::string>>,
public ::testing::Test {
void SetUp() override {
DebugManager.flags.UseLegacyLevelZeroAffinity.set(true);
DebugManager.flags.CreateMultipleSubDevices.set(numSubDevices);
VariableBackup<bool> mockDeviceFlagBackup(&MockDevice::createSingleDevice, false);
NEO::ExecutionEnvironment *executionEnvironment = new NEO::ExecutionEnvironment();
executionEnvironment->prepareRootDeviceEnvironments(numRootDevices);
for (auto i = 0u; i < executionEnvironment->rootDeviceEnvironments.size(); i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(NEO::defaultHwInfo.get());
}
for (auto i = 0u; i < executionEnvironment->rootDeviceEnvironments.size(); i++) {
devices.push_back(std::unique_ptr<NEO::MockDevice>(NEO::MockDevice::createWithExecutionEnvironment<NEO::MockDevice>(
NEO::defaultHwInfo.get(),
executionEnvironment, i)));
}
}
void getNumOfExposedDevices(uint32_t mask, uint32_t &rootDeviceExposed, uint32_t &numOfSubDevicesExposed) {
rootDeviceExposed = (((1UL << numSubDevices) - 1) & mask) ? 1 : 0;
numOfSubDevicesExposed = static_cast<uint32_t>(static_cast<std::bitset<sizeof(uint32_t) * 8>>(mask).count());
}
DebugManagerStateRestore restorer;
std::vector<std::unique_ptr<NEO::Device>> devices;
const uint32_t numRootDevices = 2u;
const uint32_t numSubDevices = 4u;
};
TEST_F(DriverTestMultipleDeviceWithLegacyAffinityMask,
whenNotSettingAffinityThenAllRootDevicesAndSubDevicesAreExposed) {
L0::DriverHandleImp *driverHandle = new DriverHandleImp;
ze_result_t res = driverHandle->initialize(std::move(devices));
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
uint32_t deviceCount = 0;
res = zeDeviceGet(driverHandle->toHandle(), &deviceCount, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_EQ(deviceCount, numRootDevices);
std::vector<ze_device_handle_t> phDevices(deviceCount);
res = zeDeviceGet(driverHandle->toHandle(), &deviceCount, phDevices.data());
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
for (uint32_t i = 0; i < numRootDevices; i++) {
ze_device_handle_t hDevice = phDevices[i];
EXPECT_NE(nullptr, hDevice);
uint32_t subDeviceCount = 0;
res = zeDeviceGetSubDevices(hDevice, &subDeviceCount, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_EQ(numSubDevices, subDeviceCount);
}
delete driverHandle;
L0::GlobalDriver = nullptr;
}
TEST_P(DriverTestMultipleDeviceWithLegacyAffinityMask,
whenSettingAffinityMaskToDifferentValuesThenCorrectNumberOfDevicesIsExposed) {
L0::DriverHandleImp *driverHandle = new DriverHandleImp;
std::string device0MaskString = std::get<0>(GetParam());
std::string device1MaskString = std::get<1>(GetParam());
uint32_t device0Mask = static_cast<uint32_t>(strtoul(device0MaskString.c_str(), nullptr, 16));
uint32_t rootDevice0Exposed = 0;
uint32_t numOfSubDevicesExposedInDevice0 = 0;
getNumOfExposedDevices(device0Mask, rootDevice0Exposed, numOfSubDevicesExposedInDevice0);
uint32_t device1Mask = static_cast<uint32_t>(strtoul(device1MaskString.c_str(), nullptr, 16));
uint32_t rootDevice1Exposed = 0;
uint32_t numOfSubDevicesExposedInDevice1 = 0;
getNumOfExposedDevices(device1Mask, rootDevice1Exposed, numOfSubDevicesExposedInDevice1);
driverHandle->affinityMaskString = device1MaskString + device0MaskString;
uint32_t totalRootDevices = rootDevice0Exposed + rootDevice1Exposed;
ze_result_t res = driverHandle->initialize(std::move(devices));
if (0 == totalRootDevices) {
EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, res);
} else {
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
}
uint32_t deviceCount = 0;
res = zeDeviceGet(driverHandle->toHandle(), &deviceCount, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_EQ(deviceCount, totalRootDevices);
if (deviceCount) {
std::vector<ze_device_handle_t> phDevices(deviceCount);
res = zeDeviceGet(driverHandle->toHandle(), &deviceCount, phDevices.data());
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
for (uint32_t i = 0; i < deviceCount; i++) {
ze_device_handle_t hDevice = phDevices[i];
EXPECT_NE(nullptr, hDevice);
uint32_t subDeviceCount = 0;
res = zeDeviceGetSubDevices(hDevice, &subDeviceCount, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
if (rootDevice0Exposed && !rootDevice1Exposed) {
EXPECT_EQ(numOfSubDevicesExposedInDevice0, subDeviceCount);
} else if (!rootDevice0Exposed && rootDevice1Exposed) {
EXPECT_EQ(numOfSubDevicesExposedInDevice1, subDeviceCount);
} else {
if (i == 0) {
EXPECT_EQ(numOfSubDevicesExposedInDevice0, subDeviceCount);
} else {
EXPECT_EQ(numOfSubDevicesExposedInDevice1, subDeviceCount);
}
}
}
}
delete driverHandle;
L0::GlobalDriver = nullptr;
}
LegacyMaskArray legacyMaskArray;
INSTANTIATE_TEST_SUITE_P(DriverTestMultipleDeviceWithLegacyAffinityMaskTests,
DriverTestMultipleDeviceWithLegacyAffinityMask,
::testing::Combine(
::testing::ValuesIn(legacyMaskArray.masks),
::testing::ValuesIn(legacyMaskArray.masks)));
struct MaskArray {
const std::string masks[4] = {"0", "1", "2", "3"}; // fixture has 4 subDevices
};
@@ -399,7 +266,6 @@ struct MaskArray {
struct DriverTestMultipleDeviceWithAffinityMask : public ::testing::WithParamInterface<std::tuple<std::string, std::string>>,
public ::testing::Test {
void SetUp() override {
DebugManager.flags.UseLegacyLevelZeroAffinity.set(false);
DebugManager.flags.CreateMultipleSubDevices.set(numSubDevices);
VariableBackup<bool> mockDeviceFlagBackup(&MockDevice::createSingleDevice, false);