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

Remove low priority and internal engine index variables 

Change-Id: I984dbcedd5456cfdee284f4d2eda1371ba77f0d0
Signed-off-by: Bartosz Dunajski <bartosz.dunajski@intel.com>
This commit is contained in:
Bartosz Dunajski 2020-09-15 17:29:02 +02:00 committed by sys_ocldev
parent e6a4aa1216
commit 5b31b31734
45 changed files with 145 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/tools/source/metrics/metric_query_imp.cpp
View File

@ -212,7 +212,7 @@ bool MetricsLibrary::createContext() {
// Check if compute command streamer is used.
auto asyncComputeEngine = std::find_if(asyncComputeEngines.begin(), asyncComputeEngines.end(), [&](const auto &engine) {
return engine == aub_stream::ENGINE_CCS;
return engine.first == aub_stream::ENGINE_CCS;
});
const auto &deviceImp = *static_cast<DeviceImp *>(&device);

2
opencl/source/cl_device/cl_device.cpp
View File

@ -135,7 +135,7 @@ ClDevice *ClDevice::getDeviceById(uint32_t deviceId) {
bool ClDevice::getDeviceAndHostTimer(uint64_t *deviceTimestamp, uint64_t *hostTimestamp) const { return device.getDeviceAndHostTimer(deviceTimestamp, hostTimestamp); }
bool ClDevice::getHostTimer(uint64_t *hostTimestamp) const { return device.getHostTimer(hostTimestamp); }
const HardwareInfo &ClDevice::getHardwareInfo() const { return device.getHardwareInfo(); }
EngineControl &ClDevice::getEngine(aub_stream::EngineType engineType, bool lowPriority) { return device.getEngine(engineType, lowPriority); }
EngineControl &ClDevice::getEngine(aub_stream::EngineType engineType, bool lowPriority, bool internalUsage) { return device.getEngine(engineType, lowPriority, internalUsage); }
EngineControl &ClDevice::getDefaultEngine() { return device.getDefaultEngine(); }
EngineControl &ClDevice::getInternalEngine() { return device.getInternalEngine(); }
std::atomic<uint32_t> &ClDevice::getSelectorCopyEngine() { return device.getSelectorCopyEngine(); }

2
opencl/source/cl_device/cl_device.h
View File

@ -65,7 +65,7 @@ class ClDevice : public BaseObject<_cl_device_id> {
bool getDeviceAndHostTimer(uint64_t *deviceTimestamp, uint64_t *hostTimestamp) const;
bool getHostTimer(uint64_t *hostTimestamp) const;
const HardwareInfo &getHardwareInfo() const;
EngineControl &getEngine(aub_stream::EngineType engineType, bool lowPriority);
EngineControl &getEngine(aub_stream::EngineType engineType, bool lowPriority, bool internalUsage);
EngineControl &getDefaultEngine();
EngineControl &getInternalEngine();
std::atomic<uint32_t> &getSelectorCopyEngine();

2
opencl/source/command_queue/command_queue.cpp
View File

@ -74,7 +74,7 @@ CommandQueue::CommandQueue(Context *context, ClDevice *device, const cl_queue_pr
}
if (hwInfo.capabilityTable.blitterOperationsSupported) {
auto &selectorCopyEngine = device->getDeviceById(0)->getSelectorCopyEngine();
bcsEngine = &device->getDeviceById(0)->getEngine(EngineHelpers::getBcsEngineType(hwInfo, selectorCopyEngine), false);
bcsEngine = &device->getDeviceById(0)->getEngine(EngineHelpers::getBcsEngineType(hwInfo, selectorCopyEngine), false, false);
}
}

2
opencl/source/command_queue/command_queue_hw.h
View File

@ -42,7 +42,7 @@ class CommandQueueHw : public CommandQueue {
if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_LOW_KHR)) {
priority = QueuePriority::LOW;
this->gpgpuEngine = &device->getDeviceById(0)->getEngine(HwHelperHw<GfxFamily>::lowPriorityEngineType, true);
this->gpgpuEngine = &device->getDeviceById(0)->getEngine(HwHelperHw<GfxFamily>::lowPriorityEngineType, true, false);
} else if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_MED_KHR)) {
priority = QueuePriority::MEDIUM;
} else if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_HIGH_KHR)) {

2
opencl/test/unit_test/api/cl_create_command_queue_with_properties_tests.cpp
View File

@ -494,7 +494,7 @@ HWTEST_F(LowPriorityCommandQueueTest, GivenDeviceWithSubdevicesWhenCreatingLowPr
auto commandQueueObj = castToObject<CommandQueue>(cmdQ);
auto subDevice = context.getDevice(0)->getDeviceById(0);
auto engine = subDevice->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true);
auto engine = subDevice->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true, false);
EXPECT_EQ(engine.commandStreamReceiver, &commandQueueObj->getGpgpuCommandStreamReceiver());
EXPECT_EQ(engine.osContext, &commandQueueObj->getGpgpuCommandStreamReceiver().getOsContext());

2
opencl/test/unit_test/command_queue/blit_enqueue_tests.cpp
View File

@ -77,7 +77,7 @@ struct BlitEnqueueTests : public ::testing::Test {
capabilityTable.blitterOperationsSupported = true;
if (createBcsEngine) {
auto &engine = device->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true);
auto &engine = device->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true, false);
bcsOsContext.reset(OsContext::create(nullptr, 1, device->getDeviceBitfield(), aub_stream::ENGINE_BCS, PreemptionMode::Disabled,
false, false, false));
engine.osContext = bcsOsContext.get();

4
opencl/test/unit_test/command_queue/command_queue_tests.cpp
View File

@ -241,13 +241,13 @@ HWTEST_P(CommandQueueWithBlitOperationsTests, givenDeviceWithSubDevicesSupportin
auto subDevice = device->getDeviceById(0);
if (createBcsEngine) {
auto &engine = subDevice->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true);
auto &engine = subDevice->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true, false);
bcsOsContext.reset(OsContext::create(nullptr, 1, 0, aub_stream::ENGINE_BCS, PreemptionMode::Disabled,
false, false, false));
engine.osContext = bcsOsContext.get();
engine.commandStreamReceiver->setupContext(*bcsOsContext);
}
auto bcsEngine = subDevice->getEngine(aub_stream::EngineType::ENGINE_BCS, false);
auto bcsEngine = subDevice->getEngine(aub_stream::EngineType::ENGINE_BCS, false, false);
MockCommandQueue cmdQ(nullptr, device.get(), 0);
auto cmdType = GetParam();

