Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-11-10 05:49:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Create only available engines

Browse Source 
Change-Id: If7880db0dd7aa76b578d0e4e300f510ca686b825
Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com>
This commit is contained in:
Dunajski, Bartosz
2020-02-21 15:25:04 +01:00
committed by sys_ocldev
parent c345939dd6
commit 750036742d
39 changed files with 242 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
opencl/source/command_queue/gpgpu_walker_base.inl
View File

@@ -160,7 +160,7 @@ void GpgpuWalkerHelper<GfxFamily>::dispatchPerfCountersCommandsStart(
LinearStream *commandStream) {
const auto pPerformanceCounters = commandQueue.getPerfCounters();
const auto commandBufferType = EngineHelpers::isCcs(commandQueue.getDevice().getDefaultEngine().osContext->getEngineType())
const auto commandBufferType = EngineHelpers::isCcs(commandQueue.getGpgpuEngine().osContext->getEngineType())
? MetricsLibraryApi::GpuCommandBufferType::Compute
: MetricsLibraryApi::GpuCommandBufferType::Render;
const uint32_t size = pPerformanceCounters->getGpuCommandsSize(commandBufferType, true);
@@ -176,7 +176,7 @@ void GpgpuWalkerHelper<GfxFamily>::dispatchPerfCountersCommandsEnd(
LinearStream *commandStream) {
const auto pPerformanceCounters = commandQueue.getPerfCounters();
const auto commandBufferType = EngineHelpers::isCcs(commandQueue.getDevice().getDefaultEngine().osContext->getEngineType())
const auto commandBufferType = EngineHelpers::isCcs(commandQueue.getGpgpuEngine().osContext->getEngineType())
? MetricsLibraryApi::GpuCommandBufferType::Compute
: MetricsLibraryApi::GpuCommandBufferType::Render;
const uint32_t size = pPerformanceCounters->getGpuCommandsSize(commandBufferType, false);

2
opencl/source/command_queue/gpgpu_walker_bdw_plus.inl
View File

@@ -199,7 +199,7 @@ size_t EnqueueOperation<GfxFamily>::getSizeRequiredCSKernel(bool reserveProfilin
}
if (reservePerfCounters) {
const auto commandBufferType = EngineHelpers::isCcs(commandQueue.getDevice().getDefaultEngine().osContext->getEngineType())
const auto commandBufferType = EngineHelpers::isCcs(commandQueue.getGpgpuEngine().osContext->getEngineType())
? MetricsLibraryApi::GpuCommandBufferType::Compute
: MetricsLibraryApi::GpuCommandBufferType::Render;

20
opencl/source/gen12lp/hw_helper_gen12lp.cpp
View File

@@ -99,12 +99,20 @@ uint32_t HwHelperHw<Family>::getMetricsLibraryGenId() const {
}
template <>
const std::vector<aub_stream::EngineType> HwHelperHw<Family>::getGpgpuEngineInstances() const {
constexpr std::array<aub_stream::EngineType, 4> gpgpuEngineInstances = {{aub_stream::ENGINE_RCS,
aub_stream::ENGINE_RCS, // low priority
aub_stream::ENGINE_RCS, // internal usage
aub_stream::ENGINE_CCS}};
return std::vector<aub_stream::EngineType>(gpgpuEngineInstances.begin(), gpgpuEngineInstances.end());
const HwHelper::EngineInstancesContainer HwHelperHw<Family>::getGpgpuEngineInstances(const HardwareInfo &hwInfo) const {
auto defaultEngine = getChosenEngineType(hwInfo);
EngineInstancesContainer engines = {
aub_stream::ENGINE_RCS,
aub_stream::ENGINE_RCS, // low priority
defaultEngine // internal usage
};
if (hwInfo.featureTable.ftrCCSNode) {
engines.push_back(aub_stream::ENGINE_CCS);
}
return engines;
};
template <>

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

@@ -254,7 +254,8 @@ HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationWhenMakeResidentC
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenMultipleInstancesInitializeTheirEnginesThenUniqueGlobalGttAdressesAreGenerated) {
pDevice->executionEnvironment->rootDeviceEnvironments[0]->aubCenter.reset(new AubCenter());
auto engineInstance = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0];
auto &hwInfo = pDevice->getHardwareInfo();
auto engineInstance = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo)[0];
MockOsContext osContext(0, 1, engineInstance, PreemptionMode::Disabled, false);
auto aubCsr1 = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>("", true, *pDevice->executionEnvironment, pDevice->getRootDeviceIndex());

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

@@ -457,7 +457,8 @@ HWTEST_F(AubCommandStreamReceiverNoHostPtrTests, givenAubCommandStreamReceiverWh
ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto memoryManager = new OsAgnosticMemoryManagerForImagesWithNoHostPtr(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager);
auto engineInstance = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0];
auto hwInfo = executionEnvironment->getHardwareInfo();
auto engineInstance = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
MockOsContext osContext(0, 1, engineInstance, PreemptionMode::Disabled, false);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>("", true, *executionEnvironment, 0));
@@ -703,9 +704,10 @@ HWTEST_F(AubCommandStreamReceiverTests, whenAubCommandStreamReceiverIsCreatedThe
}
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenEngineIsInitializedThenDumpHandleIsGenerated) {
auto engineInstance = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0];
MockOsContext osContext(0, 1, engineInstance, PreemptionMode::Disabled, false);
MockExecutionEnvironment executionEnvironment(platformDevices[0]);
auto hwInfo = executionEnvironment.getHardwareInfo();
auto engineInstance = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
MockOsContext osContext(0, 1, engineInstance, PreemptionMode::Disabled, false);
executionEnvironment.initializeMemoryManager();
auto aubCsr = std::make_unique<MockAubCsrToTestDumpContext<FamilyType>>("", true, executionEnvironment, 0);

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

