Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Checking builtinParams passed to Multidispatch 

Change-Id: Idb6c30dc5bb46403cea12acbf5174c6d9ddfbd3e
Signed-off-by: Daria Hinz <daria.hinz@intel.com>
This commit is contained in:
Daria Hinz 2019-07-18 15:52:55 +02:00 committed by sys_ocldev
parent dcd8728519
commit 06d14cdcae
13 changed files with 309 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
runtime/built_ins/built_ins.cpp
View File

@ -795,13 +795,6 @@ BuiltinDispatchInfoBuilder &BuiltIns::getBuiltinDispatchInfoBuilder(EBuiltInOps:
return *operationBuilder.first;
}
std::unique_ptr<BuiltinDispatchInfoBuilder> BuiltIns::setBuiltinDispatchInfoBuilder(EBuiltInOps::Type operation, Context &context, Device &device, std::unique_ptr<BuiltinDispatchInfoBuilder> builder) {
uint32_t operationId = static_cast<uint32_t>(operation);
auto &operationBuilder = BuiltinOpsBuilders[operationId];
operationBuilder.first.swap(builder);
return builder;
}
BuiltInOwnershipWrapper::BuiltInOwnershipWrapper(BuiltinDispatchInfoBuilder &inputBuilder, Context *context) {
takeOwnership(inputBuilder, context);
}

3
runtime/built_ins/built_ins.h
View File

