From 2403212dcd26e7d10a60aee89adf02f7058c117a Mon Sep 17 00:00:00 2001 From: John Falkowski Date: Mon, 14 Aug 2023 16:31:23 +0000 Subject: [PATCH] fix: chunking prefetch add USER_FENCE Add USER_FENCE before PREFETCH call and after the BIND Related-To: NEO-8098 Signed-off by: Jaime Arteaga Signed-off-by: John Falkowski --- .../source/cmdlist/cmdlist_hw_immediate.inl | 3 +- .../core/source/cmdqueue/cmdqueue_hw.inl | 3 +- .../sources/cmdlist/test_cmdlist_6.cpp | 48 +++++++++++++ .../xe_hpc_core/test_cmdlist_xe_hpc_core.cpp | 72 +++++++++++++++++++ .../debug_settings/debug_variables_base.inl | 1 + .../memory_manager/unified_memory_manager.cpp | 15 +++- .../os_interface/linux/drm_allocation.cpp | 6 +- .../os_interface/linux/drm_allocation.h | 2 +- .../drm_memory_operations_handler_bind.cpp | 6 -- shared/test/common/test_files/igdrcl.config | 1 + .../unified_memory_manager_tests.cpp | 28 ++++++++ .../linux/drm_with_prelim_tests.cpp | 30 ++++++++ 12 files changed, 203 insertions(+), 12 deletions(-) diff --git a/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl b/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl index 5b8aa86ede..67f2ef2331 100644 --- a/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl +++ b/level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl @@ -328,7 +328,8 @@ inline ze_result_t CommandListCoreFamilyImmediate::executeCommand auto csr = static_cast(cmdQ)->getCsr(); auto lockCSR = csr->obtainUniqueOwnership(); - if (NEO::DebugManager.flags.ForceMemoryPrefetchForKmdMigratedSharedAllocations.get()) { + if (NEO::DebugManager.flags.ForceMemoryPrefetchForKmdMigratedSharedAllocations.get() || + NEO::DebugManager.flags.EnableBOChunkingPrefetch.get()) { auto svmAllocMgr = this->device->getDriverHandle()->getSvmAllocsManager(); svmAllocMgr->prefetchSVMAllocs(*this->device->getNEODevice(), *csr); } diff --git a/level_zero/core/source/cmdqueue/cmdqueue_hw.inl b/level_zero/core/source/cmdqueue/cmdqueue_hw.inl index 738424ff78..b6a2ac18cd 100644 --- a/level_zero/core/source/cmdqueue/cmdqueue_hw.inl +++ b/level_zero/core/source/cmdqueue/cmdqueue_hw.inl @@ -67,7 +67,8 @@ ze_result_t CommandQueueHw::executeCommandLists( auto lockCSR = this->csr->obtainUniqueOwnership(); - if (NEO::DebugManager.flags.ForceMemoryPrefetchForKmdMigratedSharedAllocations.get()) { + if (NEO::DebugManager.flags.ForceMemoryPrefetchForKmdMigratedSharedAllocations.get() || + NEO::DebugManager.flags.EnableBOChunkingPrefetch.get() == 1) { auto svmAllocMgr = device->getDriverHandle()->getSvmAllocsManager(); svmAllocMgr->prefetchSVMAllocs(*device->getNEODevice(), *csr); } diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_6.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_6.cpp index f321034dc0..3456c471af 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_6.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_6.cpp @@ -133,6 +133,54 @@ HWTEST2_F(CommandListExecuteImmediate, whenExecutingCommandListImmediateWithFlus HWTEST2_F(CommandListExecuteImmediate, whenExecutingCommandListImmediateWithFlushTaskThenContainsAnyKernelFlagIsReset, IsAtLeastSkl) { std::unique_ptr commandList; + DebugManagerStateRestore restorer; + DebugManager.flags.ForceMemoryPrefetchForKmdMigratedSharedAllocations.set(true); + DebugManager.flags.EnableBOChunkingPrefetch.set(true); + const ze_command_queue_desc_t desc = {}; + ze_result_t returnValue; + commandList.reset(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::RenderCompute, returnValue)); + auto &commandListImmediate = static_cast &>(*commandList); + + commandListImmediate.containsAnyKernel = true; + commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false); + EXPECT_FALSE(commandListImmediate.containsAnyKernel); +} + +HWTEST2_F(CommandListExecuteImmediate, whenExecutingCommandListImmediateWithFlushTaskThenContainsAnyKernelFlagIsReset2, IsAtLeastSkl) { + std::unique_ptr commandList; + DebugManagerStateRestore restorer; + DebugManager.flags.ForceMemoryPrefetchForKmdMigratedSharedAllocations.set(true); + DebugManager.flags.EnableBOChunkingPrefetch.set(false); + const ze_command_queue_desc_t desc = {}; + ze_result_t returnValue; + commandList.reset(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::RenderCompute, returnValue)); + auto &commandListImmediate = static_cast &>(*commandList); + + commandListImmediate.containsAnyKernel = true; + commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false); + EXPECT_FALSE(commandListImmediate.containsAnyKernel); +} + +HWTEST2_F(CommandListExecuteImmediate, whenExecutingCommandListImmediateWithFlushTaskThenContainsAnyKernelFlagIsReset3, IsAtLeastSkl) { + std::unique_ptr commandList; + DebugManagerStateRestore restorer; + DebugManager.flags.ForceMemoryPrefetchForKmdMigratedSharedAllocations.set(false); + DebugManager.flags.EnableBOChunkingPrefetch.set(true); + const ze_command_queue_desc_t desc = {}; + ze_result_t returnValue; + commandList.reset(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::RenderCompute, returnValue)); + auto &commandListImmediate = static_cast &>(*commandList); + + commandListImmediate.containsAnyKernel = true; + commandListImmediate.executeCommandListImmediateWithFlushTask(false, false, false); + EXPECT_FALSE(commandListImmediate.containsAnyKernel); +} + +HWTEST2_F(CommandListExecuteImmediate, whenExecutingCommandListImmediateWithFlushTaskThenContainsAnyKernelFlagIsReset4, IsAtLeastSkl) { + std::unique_ptr commandList; + DebugManagerStateRestore restorer; + DebugManager.flags.ForceMemoryPrefetchForKmdMigratedSharedAllocations.set(false); + DebugManager.flags.EnableBOChunkingPrefetch.set(false); const ze_command_queue_desc_t desc = {}; ze_result_t returnValue; commandList.reset(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::RenderCompute, returnValue)); diff --git a/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdlist_xe_hpc_core.cpp b/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdlist_xe_hpc_core.cpp index 2474df6f93..2afbb44843 100644 --- a/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdlist_xe_hpc_core.cpp +++ b/level_zero/core/test/unit_tests/xe_hpc_core/test_cmdlist_xe_hpc_core.cpp @@ -120,6 +120,78 @@ HWTEST2_F(CommandListStatePrefetchXeHpcCore, givenForceMemoryPrefetchForKmdMigra DebugManagerStateRestore restore; DebugManager.flags.UseKmdMigration.set(true); DebugManager.flags.ForceMemoryPrefetchForKmdMigratedSharedAllocations.set(true); + DebugManager.flags.EnableBOChunkingPrefetch.set(false); + + size_t size = 10; + size_t alignment = 1u; + void *ptr = nullptr; + + ze_device_mem_alloc_desc_t deviceDesc = {}; + ze_host_mem_alloc_desc_t hostDesc = {}; + auto result = context->allocSharedMem(device->toHandle(), &deviceDesc, &hostDesc, size, alignment, &ptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_NE(nullptr, ptr); + + ze_result_t returnValue; + ze_command_queue_desc_t queueDesc = {}; + + ze_command_list_handle_t commandListHandle = CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)->toHandle(); + auto commandList = CommandList::fromHandle(commandListHandle); + commandList->close(); + + auto commandQueue = CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, false, returnValue); + + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + auto mockMemoryManager = reinterpret_cast(neoDevice->getMemoryManager()); + EXPECT_TRUE(mockMemoryManager->setMemPrefetchCalled); + + context->freeMem(ptr); + commandList->destroy(); + commandQueue->destroy(); +} + +HWTEST2_F(CommandListStatePrefetchXeHpcCore, givenNoForceMemoryPrefetchForKmdMigratedSharedAllocationsAndNoEnableBOChunkingPrefetchWhenExecutingCommandListsOnCommandQueueThenMemoryPrefetchIsNotCalled, IsXeHpcCore) { + DebugManagerStateRestore restore; + DebugManager.flags.UseKmdMigration.set(true); + DebugManager.flags.ForceMemoryPrefetchForKmdMigratedSharedAllocations.set(false); + DebugManager.flags.EnableBOChunkingPrefetch.set(false); + + size_t size = 10; + size_t alignment = 1u; + void *ptr = nullptr; + + ze_device_mem_alloc_desc_t deviceDesc = {}; + ze_host_mem_alloc_desc_t hostDesc = {}; + auto result = context->allocSharedMem(device->toHandle(), &deviceDesc, &hostDesc, size, alignment, &ptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_NE(nullptr, ptr); + + ze_result_t returnValue; + ze_command_queue_desc_t queueDesc = {}; + + ze_command_list_handle_t commandListHandle = CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)->toHandle(); + auto commandList = CommandList::fromHandle(commandListHandle); + commandList->close(); + + auto commandQueue = CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, false, returnValue); + + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, true); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + auto mockMemoryManager = reinterpret_cast(neoDevice->getMemoryManager()); + EXPECT_FALSE(mockMemoryManager->setMemPrefetchCalled); + + context->freeMem(ptr); + commandList->destroy(); + commandQueue->destroy(); +} + +HWTEST2_F(CommandListStatePrefetchXeHpcCore, givenEnableBOChunkingPrefetchWhenExecutingCommandListsOnCommandQueueThenMemoryPrefetchIsCalled, IsXeHpcCore) { + DebugManagerStateRestore restore; + DebugManager.flags.UseKmdMigration.set(true); + DebugManager.flags.EnableBOChunkingPrefetch.set(true); size_t size = 10; size_t alignment = 1u; diff --git a/shared/source/debug_settings/debug_variables_base.inl b/shared/source/debug_settings/debug_variables_base.inl index ae8f5f0445..c59606015d 100644 --- a/shared/source/debug_settings/debug_variables_base.inl +++ b/shared/source/debug_settings/debug_variables_base.inl @@ -513,6 +513,7 @@ DECLARE_DEBUG_VARIABLE(bool, EnableConcurrentSharedCrossP2PDeviceAccess, false, DECLARE_DEBUG_VARIABLE(bool, AllocateSharedAllocationsInHeapExtendedHost, true, "When enabled driver can allocate shared unified memory allocation in heap extended host. (0 - disable, 1 - enable)") DECLARE_DEBUG_VARIABLE(bool, AllocateHostAllocationsInHeapExtendedHost, true, "When enabled driver can allocate host unified memory allocation in heap extended host. (0 - disable, 1 - enable)") DECLARE_DEBUG_VARIABLE(bool, PrintBOChunkingLogs, false, "Print some logs on BO chunking") +DECLARE_DEBUG_VARIABLE(bool, EnableBOChunkingPrefetch, false, "Enables prefetching of chunks") DECLARE_DEBUG_VARIABLE(bool, EnableBOChunkingPreferredLocationHint, false, "Enables preferred location advise on chunks") DECLARE_DEBUG_VARIABLE(int32_t, EnableBOChunking, 0, "Enables use of chunking of BOs in the KMD, mask: 0 = no chunking, 1 = shared allocations only, 2 = device allocations only, 3 = shared and device allocations .") DECLARE_DEBUG_VARIABLE(int32_t, NumberOfBOChunks, 2, "Number of chunks to use. Must be a power of two)") diff --git a/shared/source/memory_manager/unified_memory_manager.cpp b/shared/source/memory_manager/unified_memory_manager.cpp index 6531aec187..ba3aa9ab6a 100644 --- a/shared/source/memory_manager/unified_memory_manager.cpp +++ b/shared/source/memory_manager/unified_memory_manager.cpp @@ -800,8 +800,19 @@ void SVMAllocsManager::prefetchMemory(Device &device, CommandStreamReceiver &com return subDeviceIds; }; - if (memoryManager->isKmdMigrationAvailable(device.getRootDeviceIndex()) && - (svmData.memoryType == InternalMemoryType::SHARED_UNIFIED_MEMORY)) { + // Perform prefetch for chunks if EnableBOChunkingPrefetch is 1 + // and if KMD migration is set, as current target is to use + // chunking only with KMD migration + bool isChunkingNeededForDeviceAllocations = false; + if (NEO::DebugManager.flags.EnableBOChunkingPrefetch.get() && + memoryManager->isKmdMigrationAvailable(device.getRootDeviceIndex()) && + (svmData.memoryType == InternalMemoryType::DEVICE_UNIFIED_MEMORY)) { + isChunkingNeededForDeviceAllocations = true; + } + + if ((memoryManager->isKmdMigrationAvailable(device.getRootDeviceIndex()) && + (svmData.memoryType == InternalMemoryType::SHARED_UNIFIED_MEMORY)) || + isChunkingNeededForDeviceAllocations) { auto gfxAllocation = svmData.gpuAllocations.getGraphicsAllocation(device.getRootDeviceIndex()); auto subDeviceIds = commandStreamReceiver.getActivePartitions() > 1 ? getSubDeviceIds(commandStreamReceiver) : SubDeviceIdsVec{getSubDeviceId(device)}; memoryManager->setMemPrefetch(gfxAllocation, subDeviceIds, device.getRootDeviceIndex()); diff --git a/shared/source/os_interface/linux/drm_allocation.cpp b/shared/source/os_interface/linux/drm_allocation.cpp index 209bd946da..ea7ef9edf6 100644 --- a/shared/source/os_interface/linux/drm_allocation.cpp +++ b/shared/source/os_interface/linux/drm_allocation.cpp @@ -182,7 +182,11 @@ bool DrmAllocation::setCacheAdvice(Drm *drm, size_t regionSize, CacheRegion regi return true; } -int DrmAllocation::prefetchBOWithChunking(Drm *drm) { +bool DrmAllocation::prefetchBOWithChunking(Drm *drm) { + if (!(NEO::DebugManager.flags.EnableBOChunkingPrefetch.get())) { + return false; + } + auto getSubDeviceIds = [](const DeviceBitfield &subDeviceBitfield) { SubDeviceIdsVec subDeviceIds; for (auto subDeviceId = 0u; subDeviceId < subDeviceBitfield.size(); subDeviceId++) { diff --git a/shared/source/os_interface/linux/drm_allocation.h b/shared/source/os_interface/linux/drm_allocation.h index f412cd7eb0..902c547296 100644 --- a/shared/source/os_interface/linux/drm_allocation.h +++ b/shared/source/os_interface/linux/drm_allocation.h @@ -124,7 +124,7 @@ class DrmAllocation : public GraphicsAllocation { this->osContext = context; } - int prefetchBOWithChunking(Drm *drm); + bool prefetchBOWithChunking(Drm *drm); MOCKABLE_VIRTUAL int makeBOsResident(OsContext *osContext, uint32_t vmHandleId, std::vector *bufferObjects, bool bind); MOCKABLE_VIRTUAL int bindBO(BufferObject *bo, OsContext *osContext, uint32_t vmHandleId, std::vector *bufferObjects, bool bind); MOCKABLE_VIRTUAL int bindBOs(OsContext *osContext, uint32_t vmHandleId, std::vector *bufferObjects, bool bind); diff --git a/shared/source/os_interface/linux/drm_memory_operations_handler_bind.cpp b/shared/source/os_interface/linux/drm_memory_operations_handler_bind.cpp index 73a78ceca8..562c5a50d5 100644 --- a/shared/source/os_interface/linux/drm_memory_operations_handler_bind.cpp +++ b/shared/source/os_interface/linux/drm_memory_operations_handler_bind.cpp @@ -65,12 +65,6 @@ MemoryOperationsStatus DrmMemoryOperationsHandlerBind::makeResidentWithinOsConte } } - if (bo->isChunked) { - auto memoryManager = static_cast(this->rootDeviceEnvironment.executionEnvironment.memoryManager.get()); - auto drm = &memoryManager->getDrm(drmAllocation->getRootDeviceIndex()); - drmAllocation->prefetchBOWithChunking(drm); - } - if (!evictable) { drmAllocation->updateResidencyTaskCount(GraphicsAllocation::objectAlwaysResident, osContext->getContextId()); } diff --git a/shared/test/common/test_files/igdrcl.config b/shared/test/common/test_files/igdrcl.config index 6d824ef679..6f88b519d6 100644 --- a/shared/test/common/test_files/igdrcl.config +++ b/shared/test/common/test_files/igdrcl.config @@ -519,6 +519,7 @@ OptimizeIoqBarriersHandling = -1 AllocateSharedAllocationsInHeapExtendedHost = 1 AllocateHostAllocationsInHeapExtendedHost = 1 PrintBOChunkingLogs = 0 +EnableBOChunkingPrefetch = 0 EnableBOChunkingPreferredLocationHint = 0 NumberOfBOChunks = 2 EnableBOChunking = 0 diff --git a/shared/test/unit_test/memory_manager/unified_memory_manager_tests.cpp b/shared/test/unit_test/memory_manager/unified_memory_manager_tests.cpp index d2145d1b7d..8be4c97ee3 100644 --- a/shared/test/unit_test/memory_manager/unified_memory_manager_tests.cpp +++ b/shared/test/unit_test/memory_manager/unified_memory_manager_tests.cpp @@ -241,6 +241,34 @@ TEST_F(SVMLocalMemoryAllocatorTest, givenKmdMigratedSharedAllocationWhenPrefetch svmManager->freeSVMAlloc(ptr); } +TEST_F(SVMLocalMemoryAllocatorTest, givenEnableBOChunkingPrefetchWhenPrefetchMemoryIsCalledThenSetMemPrefetchCalled) { + DebugManagerStateRestore restore; + DebugManager.flags.UseKmdMigration.set(1); + DebugManager.flags.EnableBOChunkingPrefetch.set(true); + + std::unique_ptr deviceFactory(new UltDeviceFactory(1, 2)); + auto device = deviceFactory->rootDevices[0]; + auto svmManager = std::make_unique(device->getMemoryManager(), false); + auto csr = std::make_unique(*device->getExecutionEnvironment(), device->getRootDeviceIndex(), device->getDeviceBitfield()); + csr->setupContext(*device->getDefaultEngine().osContext); + + SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::DEVICE_UNIFIED_MEMORY, 1, rootDeviceIndices, deviceBitfields); + unifiedMemoryProperties.device = device; + + auto ptr = svmManager->createUnifiedMemoryAllocation(4096, unifiedMemoryProperties); + EXPECT_NE(nullptr, ptr); + + auto svmData = svmManager->getSVMAlloc(ptr); + + csr->setActivePartitions(2); + svmManager->prefetchMemory(*device, *csr, *svmData); + + auto mockMemoryManager = static_cast(device->getMemoryManager()); + EXPECT_TRUE(mockMemoryManager->setMemPrefetchCalled); + + svmManager->freeSVMAlloc(ptr); +} + TEST_F(SVMLocalMemoryAllocatorTest, givenForceMemoryPrefetchForKmdMigratedSharedAllocationsWhenSVMAllocsIsCalledThenPrefetchSharedUnifiedMemoryInSvmAllocsManager) { DebugManagerStateRestore restore; DebugManager.flags.UseKmdMigration.set(1); diff --git a/shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp index 2aa1993259..e5f126ad7f 100644 --- a/shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp @@ -464,6 +464,7 @@ TEST_F(IoctlHelperPrelimFixture, SubDeviceIdsVec subDeviceIds{0, 1}; DebugManagerStateRestore restore; DebugManager.flags.EnableBOChunking.set(1); + DebugManager.flags.EnableBOChunkingPrefetch.set(true); DebugManager.flags.EnableBOChunkingPreferredLocationHint.set(true); std::vector memRegions{ @@ -492,6 +493,7 @@ TEST_F(IoctlHelperPrelimFixture, SubDeviceIdsVec subDeviceIds{0, 1}; DebugManagerStateRestore restore; DebugManager.flags.EnableBOChunking.set(1); + DebugManager.flags.EnableBOChunkingPrefetch.set(true); DebugManager.flags.EnableBOChunkingPreferredLocationHint.set(true); std::vector memRegions{ @@ -516,6 +518,34 @@ TEST_F(IoctlHelperPrelimFixture, EXPECT_FALSE(allocation.setMemPrefetch(drm.get(), subDeviceIds)); } +TEST_F(IoctlHelperPrelimFixture, + givenDrmAllocationWithChunkingAndsetMemPrefetchWithEnableBOChunkingPrefetchUnsetThenFailureReturned) { + SubDeviceIdsVec subDeviceIds{0, 1}; + DebugManagerStateRestore restore; + DebugManager.flags.EnableBOChunking.set(1); + DebugManager.flags.EnableBOChunkingPreferredLocationHint.set(true); + + std::vector memRegions{ + {{drm_i915_gem_memory_class::I915_MEMORY_CLASS_SYSTEM, 0}, MemoryConstants::chunkThreshold * 4, 0}, + {{drm_i915_gem_memory_class::I915_MEMORY_CLASS_DEVICE, 0}, MemoryConstants::chunkThreshold * 4, 0}, + {{drm_i915_gem_memory_class::I915_MEMORY_CLASS_DEVICE, 1}, MemoryConstants::chunkThreshold * 4, 0}, + {{drm_i915_gem_memory_class::I915_MEMORY_CLASS_DEVICE, 2}, MemoryConstants::chunkThreshold * 4, 0}}; + drm->memoryInfo.reset(new MemoryInfo(memRegions, *drm)); + + drm->ioctlCallsCount = 0; + MockBufferObject bo(0u, drm.get(), 3, 0, 0, 1); + bo.isChunked = 1; + bo.setSize(1024); + MockDrmAllocation allocation(0u, AllocationType::BUFFER, MemoryPool::LocalMemory); + allocation.bufferObjects[0] = &bo; + allocation.storageInfo.memoryBanks = 0x5; + allocation.setNumHandles(1); + allocation.storageInfo.isChunked = 1; + allocation.storageInfo.numOfChunks = 4; + allocation.storageInfo.subDeviceBitfield = 0b0001; + EXPECT_FALSE(allocation.setMemPrefetch(drm.get(), subDeviceIds)); +} + TEST_F(IoctlHelperPrelimFixture, givenVariousDirectSubmissionFlagSettingWhenCreateDrmContextIsCalledThenCorrectFlagsArePassedToIoctl) { DebugManagerStateRestore stateRestore; uint32_t vmId = 0u;