@@ -146,8 +146,10 @@ HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenCsrWithAubDumpWhenSett
executionEnvironment->initializeMemoryManager();
CommandStreamReceiverWithAUBDump<UltCommandStreamReceiver<FamilyType>> csrWithAubDump("aubfile", *executionEnvironment, 0);
MockOsContext osContext(0, 1, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto hwInfo = executionEnvironment->getHardwareInfo();
MockOsContext osContext(0, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false);
csrWithAubDump.setupContext(osContext);
EXPECT_EQ(&osContext, &csrWithAubDump.getOsContext());

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

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

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

@@ -54,7 +54,7 @@ TEST_F(DeviceTest, givenDeviceWhenEngineIsCreatedThenSetInitialValueForTag) {
}
TEST_F(DeviceTest, givenDeviceWhenAskedForSpecificEngineThenRetrunIt) {
auto &engines = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances();
auto &engines = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0]);
for (uint32_t i = 0; i < engines.size(); i++) {
bool lowPriority = (HwHelper::lowPriorityGpgpuEngineIndex == i);
auto &deviceEngine = pDevice->getEngine(engines[i], lowPriority);
@@ -68,7 +68,7 @@ TEST_F(DeviceTest, givenDeviceWhenAskedForSpecificEngineThenRetrunIt) {
TEST_F(DeviceTest, givenDebugVariableToAlwaysChooseEngineZeroWhenNotExistingEngineSelectedThenIndexZeroEngineIsReturned) {
DebugManagerStateRestore restore;
DebugManager.flags.OverrideInvalidEngineWithDefault.set(true);
auto &engines = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances();
auto &engines = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0]);
auto &deviceEngine = pDevice->getEngine(engines[0], false);
auto &notExistingEngine = pDevice->getEngine(aub_stream::ENGINE_VCS, false);
EXPECT_EQ(&notExistingEngine, &deviceEngine);
@@ -116,13 +116,18 @@ TEST_F(DeviceTest, WhenAppendingOsExtensionsThenDeviceInfoIsProperlyUpdated) {
EXPECT_STREQ(expectedExtensions.c_str(), pDevice->deviceInfo.deviceExtensions);
}
TEST_F(DeviceTest, WhenDeviceIsCreatedThenActualEngineTypeIsSameAsDefault) {
auto pTestDevice = std::unique_ptr<Device>(createWithUsDeviceId(0));
HWTEST_F(DeviceTest, WhenDeviceIsCreatedThenActualEngineTypeIsSameAsDefault) {
HardwareInfo hwInfo = *platformDevices[0];
if (hwInfo.capabilityTable.defaultEngineType == aub_stream::EngineType::ENGINE_CCS) {
hwInfo.featureTable.ftrCCSNode = true;
}
auto actualEngineType = pDevice->getDefaultEngine().osContext->getEngineType();
auto defaultEngineType = pDevice->getHardwareInfo().capabilityTable.defaultEngineType;
auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
EXPECT_EQ(&pDevice->getDefaultEngine().commandStreamReceiver->getOsContext(), pDevice->getDefaultEngine().osContext);
auto actualEngineType = device->getDefaultEngine().osContext->getEngineType();
auto defaultEngineType = device->getHardwareInfo().capabilityTable.defaultEngineType;
EXPECT_EQ(&device->getDefaultEngine().commandStreamReceiver->getOsContext(), device->getDefaultEngine().osContext);
EXPECT_EQ(defaultEngineType, actualEngineType);
}
@@ -183,7 +188,8 @@ TEST(DeviceCreation, givenDefaultHwCsrInDebugVarsWhenDeviceIsCreatedThenIsSimula
TEST(DeviceCreation, givenDeviceWhenItIsCreatedThenOsContextIsRegistredInMemoryManager) {
auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
auto memoryManager = device->getMemoryManager();
auto numEnginesForDevice = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances().size();
auto &hwInfo = device->getHardwareInfo();
auto numEnginesForDevice = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo).size();
if (device->getNumAvailableDevices() > 1) {
numEnginesForDevice *= device->getNumAvailableDevices();
numEnginesForDevice += device->engines.size();
@@ -195,7 +201,8 @@ TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachOsContextHasU
ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
const size_t numDevices = 2;
executionEnvironment->prepareRootDeviceEnvironments(numDevices);
const auto &numGpgpuEngines = static_cast<uint32_t>(HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances().size());
auto hwInfo = executionEnvironment->getHardwareInfo();
const auto &numGpgpuEngines = static_cast<uint32_t>(HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo).size());
auto device1 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0u));
auto device2 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 1u));
@@ -232,7 +239,8 @@ TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachDeviceHasSepe
ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
const size_t numDevices = 2;
executionEnvironment->prepareRootDeviceEnvironments(numDevices);
const auto &numGpgpuEngines = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances().size();
auto hwInfo = executionEnvironment->getHardwareInfo();
const auto &numGpgpuEngines = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo).size();
auto device1 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0u));
auto device2 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 1u));
@@ -244,12 +252,15 @@ TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachDeviceHasSepe
}
}
TEST(DeviceCreation, givenDeviceWhenAskingForDefaultEngineThenReturnValidValue) {
HWTEST_F(DeviceTest, givenDeviceWhenAskingForDefaultEngineThenReturnValidValue) {
ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto &hwHelper = HwHelperHw<FamilyType>::get();
hwHelper.adjustDefaultEngineType(executionEnvironment->getMutableHardwareInfo());
auto device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0));
auto osContext = device->getDefaultEngine().osContext;
EXPECT_EQ(platformDevices[0]->capabilityTable.defaultEngineType, osContext->getEngineType());
EXPECT_EQ(executionEnvironment->getHardwareInfo()->capabilityTable.defaultEngineType, osContext->getEngineType());
EXPECT_FALSE(osContext->isLowPriority());
}

2
opencl/test/unit_test/device/sub_device_tests.cpp
View File