2
opencl/test/unit_test/command_stream/aub_command_stream_receiver_1_tests.cpp
View File

@ -256,7 +256,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenMultipl
auto &hwInfo = pDevice->getHardwareInfo();
auto engineInstance = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0];
MockOsContext osContext(0, 1, engineInstance, PreemptionMode::Disabled, false, false, false);
MockOsContext osContext(0, 1, engineInstance.first, PreemptionMode::Disabled, false, false, false);
auto aubCsr1 = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>("", true, *pDevice->executionEnvironment, pDevice->getRootDeviceIndex());
auto aubCsr2 = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>("", true, *pDevice->executionEnvironment, pDevice->getRootDeviceIndex());

4
opencl/test/unit_test/command_stream/aub_command_stream_receiver_2_tests.cpp
View File

@ -501,7 +501,7 @@ HWTEST_F(AubCommandStreamReceiverNoHostPtrTests, givenAubCommandStreamReceiverWh
auto hwInfo = executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
auto engineInstance = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
MockOsContext osContext(0, 1, engineInstance, PreemptionMode::Disabled,
MockOsContext osContext(0, 1, engineInstance.first, PreemptionMode::Disabled,
false, false, false);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>("", true, *executionEnvironment, 0));
aubCsr->setupContext(osContext);
@ -751,7 +751,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenEngineI
MockExecutionEnvironment executionEnvironment(defaultHwInfo.get());
auto hwInfo = executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo();
auto engineInstance = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
MockOsContext osContext(0, 1, engineInstance, PreemptionMode::Disabled,
MockOsContext osContext(0, 1, engineInstance.first, PreemptionMode::Disabled,
false, false, false);
executionEnvironment.initializeMemoryManager();

4
opencl/test/unit_test/command_stream/command_stream_receiver_with_aub_dump_tests.cpp
View File

@ -150,7 +150,7 @@ HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenCsrWithAubDumpWhenSett
CommandStreamReceiverWithAUBDump<UltCommandStreamReceiver<FamilyType>> csrWithAubDump("aubfile", *executionEnvironment, 0);
auto hwInfo = executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
MockOsContext osContext(0, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
MockOsContext osContext(0, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first,
PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false, false, false);
csrWithAubDump.setupContext(osContext);
@ -265,7 +265,7 @@ struct CommandStreamReceiverTagTests : public ::testing::Test {
bool isTimestampPacketNodeReleasable(Args &&... args) {
CsrT csr(std::forward<Args>(args)...);
auto hwInfo = csr.peekExecutionEnvironment().rootDeviceEnvironments[0]->getHardwareInfo();
MockOsContext osContext(0, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
MockOsContext osContext(0, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first,
PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false, false, false);
csr.setupContext(osContext);

2
opencl/test/unit_test/command_stream/tbx_command_stream_tests.cpp
View File

@ -587,7 +587,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCsrWhenHardwareContextIsCreatedThenTbxSt
HWTEST_F(TbxCommandStreamTests, givenTbxCsrWhenOsContextIsSetThenCreateHardwareContext) {
auto hwInfo = pDevice->getHardwareInfo();
MockOsContext osContext(0, 1, HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0],
MockOsContext osContext(0, 1, HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0].first,
PreemptionMode::Disabled, false, false, false);
std::string fileName = "";
MockAubManager *mockManager = new MockAubManager();

3
opencl/test/unit_test/context/context_tests.cpp
View File

@ -362,7 +362,10 @@ class ContextWithAsyncDeleterTest : public ::testing::WithParamInterface<bool>,
memoryManager = new MockMemoryManager();
device = new MockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get())};
deleter = new MockDeferredDeleter();
device->engines.clear();
device->injectMemoryManager(memoryManager);
device->createEngines();
memoryManager->setDeferredDeleter(deleter);
}
void TearDown() override {

29
opencl/test/unit_test/device/device_tests.cpp
View File

@ -78,22 +78,30 @@ TEST_F(DeviceTest, givenDeviceWhenEngineIsCreatedThenSetInitialValueForTag) {
}
TEST_F(DeviceTest, givenDeviceWhenAskedForSpecificEngineThenReturnIt) {
auto &engines = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo);
auto hwInfo = *defaultHwInfo;
hwInfo.featureTable.ftrCCSNode = true;
MockClDevice mockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0)};
auto &engines = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo);
for (uint32_t i = 0; i < engines.size(); i++) {
bool lowPriority = (HwHelper::lowPriorityGpgpuEngineIndex == i);
auto &deviceEngine = pDevice->getEngine(engines[i], lowPriority);
EXPECT_EQ(deviceEngine.osContext->getEngineType(), engines[i]);
EXPECT_EQ(deviceEngine.osContext->isLowPriority(), lowPriority);
auto &deviceEngine = mockClDevice.getEngine(engines[i].first, false, false);
EXPECT_EQ(deviceEngine.osContext->getEngineType(), engines[i].first);
EXPECT_EQ(deviceEngine.osContext->isLowPriority(), false);
}
EXPECT_THROW(pDevice->getEngine(aub_stream::ENGINE_VCS, false), std::exception);
auto &deviceEngine = mockClDevice.getEngine(hwInfo.capabilityTable.defaultEngineType, true, false);
EXPECT_EQ(deviceEngine.osContext->getEngineType(), hwInfo.capabilityTable.defaultEngineType);
EXPECT_EQ(deviceEngine.osContext->isLowPriority(), true);
EXPECT_THROW(mockClDevice.getEngine(aub_stream::ENGINE_VCS, false, false), std::exception);
}
TEST_F(DeviceTest, givenDeviceWhenAskedForEngineWithValidIndexThenReturnIt) {
auto &engines = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo);
for (uint32_t i = 0; i < engines.size(); i++) {
auto &deviceEngine = pDevice->getEngine(i);
EXPECT_EQ(deviceEngine.osContext->getEngineType(), engines[i]);
EXPECT_EQ(deviceEngine.osContext->getEngineType(), engines[i].first);
}
}
@ -101,8 +109,8 @@ TEST_F(DeviceTest, givenDebugVariableToAlwaysChooseEngineZeroWhenNotExistingEngi
DebugManagerStateRestore restore;
DebugManager.flags.OverrideInvalidEngineWithDefault.set(true);
auto &engines = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo);
auto &deviceEngine = pDevice->getEngine(engines[0], false);
auto &notExistingEngine = pDevice->getEngine(aub_stream::ENGINE_VCS, false);
auto &deviceEngine = pDevice->getEngine(engines[0].first, false, false);
auto &notExistingEngine = pDevice->getEngine(aub_stream::ENGINE_VCS, false, false);
EXPECT_EQ(&notExistingEngine, &deviceEngine);
}
@ -406,9 +414,6 @@ TEST(DeviceGenEngineTest, givenHwCsrModeWhenGetEngineThenDedicatedForInternalUsa
auto &internalEngine = device->getInternalEngine();
auto &defaultEngine = device->getDefaultEngine();
EXPECT_NE(defaultEngine.commandStreamReceiver, internalEngine.commandStreamReceiver);
auto internalEngineIndex = HwHelper::internalUsageEngineIndex;
EXPECT_EQ(internalEngineIndex, internalEngine.osContext->getContextId());
}
TEST(DeviceGenEngineTest, whenCreateDeviceThenInternalEngineHasDefaultType) {

2
opencl/test/unit_test/fixtures/memory_allocator_fixture.h
View File

@ -30,7 +30,7 @@ class MemoryAllocatorFixture : public MemoryManagementFixture {
executionEnvironment->memoryManager.reset(memoryManager);
csr = &device->getGpgpuCommandStreamReceiver();
auto &hwInfo = device->getHardwareInfo();
auto engineType = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0];
auto engineType = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0].first;
auto osContext = memoryManager->createAndRegisterOsContext(csr, engineType, 1,
PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo),
false, false, false);