@ -159,8 +159,7 @@ class BuiltIns {
std::pair<std::unique_ptr<BuiltinDispatchInfoBuilder>, std::once_flag> BuiltinOpsBuilders[static_cast<uint32_t>(EBuiltInOps::COUNT)];
BuiltinDispatchInfoBuilder &getBuiltinDispatchInfoBuilder(EBuiltInOps::Type op, Context &context, Device &device);
std::unique_ptr<BuiltinDispatchInfoBuilder> setBuiltinDispatchInfoBuilder(EBuiltInOps::Type op, Context &context, Device &device,
std::unique_ptr<BuiltinDispatchInfoBuilder> newBuilder);
BuiltIns();
virtual ~BuiltIns();

175
unit_tests/command_queue/command_queue_hw_tests.cpp
View File

@ -13,8 +13,10 @@
#include "unit_tests/fixtures/buffer_fixture.h"
#include "unit_tests/fixtures/context_fixture.h"
#include "unit_tests/fixtures/device_fixture.h"
#include "unit_tests/fixtures/image_fixture.h"
#include "unit_tests/helpers/unit_test_helper.h"
#include "unit_tests/mocks/mock_buffer.h"
#include "unit_tests/mocks/mock_builtins.h"
#include "unit_tests/mocks/mock_command_queue.h"
#include "unit_tests/mocks/mock_csr.h"
#include "unit_tests/mocks/mock_event.h"
@ -704,6 +706,7 @@ struct MockBuilder : BuiltinDispatchInfoBuilder {
}
bool buildDispatchInfos(MultiDispatchInfo &d, const BuiltinOpParams &conf) const override {
wasBuildDispatchInfosWithBuiltinOpParamsCalled = true;
paramsReceived.multiDispatchInfo.setBuiltinOpParams(conf);
return true;
}
bool buildDispatchInfos(MultiDispatchInfo &d, Kernel *kernel,
@ -737,6 +740,178 @@ struct MockBuilder : BuiltinDispatchInfoBuilder {
Params paramsToUse;
};
struct BuiltinParamsCommandQueueHwTests : public CommandQueueHwTest {
void SetUpImpl(EBuiltInOps::Type operation) {
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto swapBuilder = builtIns->setBuiltinDispatchInfoBuilder(
operation,
*pContext,
*pDevice,
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuilder(*builtIns)));
mockBuilder = static_cast<MockBuilder *>(&builtIns->getBuiltinDispatchInfoBuilder(
operation,
*pContext,
*pDevice));
}
MockBuilder *mockBuilder;
};
HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadWriteBufferCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) {
SetUpImpl(EBuiltInOps::CopyBufferToBuffer);
BufferDefaults::context = context;
auto buffer = clUniquePtr(BufferHelper<>::create());
char array[3 * MemoryConstants::cacheLineSize];
char *ptr = &array[MemoryConstants::cacheLineSize];
ptr = alignUp(ptr, MemoryConstants::cacheLineSize);
ptr -= 1;
cl_int status = pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 0, ptr, nullptr, 0, 0, nullptr);
EXPECT_EQ(CL_SUCCESS, status);
void *alignedPtr = alignDown(ptr, 4);
size_t ptrOffset = ptrDiff(ptr, alignedPtr);
Vec3<size_t> offset = {0, 0, 0};
auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams();
EXPECT_EQ(alignedPtr, builtinParams.dstPtr);
EXPECT_EQ(ptrOffset, builtinParams.dstOffset.x);
EXPECT_EQ(offset, builtinParams.srcOffset);
status = pCmdQ->enqueueWriteBuffer(buffer.get(), CL_FALSE, 0, 0, ptr, nullptr, 0, 0, nullptr);
EXPECT_EQ(CL_SUCCESS, status);
builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams();
EXPECT_EQ(alignedPtr, builtinParams.srcPtr);
EXPECT_EQ(ptrOffset, builtinParams.srcOffset.x);
EXPECT_EQ(offset, builtinParams.dstOffset);
}
HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueWriteImageCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) {
SetUpImpl(EBuiltInOps::CopyBufferToImage3d);
std::unique_ptr<Image> dstImage(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
auto imageDesc = dstImage->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 0};
size_t rowPitch = dstImage->getHostPtrRowPitch();
size_t slicePitch = dstImage->getHostPtrSlicePitch();
char array[3 * MemoryConstants::cacheLineSize];
char *ptr = &array[MemoryConstants::cacheLineSize];
ptr = alignUp(ptr, MemoryConstants::cacheLineSize);
ptr -= 1;
void *alignedPtr = alignDown(ptr, 4);
size_t ptrOffset = ptrDiff(ptr, alignedPtr);
Vec3<size_t> offset = {0, 0, 0};
cl_int status = pCmdQ->enqueueWriteImage(dstImage.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
nullptr,
0,
0,
nullptr);
EXPECT_EQ(CL_SUCCESS, status);
auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams();
EXPECT_EQ(alignedPtr, builtinParams.srcPtr);
EXPECT_EQ(ptrOffset, builtinParams.srcOffset.x);
EXPECT_EQ(offset, builtinParams.dstOffset);
}
HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadImageCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) {
SetUpImpl(EBuiltInOps::CopyImage3dToBuffer);
std::unique_ptr<Image> dstImage(ImageHelper<ImageUseHostPtr<Image2dDefaults>>::create(context));
auto imageDesc = dstImage->getImageDesc();
size_t origin[] = {0, 0, 0};
size_t region[] = {imageDesc.image_width, imageDesc.image_height, 0};
size_t rowPitch = dstImage->getHostPtrRowPitch();
size_t slicePitch = dstImage->getHostPtrSlicePitch();
char array[3 * MemoryConstants::cacheLineSize];
char *ptr = &array[MemoryConstants::cacheLineSize];
ptr = alignUp(ptr, MemoryConstants::cacheLineSize);
ptr -= 1;
void *alignedPtr = alignDown(ptr, 4);
size_t ptrOffset = ptrDiff(ptr, alignedPtr);
Vec3<size_t> offset = {0, 0, 0};
cl_int status = pCmdQ->enqueueReadImage(dstImage.get(),
CL_FALSE,
origin,
region,
rowPitch,
slicePitch,
ptr,
nullptr,
0,
0,
nullptr);
EXPECT_EQ(CL_SUCCESS, status);
auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams();
EXPECT_EQ(alignedPtr, builtinParams.dstPtr);
EXPECT_EQ(ptrOffset, builtinParams.dstOffset.x);
EXPECT_EQ(offset, builtinParams.srcOffset);
}
HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadWriteBufferRectCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) {
SetUpImpl(EBuiltInOps::CopyBufferRect);
BufferDefaults::context = context;
auto buffer = clUniquePtr(BufferHelper<>::create());
size_t bufferOrigin[3] = {0, 0, 0};
size_t hostOrigin[3] = {0, 0, 0};
size_t region[3] = {0, 0, 0};
char array[3 * MemoryConstants::cacheLineSize];
char *ptr = &array[MemoryConstants::cacheLineSize];
ptr = alignUp(ptr, MemoryConstants::cacheLineSize);
ptr -= 1;
cl_int status = pCmdQ->enqueueReadBufferRect(buffer.get(), CL_FALSE, bufferOrigin, hostOrigin, region, 0, 0, 0, 0, ptr, 0, 0, nullptr);
void *alignedPtr = alignDown(ptr, 4);
size_t ptrOffset = ptrDiff(ptr, alignedPtr);
Vec3<size_t> offset = {0, 0, 0};
auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams();
EXPECT_EQ(alignedPtr, builtinParams.dstPtr);
EXPECT_EQ(ptrOffset, builtinParams.dstOffset.x);
EXPECT_EQ(offset, builtinParams.srcOffset);
status = pCmdQ->enqueueWriteBufferRect(buffer.get(), CL_FALSE, bufferOrigin, hostOrigin, region, 0, 0, 0, 0, ptr, 0, 0, nullptr);
EXPECT_EQ(CL_SUCCESS, status);
builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams();
EXPECT_EQ(alignedPtr, builtinParams.srcPtr);
EXPECT_EQ(offset, builtinParams.dstOffset);
EXPECT_EQ(ptrOffset, builtinParams.srcOffset.x);
}
HWTEST_F(CommandQueueHwTest, givenCommandQueueThatIsBlockedAndUsesCpuCopyWhenEventIsReturnedItIsNotReady) {
CommandQueueHw<FamilyType> *cmdQHw = static_cast<CommandQueueHw<FamilyType> *>(this->pCmdQ);
MockBuffer buffer;

14
unit_tests/command_queue/enqueue_copy_buffer_to_image_tests.cpp
View File

@ -11,6 +11,7 @@
#include "unit_tests/gen_common/gen_commands_common_validation.h"
#include "unit_tests/helpers/unit_test_helper.h"
#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h"
#include "unit_tests/mocks/mock_builtins.h"
#include "reg_configs_common.h"
@ -189,18 +190,19 @@ typedef EnqueueCopyBufferToImageMipMapTest MipMapCopyBufferToImageTest;
HWTEST_P(MipMapCopyBufferToImageTest, GivenImageWithMipLevelNonZeroWhenCopyBufferToImageIsCalledThenProperMipLevelIsSet) {
auto image_type = (cl_mem_object_type)GetParam();
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &origBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(builtIns, &origBuilder)));
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, &origBuilder)));
cl_int retVal = CL_SUCCESS;
cl_image_desc imageDesc = {};
@ -251,7 +253,7 @@ HWTEST_P(MipMapCopyBufferToImageTest, GivenImageWithMipLevelNonZeroWhenCopyBuffe
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
@ -259,7 +261,7 @@ HWTEST_P(MipMapCopyBufferToImageTest, GivenImageWithMipLevelNonZeroWhenCopyBuffe
EXPECT_EQ(expectedMipLevel, params->dstMipLevel);
// restore original builder and retrieve mock builder
auto newBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto newBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice(),

14
unit_tests/command_queue/enqueue_copy_image_tests.cpp
View File

@ -11,6 +11,7 @@
#include "unit_tests/gen_common/gen_commands_common_validation.h"
#include "unit_tests/helpers/unit_test_helper.h"
#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h"
#include "unit_tests/mocks/mock_builtins.h"
#include "reg_configs_common.h"
@ -199,17 +200,18 @@ typedef EnqueueCopyImageMipMapTest MipMapCopyImageTest;
HWTEST_P(MipMapCopyImageTest, GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCalledThenProperMipLevelsAreSet) {
cl_mem_object_type srcImageType, dstImageType;
std::tie(srcImageType, dstImageType) = GetParam();
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &origBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImageToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImageToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(builtIns, &origBuilder)));
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, &origBuilder)));
cl_int retVal = CL_SUCCESS;
cl_image_desc srcImageDesc = {};
@ -295,7 +297,7 @@ HWTEST_P(MipMapCopyImageTest, GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCall
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
@ -304,7 +306,7 @@ HWTEST_P(MipMapCopyImageTest, GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCall
EXPECT_EQ(expectedDstMipLevel, params->dstMipLevel);
// restore original builder and retrieve mock builder
auto newBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto newBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImageToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice(),

14
unit_tests/command_queue/enqueue_copy_image_to_buffer_tests.cpp
View File

@ -11,6 +11,7 @@
#include "unit_tests/gen_common/gen_commands_common_validation.h"
#include "unit_tests/helpers/unit_test_helper.h"
#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h"
#include "unit_tests/mocks/mock_builtins.h"
#include "reg_configs_common.h"
@ -190,18 +191,19 @@ typedef EnqueueCopyImageToBufferMipMapTest MipMapCopyImageToBufferTest;
HWTEST_P(MipMapCopyImageToBufferTest, GivenImageWithMipLevelNonZeroWhenCopyImageToBufferIsCalledThenProperMipLevelIsSet) {
auto image_type = (cl_mem_object_type)GetParam();
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &origBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(builtIns, &origBuilder)));
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, &origBuilder)));
cl_int retVal = CL_SUCCESS;
cl_image_desc imageDesc = {};
@ -251,7 +253,7 @@ HWTEST_P(MipMapCopyImageToBufferTest, GivenImageWithMipLevelNonZeroWhenCopyImage
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
@ -259,7 +261,7 @@ HWTEST_P(MipMapCopyImageToBufferTest, GivenImageWithMipLevelNonZeroWhenCopyImage
EXPECT_EQ(expectedMipLevel, params->srcMipLevel);
// restore original builder and retrieve mock builder
auto newBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto newBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),

28
unit_tests/command_queue/enqueue_read_image_tests.cpp
View File

@ -13,6 +13,7 @@
#include "unit_tests/gen_common/gen_commands_common_validation.h"
#include "unit_tests/helpers/unit_test_helper.h"
#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h"
#include "unit_tests/mocks/mock_builtins.h"
#include "unit_tests/mocks/mock_command_queue.h"
#include "reg_configs_common.h"
@ -239,19 +240,20 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenHostPtr
}
HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenRowPitchIsSetToSlicePitch) {
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
EBuiltInOps::Type copyBuiltIn = EBuiltInOps::CopyImage3dToBuffer;
auto &origBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getContext(),
pCmdQ->getDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(builtIns, &origBuilder)));
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, &origBuilder)));
auto srcImage = Image1dArrayHelper<>::create(context);
auto imageDesc = srcImage->getImageDesc();
@ -262,14 +264,14 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenRowPitc
EnqueueReadImageHelper<>::enqueueReadImage(pCmdQ, srcImage, CL_TRUE, origin, region, rowPitch, slicePitch);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns.getBuiltinDispatchInfoBuilder(copyBuiltIn,
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(copyBuiltIn,
pCmdQ->getContext(),
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(params->srcRowPitch, slicePitch);
// restore original builder and retrieve mock builder
auto newBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto newBuilder = builtIns->setBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getContext(),
pCmdQ->getDevice(),
@ -486,20 +488,20 @@ HWTEST_F(EnqueueReadImageTest, givenEnqueueReadImageNonBlockingWhenAUBDumpAllocs
typedef EnqueueReadImageMipMapTest MipMapReadImageTest;
HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalledThenProperMipLevelIsSet) {
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto image_type = (cl_mem_object_type)GetParam();
auto &origBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(builtIns, &origBuilder)));
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, &origBuilder)));
cl_int retVal = CL_SUCCESS;
cl_image_desc imageDesc = {};
@ -553,7 +555,7 @@ HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalled
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
@ -561,7 +563,7 @@ HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalled
EXPECT_EQ(expectedMipLevel, params->srcMipLevel);
// restore original builder and retrieve mock builder
auto newBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto newBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),

