Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Use GraphicsAllocation for blit operation instead of Buffer object

Browse Source 
Change-Id: I7e59a25db97082a6396d441a8fa603df27d6424d
Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com>
Related-To: NEO-3020
This commit is contained in:
Dunajski, Bartosz
2019-06-27 16:08:20 +02:00
committed by sys_ocldev
parent 83ee99ad3d
commit 41cca6d790
15 changed files with 70 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
runtime/command_queue/command_queue_hw_base.inl
View File

@ -110,7 +110,9 @@ cl_int CommandQueueHw<Family>::enqueueReadWriteBufferWithBlitTransfer(cl_command
auto copyDirection = (CL_COMMAND_WRITE_BUFFER == commandType) ? BlitterConstants::BlitWithHostPtrDirection::FromHostPtr
: BlitterConstants::BlitWithHostPtrDirection::ToHostPtr;
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(copyDirection, buffer, ptr, blocking, offset, size);
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(copyDirection, *blitCommandStreamReceiver,
buffer->getGraphicsAllocation(), ptr, blocking,
offset, size);
blitProperties.csrDependencies.fillFromEventsRequestAndMakeResident(eventsRequest, *blitCommandStreamReceiver,
CsrDependencies::DependenciesType::All);
@ -119,7 +121,7 @@ cl_int CommandQueueHw<Family>::enqueueReadWriteBufferWithBlitTransfer(cl_command
blitProperties.csrDependencies.push_back(&previousTimestampPacketNodes);
blitProperties.outputTimestampPacket = timestampPacketContainer.get();
blitCommandStreamReceiver->blitWithHostPtr(blitProperties);
blitCommandStreamReceiver->blitBuffer(blitProperties);
MultiDispatchInfo multiDispatchInfo;

16
runtime/command_stream/command_stream_receiver.cpp
View File

@ -422,20 +422,4 @@ cl_int CommandStreamReceiver::expectMemory(const void *gfxAddress, const void *s
return (isMemoryEqual == isEqualMemoryExpected) ? CL_SUCCESS : CL_INVALID_VALUE;
}
void CommandStreamReceiver::blitWithHostPtr(BlitProperties &blitProperites) {
HostPtrSurface hostPtrSurface(blitProperites.hostPtr, static_cast<size_t>(blitProperites.copySize), true);
bool success = createAllocationForHostSurface(hostPtrSurface, false);
UNRECOVERABLE_IF(!success);
auto hostPtrAllocation = hostPtrSurface.getAllocation();
auto device = platform()->getDevice(0);
auto hostPtrBuffer = std::unique_ptr<Buffer>(Buffer::createBufferHwFromDevice(device, CL_MEM_READ_WRITE,
static_cast<size_t>(blitProperites.copySize),
blitProperites.hostPtr, blitProperites.hostPtr, hostPtrAllocation,
true, false, true));
blitProperites.setHostPtrBuffer(hostPtrBuffer.get());
blitBuffer(blitProperites);
}
} // namespace NEO

3
runtime/command_stream/command_stream_receiver.h
View File

@ -177,8 +177,7 @@ class CommandStreamReceiver {
this->latestSentTaskCount = latestSentTaskCount;
}
void blitWithHostPtr(BlitProperties &blitProperites);
virtual void blitBuffer(BlitProperties &blitProperites) = 0;
virtual void blitBuffer(const BlitProperties &blitProperites) = 0;
ScratchSpaceController *getScratchSpaceController() const {
return scratchSpaceController.get();

2
runtime/command_stream/command_stream_receiver_hw.h
View File

@ -70,7 +70,7 @@ class CommandStreamReceiverHw : public CommandStreamReceiver {
return CommandStreamReceiverType::CSR_HW;
}
void blitBuffer(BlitProperties &blitProperites) override;
void blitBuffer(const BlitProperties &blitProperites) override;
protected:
using CommandStreamReceiver::osContext;

6
runtime/command_stream/command_stream_receiver_hw_base.inl
View File

@ -726,7 +726,7 @@ bool CommandStreamReceiverHw<GfxFamily>::detectInitProgrammingFlagsRequired(cons
}
template <typename GfxFamily>
void CommandStreamReceiverHw<GfxFamily>::blitBuffer(BlitProperties &blitProperites) {
void CommandStreamReceiverHw<GfxFamily>::blitBuffer(const BlitProperties &blitProperites) {
using MI_BATCH_BUFFER_END = typename GfxFamily::MI_BATCH_BUFFER_END;
using MI_FLUSH_DW = typename GfxFamily::MI_FLUSH_DW;
@ -758,8 +758,8 @@ void CommandStreamReceiverHw<GfxFamily>::blitBuffer(BlitProperties &blitProperit
alignToCacheLine(commandStream);
makeResident(*blitProperites.srcBuffer->getGraphicsAllocation());
makeResident(*blitProperites.dstBuffer->getGraphicsAllocation());
makeResident(*blitProperites.srcAllocation);
makeResident(*blitProperites.dstAllocation);
makeResident(*commandStream.getGraphicsAllocation());
makeResident(*tagAllocation);

24
runtime/helpers/blit_commands_helper.cpp
View File

@ -8,24 +8,28 @@
#include "runtime/helpers/blit_commands_helper.h"
#include "runtime/helpers/timestamp_packet.h"
#include "runtime/memory_manager/surface.h"
#include "CL/cl.h"
namespace NEO {
BlitProperties BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection copyDirection, Buffer *buffer, void *hostPtr, bool blocking, size_t offset, uint64_t copySize) {
BlitProperties BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection copyDirection,
CommandStreamReceiver &commandStreamReceiver,
GraphicsAllocation *memObjAllocation, void *hostPtr, bool blocking,
size_t offset, uint64_t copySize) {
GraphicsAllocation *hostPtrAllocation = nullptr;
if (hostPtr) {
HostPtrSurface hostPtrSurface(hostPtr, static_cast<size_t>(copySize), true);
bool success = commandStreamReceiver.createAllocationForHostSurface(hostPtrSurface, false);
UNRECOVERABLE_IF(!success);
hostPtrAllocation = hostPtrSurface.getAllocation();
}
if (BlitterConstants::BlitWithHostPtrDirection::FromHostPtr == copyDirection) {
return {nullptr, copyDirection, {}, buffer, nullptr, hostPtr, blocking, offset, 0, copySize};
return {nullptr, copyDirection, {}, memObjAllocation, hostPtrAllocation, hostPtr, blocking, offset, 0, copySize};
} else {
return {nullptr, copyDirection, {}, nullptr, buffer, hostPtr, blocking, 0, offset, copySize};
return {nullptr, copyDirection, {}, hostPtrAllocation, memObjAllocation, hostPtr, blocking, 0, offset, copySize};
}
}
void BlitProperties::setHostPtrBuffer(Buffer *hostPtrBuffer) {
if (BlitterConstants::BlitWithHostPtrDirection::FromHostPtr == copyDirection) {
srcBuffer = hostPtrBuffer;
} else {
dstBuffer = hostPtrBuffer;
}
}
} // namespace NEO

19
runtime/helpers/blit_commands_helper.h
View File

@ -12,7 +12,7 @@
#include <cstdint>
namespace NEO {
class Buffer;
class CommandStreamReceiver;
class GraphicsAllocation;
class LinearStream;
class TimestampPacketContainer;
@ -20,16 +20,17 @@ class TimestampPacketContainer;
struct BlitProperties {
BlitProperties() = delete;
static BlitProperties constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection copyDirection, Buffer *buffer,
void *hostPtr, bool blocking, size_t offset, uint64_t copySize);
void setHostPtrBuffer(Buffer *hostPtrBuffer);
static BlitProperties constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection copyDirection,
CommandStreamReceiver &commandStreamReceiver,
GraphicsAllocation *memObjAllocation, void *hostPtr, bool blocking,
size_t offset, uint64_t copySize);
TimestampPacketContainer *outputTimestampPacket = nullptr;
BlitterConstants::BlitWithHostPtrDirection copyDirection;
CsrDependencies csrDependencies;
Buffer *dstBuffer = nullptr;
Buffer *srcBuffer = nullptr;
GraphicsAllocation *dstAllocation = nullptr;
GraphicsAllocation *srcAllocation = nullptr;
void *hostPtr = nullptr;
bool blocking = false;
size_t dstOffset = 0;
@ -39,8 +40,8 @@ struct BlitProperties {
template <typename GfxFamily>
struct BlitCommandsHelper {
static size_t estimateBlitCommandsSize(uint64_t copySize, CsrDependencies &csrDependencies, bool updateTimestampPacket);
static void dispatchBlitCommandsForBuffer(BlitProperties &blitProperites, LinearStream &linearStream);
static void appendBlitCommandsForBuffer(BlitProperties &blitProperites, typename GfxFamily::XY_COPY_BLT &blitCmd);
static size_t estimateBlitCommandsSize(uint64_t copySize, const CsrDependencies &csrDependencies, bool updateTimestampPacket);
static void dispatchBlitCommandsForBuffer(const BlitProperties &blitProperites, LinearStream &linearStream);
static void appendBlitCommandsForBuffer(const BlitProperties &blitProperites, typename GfxFamily::XY_COPY_BLT &blitCmd);
};
} // namespace NEO

8
runtime/helpers/blit_commands_helper_base.inl
View File

@ -10,7 +10,7 @@
namespace NEO {
template <typename GfxFamily>
size_t BlitCommandsHelper<GfxFamily>::estimateBlitCommandsSize(uint64_t copySize, CsrDependencies &csrDependencies, bool updateTimestampPacket) {
size_t BlitCommandsHelper<GfxFamily>::estimateBlitCommandsSize(uint64_t copySize, const CsrDependencies &csrDependencies, bool updateTimestampPacket) {
size_t numberOfBlits = 0;
uint64_t sizeToBlit = copySize;
uint64_t width = 1;
@ -40,7 +40,7 @@ size_t BlitCommandsHelper<GfxFamily>::estimateBlitCommandsSize(uint64_t copySize
}
template <typename GfxFamily>
void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBuffer(BlitProperties &blitProperites, LinearStream &linearStream) {
void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBuffer(const BlitProperties &blitProperites, LinearStream &linearStream) {
uint64_t sizeToBlit = blitProperites.copySize;
uint64_t width = 1;
uint64_t height = 1;
@ -71,8 +71,8 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBuffer(BlitProperties
bltCmd->setDestinationPitch(static_cast<uint32_t>(width));
bltCmd->setSourcePitch(static_cast<uint32_t>(width));
bltCmd->setDestinationBaseAddress(blitProperites.dstBuffer->getGraphicsAllocation()->getGpuAddress() + blitProperites.dstOffset + offset);
bltCmd->setSourceBaseAddress(blitProperites.srcBuffer->getGraphicsAllocation()->getGpuAddress() + blitProperites.srcOffset + offset);
bltCmd->setDestinationBaseAddress(blitProperites.dstAllocation->getGpuAddress() + blitProperites.dstOffset + offset);
bltCmd->setSourceBaseAddress(blitProperites.srcAllocation->getGpuAddress() + blitProperites.srcOffset + offset);
appendBlitCommandsForBuffer(blitProperites, *bltCmd);

2
runtime/helpers/blit_commands_helper_bdw_plus.inl
View File

@ -10,6 +10,6 @@
namespace NEO {
template <typename GfxFamily>
void BlitCommandsHelper<GfxFamily>::appendBlitCommandsForBuffer(BlitProperties &blitProperites, typename GfxFamily::XY_COPY_BLT &blitCmd) {}
void BlitCommandsHelper<GfxFamily>::appendBlitCommandsForBuffer(const BlitProperties &blitProperites, typename GfxFamily::XY_COPY_BLT &blitCmd) {}
} // namespace NEO

5
runtime/mem_obj/buffer.cpp
View File

@ -287,8 +287,9 @@ Buffer *Buffer::create(Context *context,
auto blitCommandStreamReceiver = context->getCommandStreamReceiverForBlitOperation(*pBuffer);
if (blitCommandStreamReceiver) {
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::FromHostPtr,
pBuffer, hostPtr, true, 0, size);
blitCommandStreamReceiver->blitWithHostPtr(blitProperties);
*blitCommandStreamReceiver, memory,
hostPtr, true, 0, size);
blitCommandStreamReceiver->blitBuffer(blitProperties);
} else {
auto cmdQ = context->getSpecialQueue();
if (CL_SUCCESS != cmdQ->enqueueWriteBuffer(pBuffer, CL_TRUE, 0, size, hostPtr, nullptr, 0, nullptr, nullptr)) {

53
unit_tests/command_stream/command_stream_receiver_hw_tests.cpp
View File

@ -270,7 +270,6 @@ HWTEST_F(CommandStreamReceiverHwTest, WhenScratchSpaceIsNotRequiredThenGshAddres
struct BcsTests : public CommandStreamReceiverHwTest {
void SetUp() override {
CommandStreamReceiverHwTest::SetUp();
platform()->initialize();
auto &csr = pDevice->getCommandStreamReceiver();
auto engine = csr.getMemoryManager()->getRegisteredEngineForCsr(&csr);
@ -367,9 +366,9 @@ HWTEST_F(BcsTests, givenBltSizeWithLeftoverWhenDispatchedThenProgramAllRequiredC
csr.taskCount = newTaskCount - 1;
EXPECT_EQ(0u, csr.recursiveLockCounter.load());
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::FromHostPtr,
buffer.get(), hostPtr, true, 0, bltSize);
csr, buffer->getGraphicsAllocation(), hostPtr, true, 0, bltSize);
csr.blitWithHostPtr(blitProperties);
csr.blitBuffer(blitProperties);
EXPECT_EQ(newTaskCount, csr.taskCount);
EXPECT_EQ(newTaskCount, csr.latestFlushedTaskCount);
EXPECT_EQ(newTaskCount, csr.latestSentTaskCount);
@ -426,14 +425,14 @@ HWTEST_F(BcsTests, givenCsrDependenciesWhenProgrammingCommandStreamThenAddSemaph
size_t numberNodesPerContainer = 5;
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::FromHostPtr,
buffer.get(), hostPtr, true, 0, 1);
csr, buffer->getGraphicsAllocation(), hostPtr, true, 0, 1);
MockTimestampPacketContainer timestamp0(*csr.getTimestampPacketAllocator(), numberNodesPerContainer);
MockTimestampPacketContainer timestamp1(*csr.getTimestampPacketAllocator(), numberNodesPerContainer);
blitProperties.csrDependencies.push_back(&timestamp0);
blitProperties.csrDependencies.push_back(&timestamp1);
csr.blitWithHostPtr(blitProperties);
csr.blitBuffer(blitProperties);
HardwareParse hwParser;
hwParser.parseCommands<FamilyType>(csr.commandStream);
@ -474,9 +473,9 @@ HWTEST_F(BcsTests, givenInputAllocationsWhenBlitDispatchedThenMakeAllAllocations
EXPECT_EQ(0u, csr.makeSurfacePackNonResidentCalled);
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::FromHostPtr,
buffer.get(), hostPtr, true, 0, 1);
csr, buffer->getGraphicsAllocation(), hostPtr, true, 0, 1);
csr.blitWithHostPtr(blitProperties);
csr.blitBuffer(blitProperties);
EXPECT_TRUE(csr.isMadeResident(buffer->getGraphicsAllocation()));
EXPECT_TRUE(csr.isMadeResident(csr.commandStream.getGraphicsAllocation()));
@ -502,9 +501,9 @@ HWTEST_F(BcsTests, givenBufferWhenBlitCalledThenFlushCommandBuffer) {
csr.taskCount = newTaskCount - 1;
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::FromHostPtr,
buffer.get(), hostPtr, true, 0, 1);
csr, buffer->getGraphicsAllocation(), hostPtr, true, 0, 1);
csr.blitWithHostPtr(blitProperties);
csr.blitBuffer(blitProperties);
EXPECT_EQ(commandStream.getGraphicsAllocation(), csr.latestFlushedBatchBuffer.commandBufferAllocation);
EXPECT_EQ(commandStreamOffset, csr.latestFlushedBatchBuffer.startOffset);
@ -550,14 +549,14 @@ HWTEST_F(BcsTests, whenBlitFromHostPtrCalledThenCallWaitWithKmdFallback) {
void *hostPtr = reinterpret_cast<void *>(0x12340000);
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::FromHostPtr,
buffer.get(), hostPtr, false, 0, 1);
*myMockCsr, buffer->getGraphicsAllocation(), hostPtr, false, 0, 1);
myMockCsr->blitWithHostPtr(blitProperties);
myMockCsr->blitBuffer(blitProperties);
EXPECT_EQ(0u, myMockCsr->waitForTaskCountWithKmdNotifyFallbackCalled);
blitProperties.blocking = true;
myMockCsr->blitWithHostPtr(blitProperties);
myMockCsr->blitBuffer(blitProperties);
EXPECT_EQ(1u, myMockCsr->waitForTaskCountWithKmdNotifyFallbackCalled);
EXPECT_EQ(myMockCsr->taskCount, myMockCsr->taskCountToWaitPassed);
@ -580,14 +579,14 @@ HWTEST_F(BcsTests, whenBlitFromHostPtrCalledThenCleanTemporaryAllocations) {
EXPECT_EQ(0u, mockInternalAllocationsStorage->cleanAllocationsCalled);
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::FromHostPtr,
buffer.get(), hostPtr, false, 0, 1);
bcsCsr, buffer->getGraphicsAllocation(), hostPtr, false, 0, 1);
bcsCsr.blitWithHostPtr(blitProperties);
bcsCsr.blitBuffer(blitProperties);
EXPECT_EQ(0u, mockInternalAllocationsStorage->cleanAllocationsCalled);
blitProperties.blocking = true;
bcsCsr.blitWithHostPtr(blitProperties);
bcsCsr.blitBuffer(blitProperties);
EXPECT_EQ(1u, mockInternalAllocationsStorage->cleanAllocationsCalled);
EXPECT_EQ(bcsCsr.taskCount, mockInternalAllocationsStorage->lastCleanAllocationsTaskCount);
@ -606,9 +605,9 @@ HWTEST_F(BcsTests, givenBufferWhenBlitOperationCalledThenProgramCorrectGpuAddres
// from hostPtr
HardwareParse hwParser;
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::FromHostPtr,
buffer1.get(), hostPtr, true, 0, 1);
csr, buffer1->getGraphicsAllocation(), hostPtr, true, 0, 1);
csr.blitWithHostPtr(blitProperties);
csr.blitBuffer(blitProperties);
hwParser.parseCommands<FamilyType>(csr.commandStream);
@ -624,9 +623,9 @@ HWTEST_F(BcsTests, givenBufferWhenBlitOperationCalledThenProgramCorrectGpuAddres
HardwareParse hwParser;
auto offset = csr.commandStream.getUsed();
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::ToHostPtr,
buffer1.get(), hostPtr, true, 0, 1);
csr, buffer1->getGraphicsAllocation(), hostPtr, true, 0, 1);
csr.blitWithHostPtr(blitProperties);
csr.blitBuffer(blitProperties);
hwParser.parseCommands<FamilyType>(csr.commandStream, offset);
@ -642,8 +641,8 @@ HWTEST_F(BcsTests, givenBufferWhenBlitOperationCalledThenProgramCorrectGpuAddres
HardwareParse hwParser;
auto offset = csr.commandStream.getUsed();
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::FromHostPtr,
buffer1.get(), hostPtr, true, 0, 1);
blitProperties.setHostPtrBuffer(buffer2.get());
csr, buffer1->getGraphicsAllocation(), nullptr, true, 0, 1);
blitProperties.srcAllocation = buffer2->getGraphicsAllocation();
csr.blitBuffer(blitProperties);
@ -672,9 +671,9 @@ HWTEST_F(BcsTests, givenBufferWithOffsetWhenBlitOperationCalledThenProgramCorrec
HardwareParse hwParser;
auto offset = csr.commandStream.getUsed();
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::FromHostPtr,
buffer1.get(), hostPtr, true, buffer1Offset, 1);
csr, buffer1->getGraphicsAllocation(), hostPtr, true, buffer1Offset, 1);
csr.blitWithHostPtr(blitProperties);
csr.blitBuffer(blitProperties);
hwParser.parseCommands<FamilyType>(csr.commandStream, offset);
@ -690,9 +689,9 @@ HWTEST_F(BcsTests, givenBufferWithOffsetWhenBlitOperationCalledThenProgramCorrec
HardwareParse hwParser;
auto offset = csr.commandStream.getUsed();
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::ToHostPtr,
buffer1.get(), hostPtr, true, buffer1Offset, 1);
csr, buffer1->getGraphicsAllocation(), hostPtr, true, buffer1Offset, 1);
csr.blitWithHostPtr(blitProperties);
csr.blitBuffer(blitProperties);
hwParser.parseCommands<FamilyType>(csr.commandStream, offset);
@ -709,8 +708,8 @@ HWTEST_F(BcsTests, givenBufferWithOffsetWhenBlitOperationCalledThenProgramCorrec
HardwareParse hwParser;
auto offset = csr.commandStream.getUsed();
auto blitProperties = BlitProperties::constructPropertiesForReadWriteBuffer(BlitterConstants::BlitWithHostPtrDirection::FromHostPtr,
buffer1.get(), hostPtr, true, buffer1Offset, 1);
blitProperties.setHostPtrBuffer(buffer2.get());
csr, buffer1->getGraphicsAllocation(), nullptr, true, buffer1Offset, 1);
blitProperties.srcAllocation = buffer2->getGraphicsAllocation();
blitProperties.srcOffset = buffer2Offset;
csr.blitBuffer(blitProperties);

2
unit_tests/kernel/kernel_tests.cpp
View File

@ -457,7 +457,7 @@ class CommandStreamReceiverMock : public CommandStreamReceiver {
void waitForTaskCountWithKmdNotifyFallback(uint32_t taskCountToWait, FlushStamp flushStampToWait, bool quickKmdSleep, bool forcePowerSavingMode) override {
}
void blitBuffer(BlitProperties &blitProperites) override{};
void blitBuffer(const BlitProperties &blitProperites) override{};
CompletionStamp flushTask(
LinearStream &commandStream,

2
unit_tests/libult/ult_command_stream_receiver.h
View File

@ -168,7 +168,7 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw<GfxFamily>, publ
return CommandStreamReceiverHw<GfxFamily>::obtainUniqueOwnership();
}
void blitBuffer(BlitProperties &blitProperites) override {
void blitBuffer(const BlitProperties &blitProperites) override {
blitBufferCalled++;
CommandStreamReceiverHw<GfxFamily>::blitBuffer(blitProperites);
}

1
unit_tests/mem_obj/buffer_tests.cpp
View File

@ -666,7 +666,6 @@ struct BcsBufferTests : public ::testing::Test {
}
DebugManager.flags.EnableTimestampPacket.set(1);
DebugManager.flags.EnableBlitterOperationsForReadWriteBuffers.set(true);
platform()->initialize();
device.reset(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
device->getExecutionEnvironment()->getMutableHardwareInfo()->capabilityTable.blitterOperationsSupported = true;
bcsMockContext = std::make_unique<BcsMockContext>(device.get());

2
unit_tests/mocks/mock_csr.h
View File

@ -254,7 +254,7 @@ class MockCommandStreamReceiver : public CommandStreamReceiver {
void waitForTaskCountWithKmdNotifyFallback(uint32_t taskCountToWait, FlushStamp flushStampToWait, bool quickKmdSleep, bool forcePowerSavingMode) override {
}
void blitBuffer(BlitProperties &blitProperites) override{};
void blitBuffer(const BlitProperties &blitProperites) override{};
void setOSInterface(OSInterface *osInterface);