intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-25 05:24:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Add copy engine support for USM shared migration"

Browse Source 
This reverts commit 91e9587a07.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2021-09-28 19:11:38 +02:00
committed by Compute-Runtime-Automation
parent 996dd18b76
commit 33f88884bd
12 changed files with 43 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
level_zero/core/source/cmdlist/cmdlist_hw.h
View File

@@ -104,8 +104,8 @@ struct CommandListCoreFamily : CommandListImp {
ze_result_t appendMemoryCopy(void *dstptr, const void *srcptr, size_t size,
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) override;
ze_result_t appendPageFaultCopy(NEO::GraphicsAllocation *dstAllocation,
NEO::GraphicsAllocation *srcAllocation,
ze_result_t appendPageFaultCopy(NEO::GraphicsAllocation *dstptr,
NEO::GraphicsAllocation *srcptr,
size_t size,
bool flushHost) override;
ze_result_t appendMemoryCopyRegion(void *dstPtr,

67
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@@ -958,8 +958,8 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendCopyImageBlit(NEO::Graph
}
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendPageFaultCopy(NEO::GraphicsAllocation *dstAllocation,
NEO::GraphicsAllocation *srcAllocation,
ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendPageFaultCopy(NEO::GraphicsAllocation *dstptr,
NEO::GraphicsAllocation *srcptr,
size_t size, bool flushHost) {
using GfxFamily = typename NEO::GfxFamilyMapper<gfxCoreFamily>::GfxFamily;
@@ -972,45 +972,32 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendPageFaultCopy(NEO::Graph
isStateless = true;
}
uintptr_t dstAddress = static_cast<uintptr_t>(dstAllocation->getGpuAddress());
uintptr_t srcAddress = static_cast<uintptr_t>(srcAllocation->getGpuAddress());
ze_result_t ret = ZE_RESULT_ERROR_UNKNOWN;
if (isCopyOnly()) {
ret = appendMemoryCopyBlit(dstAddress, dstAllocation, 0u,
srcAddress, srcAllocation, 0u,
size - rightSize);
uint64_t dstAddress = dstptr->getGpuAddress();
uint64_t srcAddress = srcptr->getGpuAddress();
ze_result_t ret = appendMemoryCopyKernelWithGA(reinterpret_cast<void *>(&dstAddress),
dstptr, 0,
reinterpret_cast<void *>(&srcAddress),
srcptr, 0,
size - rightSize,
middleElSize,
Builtin::CopyBufferToBufferMiddle,
nullptr,
isStateless);
if (ret == ZE_RESULT_SUCCESS && rightSize) {
appendMemoryCopyKernelWithGA(reinterpret_cast<void *>(&dstAddress),
dstptr, size - rightSize,
reinterpret_cast<void *>(&srcAddress),
srcptr, size - rightSize,
rightSize, 1UL,
Builtin::CopyBufferToBufferSide,
nullptr,
isStateless);
}
if (ret == ZE_RESULT_SUCCESS && rightSize) {
ret = appendMemoryCopyBlit(dstAddress, dstAllocation, size - rightSize,
srcAddress, srcAllocation, size - rightSize,
rightSize);
}
} else {
ret = appendMemoryCopyKernelWithGA(reinterpret_cast<void *>(&dstAddress),
dstAllocation, 0,
reinterpret_cast<void *>(&srcAddress),
srcAllocation, 0,
size - rightSize,
middleElSize,
Builtin::CopyBufferToBufferMiddle,
nullptr,
isStateless);
if (ret == ZE_RESULT_SUCCESS && rightSize) {
ret = appendMemoryCopyKernelWithGA(reinterpret_cast<void *>(&dstAddress),
dstAllocation, size - rightSize,
reinterpret_cast<void *>(&srcAddress),
srcAllocation, size - rightSize,
rightSize, 1UL,
Builtin::CopyBufferToBufferSide,
nullptr,
isStateless);
}
if (NEO::MemorySynchronizationCommands<GfxFamily>::isDcFlushAllowed()) {
if (flushHost) {
NEO::PipeControlArgs args(true);
NEO::MemorySynchronizationCommands<GfxFamily>::addPipeControl(*commandContainer.getCommandStream(), args);
}
if (NEO::MemorySynchronizationCommands<GfxFamily>::isDcFlushAllowed()) {
if (flushHost) {
NEO::PipeControlArgs args(true);
NEO::MemorySynchronizationCommands<GfxFamily>::addPipeControl(*commandContainer.getCommandStream(), args);
}
}

3
level_zero/core/source/cmdlist/cmdlist_hw_immediate.h
View File

@@ -65,8 +65,7 @@ struct CommandListCoreFamilyImmediate : public CommandListCoreFamily<gfxCoreFami
ze_result_t appendEventReset(ze_event_handle_t hEvent) override;
ze_result_t appendPageFaultCopy(NEO::GraphicsAllocation *dstAllocation,
NEO::GraphicsAllocation *srcAllocation,
ze_result_t appendPageFaultCopy(NEO::GraphicsAllocation *dstptr, NEO::GraphicsAllocation *srcptr,
size_t size, bool flushHost) override;
ze_result_t appendWaitOnEvents(uint32_t numEvents, ze_event_handle_t *phEvent) override;

6
level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
View File

@@ -331,15 +331,13 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendEventReset(ze_e
}
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendPageFaultCopy(NEO::GraphicsAllocation *dstAllocation,
NEO::GraphicsAllocation *srcAllocation,
size_t size, bool flushHost) {
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendPageFaultCopy(NEO::GraphicsAllocation *dstptr, NEO::GraphicsAllocation *srcptr, size_t size, bool flushHost) {
if (this->isFlushTaskSubmissionEnabled) {
checkAvailableSpace();
}
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendPageFaultCopy(dstAllocation, srcAllocation, size, flushHost);
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendPageFaultCopy(dstptr, srcptr, size, flushHost);
if (ret == ZE_RESULT_SUCCESS) {
if (this->isFlushTaskSubmissionEnabled) {
executeCommandListImmediateWithFlushTask(false);

6
level_zero/core/source/cmdlist/cmdlist_imp.cpp
View File

@@ -103,11 +103,7 @@ CommandList *CommandList::createImmediate(uint32_t productFamily, Device *device
NEO::CommandStreamReceiver *csr = nullptr;
auto deviceImp = static_cast<DeviceImp *>(device);
if (internalUsage) {
if (NEO::EngineGroupType::Copy == engineGroupType && deviceImp->getActiveDevice()->getInternalCopyEngine()) {
csr = deviceImp->getActiveDevice()->getInternalCopyEngine()->commandStreamReceiver;
} else {
csr = deviceImp->getActiveDevice()->getInternalEngine().commandStreamReceiver;
}
csr = deviceImp->neoDevice->getInternalEngine().commandStreamReceiver;
} else {
device->getCsrForOrdinalAndIndex(&csr, desc->ordinal, desc->index);
}

2
level_zero/core/source/device/device_imp.cpp
View File

@@ -768,7 +768,7 @@ Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, uint3
ze_result_t resultValue = ZE_RESULT_SUCCESS;
device->pageFaultCommandList =
CommandList::createImmediate(
device->neoDevice->getHardwareInfo().platform.eProductFamily, device, &cmdQueueDesc, true, NEO::EngineGroupType::Copy, resultValue);
device->neoDevice->getHardwareInfo().platform.eProductFamily, device, &cmdQueueDesc, true, NEO::EngineGroupType::RenderCompute, resultValue);
}
if (device->getSourceLevelDebugger()) {

66
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp
View File

@@ -22,7 +22,6 @@ template <GFXCORE_FAMILY gfxCoreFamily>
class MockCommandListHw : public WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>> {
public:
MockCommandListHw() : WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>() {}
MockCommandListHw(bool failOnFirst) : WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>(), failOnFirstCopy(failOnFirst) {}
AlignedAllocationData getAlignedAllocation(L0::Device *device, const void *buffer, uint64_t bufferSize) override {
return {0, 0, nullptr, true};
@@ -41,10 +40,6 @@ class MockCommandListHw : public WhiteBox<::L0::CommandListCoreFamily<gfxCoreFam
appendMemoryCopyKernelWithGACalledTimes++;
if (isStateless)
appendMemoryCopyKernelWithGAStatelessCalledTimes++;
if (failOnFirstCopy &&
(appendMemoryCopyKernelWithGACalledTimes == 1 || appendMemoryCopyKernelWithGAStatelessCalledTimes == 1)) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t appendMemoryCopyBlit(uintptr_t dstPtr,
@@ -54,9 +49,6 @@ class MockCommandListHw : public WhiteBox<::L0::CommandListCoreFamily<gfxCoreFam
uint64_t srcOffset,
uint64_t size) override {
appendMemoryCopyBlitCalledTimes++;
if (failOnFirstCopy && appendMemoryCopyBlitCalledTimes == 1) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
@@ -125,7 +117,6 @@ class MockCommandListHw : public WhiteBox<::L0::CommandListCoreFamily<gfxCoreFam
Vec3<size_t> appendImageRegionCopySize = {0, 0, 0};
Vec3<size_t> appendImageRegionSrcOrigin = {9, 9, 9};
Vec3<size_t> appendImageRegionDstOrigin = {9, 9, 9};
bool failOnFirstCopy = false;
};
using Platforms = IsAtLeastProduct<IGFX_SKYLAKE>;
@@ -187,20 +178,6 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenPageFaultCopyCalledThenappendPa
EXPECT_EQ(cmdList.appendMemoryCopyKernelWithGAStatelessCalledTimes, 0u);
}
HWTEST2_F(CommandListCreate, givenCommandListWhenPageFaultCopyCalledWithCopyEngineThenappendPageFaultCopyWithappendMemoryCopyKernelWithGACalled, Platforms) {
MockCommandListHw<gfxCoreFamily> cmdList;
size_t size = (sizeof(uint32_t) * 4);
cmdList.initialize(device, NEO::EngineGroupType::Copy, 0u);
NEO::MockGraphicsAllocation mockAllocationSrc(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
reinterpret_cast<void *>(0x1234), size, 0, sizeof(uint32_t),
MemoryPool::System4KBPages);
NEO::MockGraphicsAllocation mockAllocationDst(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
reinterpret_cast<void *>(0x2345), size, 0, sizeof(uint32_t),
MemoryPool::System4KBPages);
cmdList.appendPageFaultCopy(&mockAllocationDst, &mockAllocationSrc, size, false);
EXPECT_EQ(cmdList.appendMemoryCopyBlitCalledTimes, 1u);
}
HWTEST2_F(CommandListCreate, givenCommandListWhenPageFaultCopyCalledThenappendPageFaultCopyWithappendMemoryCopyKernelWithGACalledForMiddleAndRightSizesAreCalled, Platforms) {
MockCommandListHw<gfxCoreFamily> cmdList;
size_t size = ((sizeof(uint32_t) * 4) + 1);
@@ -216,49 +193,6 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenPageFaultCopyCalledThenappendPa
EXPECT_EQ(cmdList.appendMemoryCopyKernelWithGAStatelessCalledTimes, 0u);
}
HWTEST2_F(CommandListCreate, givenCommandListWhenPageFaultCopyCalledAndErrorOnMidCopyThenappendPageFaultCopyWithappendMemoryCopyKernelWithGACalledForMiddleIsCalled, Platforms) {
MockCommandListHw<gfxCoreFamily> cmdList(true);
size_t size = ((sizeof(uint32_t) * 4) + 1);
cmdList.initialize(device, NEO::EngineGroupType::RenderCompute, 0u);
NEO::MockGraphicsAllocation mockAllocationSrc(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
reinterpret_cast<void *>(0x1234), size, 0, sizeof(uint32_t),
MemoryPool::System4KBPages);
NEO::MockGraphicsAllocation mockAllocationDst(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
reinterpret_cast<void *>(0x2345), size, 0, sizeof(uint32_t),
MemoryPool::System4KBPages);
cmdList.appendPageFaultCopy(&mockAllocationDst, &mockAllocationSrc, size, false);
EXPECT_EQ(cmdList.appendMemoryCopyKernelWithGACalledTimes, 1u);
EXPECT_EQ(cmdList.appendMemoryCopyKernelWithGAStatelessCalledTimes, 0u);
}
HWTEST2_F(CommandListCreate, givenCommandListWhenPageFaultCopyCalledWithCopyEngineThenappendPageFaultCopyWithappendMemoryCopyKernelWithGACalledForMiddleAndRightSizesAreCalled, Platforms) {
MockCommandListHw<gfxCoreFamily> cmdList;
size_t size = ((sizeof(uint32_t) * 4) + 1);
cmdList.initialize(device, NEO::EngineGroupType::Copy, 0u);
NEO::MockGraphicsAllocation mockAllocationSrc(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
reinterpret_cast<void *>(0x1234), size, 0, sizeof(uint32_t),
MemoryPool::System4KBPages);
NEO::MockGraphicsAllocation mockAllocationDst(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
reinterpret_cast<void *>(0x2345), size, 0, sizeof(uint32_t),
MemoryPool::System4KBPages);
cmdList.appendPageFaultCopy(&mockAllocationDst, &mockAllocationSrc, size, false);
EXPECT_EQ(cmdList.appendMemoryCopyBlitCalledTimes, 2u);
}
HWTEST2_F(CommandListCreate, givenCommandListWhenPageFaultCopyCalledWithCopyEngineAndErrorOnMidOperationThenappendPageFaultCopyWithappendMemoryCopyKernelWithGACalledForMiddleIsCalled, Platforms) {
MockCommandListHw<gfxCoreFamily> cmdList(true);
size_t size = ((sizeof(uint32_t) * 4) + 1);
cmdList.initialize(device, NEO::EngineGroupType::Copy, 0u);
NEO::MockGraphicsAllocation mockAllocationSrc(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
reinterpret_cast<void *>(0x1234), size, 0, sizeof(uint32_t),
MemoryPool::System4KBPages);
NEO::MockGraphicsAllocation mockAllocationDst(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
reinterpret_cast<void *>(0x2345), size, 0, sizeof(uint32_t),
MemoryPool::System4KBPages);
cmdList.appendPageFaultCopy(&mockAllocationDst, &mockAllocationSrc, size, false);
EXPECT_EQ(cmdList.appendMemoryCopyBlitCalledTimes, 1u);
}
HWTEST2_F(CommandListCreate, givenCommandListWhen4GBytePageFaultCopyCalledThenPageFaultCopyWithappendMemoryCopyKernelWithGAStatelessCalled, Platforms) {
MockCommandListHw<gfxCoreFamily> cmdList;
size_t size = 0x100000000;

30
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp
View File

@@ -838,11 +838,7 @@ HWTEST2_F(CommandListCreate, givenImmediateCommandListWhenMemoryCopyRegionWithSi
ASSERT_NE(nullptr, commandList0);
CommandQueueImp *cmdQueue = reinterpret_cast<CommandQueueImp *>(commandList0->cmdQImmediate);
if (neoDevice->getInternalCopyEngine()) {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalCopyEngine()->commandStreamReceiver);
} else {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
}
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
void *srcBuffer = reinterpret_cast<void *>(0x1234);
void *dstBuffer = reinterpret_cast<void *>(0x2345);
@@ -887,11 +883,7 @@ HWTEST2_F(CommandListCreate, givenImmediateCommandListWhenCopyRegionFromImageToI
ASSERT_NE(nullptr, commandList0);
CommandQueueImp *cmdQueue = reinterpret_cast<CommandQueueImp *>(commandList0->cmdQImmediate);
if (neoDevice->getInternalCopyEngine()) {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalCopyEngine()->commandStreamReceiver);
} else {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
}
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
@@ -931,11 +923,7 @@ HWTEST2_F(CommandListCreate, givenImmediateCommandListWhenCopyRegionFromImageToI
ASSERT_NE(nullptr, commandList0);
CommandQueueImp *cmdQueue = reinterpret_cast<CommandQueueImp *>(commandList0->cmdQImmediate);
if (neoDevice->getInternalCopyEngine()) {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalCopyEngine()->commandStreamReceiver);
} else {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
}
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
@@ -976,11 +964,7 @@ HWTEST2_F(CommandListCreate, givenImmediateCommandListWhenCopyFromImageToImageUs
ASSERT_NE(nullptr, commandList0);
CommandQueueImp *cmdQueue = reinterpret_cast<CommandQueueImp *>(commandList0->cmdQImmediate);
if (neoDevice->getInternalCopyEngine()) {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalCopyEngine()->commandStreamReceiver);
} else {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
}
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
@@ -1019,11 +1003,7 @@ HWTEST2_F(CommandListCreate, givenImmediateCommandListWhenMemoryCopyRegionWithSi
ASSERT_NE(nullptr, commandList0);
CommandQueueImp *cmdQueue = reinterpret_cast<CommandQueueImp *>(commandList0->cmdQImmediate);
if (neoDevice->getInternalCopyEngine()) {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalCopyEngine()->commandStreamReceiver);
} else {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
}
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
void *srcBuffer = reinterpret_cast<void *>(0x1234);
void *dstBuffer = reinterpret_cast<void *>(0x2345);

12
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp
View File

@@ -573,11 +573,7 @@ HWTEST2_F(HostPointerManagerCommandListTest, givenImmediateCommandListWhenMemory
ASSERT_NE(nullptr, commandList0);
CommandQueueImp *cmdQueue = reinterpret_cast<CommandQueueImp *>(commandList0->cmdQImmediate);
if (neoDevice->getInternalCopyEngine()) {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalCopyEngine()->commandStreamReceiver);
} else {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
}
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
ret = hostDriverHandle->importExternalPointer(heapPointer, MemoryConstants::pageSize);
EXPECT_EQ(ZE_RESULT_SUCCESS, ret);
@@ -623,11 +619,7 @@ HWTEST2_F(HostPointerManagerCommandListTest, givenImmediateCommandListWhenMemory
ASSERT_NE(nullptr, commandList0);
CommandQueueImp *cmdQueue = reinterpret_cast<CommandQueueImp *>(commandList0->cmdQImmediate);
if (neoDevice->getInternalCopyEngine()) {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalCopyEngine()->commandStreamReceiver);
} else {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
}
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
ret = hostDriverHandle->importExternalPointer(heapPointer, MemoryConstants::pageSize);
EXPECT_EQ(ZE_RESULT_SUCCESS, ret);

12
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger.cpp
View File

@@ -745,11 +745,7 @@ HWTEST2_F(L0DebuggerInternalUsageTest, givenUseCsrImmediateSubmissionEnabledForI
ASSERT_NE(nullptr, commandList0);
CommandQueueImp *cmdQueue = reinterpret_cast<CommandQueueImp *>(commandList0->cmdQImmediate);
if (neoDevice->getInternalCopyEngine()) {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalCopyEngine()->commandStreamReceiver);
} else {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
}
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
@@ -797,11 +793,7 @@ HWTEST2_F(L0DebuggerInternalUsageTest, givenUseCsrImmediateSubmissionDisabledFor
ASSERT_NE(nullptr, commandList0);
CommandQueueImp *cmdQueue = reinterpret_cast<CommandQueueImp *>(commandList0->cmdQImmediate);
if (neoDevice->getInternalCopyEngine()) {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalCopyEngine()->commandStreamReceiver);
} else {
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
}
EXPECT_EQ(cmdQueue->getCsr(), neoDevice->getInternalEngine().commandStreamReceiver);
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;

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

@@ -565,16 +565,6 @@ EngineControl &Device::getInternalEngine() {
return this->getNearestGenericSubDevice(0)->getEngine(engineType, EngineUsage::Internal);
}
EngineControl *Device::getInternalCopyEngine() {
for (auto &engine : engines) {
if (engine.osContext->getEngineType() == aub_stream::ENGINE_BCS &&
engine.osContext->isInternalEngine()) {
return &engine;
}
}
return nullptr;
}
void Device::initializeRayTracing() {
if (rtMemoryBackedBuffer == nullptr) {
auto size = RayTracingHelper::getTotalMemoryBackedFifoSize(*this);

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

@@ -66,7 +66,6 @@ class Device : public ReferenceTrackedObject<Device> {
EngineControl &getEngine(uint32_t index);
EngineControl &getDefaultEngine();
EngineControl &getInternalEngine();
EngineControl *getInternalCopyEngine();
SelectorCopyEngine &getSelectorCopyEngine();
MemoryManager *getMemoryManager() const;
GmmHelper *getGmmHelper() const;