intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-05 09:09:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Implement cl_khr_mipmap_image [2/n]

Browse Source 
- Add mipmap handling for clEnqueueCopyImage
- Add mipmap handling for clEnqueueCopyImageToBuffer
- Add mipmap handling for clEnqueueCopyBufferToImage
- Fix typos

Change-Id: Ie1a23b1699135afa17fe11bcba3c1e8bdf9a3dd9
This commit is contained in:
Woloszyn, Wojciech
2018-03-21 14:35:26 +01:00
committed by sys_ocldev
parent c4c75e542e
commit ce2f1468b7
11 changed files with 384 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
unit_tests/command_queue/enqueue_copy_buffer_to_image_fixture.h
View File

@@ -69,4 +69,30 @@ struct EnqueueCopyBufferToImageTest : public CommandEnqueueFixture,
Buffer *srcBuffer;
Image *dstImage;
};
}
struct EnqueueCopyBufferToImageMipMapTest : public CommandEnqueueFixture,
public ::testing::Test,
public ::testing::WithParamInterface<uint32_t> {
EnqueueCopyBufferToImageMipMapTest() : srcBuffer(nullptr) {
}
virtual void SetUp(void) override {
CommandEnqueueFixture::SetUp();
BufferDefaults::context = new MockContext(pDevice);
context = new MockContext(pDevice);
srcBuffer = BufferHelper<>::create(context);
}
virtual void TearDown(void) override {
delete srcBuffer;
delete BufferDefaults::context;
delete context;
CommandEnqueueFixture::TearDown();
}
MockContext *context;
Buffer *srcBuffer;
};
} // namespace OCLRT

85
unit_tests/command_queue/enqueue_copy_buffer_to_image_tests.cpp
View File

@@ -24,6 +24,7 @@
#include "unit_tests/command_queue/enqueue_copy_buffer_to_image_fixture.h"
#include "test.h"
#include <algorithm>
#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h"
using namespace OCLRT;
@@ -253,3 +254,87 @@ HWTEST_F(EnqueueCopyBufferToImageTest, mediaVFEState) {
// Generically validate this command
FamilyType::PARSE::template validateCommand<MEDIA_VFE_STATE *>(cmdList.begin(), itorMediaVfeState);
}
typedef EnqueueCopyBufferToImageMipMapTest MipMapCopyBufferToImageTest;
HWTEST_P(MipMapCopyBufferToImageTest, GivenImageWithMipLevelNonZeroWhenCopyBufferToImageIsCalledThenProperMipLevelIsSet) {
auto image_type = (cl_mem_object_type)GetParam();
auto &origBuilder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice());
// substitute original builder with mock builder
auto oldBuilder = BuiltIns::getInstance().setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<OCLRT::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(BuiltIns::getInstance(), &origBuilder)));
cl_int retVal = CL_SUCCESS;
cl_image_desc imageDesc = {};
uint32_t expectedMipLevel = 3;
imageDesc.image_type = image_type;
imageDesc.num_mip_levels = 10;
imageDesc.image_width = 4;
imageDesc.image_height = 1;
imageDesc.image_depth = 1;
size_t origin[] = {0, 0, 0, 0};
size_t region[] = {imageDesc.image_width, 1, 1};
std::unique_ptr<Image> image;
switch (image_type) {
case CL_MEM_OBJECT_IMAGE1D:
origin[1] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
imageDesc.image_array_size = 2;
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
imageDesc.image_array_size = 2;
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
break;
}
EXPECT_NE(nullptr, image.get());
std::unique_ptr<uint32_t[]> ptr = std::unique_ptr<uint32_t[]>(new uint32_t[3]);
retVal = pCmdQ->enqueueCopyBufferToImage(srcBuffer,
image.get(),
0,
origin,
region,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedMipLevel, params->dstMipLevel);
// restore original builder and retrieve mock builder
auto newBuilder = BuiltIns::getInstance().setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::move(oldBuilder));
EXPECT_NE(nullptr, newBuilder);
}
INSTANTIATE_TEST_CASE_P(MipMapCopyBufferToImageTest_GivenImageWithMipLevelNonZeroWhenCopyBufferToImageIsCalledThenProperMipLevelIsSet,
MipMapCopyBufferToImageTest, ::testing::Values(CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D));

19
unit_tests/command_queue/enqueue_copy_image_fixture.h
View File

