diff --git a/runtime/command_queue/dispatch_walker_helper.h b/runtime/command_queue/dispatch_walker_helper.h index 0a57299711..c1433797b1 100644 --- a/runtime/command_queue/dispatch_walker_helper.h +++ b/runtime/command_queue/dispatch_walker_helper.h @@ -24,6 +24,8 @@ namespace OCLRT { +#define NUM_ALU_INST_FOR_READ_MODIFY_WRITE 4 + #define L3SQC_BIT_LQSC_RO_PERF_DIS 0x08000000 #define L3SQC_REG4 0xB118 @@ -32,4 +34,4 @@ void applyWADisableLSQCROPERFforOCL(OCLRT::LinearStream *pCommandStream, const K template size_t getSizeForWADisableLSQCROPERFforOCL(const Kernel *pKernel); -} +} // namespace OCLRT diff --git a/runtime/command_queue/dispatch_walker_helper.inl b/runtime/command_queue/dispatch_walker_helper.inl index 2857aa6e07..b1209e226a 100644 --- a/runtime/command_queue/dispatch_walker_helper.inl +++ b/runtime/command_queue/dispatch_walker_helper.inl @@ -25,7 +25,6 @@ namespace OCLRT { #define CS_GPR_R0 0x2600 #define CS_GPR_R1 0x2608 -#define NUM_ALU_INST_FOR_READ_MODIFY_WRITE 4 #define ALU_OPCODE_LOAD 0x080 #define ALU_OPCODE_STORE 0x180 #define ALU_OPCODE_OR 0x103 diff --git a/runtime/command_queue/enqueue_common.h b/runtime/command_queue/enqueue_common.h index f49795a0f2..8f6f1a59c6 100644 --- a/runtime/command_queue/enqueue_common.h +++ b/runtime/command_queue/enqueue_common.h @@ -324,19 +324,23 @@ void CommandQueueHw::enqueueHandler(Surface **surfacesForResidency, eventBuilder.getEvent()->flushStamp->replaceStampObject(this->flushStamp->getStampReference()); } - if (executionModelKernel && devQueueHw->getSchedulerReturnInstance() > 0) { - waitUntilComplete(completionStamp.taskCount, completionStamp.flushStamp); + if (executionModelKernel) { + commandStreamReceiver.overrideMediaVFEStateDirty(true); - BuiltinKernelsSimulation::SchedulerSimulation simulation; - simulation.runSchedulerSimulation(devQueueHw->getQueueBuffer(), - devQueueHw->getStackBuffer(), - devQueueHw->getEventPoolBuffer(), - devQueueHw->getSlbBuffer(), - devQueueHw->getDshBuffer(), - multiDispatchInfo.begin()->getKernel()->getKernelReflectionSurface(), - devQueueHw->getQueueStorageBuffer(), - this->getIndirectHeap(IndirectHeap::SURFACE_STATE).getGraphicsAllocation(), - devQueueHw->getDebugQueue()); + if (devQueueHw->getSchedulerReturnInstance() > 0) { + waitUntilComplete(completionStamp.taskCount, completionStamp.flushStamp); + + BuiltinKernelsSimulation::SchedulerSimulation simulation; + simulation.runSchedulerSimulation(devQueueHw->getQueueBuffer(), + devQueueHw->getStackBuffer(), + devQueueHw->getEventPoolBuffer(), + devQueueHw->getSlbBuffer(), + devQueueHw->getDshBuffer(), + multiDispatchInfo.begin()->getKernel()->getKernelReflectionSurface(), + devQueueHw->getQueueStorageBuffer(), + this->getIndirectHeap(IndirectHeap::SURFACE_STATE).getGraphicsAllocation(), + devQueueHw->getDebugQueue()); + } } } else { auto maxTaskCount = this->taskCount; diff --git a/runtime/device_queue/device_queue_hw.h b/runtime/device_queue/device_queue_hw.h index 1d7e6392f3..23ca5a64ef 100644 --- a/runtime/device_queue/device_queue_hw.h +++ b/runtime/device_queue/device_queue_hw.h @@ -44,6 +44,11 @@ class DeviceQueueHw : public DeviceQueue { using BINDING_TABLE_STATE = typename GfxFamily::BINDING_TABLE_STATE; using RENDER_SURFACE_STATE = typename GfxFamily::RENDER_SURFACE_STATE; using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM; + using MI_LOAD_REGISTER_REG = typename GfxFamily::MI_LOAD_REGISTER_REG; + using MI_LOAD_REGISTER_IMM = typename GfxFamily::MI_LOAD_REGISTER_IMM; + using MI_MATH = typename GfxFamily::MI_MATH; + using MI_MATH_ALU_INST_INLINE = typename GfxFamily::MI_MATH_ALU_INST_INLINE; + using MEDIA_VFE_STATE = typename GfxFamily::MEDIA_VFE_STATE; public: DeviceQueueHw(Context *context, @@ -92,6 +97,12 @@ class DeviceQueueHw : public DeviceQueue { void buildSlbDummyCommands(); void addProfilingEndCmds(uint64_t timestampAddress); + static size_t getProfilingEndCmdsSize(); + + MOCKABLE_VIRTUAL void addMediaStateClearCmds(); + static size_t getMediaStateClearCmdsSize(); + + static size_t getExecutionModelCleanupSectionSize(); LinearStream slbCS; IGIL_CommandQueue *igilQueue = nullptr; diff --git a/runtime/device_queue/device_queue_hw.inl b/runtime/device_queue/device_queue_hw.inl index b5af5ffe97..24fe89a4d2 100644 --- a/runtime/device_queue/device_queue_hw.inl +++ b/runtime/device_queue/device_queue_hw.inl @@ -25,6 +25,7 @@ #include "runtime/command_queue/dispatch_walker.h" #include "runtime/command_queue/dispatch_walker_helper.h" #include "runtime/helpers/kernel_commands.h" +#include "runtime/helpers/preamble.h" #include "runtime/helpers/string.h" #include "runtime/memory_manager/memory_manager.h" @@ -33,8 +34,10 @@ template void DeviceQueueHw::allocateSlbBuffer() { auto slbSize = getMinimumSlbSize() + getWaCommandsSize(); slbSize *= 128; //num of enqueues - slbSize += sizeof(MI_BATCH_BUFFER_START) + - (4 * MemoryConstants::pageSize); // +4 pages spec restriction + slbSize += sizeof(MI_BATCH_BUFFER_START); + slbSize = alignUp(slbSize, MemoryConstants::pageSize); + slbSize += DeviceQueueHw::getExecutionModelCleanupSectionSize(); + slbSize += (4 * MemoryConstants::pageSize); // +4 pages spec restriction slbSize = alignUp(slbSize, MemoryConstants::pageSize); slbBuffer = device->getMemoryManager()->allocateGraphicsMemory(slbSize); @@ -253,6 +256,8 @@ void DeviceQueueHw::addExecutionModelCleanUpSection(Kernel *parentKer pipeControl2->setAddress(tagAddress & (0xffffffff)); pipeControl2->setImmediateData(taskCount); + addMediaStateClearCmds(); + auto pBBE = slbCS.getSpaceForCmd(); *pBBE = MI_BATCH_BUFFER_END::sInit(); @@ -404,4 +409,55 @@ void DeviceQueueHw::addLriCmd(bool setArbCheck) { lri->setDataDword(0x0); } +template +void DeviceQueueHw::addMediaStateClearCmds() { + typedef typename GfxFamily::MEDIA_VFE_STATE MEDIA_VFE_STATE; + + addPipeControlCmdWa(); + + auto pipeControl = slbCS.getSpaceForCmd(); + *pipeControl = PIPE_CONTROL::sInit(); + pipeControl->setGenericMediaStateClear(true); + pipeControl->setCommandStreamerStallEnable(true); + + PreambleHelper::programVFEState(&slbCS, device->getHardwareInfo(), 0, 0); +} + +template +size_t DeviceQueueHw::getMediaStateClearCmdsSize() { + // PC with GenreicMediaStateClear + WA PC + size_t size = 2 * sizeof(PIPE_CONTROL); + + // VFE state cmds + size += sizeof(PIPE_CONTROL); + size += sizeof(MEDIA_VFE_STATE); + return size; +} + +template +size_t DeviceQueueHw::getExecutionModelCleanupSectionSize() { + size_t totalSize = 0; + totalSize += sizeof(PIPE_CONTROL) + + 2 * sizeof(MI_LOAD_REGISTER_REG) + + sizeof(MI_LOAD_REGISTER_IMM) + + sizeof(PIPE_CONTROL) + + sizeof(MI_MATH) + + NUM_ALU_INST_FOR_READ_MODIFY_WRITE * sizeof(MI_MATH_ALU_INST_INLINE); + + totalSize += getProfilingEndCmdsSize(); + totalSize += getMediaStateClearCmdsSize(); + + totalSize += 4 * sizeof(PIPE_CONTROL); + totalSize += sizeof(MI_BATCH_BUFFER_END); + return totalSize; +} + +template +size_t DeviceQueueHw::getProfilingEndCmdsSize() { + size_t size = 0; + size += sizeof(PIPE_CONTROL) + 2 * sizeof(MI_STORE_REGISTER_MEM); + size += sizeof(MI_LOAD_REGISTER_IMM); + return size; +} + } // namespace OCLRT diff --git a/runtime/os_interface/windows/wddm.cpp b/runtime/os_interface/windows/wddm.cpp index 4df44f9072..e383f5b07f 100644 --- a/runtime/os_interface/windows/wddm.cpp +++ b/runtime/os_interface/windows/wddm.cpp @@ -858,8 +858,9 @@ bool Wddm::submit(void *commandBuffer, size_t size, void *commandHeader) { monitoredFence.currentFenceValue++; } } - UNRECOVERABLE_IF(!success); + getDeviceState(); + UNRECOVERABLE_IF(!success); return success; } diff --git a/unit_tests/device_queue/device_queue_hw_tests.cpp b/unit_tests/device_queue/device_queue_hw_tests.cpp index 672b45b6bb..f948f5704c 100644 --- a/unit_tests/device_queue/device_queue_hw_tests.cpp +++ b/unit_tests/device_queue/device_queue_hw_tests.cpp @@ -34,6 +34,8 @@ #include "runtime/command_queue/dispatch_walker_helper.h" #include "runtime/helpers/kernel_commands.h" +#include + using namespace OCLRT; using namespace DeviceHostQueue; @@ -163,6 +165,20 @@ class DeviceQueueSlb : public DeviceQueueHwTest { } }; +HWTEST_F(DeviceQueueSlb, allocateSlbBufferAllocatesCorrectSize) { + std::unique_ptr> mockDeviceQueueHw(new MockDeviceQueueHw(pContext, device, deviceQueueProperties::minimumProperties[0])); + + LinearStream *slbCS = mockDeviceQueueHw->getSlbCS(); + size_t expectedSize = (mockDeviceQueueHw->getMinimumSlbSize() + mockDeviceQueueHw->getWaCommandsSize()) * 128; + expectedSize += sizeof(typename FamilyType::MI_BATCH_BUFFER_START); + expectedSize = alignUp(expectedSize, MemoryConstants::pageSize); + + expectedSize += MockDeviceQueueHw::getExecutionModelCleanupSectionSize(); + expectedSize += (4 * MemoryConstants::pageSize); + + EXPECT_LE(expectedSize, slbCS->getAvailableSpace()); +} + HWTEST_F(DeviceQueueSlb, buildSlbAfterReset) { auto mockDeviceQueueHw = new MockDeviceQueueHw(pContext, device, deviceQueueProperties::minimumProperties[0]); @@ -305,6 +321,13 @@ HWTEST_F(DeviceQueueSlb, cleanupSection) { size_t cleanupSectionOffset = alignUp(mockDeviceQueueHw->numberOfDeviceEnqueues * commandsSize + sizeof(MI_BATCH_BUFFER_START), MemoryConstants::pageSize); size_t cleanupSectionOffsetToParse = cleanupSectionOffset; + size_t slbUsed = slbCS->getUsed(); + slbUsed = alignUp(slbUsed, MemoryConstants::pageSize); + size_t slbMax = slbCS->getMaxAvailableSpace(); + + // 4 pages padding expected after cleanup section + EXPECT_LE(4 * MemoryConstants::pageSize, slbMax - slbUsed); + if (mockParentKernel->getKernelInfo().patchInfo.executionEnvironment->UsesFencesForReadWriteImages) { cleanupSectionOffsetToParse += getSizeForWADisableLSQCROPERFforOCL(mockParentKernel) / 2; @@ -618,15 +641,127 @@ HWTEST_F(TheSimplestDeviceQueueFixture, resetDeviceQueueSetEarlyReturnValues) { DebugManager.flags.SchedulerSimulationReturnInstance.set(3); - MockDevice *device = Device::create(platformDevices[0]); + std::unique_ptr device(Device::create(platformDevices[0])); MockContext context; - MockDeviceQueueHw *mockDeviceQueueHw = new MockDeviceQueueHw(&context, device, deviceQueueProperties::minimumProperties[0]); + std::unique_ptr> mockDeviceQueueHw(new MockDeviceQueueHw(&context, device.get(), deviceQueueProperties::minimumProperties[0])); mockDeviceQueueHw->resetDeviceQueue(); EXPECT_EQ(3u, mockDeviceQueueHw->getIgilQueue()->m_controls.m_SchedulerEarlyReturn); EXPECT_EQ(0u, mockDeviceQueueHw->getIgilQueue()->m_controls.m_SchedulerEarlyReturnCounter); - - delete mockDeviceQueueHw; - delete device; +} + +HWTEST_F(TheSimplestDeviceQueueFixture, addMediaStateClearCmds) { + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + using MEDIA_VFE_STATE = typename FamilyType::MEDIA_VFE_STATE; + + std::unique_ptr device(Device::create(platformDevices[0])); + MockContext context; + std::unique_ptr> mockDeviceQueueHw(new MockDeviceQueueHw(&context, device.get(), deviceQueueProperties::minimumProperties[0])); + + HardwareParse hwParser; + auto *slbCS = mockDeviceQueueHw->getSlbCS(); + + mockDeviceQueueHw->addMediaStateClearCmds(); + + hwParser.parseCommands(*slbCS, 0); + hwParser.findHardwareCommands(); + + auto pipeControlItor = find(hwParser.cmdList.begin(), hwParser.cmdList.end()); + EXPECT_NE(hwParser.cmdList.end(), pipeControlItor); + + if (mockDeviceQueueHw->pipeControlWa) { + pipeControlItor++; + EXPECT_NE(hwParser.cmdList.end(), pipeControlItor); + } + + PIPE_CONTROL *pipeControl = (PIPE_CONTROL *)*pipeControlItor; + EXPECT_TRUE(pipeControl->getGenericMediaStateClear()); + + auto mediaVfeStateItor = find(pipeControlItor, hwParser.cmdList.end()); + + EXPECT_NE(hwParser.cmdList.end(), mediaVfeStateItor); +} + +HWTEST_F(TheSimplestDeviceQueueFixture, addExecutionModelCleanupSectionClearsMediaState) { + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + using MEDIA_VFE_STATE = typename FamilyType::MEDIA_VFE_STATE; + + class MockDeviceQueueWithMediaStateClearRegistering : public MockDeviceQueueHw { + public: + MockDeviceQueueWithMediaStateClearRegistering(Context *context, + Device *device, + cl_queue_properties &properties) : MockDeviceQueueHw(context, device, properties) { + } + + bool addMediaStateClearCmdsCalled = false; + void addMediaStateClearCmds() override { + addMediaStateClearCmdsCalled = true; + } + }; + std::unique_ptr device(Device::create(platformDevices[0])); + MockContext context; + std::unique_ptr mockDeviceQueueHw(new MockDeviceQueueWithMediaStateClearRegistering(&context, device.get(), deviceQueueProperties::minimumProperties[0])); + + std::unique_ptr mockParentKernel(MockParentKernel::create(*device)); + uint32_t taskCount = 7; + mockDeviceQueueHw->buildSlbDummyCommands(); + + EXPECT_FALSE(mockDeviceQueueHw->addMediaStateClearCmdsCalled); + mockDeviceQueueHw->addExecutionModelCleanUpSection(mockParentKernel.get(), nullptr, taskCount); + EXPECT_TRUE(mockDeviceQueueHw->addMediaStateClearCmdsCalled); +} + +HWTEST_F(TheSimplestDeviceQueueFixture, getMediaStateClearCmdsSize) { + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + using MEDIA_VFE_STATE = typename FamilyType::MEDIA_VFE_STATE; + + std::unique_ptr device(Device::create(platformDevices[0])); + MockContext context; + std::unique_ptr> mockDeviceQueueHw(new MockDeviceQueueHw(&context, device.get(), deviceQueueProperties::minimumProperties[0])); + + size_t expectedSize = 2 * sizeof(PIPE_CONTROL) + sizeof(PIPE_CONTROL) + sizeof(MEDIA_VFE_STATE); + EXPECT_EQ(expectedSize, MockDeviceQueueHw::getMediaStateClearCmdsSize()); +} + +HWTEST_F(TheSimplestDeviceQueueFixture, getExecutionModelCleanupSectionSize) { + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + using MI_MATH_ALU_INST_INLINE = typename FamilyType::MI_MATH_ALU_INST_INLINE; + using MI_LOAD_REGISTER_REG = typename FamilyType::MI_LOAD_REGISTER_REG; + using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM; + using MI_MATH = typename FamilyType::MI_MATH; + using MI_BATCH_BUFFER_END = typename FamilyType::MI_BATCH_BUFFER_END; + + std::unique_ptr device(Device::create(platformDevices[0])); + MockContext context; + std::unique_ptr> mockDeviceQueueHw(new MockDeviceQueueHw(&context, device.get(), deviceQueueProperties::minimumProperties[0])); + + size_t expectedSize = sizeof(PIPE_CONTROL) + + 2 * sizeof(MI_LOAD_REGISTER_REG) + + sizeof(MI_LOAD_REGISTER_IMM) + + sizeof(PIPE_CONTROL) + + sizeof(MI_MATH) + + NUM_ALU_INST_FOR_READ_MODIFY_WRITE * sizeof(MI_MATH_ALU_INST_INLINE); + + expectedSize += MockDeviceQueueHw::getProfilingEndCmdsSize(); + expectedSize += MockDeviceQueueHw::getMediaStateClearCmdsSize(); + + expectedSize += 4 * sizeof(PIPE_CONTROL); + expectedSize += sizeof(MI_BATCH_BUFFER_END); + + EXPECT_EQ(expectedSize, MockDeviceQueueHw::getExecutionModelCleanupSectionSize()); +} + +HWTEST_F(TheSimplestDeviceQueueFixture, getProfilingEndCmdsSize) { + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + using MI_STORE_REGISTER_MEM = typename FamilyType::MI_STORE_REGISTER_MEM; + using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM; + + std::unique_ptr device(Device::create(platformDevices[0])); + MockContext context; + std::unique_ptr> mockDeviceQueueHw(new MockDeviceQueueHw(&context, device.get(), deviceQueueProperties::minimumProperties[0])); + + size_t expectedSize = sizeof(PIPE_CONTROL) + 2 * sizeof(MI_STORE_REGISTER_MEM) + sizeof(MI_LOAD_REGISTER_IMM); + + EXPECT_EQ(expectedSize, MockDeviceQueueHw::getProfilingEndCmdsSize()); } diff --git a/unit_tests/execution_model/enqueue_execution_model_kernel_tests.cpp b/unit_tests/execution_model/enqueue_execution_model_kernel_tests.cpp index bb9bdc44cf..3fec6156e7 100644 --- a/unit_tests/execution_model/enqueue_execution_model_kernel_tests.cpp +++ b/unit_tests/execution_model/enqueue_execution_model_kernel_tests.cpp @@ -506,3 +506,19 @@ HWTEST_F(ParentKernelEnqueueFixture, givenCsrInBatchingModeWhenExecutionModelKer EXPECT_EQ(1, mockCsr->flushCalledCount); } } + +HWTEST_F(ParentKernelEnqueueFixture, ParentKernelEnqueueMarksCSRMediaVFEStateDirty) { + + if (pDevice->getSupportedClVersion() >= 20) { + size_t offset[3] = {0, 0, 0}; + size_t gws[3] = {1, 1, 1}; + int32_t execStamp; + auto mockCsr = new MockCsr(execStamp); + pDevice->resetCommandStreamReceiver(mockCsr); + + mockCsr->overrideMediaVFEStateDirty(false); + pCmdQ->enqueueKernel(parentKernel, 1, offset, gws, gws, 0, nullptr, nullptr); + + EXPECT_TRUE(mockCsr->peekMediaVfeStateDirty()); + } +} diff --git a/unit_tests/gen8/test_device_queue_hw.cpp b/unit_tests/gen8/test_device_queue_hw.cpp index 5b070f5a5d..5da875c588 100644 --- a/unit_tests/gen8/test_device_queue_hw.cpp +++ b/unit_tests/gen8/test_device_queue_hw.cpp @@ -39,9 +39,11 @@ GEN8TEST_F(Gen8DeviceQueueSlb, expectedAllocationSize) { sizeof(typename FamilyType::MI_LOAD_REGISTER_IMM) + sizeof(typename FamilyType::MI_LOAD_REGISTER_IMM); expectedSize *= 128; //num of enqueues - expectedSize += sizeof(typename FamilyType::MI_BATCH_BUFFER_START) + (4 * MemoryConstants::pageSize); + expectedSize += sizeof(typename FamilyType::MI_BATCH_BUFFER_START); + expectedSize = alignUp(expectedSize, MemoryConstants::pageSize); + expectedSize += MockDeviceQueueHw::getExecutionModelCleanupSectionSize(); + expectedSize += (4 * MemoryConstants::pageSize); expectedSize = alignUp(expectedSize, MemoryConstants::pageSize); - ASSERT_NE(deviceQueue->getSlbBuffer(), nullptr); EXPECT_EQ(deviceQueue->getSlbBuffer()->getUnderlyingBufferSize(), expectedSize); diff --git a/unit_tests/gen9/test_device_queue_hw.cpp b/unit_tests/gen9/test_device_queue_hw.cpp index 9445cdfba9..54ab3557c0 100644 --- a/unit_tests/gen9/test_device_queue_hw.cpp +++ b/unit_tests/gen9/test_device_queue_hw.cpp @@ -42,7 +42,10 @@ GEN9TEST_F(Gen9DeviceQueueSlb, expectedAllocationSize) { sizeof(typename FamilyType::PIPE_CONTROL) + sizeof(typename FamilyType::PIPE_CONTROL); expectedSize *= 128; //num of enqueues - expectedSize += sizeof(typename FamilyType::MI_BATCH_BUFFER_START) + (4 * MemoryConstants::pageSize); + expectedSize += sizeof(typename FamilyType::MI_BATCH_BUFFER_START); + expectedSize = alignUp(expectedSize, MemoryConstants::pageSize); + expectedSize += MockDeviceQueueHw::getExecutionModelCleanupSectionSize(); + expectedSize += (4 * MemoryConstants::pageSize); expectedSize = alignUp(expectedSize, MemoryConstants::pageSize); ASSERT_NE(deviceQueue->getSlbBuffer(), nullptr); diff --git a/unit_tests/mocks/mock_csr.h b/unit_tests/mocks/mock_csr.h index 1e3781f3fa..04be44f024 100644 --- a/unit_tests/mocks/mock_csr.h +++ b/unit_tests/mocks/mock_csr.h @@ -96,6 +96,7 @@ template class MockCsr : public MockCsrBase { public: using BaseClass = MockCsrBase; + using CommandStreamReceiver::mediaVfeStateDirty; MockCsr() = delete; MockCsr(const HardwareInfo &hwInfoIn) = delete; @@ -132,6 +133,8 @@ class MockCsr : public MockCsrBase { dispatchFlags); } + bool peekMediaVfeStateDirty() const { return mediaVfeStateDirty; } + bool slmUsedInLastFlushTask = false; uint32_t lastTaskLevelToFlushTask = 0; }; diff --git a/unit_tests/mocks/mock_device_queue.h b/unit_tests/mocks/mock_device_queue.h index b43f0f0e26..1deb5b0b32 100644 --- a/unit_tests/mocks/mock_device_queue.h +++ b/unit_tests/mocks/mock_device_queue.h @@ -51,6 +51,10 @@ class MockDeviceQueueHw : public DeviceQueueHw { using BaseClass::getSlbCS; using BaseClass::getWaCommandsSize; using BaseClass::offsetDsh; + using BaseClass::addMediaStateClearCmds; + using BaseClass::getMediaStateClearCmdsSize; + using BaseClass::getProfilingEndCmdsSize; + using BaseClass::getExecutionModelCleanupSectionSize; bool arbCheckWa; bool miAtomicWa;