41
unit_tests/command_queue/enqueue_svm_mem_copy_tests.cpp
View File

@ -11,6 +11,7 @@
#include "unit_tests/command_queue/command_queue_fixture.h"
#include "unit_tests/fixtures/device_fixture.h"
#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h"
#include "unit_tests/mocks/mock_builtins.h"
using namespace NEO;
@ -64,21 +65,21 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
return;
}
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
// retrieve original builder
auto &origBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice());
ASSERT_NE(nullptr, &origBuilder);
// substitute original builder with mock builder
auto oldBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(builtIns, &origBuilder)));
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, &origBuilder)));
EXPECT_EQ(&origBuilder, oldBuilder.get());
// call enqueue on mock builder
@ -94,7 +95,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
EXPECT_EQ(CL_SUCCESS, retVal);
// restore original builder and retrieve mock builder
auto newBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto newBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
@ -102,7 +103,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
EXPECT_NE(nullptr, newBuilder);
// check if original builder is restored correctly
auto &restoredBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto &restoredBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice());
@ -140,22 +141,23 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
return;
}
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
void *srcHostPtr = alignedMalloc(256, 64);
// retrieve original builder
auto &origBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice());
ASSERT_NE(nullptr, &origBuilder);
// substitute original builder with mock builder
auto oldBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(builtIns, &origBuilder)));
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, &origBuilder)));
EXPECT_EQ(&origBuilder, oldBuilder.get());
// call enqueue on mock builder
@ -171,7 +173,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
EXPECT_EQ(CL_SUCCESS, retVal);
// restore original builder and retrieve mock builder
auto newBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto newBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
@ -179,7 +181,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
EXPECT_NE(nullptr, newBuilder);
// check if original builder is restored correctly
auto &restoredBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto &restoredBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice());
@ -218,22 +220,23 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
return;
}
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto dstHostPtr = alignedMalloc(256, 64);
// retrieve original builder
auto &origBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice());
ASSERT_NE(nullptr, &origBuilder);
// substitute original builder with mock builder
auto oldBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(builtIns, &origBuilder)));
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, &origBuilder)));
EXPECT_EQ(&origBuilder, oldBuilder.get());
// call enqueue on mock builder
@ -249,7 +252,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
EXPECT_EQ(CL_SUCCESS, retVal);
// restore original builder and retrieve mock builder
auto newBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto newBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
@ -257,7 +260,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
EXPECT_NE(nullptr, newBuilder);
// check if original builder is restored correctly
auto &restoredBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto &restoredBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice());

