intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-29 09:03:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

[1/n] Mipmap support

Browse Source 
* adding support for map/unmap
* adding support for origin/region validation with mipmaps
* fixing slices returned in map/unmap
* removing ambiguity around mipLevel naming
* enabling cl_khr_mipmap_image in current shape
* enabling cl_khr_mipmap_image_writes in current shape

* fixing CompileProgramWithReraFlag test

Change-Id: I0c9d83028c5c376f638e45151755fd2c7d0fb0ab
This commit is contained in:
Chodor, Jaroslaw
2018-04-04 09:29:48 +02:00
parent 6506df559b
commit 0a97dfbb2f
44 changed files with 777 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
unit_tests/command_queue/enqueue_map_buffer_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2017, Intel Corporation
* Copyright (c) 2017 - 2018, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
@@ -24,6 +24,7 @@
#include "unit_tests/command_queue/enqueue_map_buffer_fixture.h"
#include "unit_tests/fixtures/device_fixture.h"
#include "unit_tests/fixtures/buffer_fixture.h"
#include "unit_tests/mocks/mock_buffer.h"
#include "unit_tests/mocks/mock_context.h"
#include "unit_tests/mocks/mock_kernel.h"
#include "unit_tests/helpers/debug_manager_state_restore.h"
@@ -585,6 +586,27 @@ TEST_F(EnqueueMapBufferTest, GivenBufferThatIsNotZeroCopyWhenNonBlockingMapIsCal
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(EnqueueMapBufferTest, GivenWrongMemObjectWhenMapIsCalledThenInvalidMemObjectErrorCodeIsReturned) {
MockBuffer buffer;
cl_mem mem = &buffer;
buffer.magic = -1;
auto ptrResult = clEnqueueMapBuffer(
pCmdQ,
mem,
CL_FALSE,
CL_MAP_READ,
0,
8,
0,
nullptr,
nullptr,
&retVal);
EXPECT_EQ(nullptr, ptrResult);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
HWTEST_F(EnqueueMapBufferTest, MapBufferEventProperties) {
cl_event eventReturned = NULL;

116
unit_tests/command_queue/enqueue_map_image_tests.cpp
View File

@@ -67,6 +67,10 @@ struct EnqueueMapImageTest : public DeviceFixture,
char srcMemory[128];
};
struct EnqueueMapImageParamsTest : public EnqueueMapImageTest,
public ::testing::WithParamInterface<uint32_t> {
};
TEST_F(EnqueueMapImageTest, reuseMappedPtrForTiledImg) {
if (!image->allowTiling()) {
return;
@@ -118,6 +122,71 @@ TEST_F(EnqueueMapImageTest, givenAllocatedMapPtrAndMapWithDifferentOriginIsCalle
EXPECT_EQ(ptr2, ptrOffset(ptr1, mapOffset));
}
typedef EnqueueMapImageParamsTest MipMapMapImageParamsTest;
TEST_P(MipMapMapImageParamsTest, givenAllocatedMapPtrAndMapWithDifferentMipMapsIsCalledThenReturnDifferentPointers) {
auto image_type = (cl_mem_object_type)GetParam();
cl_int retVal = CL_SUCCESS;
cl_image_desc imageDesc = {};
imageDesc.image_type = image_type;
imageDesc.num_mip_levels = 10;
imageDesc.image_width = 4;
imageDesc.image_height = 1;
imageDesc.image_depth = 1;
const size_t origin1[4] = {0, 0, 0, 0};
size_t origin2[4] = {0, 0, 0, 0};
std::unique_ptr<Image> image;
switch (image_type) {
case CL_MEM_OBJECT_IMAGE1D:
origin2[1] = 1;
image = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE1D_ARRAY:
origin2[2] = 1;
imageDesc.image_array_size = 2;
image = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D:
origin2[2] = 1;
image = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE2D_ARRAY:
origin2[3] = 1;
imageDesc.image_array_size = 2;
image = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &imageDesc));
break;
case CL_MEM_OBJECT_IMAGE3D:
origin2[3] = 1;
image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &imageDesc));
break;
}
EXPECT_NE(nullptr, image.get());
auto mapFlags = CL_MAP_READ;
const size_t region[3] = {1, 1, 1};
auto ptr1 = pCmdQ->enqueueMapImage(image.get(), true, mapFlags, origin1,
region, nullptr, nullptr, 0,
nullptr, nullptr, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
auto ptr2 = pCmdQ->enqueueMapImage(image.get(), true, mapFlags, origin2,
region, nullptr, nullptr, 0,
nullptr, nullptr, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(ptr1, ptr2);
if (image->mappingOnCpuAllowed() == false) {
EXPECT_NE(nullptr, image->getAllocatedMapPtr());
}
size_t mapOffset = 16u;
EXPECT_EQ(ptr2, ptrOffset(ptr1, mapOffset));
}
INSTANTIATE_TEST_CASE_P(MipMapMapImageParamsTest_givenAllocatedMapPtrAndMapWithDifferentMipMapsIsCalledThenReturnDifferentPointers,
MipMapMapImageParamsTest, ::testing::Values(CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D));
template <typename GfxFamily>
struct mockedImage : public ImageHw<GfxFamily> {
using ImageHw<GfxFamily>::ImageHw;
@@ -146,7 +215,8 @@ HWTEST_F(EnqueueMapImageTest, givenTiledImageWhenMapImageIsCalledThenStorageIsSe
true,
true,
0,
&surfaceFormatInfo,
0,
surfaceFormatInfo,
nullptr);
mockImage.createFunction = image->createFunction;
@@ -699,7 +769,7 @@ TEST_F(EnqueueMapImageTest, givenBlockedCommandQueueWhenBlockingCpuMapIsCalledTh
}
};
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(context));
std::unique_ptr<Image> image(ImageHelper<Image1dArrayDefaults>::create(context));
EXPECT_TRUE(image->mappingOnCpuAllowed());
MyMockUserEvent blockingEvent;
@@ -712,6 +782,15 @@ TEST_F(EnqueueMapImageTest, givenBlockedCommandQueueWhenBlockingCpuMapIsCalledTh
EXPECT_NE(0u, retImageRowPitch);
EXPECT_NE(0u, retImageSlicePitch);
image.reset(ImageHelper<Image1dDefaults>::create(context));
pCmdQ->enqueueMapImage(image.get(), true, CL_MAP_READ, origin, region,
&retImageRowPitch, &retImageSlicePitch,
1, &blockingClEvent, nullptr, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(0u, retImageRowPitch);
EXPECT_EQ(0u, retImageSlicePitch);
}
TEST_F(EnqueueMapImageTest, givenZeroCopyImageWhenMappedOnCpuThenReturnImageRowAndSlicePitch) {
@@ -720,7 +799,7 @@ TEST_F(EnqueueMapImageTest, givenZeroCopyImageWhenMappedOnCpuThenReturnImageRowA
size_t retImageRowPitch = 0;
size_t retImageSlicePitch = 0;
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(context));
std::unique_ptr<Image> image(ImageHelper<Image1dArrayDefaults>::create(context));
EXPECT_TRUE(image->mappingOnCpuAllowed());
EXPECT_TRUE(image->isMemObjZeroCopy());
@@ -739,7 +818,7 @@ TEST_F(EnqueueMapImageTest, givenNonZeroCopyImageWhenMappedOnCpuThenReturnHostRo
size_t retImageRowPitch = 0;
size_t retImageSlicePitch = 0;
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context));
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dArrayDefaults>>::create(context));
EXPECT_TRUE(image->mappingOnCpuAllowed());
EXPECT_FALSE(image->isMemObjZeroCopy());
@@ -758,7 +837,7 @@ TEST_F(EnqueueMapImageTest, givenZeroCopyImageWhenMappedOnGpuThenReturnHostRowAn
size_t retImageRowPitch = 0;
size_t retImageSlicePitch = 0;
std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(context));
std::unique_ptr<Image> image(ImageHelper<Image1dArrayDefaults>::create(context));
image->setSharingHandler(new SharingHandler());
EXPECT_FALSE(image->mappingOnCpuAllowed());
EXPECT_TRUE(image->isMemObjZeroCopy());
@@ -778,7 +857,32 @@ TEST_F(EnqueueMapImageTest, givenNonZeroCopyImageWhenMappedOnGpuThenReturnHostRo
size_t retImageRowPitch = 0;
size_t retImageSlicePitch = 0;
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context));
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dArrayDefaults>>::create(context));
image->setSharingHandler(new SharingHandler());
EXPECT_FALSE(image->mappingOnCpuAllowed());
EXPECT_FALSE(image->isMemObjZeroCopy());
pCmdQ->enqueueMapImage(image.get(), true, CL_MAP_READ, origin, region,
&retImageRowPitch, &retImageSlicePitch,
0, nullptr, nullptr, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(image->getHostPtrRowPitch(), retImageRowPitch);
EXPECT_EQ(image->getHostPtrSlicePitch(), retImageSlicePitch);
}
TEST_F(EnqueueMapImageTest, givenMipMapImageWhenMappedThenReturnHostRowAndSlicePitch) {
const size_t origin[3] = {0, 0, 0};
const size_t region[3] = {1, 1, 1};
size_t retImageRowPitch = 0;
size_t retImageSlicePitch = 0;
cl_image_desc imageDesc = {};
imageDesc.image_type = CL_MEM_OBJECT_IMAGE1D;
imageDesc.num_mip_levels = 10;
imageDesc.image_width = 4;
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dArrayDefaults>>::create(context, &imageDesc));
image->setSharingHandler(new SharingHandler());
EXPECT_FALSE(image->mappingOnCpuAllowed());
EXPECT_FALSE(image->isMemObjZeroCopy());