2
opencl/test/unit_test/fixtures/memory_manager_fixture.cpp
View File

@ -25,7 +25,7 @@ void MemoryManagerWithCsrFixture::SetUp() {
csr->tagAddress = &currentGpuTag;
auto hwInfo = executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo();
auto engine = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
auto osContext = memoryManager->createAndRegisterOsContext(csr.get(), engine, 1,
auto osContext = memoryManager->createAndRegisterOsContext(csr.get(), engine.first, 1,
PreemptionHelper::getDefaultPreemptionMode(*hwInfo),
false, false, false);
csr->setupContext(*osContext);

61
opencl/test/unit_test/gen12lp/hw_helper_tests_gen12lp.inl
View File

@ -118,10 +118,10 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeNotSetAndBcsInfoSetWhenGetGpgp
EXPECT_EQ(4u, device->engines.size());
auto &engines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances(hwInfo);
EXPECT_EQ(4u, engines.size());
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[2]);
EXPECT_EQ(aub_stream::ENGINE_BCS, engines[3]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0].first);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1].first);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[2].first);
EXPECT_EQ(aub_stream::ENGINE_BCS, engines[3].first);
}
GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeNotSetWhenGetGpgpuEnginesThenReturnThreeRcsEngines) {
@ -136,9 +136,9 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeNotSetWhenGetGpgpuEnginesThenR
auto &engines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances(hwInfo);
EXPECT_EQ(expectedEnginesCount, engines.size());
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[2]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0].first);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1].first);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[2].first);
}
GEN12LPTEST_F(HwHelperTestGen12Lp, givenEvenContextCountRequiredWhenGetGpgpuEnginesIsCalledThenInsertAdditionalEngineAtTheEndIfNeeded) {
@ -165,7 +165,7 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, givenEvenContextCountRequiredWhenGetGpgpuEngi
hwInfoConfig.evenContextCountRequired = true;
engines = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo);
EXPECT_EQ(4u, engines.size());
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[engines.size() - 1]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[engines.size() - 1].first);
hwInfo.featureTable.ftrCCSNode = true;
engines = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo);
@ -191,10 +191,10 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeSetWhenGetGpgpuEnginesThenRetu
EXPECT_EQ(4u, device->engines.size());
auto &engines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances(hwInfo);
EXPECT_EQ(4u, engines.size());
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1]);
EXPECT_EQ(aub_stream::ENGINE_CCS, engines[2]);
EXPECT_EQ(aub_stream::ENGINE_CCS, engines[3]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0].first);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1].first);
EXPECT_EQ(aub_stream::ENGINE_CCS, engines[2].first);
EXPECT_EQ(aub_stream::ENGINE_CCS, engines[3].first);
}
GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeSetFtrGpGpuMidThreadLevelPreemptSetWhenGetGpgpuEnginesThenReturn2RcsAndCcsEngines) {
@ -209,9 +209,9 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeSetFtrGpGpuMidThreadLevelPreem
EXPECT_EQ(retDeivices, device->engines.size());
auto &engines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances(hwInfo);
EXPECT_EQ(retDeivices, engines.size());
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1]);
EXPECT_EQ(aub_stream::ENGINE_CCS, engines[2]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0].first);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1].first);
EXPECT_EQ(aub_stream::ENGINE_CCS, engines[2].first);
}
GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeSetFtrGpGpuMidThreadLevelPreemptNotSetWhenGetGpgpuEnginesThenReturn2RcsAnd2CcsEngines) {
@ -225,10 +225,10 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeSetFtrGpGpuMidThreadLevelPreem
EXPECT_EQ(4u, device->engines.size());
auto &engines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances(hwInfo);
EXPECT_EQ(4u, engines.size());
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1]);
EXPECT_EQ(aub_stream::ENGINE_CCS, engines[2]);
EXPECT_EQ(aub_stream::ENGINE_CCS, engines[3]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0].first);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1].first);
EXPECT_EQ(aub_stream::ENGINE_CCS, engines[2].first);
EXPECT_EQ(aub_stream::ENGINE_CCS, engines[3].first);
}
GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeSetAndDefaultRcsWhenGetGpgpuEnginesThenReturnAppropriateNumberOfRcsEngines) {
@ -242,11 +242,11 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeSetAndDefaultRcsWhenGetGpgpuEn
EXPECT_EQ(expectedEnginesCount, device->engines.size());
auto &engines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances(hwInfo);
EXPECT_EQ(expectedEnginesCount, engines.size());
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[2]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[0].first);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[1].first);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[2].first);
if (expectedEnginesCount == 4) {
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[3]);
EXPECT_EQ(aub_stream::ENGINE_RCS, engines[3].first);
}
}
@ -274,21 +274,6 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, givenTgllpWhenIsFusedEuDispatchEnabledIsCalle
}
}
GEN12LPTEST_F(HwHelperTestGen12Lp, whenGettingComputeEngineIndexByOrdinalThenCorrectIndexIsReturned) {
auto &helper = HwHelper::get(renderCoreFamily);
HardwareInfo hwInfo = *defaultHwInfo;
hwInfo.featureTable.ftrCCSNode = true;
EXPECT_EQ(helper.internalUsageEngineIndex + 1, helper.getComputeEngineIndexByOrdinal(hwInfo, 0));
EXPECT_EQ(0u, helper.getComputeEngineIndexByOrdinal(hwInfo, 1));
if (helper.getEnginesCount(hwInfo) > 1) {
auto engine0 = helper.getGpgpuEngineInstances(hwInfo)[helper.getComputeEngineIndexByOrdinal(hwInfo, 0)];
auto engine1 = helper.getGpgpuEngineInstances(hwInfo)[helper.getComputeEngineIndexByOrdinal(hwInfo, 1)];
EXPECT_NE(engine0, engine1);
}
}
class HwHelperTestsGen12LpBuffer : public ::testing::Test {
public:
void SetUp() override {

6
opencl/test/unit_test/helpers/get_gpgpu_engines_tests.inl
View File

@ -15,7 +15,7 @@ template <typename FamilyType>
void whenGetGpgpuEnginesThenReturnTwoRcsEngines(const HardwareInfo &hwInfo) {
auto gpgpuEngines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances(hwInfo);
EXPECT_EQ(3u, gpgpuEngines.size());
EXPECT_EQ(aub_stream::ENGINE_RCS, gpgpuEngines[0]);
EXPECT_EQ(aub_stream::ENGINE_RCS, gpgpuEngines[1]);
EXPECT_EQ(aub_stream::ENGINE_RCS, gpgpuEngines[2]);
EXPECT_EQ(aub_stream::ENGINE_RCS, gpgpuEngines[0].first);
EXPECT_EQ(aub_stream::ENGINE_RCS, gpgpuEngines[1].first);
EXPECT_EQ(aub_stream::ENGINE_RCS, gpgpuEngines[2].first);
}

5
opencl/test/unit_test/helpers/hw_helper_tests.cpp
View File

@ -947,11 +947,6 @@ HWTEST_F(HwHelperTest, givenVariousDebugKeyValuesWhenGettingLocalMemoryAccessMod
EXPECT_EQ(LocalMemoryAccessMode::CpuAccessDisallowed, hwHelper.getLocalMemoryAccessMode(*defaultHwInfo));
}
HWTEST2_F(HwHelperTest, givenSingleEnginePlatformWhenGettingComputeEngineIndexByOrdinalThenZeroIndexIsReturned, IsAtMostGen11) {
auto &helper = HwHelper::get(renderCoreFamily);
EXPECT_EQ(0u, helper.getComputeEngineIndexByOrdinal(*defaultHwInfo, 0));
}
HWTEST2_F(HwHelperTest, givenDefaultHwHelperHwWhenGettingIsBlitCopyRequiredForLocalMemoryThenFalseIsReturned, IsAtMostGen11) {
auto &helper = HwHelper::get(renderCoreFamily);
EXPECT_FALSE(helper.isBlitCopyRequiredForLocalMemory(*defaultHwInfo));

2
opencl/test/unit_test/helpers/timestamp_packet_tests.cpp
View File

@ -1639,7 +1639,7 @@ HWTEST_F(TimestampPacketTests, givenBlockedEnqueueWithoutKernelWhenSubmittingThe
auto cmdQ0 = clUniquePtr(new MockCommandQueueHw<FamilyType>(context, device.get(), nullptr));
auto &secondEngine = device->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true);
auto &secondEngine = device->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true, false);
static_cast<UltCommandStreamReceiver<FamilyType> *>(secondEngine.commandStreamReceiver)->timestampPacketWriteEnabled = true;
auto cmdQ1 = clUniquePtr(new MockCommandQueueHw<FamilyType>(context, device.get(), nullptr));

2
opencl/test/unit_test/mem_obj/buffer_bcs_tests.cpp
View File

@ -99,7 +99,7 @@ struct BcsBufferTests : public ::testing::Test {
capabilityTable.blitterOperationsSupported = true;
if (createBcsEngine) {
auto &engine = device->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true);
auto &engine = device->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true, false);
bcsOsContext.reset(OsContext::create(nullptr, 1, device->getDeviceBitfield(), aub_stream::ENGINE_BCS, PreemptionMode::Disabled,
false, false, false));
engine.osContext = bcsOsContext.get();

2
opencl/test/unit_test/memory_manager/memory_manager_allocate_in_preferred_pool_tests.inl
View File

@ -897,7 +897,7 @@ TEST(MemoryManagerTest, givenPropertiesWithOsContextWhenGetAllocationDataIsCalle
AllocationProperties properties{0, 1, GraphicsAllocation::AllocationType::DEBUG_CONTEXT_SAVE_AREA, mockDeviceBitfield};
MockOsContext osContext(0u, 1,
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
PreemptionMode::Disabled, false, false, false);
properties.osContext = &osContext;

32
opencl/test/unit_test/memory_manager/memory_manager_tests.cpp
View File

@ -225,7 +225,7 @@ TEST_F(MemoryAllocatorTest, WhenAllocatingGraphicsMemoryThenAllocationHasCorrect
unsigned int alignment = 4096;
memoryManager->createAndRegisterOsContext(csr,
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
1, PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo),
false, false, false);
auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), MemoryConstants::pageSize});
@ -1316,7 +1316,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenGpuAddressIsSetThenAllocatio
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, 0u));
executionEnvironment.memoryManager.reset(memoryManager);
auto osContext = memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
1, PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo),
false, false, false);
@ -1477,7 +1477,7 @@ TEST_F(MemoryManagerWithCsrTest, givenAllocationThatWasUsedAndIsCompletedWhenche
TEST_F(MemoryManagerWithCsrTest, givenAllocationThatWasUsedAndIsNotCompletedWhencheckGpuUsageAndDestroyGraphicsAllocationsIsCalledThenItIsAddedToTemporaryAllocationList) {
memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
1, PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo),
false, false, false);
auto usedAllocationAndNotGpuCompleted = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), MemoryConstants::pageSize});
@ -1644,8 +1644,11 @@ using GraphicsAllocationTests = ::testing::Test;
HWTEST_F(GraphicsAllocationTests, givenAllocationUsedOnlyByNonDefaultCsrWhenCheckingUsageBeforeDestroyThenStoreItAsTemporaryAllocation) {
auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
auto nonDefaultOsContext = device->engines[HwHelper::lowPriorityGpgpuEngineIndex].osContext;
auto nonDefaultCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(device->engines[HwHelper::lowPriorityGpgpuEngineIndex].commandStreamReceiver);
auto &lowPriorityEngine = device->getEngine(device->getHardwareInfo().capabilityTable.defaultEngineType, true, false);
auto nonDefaultOsContext = lowPriorityEngine.osContext;
auto nonDefaultCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(lowPriorityEngine.commandStreamReceiver);
auto memoryManager = device->getExecutionEnvironment()->memoryManager.get();
auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), MemoryConstants::pageSize});
@ -1691,8 +1694,11 @@ HWTEST_F(GraphicsAllocationTests, givenAllocationUsedByManyOsContextsWhenCheckin
memoryManager->multiContextResourceDestructor.reset(multiContextDestructor);
auto device = std::unique_ptr<MockDevice>(MockDevice::create<MockDevice>(executionEnvironment, 0u));
auto nonDefaultOsContext = device->engines[HwHelper::lowPriorityGpgpuEngineIndex].osContext;
auto nonDefaultCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(device->engines[HwHelper::lowPriorityGpgpuEngineIndex].commandStreamReceiver);
auto &lowPriorityEngine = device->getEngine(device->getHardwareInfo().capabilityTable.defaultEngineType, true, false);
auto nonDefaultOsContext = lowPriorityEngine.osContext;
auto nonDefaultCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(lowPriorityEngine.commandStreamReceiver);
auto defaultCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(device->getDefaultEngine().commandStreamReceiver);
auto defaultOsContext = device->getDefaultEngine().osContext;
@ -1729,7 +1735,7 @@ TEST(ResidencyDataTest, givenOsContextWhenItIsRegisteredToMemoryManagerThenRefCo
executionEnvironment.memoryManager.reset(memoryManager);
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, 0u));
memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
1, PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo),
false, false, false);
EXPECT_EQ(1u, memoryManager->getRegisteredEnginesCount());
@ -1758,7 +1764,7 @@ TEST(ResidencyDataTest, givenDeviceBitfieldWhenCreatingOsContextThenSetValidValu
DeviceBitfield deviceBitfield = 0b11;
PreemptionMode preemptionMode = PreemptionMode::MidThread;
memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
deviceBitfield, preemptionMode,
false, false, false);
EXPECT_EQ(2u, memoryManager->registeredEngines[0].osContext->getNumSupportedDevices());
@ -1773,11 +1779,11 @@ TEST(ResidencyDataTest, givenTwoOsContextsWhenTheyAreRegisteredFromHigherToLower
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, 0u));
std::unique_ptr<CommandStreamReceiver> csr1(createCommandStream(executionEnvironment, 1u));
memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
1, PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo),
false, false, false);
memoryManager->createAndRegisterOsContext(csr1.get(),
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[1],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[1].first,
1, PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo),
false, false, false);
EXPECT_EQ(2u, memoryManager->getRegisteredEnginesCount());
@ -1799,10 +1805,10 @@ TEST(ResidencyDataTest, givenResidencyDataWhenUpdateCompletionDataIsCalledThenIt
MockResidencyData residency(MemoryManager::maxOsContextCount);
MockOsContext osContext(0u, 1,
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo), false, false, false);
MockOsContext osContext2(1u, 1,
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[1],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[1].first,
PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo), false, false, false);
auto lastFenceValue = 45llu;