@@ -170,7 +170,7 @@ TEST(SubDevicesTest, givenSubDevicesWhenGettingDeviceByIdZeroThenGetThisSubDevic
TEST(RootDevicesTest, givenRootDeviceWithoutSubdevicesWhenCreateEnginesThenDeviceCreatesCorrectNumberOfEngines) {
auto hwInfo = *platformDevices[0];
auto &gpgpuEngines = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances();
auto &gpgpuEngines = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo);
auto executionEnvironment = new MockExecutionEnvironment;
MockDevice device(executionEnvironment, 0);

7
opencl/test/unit_test/execution_environment/execution_environment_tests.cpp
View File

@@ -231,9 +231,10 @@ TEST(ExecutionEnvironment, whenCalculateMaxOsContexCountThenGlobalVariableHasPro
auto expectedOsContextCount = 0u;
for (const auto &rootDeviceEnvironment : executionEnvironment.rootDeviceEnvironments) {
auto &hwHelper = HwHelper::get(rootDeviceEnvironment->getHardwareInfo()->platform.eRenderCoreFamily);
auto osContextCount = hwHelper.getGpgpuEngineInstances().size();
auto subDevicesCount = HwHelper::getSubDevicesCount(rootDeviceEnvironment->getHardwareInfo());
auto hwInfo = rootDeviceEnvironment->getHardwareInfo();
auto &hwHelper = HwHelper::get(hwInfo->platform.eRenderCoreFamily);
auto osContextCount = hwHelper.getGpgpuEngineInstances(*hwInfo).size();
auto subDevicesCount = HwHelper::getSubDevicesCount(hwInfo);
bool hasRootCsr = subDevicesCount > 1;
expectedOsContextCount += static_cast<uint32_t>(osContextCount * subDevicesCount + hasRootCsr);
}

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

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

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

@@ -23,8 +23,9 @@ void MemoryManagerWithCsrFixture::SetUp() {
memoryManager = new MockMemoryManager(executionEnvironment);
executionEnvironment.memoryManager.reset(memoryManager);
csr->tagAddress = &currentGpuTag;
auto engine = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0];
auto osContext = memoryManager->createAndRegisterOsContext(csr.get(), engine, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto hwInfo = executionEnvironment.getHardwareInfo();
auto engine = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
auto osContext = memoryManager->createAndRegisterOsContext(csr.get(), engine, 1, PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false);
csr->setupContext(*osContext);
}

2
opencl/test/unit_test/gen11/hw_helper_tests_gen11.cpp
View File

@@ -43,6 +43,6 @@ GEN11TEST_F(HwHelperTestGen11, givenGen11PlatformWhenSetupHardwareCapabilitiesIs
}
GEN11TEST_F(HwHelperTestGen11, whenGetGpgpuEnginesThenReturnThreeRcsEngines) {
whenGetGpgpuEnginesThenReturnTwoRcsEngines<FamilyType>();
whenGetGpgpuEnginesThenReturnTwoRcsEngines<FamilyType>(pDevice->getHardwareInfo());
EXPECT_EQ(3u, pDevice->engines.size());
}

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

@@ -104,9 +104,43 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, givenDifferentSizesOfAllocationWhenCheckingCo
}
}
GEN12LPTEST_F(HwHelperTestGen12Lp, whenGetGpgpuEnginesThenReturnThreeRcsEnginesAndCcsEngine) {
EXPECT_EQ(4u, pDevice->engines.size());
auto &engines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances();
GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeNotSetWhenGetGpgpuEnginesThenReturnThreeRcsEngines) {
HardwareInfo hwInfo = *platformDevices[0];
hwInfo.featureTable.ftrCCSNode = false;
hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_RCS;
auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
EXPECT_EQ(3u, device->engines.size());
auto &engines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances(hwInfo);
EXPECT_EQ(3u, 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]);
}
GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeSetWhenGetGpgpuEnginesThenReturnTwoRcsAndCcsEngines) {
HardwareInfo hwInfo = *platformDevices[0];
hwInfo.featureTable.ftrCCSNode = true;
hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_CCS;
auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
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]);
}
GEN12LPTEST_F(HwHelperTestGen12Lp, givenFtrCcsNodeSetAndDefaultRcsWhenGetGpgpuEnginesThenReturnThreeRcsAndCcsEngines) {
HardwareInfo hwInfo = *platformDevices[0];
hwInfo.featureTable.ftrCCSNode = true;
hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_RCS;
auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
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]);

2
opencl/test/unit_test/gen8/hw_helper_tests_gen8.cpp
View File

@@ -50,6 +50,6 @@ GEN8TEST_F(HwHelperTestGen8, givenGen8PlatformWhenSetupHardwareCapabilitiesIsCal
}
GEN8TEST_F(HwHelperTestGen8, whenGetGpgpuEnginesThenReturnTwoThreeEngines) {
whenGetGpgpuEnginesThenReturnTwoRcsEngines<FamilyType>();
whenGetGpgpuEnginesThenReturnTwoRcsEngines<FamilyType>(pDevice->getHardwareInfo());
EXPECT_EQ(3u, pDevice->engines.size());
}

2
opencl/test/unit_test/gen9/hw_helper_tests_gen9.cpp
View File

@@ -50,6 +50,6 @@ GEN9TEST_F(HwHelperTestGen9, givenDebuggingActiveWhenSipKernelTypeIsQueriedThenD
}
GEN9TEST_F(HwHelperTestGen9, whenGetGpgpuEnginesThenReturnThreeRcsEngines) {
whenGetGpgpuEnginesThenReturnTwoRcsEngines<FamilyType>();
whenGetGpgpuEnginesThenReturnTwoRcsEngines<FamilyType>(pDevice->getHardwareInfo());
EXPECT_EQ(3u, pDevice->engines.size());
}

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