14
unit_tests/command_queue/enqueue_svm_mem_fill_tests.cpp
View File

@ -11,6 +11,7 @@
#include "unit_tests/command_queue/command_queue_fixture.h"
#include "unit_tests/fixtures/device_fixture.h"
#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h"
#include "unit_tests/mocks/mock_builtins.h"
using namespace NEO;
@ -71,21 +72,22 @@ HWTEST_P(EnqueueSvmMemFillTest, givenEnqueueSVMMemFillWhenUsingFillBufferBuilder
size_t patternSize;
};
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
// retrieve original builder
auto &origBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::FillBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice());
ASSERT_NE(nullptr, &origBuilder);
// substitute original builder with mock builder
auto oldBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::FillBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockFillBufferBuilder(builtIns, &origBuilder, pattern, patternSize)));
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockFillBufferBuilder(*builtIns, &origBuilder, pattern, patternSize)));
EXPECT_EQ(&origBuilder, oldBuilder.get());
// call enqueue on mock builder
@ -101,7 +103,7 @@ HWTEST_P(EnqueueSvmMemFillTest, givenEnqueueSVMMemFillWhenUsingFillBufferBuilder
EXPECT_EQ(CL_SUCCESS, retVal);
// restore original builder and retrieve mock builder
auto newBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto newBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::FillBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
@ -109,7 +111,7 @@ HWTEST_P(EnqueueSvmMemFillTest, givenEnqueueSVMMemFillWhenUsingFillBufferBuilder
EXPECT_NE(nullptr, newBuilder);
// check if original builder is restored correctly
auto &restoredBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto &restoredBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::FillBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice());

30
unit_tests/command_queue/enqueue_write_image_tests.cpp
View File

@ -13,6 +13,7 @@
#include "unit_tests/gen_common/gen_commands_common_validation.h"
#include "unit_tests/helpers/unit_test_helper.h"
#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h"
#include "unit_tests/mocks/mock_builtins.h"
#include "reg_configs_common.h"
@ -217,19 +218,22 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenReadWriteImageIsCalledThenH
}
HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenWriteImageIsCalledThenRowPitchIsSetToSlicePitch) {
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
EBuiltInOps::Type copyBuiltIn = EBuiltInOps::CopyBufferToImage3d;
auto &origBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getContext(),
pCmdQ->getDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(builtIns, &origBuilder)));
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, &origBuilder)));
std::unique_ptr<Image> image;
auto destImage = Image1dArrayHelper<>::create(context);
@ -241,14 +245,14 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenWriteImageIsCalledThenRowPi
EnqueueWriteImageHelper<>::enqueueWriteImage(pCmdQ, destImage, CL_FALSE, origin, region, rowPitch, slicePitch);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns.getBuiltinDispatchInfoBuilder(copyBuiltIn,
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(copyBuiltIn,
pCmdQ->getContext(),
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(params->dstRowPitch, slicePitch);
// restore original builder and retrieve mock builder
auto newBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto newBuilder = builtIns->setBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getContext(),
pCmdQ->getDevice(),
@ -413,18 +417,20 @@ typedef EnqueueWriteImageMipMapTest MipMapWriteImageTest;
HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalledThenProperMipLevelIsSet) {
auto image_type = (cl_mem_object_type)GetParam();
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &origBuilder = builtIns.getBuiltinDispatchInfoBuilder(
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice());
// substitute original builder with mock builder
auto oldBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto oldBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(builtIns, &origBuilder)));
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, &origBuilder)));
cl_int retVal = CL_SUCCESS;
cl_image_desc imageDesc = {};
@ -481,7 +487,7 @@ HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalle
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
@ -489,7 +495,7 @@ HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalle
EXPECT_EQ(expectedMipLevel, params->dstMipLevel);
// restore original builder and retrieve mock builder
auto newBuilder = builtIns.setBuiltinDispatchInfoBuilder(
auto newBuilder = builtIns->setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice(),

1
unit_tests/mocks/CMakeLists.txt
View File

@ -18,6 +18,7 @@ set(IGDRCL_SRCS_tests_mocks
${CMAKE_CURRENT_SOURCE_DIR}/mock_block_kernel_manager.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_buffer.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_builtins.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_builtins.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_cif.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_cif.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_command_queue.h

20
unit_tests/mocks/mock_builtins.cpp Normal file
View File

@ -0,0 +1,20 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "unit_tests/mocks/mock_builtins.h"
namespace NEO {
std::unique_ptr<BuiltinDispatchInfoBuilder> MockBuiltins::setBuiltinDispatchInfoBuilder(EBuiltInOps::Type operation, Context &context, Device &device, std::unique_ptr<BuiltinDispatchInfoBuilder> builder) {
uint32_t operationId = static_cast<uint32_t>(operation);
auto &operationBuilder = BuiltinOpsBuilders[operationId];
std::call_once(operationBuilder.second, [] {});
operationBuilder.first.swap(builder);
return builder;
}
} // namespace NEO

18
unit_tests/mocks/mock_builtins.h
View File

@ -8,14 +8,17 @@
#pragma once
#include "runtime/built_ins/built_ins.h"
#include "runtime/built_ins/builtins_dispatch_builder.h"
#include "runtime/built_ins/sip.h"
#include "runtime/program/program.h"
#include <memory>
class MockBuiltins : public NEO::BuiltIns {
namespace NEO {
class MockBuiltins : public BuiltIns {
public:
const NEO::SipKernel &getSipKernel(NEO::SipKernelType type, NEO::Device &device) override {
const SipKernel &getSipKernel(SipKernelType type, Device &device) override {
if (sipKernelsOverride.find(type) != sipKernelsOverride.end()) {
return *sipKernelsOverride[type];
}
@ -24,12 +27,13 @@ class MockBuiltins : public NEO::BuiltIns {
return BuiltIns::getSipKernel(type, device);
}
void overrideSipKernel(std::unique_ptr<NEO::SipKernel> kernel) {
void overrideSipKernel(std::unique_ptr<SipKernel> kernel) {
sipKernelsOverride[kernel->getType()] = std::move(kernel);
}
NEO::BuiltIns *originalGlobalBuiltins = nullptr;
std::map<NEO::SipKernelType, std::unique_ptr<NEO::SipKernel>> sipKernelsOverride;
std::unique_ptr<BuiltinDispatchInfoBuilder> setBuiltinDispatchInfoBuilder(EBuiltInOps::Type operation, Context &context, Device &device, std::unique_ptr<BuiltinDispatchInfoBuilder> builder);
BuiltIns *originalGlobalBuiltins = nullptr;
std::map<SipKernelType, std::unique_ptr<SipKernel>> sipKernelsOverride;
bool getSipKernelCalled = false;
NEO::SipKernelType getSipKernelType = NEO::SipKernelType::COUNT;
SipKernelType getSipKernelType = SipKernelType::COUNT;
};
} // namespace NEO