2
opencl/test/unit_test/memory_manager/surface_tests.cpp
View File

@ -66,7 +66,7 @@ HWTEST_TYPED_TEST(SurfaceTest, GivenSurfaceWhenInterfaceIsUsedThenSurfaceBehaves
executionEnvironment->initializeMemoryManager();
auto csr = std::make_unique<MockCsr<FamilyType>>(execStamp, *executionEnvironment, 0);
auto hwInfo = *defaultHwInfo;
auto engine = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0];
auto engine = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0].first;
auto osContext = executionEnvironment->memoryManager->createAndRegisterOsContext(csr.get(), engine, 1,
PreemptionHelper::getDefaultPreemptionMode(hwInfo),
false, false, false);

2
opencl/test/unit_test/os_interface/linux/drm_command_stream_fixture.h
View File

@ -39,7 +39,7 @@ class DrmCommandStreamTest : public ::testing::Test {
auto hwInfo = executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo();
mock->createVirtualMemoryAddressSpace(HwHelper::getSubDevicesCount(hwInfo));
osContext = std::make_unique<OsContextLinux>(*mock, 0u, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
osContext = std::make_unique<OsContextLinux>(*mock, 0u, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first,
PreemptionHelper::getDefaultPreemptionMode(*hwInfo),
false, false, false);

2
opencl/test/unit_test/os_interface/linux/drm_command_stream_tests.cpp
View File

@ -231,7 +231,7 @@ HWTEST_TEMPLATED_F(DrmCommandStreamTest, givenDrmContextIdWhenFlushingThenSetIdT
.RetiresOnSaturation();
osContext = std::make_unique<OsContextLinux>(*mock, 1, 1,
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo),
false, false, false);
csr->setupContext(*osContext);

2
opencl/test/unit_test/os_interface/performance_counters_tests.cpp
View File

@ -213,7 +213,7 @@ struct PerformanceCountersMetricsLibraryTest : public PerformanceCountersMetrics
void SetUp() override {
PerformanceCountersMetricsLibraryFixture::SetUp();
auto hwInfo = rootDeviceEnvironment->getHardwareInfo();
osContext = std::make_unique<MockOsContext>(0, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
osContext = std::make_unique<MockOsContext>(0, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first,
PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false, false, false);
queue->getGpgpuCommandStreamReceiver().setupContext(*osContext);
}

4
opencl/test/unit_test/os_interface/windows/device_command_stream_tests.cpp
View File

@ -292,7 +292,7 @@ TEST(WddmPreemptionHeaderTests, givenWddmCommandStreamReceiverWhenPreemptionIsOf
auto csr = std::make_unique<MockWddmCsr<DEFAULT_TEST_FAMILY_NAME>>(*executionEnvironment, 0);
executionEnvironment->memoryManager.reset(new MemoryManagerCreate<WddmMemoryManager>(false, false, *executionEnvironment));
csr->overrideDispatchPolicy(DispatchMode::ImmediateDispatch);
OsContextWin osContext(*wddm, 0u, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
OsContextWin osContext(*wddm, 0u, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first,
PreemptionHelper::getDefaultPreemptionMode(*hwInfo),
false, false, false);
csr->setupContext(osContext);
@ -318,7 +318,7 @@ TEST(WddmPreemptionHeaderTests, givenWddmCommandStreamReceiverWhenPreemptionIsOn
auto csr = std::make_unique<MockWddmCsr<DEFAULT_TEST_FAMILY_NAME>>(*executionEnvironment, 0);
executionEnvironment->memoryManager.reset(new MemoryManagerCreate<WddmMemoryManager>(false, false, *executionEnvironment));
csr->overrideDispatchPolicy(DispatchMode::ImmediateDispatch);
OsContextWin osContext(*wddm, 0u, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
OsContextWin osContext(*wddm, 0u, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first,
PreemptionHelper::getDefaultPreemptionMode(*hwInfo),
false, false, false);
csr->setupContext(osContext);

2
opencl/test/unit_test/os_interface/windows/os_context_win_tests.cpp
View File

@ -16,7 +16,7 @@ struct OsContextWinTest : public WddmTestWithMockGdiDll {
void SetUp() override {
WddmTestWithMockGdiDll::SetUp();
preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo);
engineType = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0];
engineType = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first;
init();
}

2
opencl/test/unit_test/os_interface/windows/os_interface_win_tests.cpp
View File

@ -32,7 +32,7 @@ TEST(OsContextTest, givenWddmWhenCreateOsContextAfterInitWddmThenOsContextIsInit
wddm->init();
EXPECT_EQ(0u, wddm->registerTrimCallbackResult.called);
auto osContext = std::make_unique<OsContextWin>(*wddm, 0u, 1,
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
preemptionMode, false, false, false);
EXPECT_TRUE(osContext->isInitialized());
EXPECT_EQ(osContext->getWddm(), wddm);

2
opencl/test/unit_test/os_interface/windows/wddm20_tests.cpp
View File

@ -623,7 +623,7 @@ TEST_F(Wddm20WithMockGdiDllTestsWithoutWddmInit, givenUseNoRingFlushesKmdModeDeb
TEST_F(Wddm20WithMockGdiDllTestsWithoutWddmInit, givenEngineTypeWhenCreatingContextThenPassCorrectNodeOrdinal) {
init();
auto createContextParams = this->getCreateContextDataFcn();
UINT expected = WddmEngineMapper::engineNodeMap(HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0]);
UINT expected = WddmEngineMapper::engineNodeMap(HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first);
EXPECT_EQ(expected, createContextParams->NodeOrdinal);
}

4
opencl/test/unit_test/os_interface/windows/wddm23_tests.cpp
View File

@ -46,7 +46,7 @@ struct Wddm23TestsWithoutWddmInit : public ::testing::Test, GdiDllFixture {
wddm->init();
wddm->wddmInterface.reset(wddmMockInterface);
osContext = std::make_unique<OsContextWin>(*wddm, 0u, 1,
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
preemptionMode, false, false, false);
}
@ -78,7 +78,7 @@ TEST_F(Wddm23Tests, whenCreateContextIsCalledThenEnableHwQueues) {
}
TEST_F(Wddm23Tests, givenPreemptionModeWhenCreateHwQueueCalledThenSetGpuTimeoutIfEnabled) {
auto defaultEngine = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0];
auto defaultEngine = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first;
OsContextWin osContextWithoutPreemption(*wddm, 0u, 1, defaultEngine, PreemptionMode::Disabled,
false, false, false);
OsContextWin osContextWithPreemption(*wddm, 0u, 1, defaultEngine, PreemptionMode::MidBatch,

4
opencl/test/unit_test/os_interface/windows/wddm_fixture.h
View File

@ -46,7 +46,7 @@ struct WddmFixture : public Test<MockExecutionEnvironmentGmmFixture> {
auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo);
wddm->init();
auto hwInfo = rootDeviceEnvironemnt->getHardwareInfo();
auto engine = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
auto engine = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first;
osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1u, engine, preemptionMode,
false, false, false);
mockTemporaryResources = static_cast<MockWddmResidentAllocationsContainer *>(wddm->temporaryResources.get());
@ -82,7 +82,7 @@ struct WddmFixtureWithMockGdiDll : public GdiDllFixture, public MockExecutionEnv
wddm->wddmInterface.reset(wddmMockInterface);
auto hwInfo = rootDeviceEnvironment->getHardwareInfo();
auto engine = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
auto engine = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first;
osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engine, preemptionMode,
false, false, false);
}

4
opencl/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp
View File

@ -358,7 +358,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValuesOnMultipleEnginesRegi
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm2);
auto hwInfo = executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo();
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[1],
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[1].first,
2, PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false, false, false);
ASSERT_EQ(2u, memoryManager->getRegisteredEnginesCount());
@ -390,7 +390,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValueOnSomeOfMultipleEngine
executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm2);
auto hwInfo = executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo();
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[1],
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[1].first,
2, PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false, false, false);
ASSERT_EQ(2u, memoryManager->getRegisteredEnginesCount());

4
opencl/test/unit_test/os_interface/windows/wddm_memory_manager_tests.h
View File

@ -68,7 +68,7 @@ class MockWddmMemoryManagerFixture {
csr.reset(createCommandStream(*executionEnvironment, 0u));
auto hwInfo = rootDeviceEnvironment->getHardwareInfo();
osContext = memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first,
1, PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false, false, false);
osContext->incRefInternal();
@ -120,7 +120,7 @@ class WddmMemoryManagerFixtureWithGmockWddm : public ExecutionEnvironmentFixture
csr.reset(createCommandStream(*executionEnvironment, 0u));
auto hwInfo = executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
osContext = memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first,
1, preemptionMode, false, false, false);
osContext->incRefInternal();