@@ -66,4 +66,21 @@ struct EnqueueCopyImageTest : public CommandEnqueueFixture,
Image *srcImage;
Image *dstImage;
};
}
struct EnqueueCopyImageMipMapTest : public CommandEnqueueFixture,
public ::testing::Test,
public ::testing::WithParamInterface<std::tuple<uint32_t, uint32_t>> {
void SetUp(void) override {
CommandEnqueueFixture::SetUp();
context = new MockContext(pDevice);
}
virtual void TearDown(void) override {
delete context;
CommandEnqueueFixture::TearDown();
}
MockContext *context;
};
} // namespace OCLRT

126
unit_tests/command_queue/enqueue_copy_image_tests.cpp
View File

@@ -24,6 +24,7 @@
#include "unit_tests/command_queue/enqueue_copy_image_fixture.h"
#include "test.h"
#include <algorithm>
#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h"
using namespace OCLRT;
@@ -262,3 +263,128 @@ HWTEST_F(EnqueueCopyImageTest, mediaVFEState) {
// Generically validate this command
FamilyType::PARSE::template validateCommand<MEDIA_VFE_STATE *>(cmdList.begin(), itorMediaVfeState);
}
typedef EnqueueCopyImageMipMapTest MipMapCopyImageTest;
HWTEST_P(MipMapCopyImageTest, GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCalledThenProperMipLevelsAreSet) {
cl_mem_object_type srcImageType, dstImageType;
std::tie(srcImageType, dstImageType) = GetParam();
auto &origBuilder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImageToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice());
// substitute original builder with mock builder
auto oldBuilder = BuiltIns::getInstance().setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImageToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<OCLRT::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(BuiltIns::getInstance(), &origBuilder)));
cl_int retVal = CL_SUCCESS;
cl_image_desc srcImageDesc = {};
uint32_t expectedSrcMipLevel = 3;
uint32_t expectedDstMipLevel = 4;
srcImageDesc.image_type = srcImageType;
srcImageDesc.num_mip_levels = 10;
srcImageDesc.image_width = 4;
srcImageDesc.image_height = 1;
srcImageDesc.image_depth = 1;
cl_image_desc dstImageDesc = srcImageDesc;
dstImageDesc.image_type = dstImageType;
size_t srcOrigin[] = {0, 0, 0, 0};
size_t dstOrigin[] = {0, 0, 0, 0};
size_t region[] = {srcImageDesc.image_width, 1, 1};
std::unique_ptr<Image> srcImage;
std::unique_ptr<Image> dstImage;
switch (srcImageType) {
case CL_MEM_OBJECT_IMAGE1D:
srcOrigin[1] = expectedSrcMipLevel;
srcImage = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &srcImageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
srcImageDesc.image_array_size = 2;
srcOrigin[2] = expectedSrcMipLevel;
srcImage = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &srcImageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
srcOrigin[2] = expectedSrcMipLevel;
srcImage = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &srcImageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
srcImageDesc.image_array_size = 2;
srcOrigin[3] = expectedSrcMipLevel;
srcImage = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &srcImageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
srcOrigin[3] = expectedSrcMipLevel;
srcImage = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &srcImageDesc));
break;
}
EXPECT_NE(nullptr, srcImage.get());
switch (dstImageType) {
case CL_MEM_OBJECT_IMAGE1D:
dstOrigin[1] = expectedDstMipLevel;
dstImage = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &dstImageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
dstImageDesc.image_array_size = 2;
dstOrigin[2] = expectedDstMipLevel;
dstImage = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &dstImageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
dstOrigin[2] = expectedDstMipLevel;
dstImage = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &dstImageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
dstImageDesc.image_array_size = 2;
dstOrigin[3] = expectedDstMipLevel;
dstImage = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &dstImageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
dstOrigin[3] = expectedDstMipLevel;
dstImage = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &dstImageDesc));
break;
}
EXPECT_NE(nullptr, dstImage.get());
retVal = pCmdQ->enqueueCopyImage(srcImage.get(),
dstImage.get(),
srcOrigin,
dstOrigin,
region,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedSrcMipLevel, params->srcMipLevel);
EXPECT_EQ(expectedDstMipLevel, params->dstMipLevel);
// restore original builder and retrieve mock builder
auto newBuilder = BuiltIns::getInstance().setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImageToImage3d,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::move(oldBuilder));
EXPECT_NE(nullptr, newBuilder);
}
uint32_t types[] = {CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D};
INSTANTIATE_TEST_CASE_P(MipMapCopyImageTest_GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCalledThenProperMipLevelsAreSet,
MipMapCopyImageTest,
::testing::Combine(
::testing::ValuesIn(types),
::testing::ValuesIn(types)));