@@ -12,8 +12,8 @@
using namespace NEO;
template <typename FamilyType>
void whenGetGpgpuEnginesThenReturnTwoRcsEngines() {
auto gpgpuEngines = HwHelperHw<FamilyType>::get().getGpgpuEngineInstances();
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]);

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

@@ -198,7 +198,8 @@ TEST_F(MemoryAllocatorTest, allocateSystemAligned) {
TEST_F(MemoryAllocatorTest, allocateGraphics) {
unsigned int alignment = 4096;
memoryManager->createAndRegisterOsContext(csr, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
memoryManager->createAndRegisterOsContext(csr,
HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
@@ -1407,7 +1408,8 @@ TEST_F(MemoryManagerWithCsrTest, givenAllocationThatWasUsedAndIsCompletedWhenche
}
TEST_F(MemoryManagerWithCsrTest, givenAllocationThatWasUsedAndIsNotCompletedWhencheckGpuUsageAndDestroyGraphicsAllocationsIsCalledThenItIsAddedToTemporaryAllocationList) {
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto usedAllocationAndNotGpuCompleted = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
@@ -1657,7 +1659,8 @@ TEST(ResidencyDataTest, givenOsContextWhenItIsRegisteredToMemoryManagerThenRefCo
auto memoryManager = new MockMemoryManager(false, false, executionEnvironment);
executionEnvironment.memoryManager.reset(memoryManager);
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, 0u));
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
EXPECT_EQ(1u, memoryManager->getRegisteredEnginesCount());
EXPECT_EQ(1, memoryManager->registeredEngines[0].osContext->getRefInternalCount());
@@ -1684,7 +1687,8 @@ TEST(ResidencyDataTest, givenDeviceBitfieldWhenCreatingOsContextThenSetValidValu
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, 0u));
DeviceBitfield deviceBitfield = 0b11;
PreemptionMode preemptionMode = PreemptionMode::MidThread;
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[0],
deviceBitfield, preemptionMode, false);
EXPECT_EQ(2u, memoryManager->registeredEngines[0].osContext->getNumSupportedDevices());
EXPECT_EQ(deviceBitfield, memoryManager->registeredEngines[0].osContext->getDeviceBitfield());
@@ -1697,9 +1701,11 @@ TEST(ResidencyDataTest, givenTwoOsContextsWhenTheyAreRegisteredFromHigherToLower
executionEnvironment.memoryManager.reset(memoryManager);
std::unique_ptr<CommandStreamReceiver> csr(createCommandStream(executionEnvironment, 0u));
std::unique_ptr<CommandStreamReceiver> csr1(createCommandStream(executionEnvironment, 1u));
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
memoryManager->createAndRegisterOsContext(csr1.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[1],
memoryManager->createAndRegisterOsContext(csr1.get(),
HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[1],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
EXPECT_EQ(2u, memoryManager->getRegisteredEnginesCount());
EXPECT_EQ(1, memoryManager->registeredEngines[0].osContext->getRefInternalCount());
@@ -1707,7 +1713,7 @@ TEST(ResidencyDataTest, givenTwoOsContextsWhenTheyAreRegisteredFromHigherToLower
}
TEST(ResidencyDataTest, givenGpgpuEnginesWhenAskedForMaxOsContextCountThenValueIsGreaterOrEqual) {
auto &engines = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances();
auto &engines = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0]);
EXPECT_TRUE(MemoryManager::maxOsContextCount >= engines.size());
}
@@ -1718,8 +1724,12 @@ TEST(ResidencyDataTest, givenResidencyDataWhenUpdateCompletionDataIsCalledThenIt
MockResidencyData residency;
MockOsContext osContext(0u, 1, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
MockOsContext osContext2(1u, 1, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[1], PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
MockOsContext osContext(0u, 1,
HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[0],
PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
MockOsContext osContext2(1u, 1,
HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[1],
PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto lastFenceValue = 45llu;
auto lastFenceValue2 = 23llu;

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

@@ -64,8 +64,9 @@ HWTEST_TYPED_TEST(SurfaceTest, GivenSurfaceWhenInterfaceIsUsedThenSurfaceBehaves
ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager();
auto csr = std::make_unique<MockCsr<FamilyType>>(execStamp, *executionEnvironment, 0);
auto engine = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0];
auto osContext = executionEnvironment->memoryManager->createAndRegisterOsContext(csr.get(), engine, 1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto hwInfo = executionEnvironment->getHardwareInfo();
auto engine = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
auto osContext = executionEnvironment->memoryManager->createAndRegisterOsContext(csr.get(), engine, 1, PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false);
csr->setupContext(*osContext);
Surface *surface = createSurface::Create<TypeParam>(this->data,

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

@@ -331,7 +331,7 @@ class DrmMockCustom : public Drm {
DrmMockCustom() : Drm(std::make_unique<HwDeviceId>(mockFd), *constructPlatform()->peekExecutionEnvironment()->rootDeviceEnvironments[0]) {
reset();
ioctl_expected.contextCreate = static_cast<int>(NEO::HwHelper::get(NEO::platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances().size());
ioctl_expected.contextCreate = static_cast<int>(NEO::HwHelper::get(NEO::platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*NEO::platformDevices[0]).size());
ioctl_expected.contextDestroy = ioctl_expected.contextCreate.load();
}
int getErrno() override {

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

@@ -36,8 +36,9 @@ class DrmCommandStreamTest : public ::testing::Test {
executionEnvironment.rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment.rootDeviceEnvironments[0]->osInterface->get()->setDrm(mock);
osContext = std::make_unique<OsContextLinux>(*mock, 0u, 1, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto hwInfo = executionEnvironment.getHardwareInfo();
osContext = std::make_unique<OsContextLinux>(*mock, 0u, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false);
csr = new DrmCommandStreamReceiver<GfxFamily>(executionEnvironment, 0, gemCloseWorkerMode::gemCloseWorkerActive);
ASSERT_NE(nullptr, csr);

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

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

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

@@ -248,7 +248,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(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
OsContextWin osContext(*wddm, 0u, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false);
csr->setupContext(osContext);
@@ -273,7 +273,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(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
OsContextWin osContext(*wddm, 0u, 1, HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false);
csr->setupContext(osContext);

6
opencl/test/unit_test/os_interface/windows/gl/gl_os_sharing_tests.cpp
View File

@@ -332,7 +332,8 @@ TEST_F(GlArbSyncEventOsTest, GivenCallToSignalArbSyncObjectWhenSignalSynchroniza
FailSignalSyncObjectMock::reset();
auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]);
wddm->init();
OsContextWin osContext(*osInterface.get()->getWddm(), 0u, 1, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], preemptionMode, false);
OsContextWin osContext(*osInterface.get()->getWddm(), 0u, 1,
HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[0], preemptionMode, false);
CL_GL_SYNC_INFO syncInfo = {};
syncInfo.serverSynchronizationObject = 0x5cU;
@@ -391,7 +392,8 @@ TEST_F(GlArbSyncEventOsTest, GivenCallToSignalArbSyncObjectWhenSignalSynchroniza
FailSignalSyncObjectMock::reset();
auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]);
wddm->init();
OsContextWin osContext(*osInterface.get()->getWddm(), 0u, 1, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], preemptionMode, false);
OsContextWin osContext(*osInterface.get()->getWddm(), 0u, 1,
HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[0], preemptionMode, false);
CL_GL_SYNC_INFO syncInfo = {};
syncInfo.submissionSynchronizationObject = 0x7cU;

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(*platformDevices[0]);
engineType = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0];
engineType = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[0];
init();
}

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

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

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

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

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

@@ -42,7 +42,7 @@ struct Wddm23TestsWithoutWddmInit : public ::testing::Test, GdiDllFixture {
wddmMockInterface = static_cast<WddmMockInterface23 *>(wddm->wddmInterface.release());
wddm->init();
wddm->wddmInterface.reset(wddmMockInterface);
osContext = std::make_unique<OsContextWin>(*wddm, 0u, 1, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], preemptionMode, false);
osContext = std::make_unique<OsContextWin>(*wddm, 0u, 1, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[0], preemptionMode, false);
}
void TearDown() override {
@@ -74,7 +74,7 @@ TEST_F(Wddm23Tests, whenCreateContextIsCalledThenEnableHwQueues) {
}
TEST_F(Wddm23Tests, givenPreemptionModeWhenCreateHwQueueCalledThenSetGpuTimeoutIfEnabled) {
auto defaultEngine = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0];
auto defaultEngine = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*platformDevices[0])[0];
OsContextWin osContextWithoutPreemption(*osInterface->get()->getWddm(), 0u, 1, defaultEngine, PreemptionMode::Disabled, false);
OsContextWin osContextWithPreemption(*osInterface->get()->getWddm(), 0u, 1, defaultEngine, PreemptionMode::MidBatch, false);

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

@@ -40,7 +40,9 @@ struct WddmFixture : ::testing::Test {
wddm->resetGdi(gdi);
auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]);
wddm->init();
osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1u, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], preemptionMode, false);
auto hwInfo = executionEnvironment->getHardwareInfo();
auto engine = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1u, engine, preemptionMode, false);
mockTemporaryResources = static_cast<MockWddmResidentAllocationsContainer *>(wddm->temporaryResources.get());
}
@@ -71,7 +73,10 @@ struct WddmFixtureWithMockGdiDll : public GdiDllFixture {
wddmMockInterface = static_cast<WddmMockInterface20 *>(wddm->wddmInterface.release());
wddm->init();
wddm->wddmInterface.reset(wddmMockInterface);
osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], preemptionMode, false);
auto hwInfo = executionEnvironment->getHardwareInfo();
auto engine = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
osContext = std::make_unique<OsContextWin>(*osInterface->get()->getWddm(), 0u, 1, engine, preemptionMode, false);
}
void TearDown() override {

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

@@ -351,8 +351,9 @@ TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValuesOnMultipleEnginesRegi
executionEnvironment->rootDeviceEnvironments[1]->osInterface->get()->setWddm(wddm2);
executionEnvironment->rootDeviceEnvironments[1]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm2);
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[1],
2, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto hwInfo = executionEnvironment->getHardwareInfo();
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[1],
2, PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false);
ASSERT_EQ(2u, memoryManager->getRegisteredEnginesCount());
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0, 32, GraphicsAllocation::AllocationType::BUFFER}));
@@ -380,8 +381,9 @@ TEST_F(WddmMemoryManagerSimpleTest, givenNonZeroFenceValueOnSomeOfMultipleEngine
executionEnvironment->rootDeviceEnvironments[1]->osInterface->get()->setWddm(wddm2);
executionEnvironment->rootDeviceEnvironments[1]->memoryOperationsInterface = std::make_unique<WddmMemoryOperationsHandler>(wddm2);
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[1],
2, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto hwInfo = executionEnvironment->getHardwareInfo();
memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[1],
2, PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false);
ASSERT_EQ(2u, memoryManager->getRegisteredEnginesCount());
auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties({0, 32, GraphicsAllocation::AllocationType::BUFFER}));

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