4
opencl/test/unit_test/os_interface/windows/wddm_residency_controller_tests.cpp
View File

@ -132,7 +132,7 @@ struct WddmResidencyControllerWithMockWddmTest : public WddmResidencyControllerT
csr.reset(createCommandStream(*executionEnvironment, 0u));
auto hwInfo = executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
osContext = memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0], 1, preemptionMode,
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first, 1, preemptionMode,
false, false, false);
osContext->incRefInternal();
@ -168,7 +168,7 @@ struct WddmResidencyControllerWithGdiAndMemoryManagerTest : ::testing::Test {
csr.reset(createCommandStream(*executionEnvironment, 0u));
auto hwInfo = executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
osContext = memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first,
1, PreemptionHelper::getDefaultPreemptionMode(*hwInfo),
false, false, false);

4
opencl/test/unit_test/sharings/gl/windows/gl_os_sharing_tests.cpp
View File

@ -343,7 +343,7 @@ TEST_F(GlArbSyncEventOsTest, GivenCallToSignalArbSyncObjectWhenSignalSynchroniza
auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo);
wddm->init();
OsContextWin osContext(*wddm, 0u, 1,
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
preemptionMode, false, false, false);
CL_GL_SYNC_INFO syncInfo = {};
@ -404,7 +404,7 @@ TEST_F(GlArbSyncEventOsTest, GivenCallToSignalArbSyncObjectWhenSignalSynchroniza
auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo);
wddm->init();
OsContextWin osContext(*wddm, 0u, 1,
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0],
HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0].first,
preemptionMode, false, false, false);
CL_GL_SYNC_INFO syncInfo = {};

