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

Limit usage of blitter for images

Browse Source 
Change-Id: I15223ef4ebdbfef67b05647188bdd92d35a9dcad
Signed-off-by: Kamil Kopryk <kamil.kopryk@intel.com>
Related-To: NEO-4692
This commit is contained in:
Kamil Kopryk
2020-10-27 17:17:26 +01:00
committed by sys_ocldev
parent 4be05409a3
commit bc6ba0688e
9 changed files with 86 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
opencl/source/command_queue/command_queue.cpp
View File

@ -660,6 +660,11 @@ bool CommandQueue::blitEnqueueAllowed(cl_command_type cmdType) const {
}
}
bool CommandQueue::blitEnqueueImageAllowed(const size_t *origin, const size_t *region) {
return (origin[0] + region[0] <= BlitterConstants::maxBlitWidth) && (origin[1] + region[1] <= BlitterConstants::maxBlitHeight);
}
bool CommandQueue::isBlockedCommandStreamRequired(uint32_t commandType, const EventsRequest &eventsRequest, bool blockedQueue) const {
if (!blockedQueue) {
return false;

1
opencl/source/command_queue/command_queue.h
View File

@ -344,6 +344,7 @@ class CommandQueue : public BaseObject<_cl_command_queue> {
void providePerformanceHint(TransferProperties &transferProperties);
bool queueDependenciesClearRequired() const;
bool blitEnqueueAllowed(cl_command_type cmdType) const;
MOCKABLE_VIRTUAL bool blitEnqueueImageAllowed(const size_t *origin, const size_t *region);
void aubCaptureHook(bool &blocking, bool &clearAllDependencies, const MultiDispatchInfo &multiDispatchInfo);
virtual bool obtainTimestampPacketForCacheFlush(bool isCacheFlushRequired) const = 0;

2
opencl/source/command_queue/enqueue_read_image.h
View File

@ -42,7 +42,7 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadImage(
cl_event *event) {
cl_command_type cmdType = CL_COMMAND_READ_IMAGE;
auto blitAllowed = blitEnqueueAllowed(cmdType);
auto blitAllowed = blitEnqueueAllowed(cmdType) && blitEnqueueImageAllowed(origin, region);
auto &csr = getCommandStreamReceiver(blitAllowed);
if (nullptr == mapAllocation) {
notifyEnqueueReadImage(srcImage, static_cast<bool>(blockingRead), EngineHelpers::isBcs(csr.getOsContext().getEngineType()));

2
opencl/source/command_queue/enqueue_write_image.h
View File

@ -54,7 +54,7 @@ cl_int CommandQueueHw<GfxFamily>::enqueueWriteImage(
HostPtrSurface hostPtrSurf(srcPtr, hostPtrSize, true);
GeneralSurface mapSurface;
Surface *surfaces[] = {&dstImgSurf, nullptr};
auto blitAllowed = blitEnqueueAllowed(cmdType);
auto blitAllowed = blitEnqueueAllowed(cmdType) && blitEnqueueImageAllowed(origin, region);
if (mapAllocation) {
surfaces[1] = &mapSurface;
mapSurface.setGraphicsAllocation(mapAllocation);

26
opencl/test/unit_test/command_queue/command_queue_tests.cpp
View File

@ -1171,3 +1171,29 @@ TEST(CommandQueue, giveClCommandWhenCallingBlitEnqueueAllowedThenReturnCorrectVa
EXPECT_TRUE(queue.blitEnqueueAllowed(CL_COMMAND_WRITE_IMAGE));
EXPECT_FALSE(queue.blitEnqueueAllowed(CL_COMMAND_COPY_IMAGE));
}
TEST(CommandQueue, givenCopySizeAndOffsetWhenCallingBlitEnqueueImageAllowedThenReturnCorrectValue) {
MockContext context{};
MockCommandQueue queue(&context, context.getDevice(0), 0);
auto maxBlitWidth = static_cast<size_t>(BlitterConstants::maxBlitWidth);
auto maxBlitHeight = static_cast<size_t>(BlitterConstants::maxBlitHeight);
std::array<std::tuple<size_t, size_t, size_t, size_t, bool>, 7> testParams{
std::make_tuple(1, 1, 0, 0, true),
std::make_tuple(maxBlitWidth, maxBlitHeight, 0, 0, true),
std::make_tuple(maxBlitWidth + 1, maxBlitHeight, 0, 0, false),
std::make_tuple(maxBlitWidth, maxBlitHeight + 1, 0, 0, false),
std::make_tuple(maxBlitWidth, maxBlitHeight, 1, 0, false),
std::make_tuple(maxBlitWidth, maxBlitHeight, 0, 1, false),
std::make_tuple(maxBlitWidth - 1, maxBlitHeight - 1, 1, 1, true)};
for (auto &params : testParams) {
size_t region[3];
size_t origin[3];
bool expectedResult;
std::tie(region[0], region[1], origin[0], origin[1], expectedResult) = params;
EXPECT_EQ(expectedResult, queue.blitEnqueueImageAllowed(origin, region));
}
}

21
opencl/test/unit_test/command_queue/enqueue_read_image_tests.cpp
View File

@ -430,6 +430,27 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DThatIsZeroCopyWhenReadImageWithTheSam
pEvent->release();
}
HWTEST_F(EnqueueReadImageTest, givenDeviceWithBlitterSupportWhenEnqueueReadImageThenBlitEnqueueImageAllowedReturnsCorrectResult) {
DebugManagerStateRestore restorer;
DebugManager.flags.OverrideInvalidEngineWithDefault.set(1);
auto &capabilityTable = pClDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->capabilityTable;
capabilityTable.blitterOperationsSupported = true;
size_t origin[] = {0, 0, 0};
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
std::unique_ptr<Image> image(Image2dHelper<>::create(context));
{
size_t region[] = {BlitterConstants::maxBlitWidth + 1, BlitterConstants::maxBlitHeight, 1};
EnqueueReadImageHelper<>::enqueueReadImage(mockCmdQ.get(), image.get(), CL_TRUE, origin, region);
EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
}
{
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueReadImageHelper<>::enqueueReadImage(mockCmdQ.get(), image.get(), CL_TRUE, origin, region);
EXPECT_TRUE(mockCmdQ->isBlitEnqueueImageAllowed);
}
}
HWTEST_F(EnqueueReadImageTest, givenCommandQueueWhenEnqueueReadImageIsCalledThenItCallsNotifyFunction) {
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
std::unique_ptr<Image> srcImage(Image2dArrayHelper<>::create(context));

23
opencl/test/unit_test/command_queue/enqueue_write_image_tests.cpp
View File

@ -7,6 +7,7 @@
#include "shared/source/memory_manager/allocations_list.h"
#include "shared/source/memory_manager/memory_manager.h"
#include "shared/test/unit_test/helpers/debug_manager_state_restore.h"
#include "opencl/source/built_ins/builtins_dispatch_builder.h"
#include "opencl/test/unit_test/command_queue/enqueue_write_image_fixture.h"
@ -15,6 +16,7 @@
#include "opencl/test/unit_test/libult/ult_command_stream_receiver.h"
#include "opencl/test/unit_test/mocks/mock_builtin_dispatch_info_builder.h"
#include "opencl/test/unit_test/mocks/mock_builtins.h"
#include "opencl/test/unit_test/mocks/mock_command_queue.h"
#include "test.h"
#include "reg_configs_common.h"
@ -200,6 +202,27 @@ HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteImageTest, WhenWritingImageThenMediaVfeS
validateMediaVFEState<FamilyType>(&pDevice->getHardwareInfo(), cmdMediaVfeState, cmdList, itorMediaVfeState);
}
HWTEST_F(EnqueueWriteImageTest, givenDeviceWithBlitterSupportWhenEnqueueWriteImageThenBlitEnqueueImageAllowedReturnsCorrectResult) {
DebugManagerStateRestore restorer;
DebugManager.flags.OverrideInvalidEngineWithDefault.set(1);
auto &capabilityTable = pClDevice->getRootDeviceEnvironment().getMutableHardwareInfo()->capabilityTable;
capabilityTable.blitterOperationsSupported = true;
size_t origin[] = {0, 0, 0};
auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
std::unique_ptr<Image> image(Image2dHelper<>::create(context));
{
size_t region[] = {BlitterConstants::maxBlitWidth + 1, BlitterConstants::maxBlitHeight, 1};
EnqueueWriteImageHelper<>::enqueueWriteImage(mockCmdQ.get(), image.get(), CL_FALSE, origin, region);
EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
}
{
size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
EnqueueWriteImageHelper<>::enqueueWriteImage(mockCmdQ.get(), image.get(), CL_FALSE, origin, region);
EXPECT_TRUE(mockCmdQ->isBlitEnqueueImageAllowed);
}
}
HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenReadWriteImageIsCalledThenHostPtrSizeIsCalculatedProperly) {
auto dstImage2 = Image1dArrayHelper<>::create(context);
auto imageDesc = dstImage2->getImageDesc();

7
opencl/test/unit_test/mocks/mock_command_queue.h
View File

@ -19,6 +19,7 @@ namespace NEO {
class MockCommandQueue : public CommandQueue {
public:
using CommandQueue::blitEnqueueAllowed;
using CommandQueue::blitEnqueueImageAllowed;
using CommandQueue::bufferCpuCopyAllowed;
using CommandQueue::device;
using CommandQueue::gpgpuEngine;
@ -297,6 +298,11 @@ class MockCommandQueueHw : public CommandQueueHw<GfxFamily> {
return BaseClass::isCacheFlushForBcsRequired();
}
bool blitEnqueueImageAllowed(const size_t *origin, const size_t *region) override {
isBlitEnqueueImageAllowed = BaseClass::blitEnqueueImageAllowed(origin, region);
return isBlitEnqueueImageAllowed;
}
unsigned int lastCommandType;
std::vector<Kernel *> lastEnqueuedKernels;
MultiDispatchInfo storedMultiDispatchInfo;
@ -310,6 +316,7 @@ class MockCommandQueueHw : public CommandQueueHw<GfxFamily> {
bool notifyEnqueueSVMMemcpyCalled = false;
bool cpuDataTransferHandlerCalled = false;
bool useBcsCsrOnNotifyEnabled = false;
bool isBlitEnqueueImageAllowed = false;
struct OverrideReturnValue {
bool enabled = false;
bool returnValue = false;

2
shared/source/helpers/blit_commands_helper_base.inl
View File

@ -235,7 +235,7 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsRegion(const BlitPropert
auto srcSlicePitch = static_cast<uint32_t>(blitProperties.srcSlicePitch);
auto dstSlicePitch = static_cast<uint32_t>(blitProperties.dstSlicePitch);
UNRECOVERABLE_IF(blitProperties.copySize.x > BlitterConstants::maxBlitWidth || blitProperties.copySize.y > BlitterConstants::maxBlitWidth);
UNRECOVERABLE_IF(blitProperties.copySize.x > BlitterConstants::maxBlitWidth || blitProperties.copySize.y > BlitterConstants::maxBlitHeight);
auto bltCmd = GfxFamily::cmdInitXyCopyBlt;
bltCmd.setSourceBaseAddress(blitProperties.srcAllocation->getGpuAddress());