6
unit_tests/command_queue/multiple_map_buffer_tests.cpp
View File

@@ -311,9 +311,9 @@ HWTEST_F(MultipleMapBufferTest, givenMultimpleMapsWhenUnmappingThenRemoveCorrect
auto cmdQ = createMockCmdQ<FamilyType>();
MapInfo mappedPtrs[3] = {
{nullptr, 1, {{1, 0, 0}}, {{1, 0, 0}}},
{nullptr, 1, {{2, 0, 0}}, {{2, 0, 0}}},
{nullptr, 1, {{5, 0, 0}}, {{5, 0, 0}}},
{nullptr, 1, {{1, 0, 0}}, {{1, 0, 0}}, 0},
{nullptr, 1, {{2, 0, 0}}, {{2, 0, 0}}, 0},
{nullptr, 1, {{5, 0, 0}}, {{5, 0, 0}}, 0},
};
for (size_t i = 0; i < 3; i++) {

8
unit_tests/command_queue/multiple_map_image_tests.cpp
View File

@@ -108,7 +108,7 @@ struct MultipleMapImageTest : public DeviceFixture, public ::testing::Test {
auto surfaceFormat = Image::getSurfaceFormatFromTable(Traits::flags, &Traits::imageFormat);
auto img = new MockImage<FamilyType>(context, Traits::flags, 1024, Traits::hostPtr,
Traits::imageFormat, Traits::imageDesc, false, mockAlloc, false,
tiledImage, 0, surfaceFormat);
tiledImage, 0, 0, *surfaceFormat);
return std::unique_ptr<MockImage<FamilyType>>(img);
}
@@ -321,9 +321,9 @@ HWTEST_F(MultipleMapImageTest, givenMultimpleMapsWhenUnmappingThenRemoveCorrectP
auto cmdQ = createMockCmdQ<FamilyType>();
MapInfo mappedPtrs[3] = {
{nullptr, 1, {{1, 1, 1}}, {{1, 1, 1}}},
{nullptr, 1, {{4, 4, 2}}, {{4, 4, 4}}},
{nullptr, 1, {{10, 10, 10}}, {{10, 10, 10}}}};
{nullptr, 1, {{1, 1, 1}}, {{1, 1, 1}}, 0},
{nullptr, 1, {{4, 4, 2}}, {{4, 4, 4}}, 0},
{nullptr, 1, {{10, 10, 10}}, {{10, 10, 10}}, 0}};
for (size_t i = 0; i < 3; i++) {
mappedPtrs[i].ptr = clEnqueueMapImage(cmdQ.get(), image.get(), CL_TRUE, CL_MAP_WRITE, &mappedPtrs[i].offset[0], &mappedPtrs[i].size[0],