13
shared/source/device/device.cpp
View File

@ -115,7 +115,7 @@ std::unique_ptr<CommandStreamReceiver> Device::createCommandStreamReceiver() con
return std::unique_ptr<CommandStreamReceiver>(createCommandStream(*executionEnvironment, getRootDeviceIndex()));
}
bool Device::createEngine(uint32_t deviceCsrIndex, aub_stream::EngineType engineType) {
bool Device::createEngine(uint32_t deviceCsrIndex, EngineTypeUsage engineTypeUsage) {
auto &hwInfo = getHardwareInfo();
auto defaultEngineType = getChosenEngineType(hwInfo);
@ -124,7 +124,9 @@ bool Device::createEngine(uint32_t deviceCsrIndex, aub_stream::EngineType engine
return false;
}
bool internalUsage = (deviceCsrIndex == HwHelper::internalUsageEngineIndex);
auto engineType = engineTypeUsage.first;
bool internalUsage = (engineTypeUsage.second == EngineUsage::Internal);
if (internalUsage) {
commandStreamReceiver->initializeDefaultsForInternalEngine();
}
@ -133,7 +135,7 @@ bool Device::createEngine(uint32_t deviceCsrIndex, aub_stream::EngineType engine
commandStreamReceiver->createPageTableManager();
}
bool lowPriority = (deviceCsrIndex == HwHelper::lowPriorityGpgpuEngineIndex);
bool lowPriority = (engineTypeUsage.second == EngineUsage::LowPriority);
auto osContext = executionEnvironment->memoryManager->createAndRegisterOsContext(commandStreamReceiver.get(), engineType,
getDeviceBitfield(), preemptionMode,
lowPriority, internalUsage, false);
@ -208,10 +210,11 @@ bool Device::isDebuggerActive() const {
return deviceInfo.debuggerActive;
}
EngineControl &Device::getEngine(aub_stream::EngineType engineType, bool lowPriority) {
EngineControl &Device::getEngine(aub_stream::EngineType engineType, bool lowPriority, bool internalUsage) {
for (auto &engine : engines) {
if (engine.osContext->getEngineType() == engineType &&
engine.osContext->isLowPriority() == lowPriority) {
engine.osContext->isLowPriority() == lowPriority &&
engine.osContext->isInternalEngine() == internalUsage) {
return engine;
}
}

5
shared/source/device/device.h
View File

@ -12,6 +12,7 @@
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/common_types.h"
#include "shared/source/helpers/engine_control.h"
#include "shared/source/helpers/engine_node_helper.h"
#include "shared/source/helpers/hw_info.h"
#include "opencl/source/os_interface/performance_counters.h"
@ -43,7 +44,7 @@ class Device : public ReferenceTrackedObject<Device> {
bool getHostTimer(uint64_t *hostTimestamp) const;
const HardwareInfo &getHardwareInfo() const;
const DeviceInfo &getDeviceInfo() const;
EngineControl &getEngine(aub_stream::EngineType engineType, bool lowPriority);
EngineControl &getEngine(aub_stream::EngineType engineType, bool lowPriority, bool internalUsage);
std::vector<std::vector<EngineControl>> &getEngineGroups() {
return this->engineGroups;
}
@ -111,7 +112,7 @@ class Device : public ReferenceTrackedObject<Device> {
virtual bool createDeviceImpl();
virtual bool createEngines();
bool createEngine(uint32_t deviceCsrIndex, aub_stream::EngineType engineType);
bool createEngine(uint32_t deviceCsrIndex, EngineTypeUsage engineTypeUsage);
MOCKABLE_VIRTUAL std::unique_ptr<CommandStreamReceiver> createCommandStreamReceiver() const;
virtual uint64_t getGlobalMemorySize() const;

5
shared/source/device/device_get_engine.cpp
View File

@ -15,6 +15,9 @@ EngineControl &Device::getInternalEngine() {
if (this->engines[0].commandStreamReceiver->getType() != CommandStreamReceiverType::CSR_HW) {
return this->getDefaultEngine();
}
return this->getDeviceById(0)->engines[HwHelper::internalUsageEngineIndex];
auto engineType = getChosenEngineType(getHardwareInfo());
return this->getDeviceById(0)->getEngine(engineType, false, true);
}
} // namespace NEO

12
shared/source/gen12lp/hw_helper_gen12lp.cpp
View File

@ -158,22 +158,22 @@ const HwHelper::EngineInstancesContainer HwHelperHw<Family>::getGpgpuEngineInsta
auto defaultEngine = getChosenEngineType(hwInfo);
EngineInstancesContainer engines = {
aub_stream::ENGINE_RCS,
aub_stream::ENGINE_RCS, // low priority
defaultEngine // internal usage
{aub_stream::ENGINE_RCS, EngineUsage::Regular},
{aub_stream::ENGINE_RCS, EngineUsage::LowPriority}, // low priority
{defaultEngine, EngineUsage::Internal}, // internal usage
};
if (defaultEngine == aub_stream::EngineType::ENGINE_CCS && hwInfo.featureTable.ftrCCSNode && !hwInfo.featureTable.ftrGpGpuMidThreadLevelPreempt) {
engines.push_back(aub_stream::ENGINE_CCS);
engines.push_back({aub_stream::ENGINE_CCS, EngineUsage::Regular});
}
if (hwInfo.featureTable.ftrBcsInfo.test(0)) {
engines.push_back(aub_stream::ENGINE_BCS);
engines.push_back({aub_stream::ENGINE_BCS, EngineUsage::Regular});
}
auto hwInfoConfig = HwInfoConfig::get(hwInfo.platform.eProductFamily);
if (hwInfoConfig->isEvenContextCountRequired() && engines.size() & 1) {
engines.push_back(aub_stream::ENGINE_RCS);
engines.push_back({aub_stream::ENGINE_RCS, EngineUsage::Regular});
}
return engines;

9
shared/source/helpers/engine_node_helper.h
View File

@ -10,10 +10,19 @@
#include "engine_node.h"
#include <atomic>
#include <utility>
namespace NEO {
struct HardwareInfo;
enum class EngineUsage : uint32_t {
Regular,
LowPriority,
Internal
};
using EngineTypeUsage = std::pair<aub_stream::EngineType, EngineUsage>;
namespace EngineHelpers {
bool isCcs(aub_stream::EngineType engineType);
bool isBcs(aub_stream::EngineType engineType);

14
shared/source/helpers/hw_helper.h
View File

@ -10,6 +10,7 @@
#include "shared/source/command_stream/linear_stream.h"
#include "shared/source/commands/bxml_generator_glue.h"
#include "shared/source/helpers/aux_translation.h"
#include "shared/source/helpers/engine_node_helper.h"
#include "opencl/source/aub_mem_dump/aub_mem_dump.h"
#include "opencl/source/mem_obj/buffer.h"
@ -44,7 +45,7 @@ enum class EngineGroupType : uint32_t {
class HwHelper {
public:
using EngineInstancesContainer = StackVec<aub_stream::EngineType, 32>;
using EngineInstancesContainer = StackVec<EngineTypeUsage, 32>;
static HwHelper &get(GFXCORE_FAMILY gfxCore);
virtual uint32_t getBindingTableStateSurfaceStatePointer(const void *pBindingTable, uint32_t index) = 0;
virtual size_t getBindingTableStateSize() const = 0;
@ -56,7 +57,6 @@ class HwHelper {
virtual uint32_t getMaxNumSamplers() const = 0;
virtual void setCapabilityCoherencyFlag(const HardwareInfo *pHwInfo, bool &coherencyFlag) = 0;
virtual void adjustDefaultEngineType(HardwareInfo *pHwInfo) = 0;
virtual uint32_t getComputeEngineIndexByOrdinal(const HardwareInfo &hwInfo, uint32_t ordinal) const = 0;
virtual void setupHardwareCapabilities(HardwareCapabilities *caps, const HardwareInfo &hwInfo) = 0;
virtual bool isL3Configurable(const HardwareInfo &hwInfo) = 0;
virtual SipKernelType getSipKernelType(bool debuggingActive) = 0;
@ -129,9 +129,6 @@ class HwHelper {
static uint32_t getEnginesCount(const HardwareInfo &hwInfo);
static uint32_t getCopyEnginesCount(const HardwareInfo &hwInfo);
static constexpr uint32_t lowPriorityGpgpuEngineIndex = 1;
static constexpr uint32_t internalUsageEngineIndex = 2;
protected:
virtual LocalMemoryAccessMode getDefaultLocalMemoryAccessMode(const HardwareInfo &hwInfo) const = 0;
@ -198,13 +195,6 @@ class HwHelperHw : public HwHelper {
void adjustDefaultEngineType(HardwareInfo *pHwInfo) override;
uint32_t getComputeEngineIndexByOrdinal(const HardwareInfo &hwInfo, uint32_t ordinal) const override {
if (hwInfo.featureTable.ftrCCSNode && ordinal < hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled) {
return ordinal + internalUsageEngineIndex + 1;
}
return 0;
}
void setupHardwareCapabilities(HardwareCapabilities *caps, const HardwareInfo &hwInfo) override;
bool isL3Configurable(const HardwareInfo &hwInfo) override;

8
shared/source/helpers/hw_helper_bdw_plus.inl
View File

@ -57,9 +57,11 @@ bool HwHelperHw<Family>::obtainBlitterPreference(const HardwareInfo &hwInfo) con
template <typename GfxFamily>
const HwHelper::EngineInstancesContainer HwHelperHw<GfxFamily>::getGpgpuEngineInstances(const HardwareInfo &hwInfo) const {
return {aub_stream::ENGINE_RCS,
aub_stream::ENGINE_RCS, // low priority
aub_stream::ENGINE_RCS}; // internal usage
return {
{aub_stream::ENGINE_RCS, EngineUsage::Regular},
{aub_stream::ENGINE_RCS, EngineUsage::LowPriority},
{aub_stream::ENGINE_RCS, EngineUsage::Internal},
};
}
template <typename GfxFamily>

4
shared/test/unit_test/os_interface/windows/wddm_preemption_tests.cpp
View File

@ -43,7 +43,7 @@ class WddmPreemptionTests : public Test<WddmFixtureWithMockGdiDll> {
wddm->init();
hwInfo = executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
ASSERT_NE(nullptr, hwInfo);
auto engine = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
auto engine = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0].first;
osContext = std::make_unique<OsContextWin>(*wddm, 0u, 1, engine, preemptionMode, false, false, false);
}
@ -116,4 +116,4 @@ TEST_F(WddmPreemptionTests, whenFlagToOverridePreemptionSurfaceSizeIsSetThenSurf
TEST_F(WddmPreemptionTests, whenFlagToOverridePreemptionSurfaceSizeIsNotSetThenSurfaceSizeIsNotChanged) {
createAndInitWddm(0u);
EXPECT_EQ(wddm->getGtSysInfo()->CsrSizeInMb, hwInfo->gtSystemInfo.CsrSizeInMb);
}
}