@@ -62,8 +62,10 @@ class MockWddmMemoryManagerFixture {
memoryManager = std::make_unique<MockWddmMemoryManager>(*executionEnvironment);
csr.reset(createCommandStream(*executionEnvironment, 0u));
osContext = memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto hwInfo = executionEnvironment->getHardwareInfo();
osContext = memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
1, PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false);
osContext->incRefInternal();
mockTemporaryResources = reinterpret_cast<MockWddmResidentAllocationsContainer *>(wddm->getTemporaryResourcesContainer());
@@ -113,7 +115,9 @@ class WddmMemoryManagerFixtureWithGmockWddm : public ExecutionEnvironmentFixture
//assert we have memory manager
ASSERT_NE(nullptr, memoryManager);
csr.reset(createCommandStream(*executionEnvironment, 0u));
osContext = memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], 1, preemptionMode, false);
auto hwInfo = executionEnvironment->getHardwareInfo();
osContext = memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0], 1, preemptionMode, false);
osContext->incRefInternal();

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

@@ -127,7 +127,9 @@ struct WddmResidencyControllerWithMockWddmTest : public WddmResidencyControllerT
memoryManager = std::make_unique<MockWddmMemoryManager>(*executionEnvironment);
csr.reset(createCommandStream(*executionEnvironment, 0u));
osContext = memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], 1, preemptionMode, false);
auto hwInfo = executionEnvironment->getHardwareInfo();
osContext = memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0], 1, preemptionMode, false);
osContext->incRefInternal();
residencyController = &static_cast<OsContextWin *>(osContext)->getResidencyController();
@@ -162,8 +164,10 @@ struct WddmResidencyControllerWithGdiAndMemoryManagerTest : ::testing::Test {
memoryManager = std::make_unique<MockWddmMemoryManager>(*executionEnvironment);
csr.reset(createCommandStream(*executionEnvironment, 0u));
osContext = memoryManager->createAndRegisterOsContext(csr.get(), HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
1, PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
auto hwInfo = executionEnvironment->getHardwareInfo();
osContext = memoryManager->createAndRegisterOsContext(csr.get(),
HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0],
1, PreemptionHelper::getDefaultPreemptionMode(*hwInfo), false);
osContext->incRefInternal();

132
opencl/test/unit_test/profiling/profiling_tests.cpp
View File

@@ -522,22 +522,36 @@ TEST(EventProfilingTest, givenRawTimestampsDebugModeWhenDataIsQueriedThenRawData
event.timeStampNode = nullptr;
}
struct ProfilingWithPerfCountersTests : public ProfilingTests,
public PerformanceCountersFixture {
struct ProfilingWithPerfCountersTests : public PerformanceCountersFixture, ::testing::Test {
void SetUp() override {
PerformanceCountersFixture::SetUp();
ProfilingTests::SetUp();
createPerfCounters();
HardwareInfo hwInfo = *platformDevices[0];
if (hwInfo.capabilityTable.defaultEngineType == aub_stream::EngineType::ENGINE_CCS) {
hwInfo.featureTable.ftrCCSNode = true;
}
pDevice = MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0);
pClDevice = std::make_unique<ClDevice>(*pDevice, nullptr);
pDevice->setPerfCounters(performanceCountersBase.release());
context = std::make_unique<MockContext>(pClDevice.get());
cl_int retVal = CL_SUCCESS;
cl_queue_properties properties[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
pCmdQ.reset(CommandQueue::create(context.get(), pClDevice.get(), properties, false, retVal));
kernel = std::make_unique<MockKernelWithInternals>(*pClDevice);
}
void TearDown() override {
ProfilingTests::TearDown();
PerformanceCountersFixture::TearDown();
}
template <typename GfxFamily>
GenCmdList::iterator expectStoreRegister(GenCmdList::iterator itor, uint64_t memoryAddress, uint32_t registerAddress) {
GenCmdList::iterator expectStoreRegister(const GenCmdList &cmdList, GenCmdList::iterator itor, uint64_t memoryAddress, uint32_t registerAddress) {
using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM;
itor = find<MI_STORE_REGISTER_MEM *>(itor, cmdList.end());
@@ -548,6 +562,12 @@ struct ProfilingWithPerfCountersTests : public ProfilingTests,
itor++;
return itor;
}
MockDevice *pDevice = nullptr;
std::unique_ptr<ClDevice> pClDevice;
std::unique_ptr<MockContext> context;
std::unique_ptr<CommandQueue> pCmdQ;
std::unique_ptr<MockKernelWithInternals> kernel;
};
HWTEST_F(ProfilingWithPerfCountersTests,
@@ -582,26 +602,17 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWit
pCmdQ->setPerfCountersEnabled();
MockKernel kernel(program.get(), kernelInfo, *pClDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
size_t globalOffsets[3] = {0, 0, 0};
size_t workItems[3] = {1, 1, 1};
uint32_t dimensions = 1;
cl_event event;
cl_kernel clKernel = &kernel;
cl_kernel clKernel = kernel->mockKernel;
static_cast<CommandQueueHw<FamilyType> *>(pCmdQ)->enqueueKernel(
clKernel,
dimensions,
globalOffsets,
workItems,
nullptr,
0,
nullptr,
&event);
static_cast<CommandQueueHw<FamilyType> *>(pCmdQ.get())->enqueueKernel(clKernel, dimensions, globalOffsets, workItems, nullptr, 0, nullptr, &event);
parseCommands<FamilyType>(*pCmdQ);
HardwareParse parse;
auto &cmdList = parse.cmdList;
parse.parseCommands<FamilyType>(*pCmdQ);
// expect MI_REPORT_PERF_COUNT before WALKER
auto itorBeforeReportPerf = find<MI_REPORT_PERF_COUNT *>(cmdList.begin(), cmdList.end());
@@ -643,26 +654,17 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWit
pCmdQ->setPerfCountersEnabled();
MockKernel kernel(program.get(), kernelInfo, *pClDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
size_t globalOffsets[3] = {0, 0, 0};
size_t workItems[3] = {1, 1, 1};
uint32_t dimensions = 1;
cl_event event;
cl_kernel clKernel = &kernel;
cl_kernel clKernel = kernel->mockKernel;
static_cast<CommandQueueHw<FamilyType> *>(pCmdQ)->enqueueKernel(
clKernel,
dimensions,
globalOffsets,
workItems,
nullptr,
0,
nullptr,
&event);
static_cast<CommandQueueHw<FamilyType> *>(pCmdQ.get())->enqueueKernel(clKernel, dimensions, globalOffsets, workItems, nullptr, 0, nullptr, &event);
parseCommands<FamilyType>(*pCmdQ);
HardwareParse parse;
auto &cmdList = parse.cmdList;
parse.parseCommands<FamilyType>(*pCmdQ);
// expect MI_REPORT_PERF_COUNT before WALKER
auto itorBeforeReportPerf = find<MI_REPORT_PERF_COUNT *>(cmdList.begin(), cmdList.end());
@@ -704,30 +706,26 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueBlo
pCmdQ->setPerfCountersEnabled();
MockKernel kernel(program.get(), kernelInfo, *pClDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
size_t globalOffsets[3] = {0, 0, 0};
size_t workItems[3] = {1, 1, 1};
uint32_t dimensions = 1;
cl_event event;
cl_event ue = new UserEvent();
static_cast<CommandQueueHw<FamilyType> *>(pCmdQ)->enqueueKernel(
&kernel,
dimensions,
globalOffsets,
workItems,
nullptr,
1, // one user event to block queue
&ue, // user event not signaled
&event);
cl_kernel clKernel = kernel->mockKernel;
static_cast<CommandQueueHw<FamilyType> *>(pCmdQ.get())->enqueueKernel(clKernel, dimensions, globalOffsets, workItems, nullptr,
1, // one user event to block queue
&ue, // user event not signaled
&event);
//rseCommands<FamilyType>(*pCmdQ);
ASSERT_NE(nullptr, pCmdQ->virtualEvent);
ASSERT_NE(nullptr, pCmdQ->virtualEvent->peekCommand());
NEO::LinearStream *eventCommandStream = pCmdQ->virtualEvent->peekCommand()->getCommandStream();
ASSERT_NE(nullptr, eventCommandStream);
parseCommands<FamilyType>(*eventCommandStream);
HardwareParse parse;
auto &cmdList = parse.cmdList;
parse.parseCommands<FamilyType>(*eventCommandStream);
// expect MI_REPORT_PERF_COUNT before WALKER
auto itorBeforeReportPerf = find<MI_REPORT_PERF_COUNT *>(cmdList.begin(), cmdList.end());
@@ -768,25 +766,16 @@ HWTEST_F(ProfilingWithPerfCountersTests,
pCmdQ->setPerfCountersEnabled();
MockKernel kernel(program.get(), kernelInfo, *pClDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
size_t globalOffsets[3] = {0, 0, 0};
size_t workItems[3] = {1, 1, 1};
uint32_t dimensions = 1;
cl_kernel clKernel = &kernel;
cl_kernel clKernel = kernel->mockKernel;
static_cast<CommandQueueHw<FamilyType> *>(pCmdQ)->enqueueKernel(
clKernel,
dimensions,
globalOffsets,
workItems,
nullptr,
0,
nullptr,
nullptr);
static_cast<CommandQueueHw<FamilyType> *>(pCmdQ.get())->enqueueKernel(clKernel, dimensions, globalOffsets, workItems, nullptr, 0, nullptr, nullptr);
parseCommands<FamilyType>(*pCmdQ);
HardwareParse parse;
auto &cmdList = parse.cmdList;
parse.parseCommands<FamilyType>(*pCmdQ);
// expect no MI_REPORT_PERF_COUNT before WALKER
auto itorBeforeReportPerf = find<MI_REPORT_PERF_COUNT *>(cmdList.begin(), cmdList.end());
@@ -842,34 +831,25 @@ HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCount
pCmdQ->setPerfCountersEnabled();
MockKernel kernel(program.get(), kernelInfo, *pClDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
size_t globalOffsets[3] = {0, 0, 0};
size_t workItems[3] = {1, 1, 1};
uint32_t dimensions = 1;
cl_event event;
cl_kernel clKernel = &kernel;
cl_kernel clKernel = kernel->mockKernel;
static_cast<CommandQueueHw<FamilyType> *>(pCmdQ)->enqueueKernel(
clKernel,
dimensions,
globalOffsets,
workItems,
nullptr,
0,
nullptr,
&event);
static_cast<CommandQueueHw<FamilyType> *>(pCmdQ.get())->enqueueKernel(clKernel, dimensions, globalOffsets, workItems, nullptr, 0, nullptr, &event);
auto pEvent = static_cast<MockEvent<Event> *>(event);
EXPECT_EQ(pEvent->getHwTimeStampNode()->getGpuAddress(), timeStampGpuAddress);
EXPECT_EQ(pEvent->getHwPerfCounterNode()->getGpuAddress(), perfCountersGpuAddress);
parseCommands<FamilyType>(*pCmdQ);
HardwareParse parse;
auto &cmdList = parse.cmdList;
parse.parseCommands<FamilyType>(*pCmdQ);
auto itor = expectStoreRegister<FamilyType>(cmdList.begin(), timeStampGpuAddress + offsetof(HwTimeStamps, ContextStartTS), GP_THREAD_TIME_REG_ADDRESS_OFFSET_LOW);
auto itor = expectStoreRegister<FamilyType>(cmdList, cmdList.begin(), timeStampGpuAddress + offsetof(HwTimeStamps, ContextStartTS), GP_THREAD_TIME_REG_ADDRESS_OFFSET_LOW);
// after WALKER:
itor = expectStoreRegister<FamilyType>(itor, timeStampGpuAddress + offsetof(HwTimeStamps, ContextEndTS), GP_THREAD_TIME_REG_ADDRESS_OFFSET_LOW);
itor = expectStoreRegister<FamilyType>(cmdList, itor, timeStampGpuAddress + offsetof(HwTimeStamps, ContextEndTS), GP_THREAD_TIME_REG_ADDRESS_OFFSET_LOW);
EXPECT_TRUE(pEvent->calcProfilingData());

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

@@ -93,7 +93,7 @@ bool Device::createDeviceImpl() {
bool Device::createEngines() {
auto &hwInfo = getHardwareInfo();
auto &gpgpuEngines = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances();
auto gpgpuEngines = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(hwInfo);
for (uint32_t deviceCsrIndex = 0; deviceCsrIndex < gpgpuEngines.size(); deviceCsrIndex++) {
if (!createEngine(deviceCsrIndex, gpgpuEngines[deviceCsrIndex])) {
@@ -117,9 +117,6 @@ bool Device::createEngine(uint32_t deviceCsrIndex, aub_stream::EngineType engine
}
bool internalUsage = (deviceCsrIndex == HwHelper::internalUsageEngineIndex);
if (internalUsage) {
engineType = defaultEngineType;
}
if (commandStreamReceiver->needsPageTableManager(engineType)) {
commandStreamReceiver->createPageTableManager();

7
shared/source/execution_environment/execution_environment.cpp
View File

@@ -73,9 +73,10 @@ void ExecutionEnvironment::initDebugger() {
void ExecutionEnvironment::calculateMaxOsContextCount() {
for (const auto &rootDeviceEnvironment : this->rootDeviceEnvironments) {
auto &hwHelper = HwHelper::get(rootDeviceEnvironment->getHardwareInfo()->platform.eRenderCoreFamily);
auto osContextCount = hwHelper.getGpgpuEngineInstances().size();
auto subDevicesCount = HwHelper::getSubDevicesCount(rootDeviceEnvironment->getHardwareInfo());
auto hwInfo = rootDeviceEnvironment->getHardwareInfo();
auto &hwHelper = HwHelper::get(hwInfo->platform.eRenderCoreFamily);
auto osContextCount = hwHelper.getGpgpuEngineInstances(*hwInfo).size();
auto subDevicesCount = HwHelper::getSubDevicesCount(hwInfo);
bool hasRootCsr = subDevicesCount > 1;
MemoryManager::maxOsContextCount += static_cast<uint32_t>(osContextCount * subDevicesCount + hasRootCsr);

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

@@ -26,6 +26,7 @@ class GmmHelper;
class HwHelper {
public:
using EngineInstancesContainer = StackVec<aub_stream::EngineType, 32>;
static HwHelper &get(GFXCORE_FAMILY gfxCore);
virtual uint32_t getBindingTableStateSurfaceStatePointer(const void *pBindingTable, uint32_t index) = 0;
virtual size_t getBindingTableStateSize() const = 0;
@@ -61,7 +62,7 @@ class HwHelper {
bool isReadOnly,
uint32_t surfaceType,
bool forceNonAuxMode) = 0;
virtual const std::vector<aub_stream::EngineType> getGpgpuEngineInstances() const = 0;
virtual const EngineInstancesContainer getGpgpuEngineInstances(const HardwareInfo &hwInfo) const = 0;
virtual const StackVec<size_t, 3> getDeviceSubGroupSizes() const = 0;
virtual bool getEnableLocalMemory(const HardwareInfo &hwInfo) const = 0;
virtual std::string getExtensions() const = 0;
@@ -171,7 +172,7 @@ class HwHelperHw : public HwHelper {
uint32_t surfaceType,
bool forceNonAuxMode) override;
const std::vector<aub_stream::EngineType> getGpgpuEngineInstances() const override;
const EngineInstancesContainer getGpgpuEngineInstances(const HardwareInfo &hwInfo) const override;
const StackVec<size_t, 3> getDeviceSubGroupSizes() const override;

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

@@ -41,11 +41,10 @@ bool HwHelperHw<GfxFamily>::timestampPacketWriteSupported() const {
}
template <typename GfxFamily>
const std::vector<aub_stream::EngineType> HwHelperHw<GfxFamily>::getGpgpuEngineInstances() const {
constexpr std::array<aub_stream::EngineType, 3> gpgpuEngineInstances = {{aub_stream::ENGINE_RCS,
aub_stream::ENGINE_RCS, // low priority
aub_stream::ENGINE_RCS}}; // internal usage
return std::vector<aub_stream::EngineType>(gpgpuEngineInstances.begin(), gpgpuEngineInstances.end());
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
}
template <typename GfxFamily>

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

@@ -41,7 +41,9 @@ class WddmPreemptionTests : public Test<WddmFixtureWithMockGdiDll> {
regReader->forceRetValue = forceReturnPreemptionRegKeyValue;
auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(hwInfoTest);
wddm->init();
osContext = std::make_unique<OsContextWin>(*wddm, 0u, 1, HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0], preemptionMode, false);
auto hwInfo = executionEnvironment->getHardwareInfo();
auto engine = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo)[0];
osContext = std::make_unique<OsContextWin>(*wddm, 0u, 1, engine, preemptionMode, false);
}
DebugManagerStateRestore *dbgRestorer = nullptr;

3
shared/test/unit_test/preemption/preemption_tests.cpp
View File

@@ -539,7 +539,8 @@ HWTEST_F(MidThreadPreemptionTests, givenMidThreadPreemptionWhenFailingOnCsrSurfa
FailingMemoryManager(ExecutionEnvironment &executionEnvironment) : OsAgnosticMemoryManager(executionEnvironment) {}
GraphicsAllocation *allocateGraphicsMemoryWithAlignment(const AllocationData &allocationData) override {
if (++allocateGraphicsMemoryCount > HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances().size() - 1) {
auto hwInfo = executionEnvironment.getHardwareInfo();
if (++allocateGraphicsMemoryCount > HwHelper::get(hwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*hwInfo).size() - 1) {
return nullptr;
}
return OsAgnosticMemoryManager::allocateGraphicsMemoryWithAlignment(allocationData);