27
unit_tests/command_queue/enqueue_copy_image_to_buffer_fixture.h
View File

@@ -68,4 +68,29 @@ struct EnqueueCopyImageToBufferTest : public CommandEnqueueFixture,
Image *srcImage;
Buffer *dstBuffer;
};
}
struct EnqueueCopyImageToBufferMipMapTest : public CommandEnqueueFixture,
public ::testing::Test,
public ::testing::WithParamInterface<uint32_t> {
EnqueueCopyImageToBufferMipMapTest() : dstBuffer(nullptr) {
}
virtual void SetUp(void) override {
CommandEnqueueFixture::SetUp();
BufferDefaults::context = new MockContext(pDevice);
context = new MockContext(pDevice);
dstBuffer = BufferHelper<>::create(context);
}
virtual void TearDown(void) override {
delete dstBuffer;
delete BufferDefaults::context;
delete context;
CommandEnqueueFixture::TearDown();
}
MockContext *context;
Buffer *dstBuffer;
};
} // namespace OCLRT

84
unit_tests/command_queue/enqueue_copy_image_to_buffer_tests.cpp
View File

@@ -24,6 +24,7 @@
#include "unit_tests/command_queue/enqueue_copy_image_to_buffer_fixture.h"
#include "test.h"
#include <algorithm>
#include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h"
using namespace OCLRT;
@@ -254,3 +255,86 @@ HWTEST_F(EnqueueCopyImageToBufferTest, mediaVFEState) {
// Generically validate this command
FamilyType::PARSE::template validateCommand<MEDIA_VFE_STATE *>(cmdList.begin(), itorMediaVfeState);
}
typedef EnqueueCopyImageToBufferMipMapTest MipMapCopyImageToBufferTest;
HWTEST_P(MipMapCopyImageToBufferTest, GivenImageWithMipLevelNonZeroWhenCopyImageToBufferIsCalledThenProperMipLevelIsSet) {
auto image_type = (cl_mem_object_type)GetParam();
auto &origBuilder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice());
// substitute original builder with mock builder
auto oldBuilder = BuiltIns::getInstance().setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::unique_ptr<OCLRT::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(BuiltIns::getInstance(), &origBuilder)));
cl_int retVal = CL_SUCCESS;
cl_image_desc imageDesc = {};
uint32_t expectedMipLevel = 3;
imageDesc.image_type = image_type;
imageDesc.num_mip_levels = 10;
imageDesc.image_width = 4;
imageDesc.image_height = 1;
imageDesc.image_depth = 1;
size_t origin[] = {0, 0, 0, 0};
size_t region[] = {imageDesc.image_width, 1, 1};
std::unique_ptr<Image> image;
switch (image_type) {
case CL_MEM_OBJECT_IMAGE1D:
origin[1] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
imageDesc.image_array_size = 2;
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
origin[2] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
imageDesc.image_array_size = 2;
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
origin[3] = expectedMipLevel;
image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
break;
}
EXPECT_NE(nullptr, image.get());
retVal = pCmdQ->enqueueCopyImageToBuffer(image.get(),
dstBuffer,
origin,
region,
0,
0,
nullptr,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedMipLevel, params->srcMipLevel);
// restore original builder and retrieve mock builder
auto newBuilder = BuiltIns::getInstance().setBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getContext(),
pCmdQ->getDevice(),
std::move(oldBuilder));
EXPECT_NE(nullptr, newBuilder);
}
INSTANTIATE_TEST_CASE_P(MipMapCopyImageToBufferTest_GivenImageWithMipLevelNonZeroWhenCopyImageToBufferIsCalledThenProperMipLevelIsSet,
MipMapCopyImageToBufferTest, ::testing::Values(CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D));

2
unit_tests/mem_obj/image_set_arg_tests.cpp
View File

@@ -292,7 +292,7 @@ HWTEST_F(ImageSetArgTest, clSetKernelArgImage) {
}
}
HWTEST_F(ImageSetArgTest, givenImage2DWithMipMapsWhenSetKernelArgIsCalledThenMipLevelAndMipCounttIsSet) {
HWTEST_F(ImageSetArgTest, givenImage2DWithMipMapsWhenSetKernelArgIsCalledThenMipLevelAndMipCountIsSet) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
cl_mem memObj = srcImage;
int mipLevel = 2;