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

Patch flat image params on setKernelArg 

Change-Id: Iae0f37dfcd2ee14a3874835f2e444549d1769074
Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com>
This commit is contained in:
Dunajski, Bartosz 2019-12-10 10:06:00 +01:00 committed by sys_ocldev
parent 195f610fa3
commit 3eab5cfe35
6 changed files with 88 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
runtime/kernel/kernel.cpp
View File

@ -1387,6 +1387,12 @@ cl_int Kernel::setArgImageWithMipLevel(uint32_t argIndex,
patch<uint32_t, cl_channel_order>(imageFormat.image_channel_order, crossThreadData, kernelArgInfo.offsetChannelOrder);
patch<uint32_t, uint32_t>(kernelArgInfo.offsetHeap, crossThreadData, kernelArgInfo.offsetObjectId);
patch<uint32_t, cl_uint>(imageDesc.num_mip_levels, crossThreadData, kernelArgInfo.offsetNumMipLevels);
patch<uint64_t, uint64_t>(pImage->getGraphicsAllocation()->getGpuAddress(), crossThreadData, kernelArgInfo.offsetFlatBaseOffset);
patch<uint32_t, size_t>(imageDesc.image_width - 1, crossThreadData, kernelArgInfo.offsetFlatWidth);
patch<uint32_t, size_t>(imageDesc.image_height - 1, crossThreadData, kernelArgInfo.offsetFlatHeight);
patch<uint32_t, size_t>(imageDesc.image_row_pitch - 1, crossThreadData, kernelArgInfo.offsetFlatPitch);
addAllocationToCacheFlushVector(argIndex, pImage->getGraphicsAllocation());
retVal = CL_SUCCESS;
}

4
runtime/program/kernel_arg_info.h
View File

@ -55,6 +55,10 @@ struct KernelArgInfo {
uint32_t offsetObjectId = undefinedOffset;
uint32_t offsetBufferOffset = undefinedOffset;
uint32_t offsetNumMipLevels = undefinedOffset;
uint32_t offsetFlatBaseOffset = undefinedOffset;
uint32_t offsetFlatWidth = undefinedOffset;
uint32_t offsetFlatHeight = undefinedOffset;
uint32_t offsetFlatPitch = undefinedOffset;
bool needPatch = false;
bool isTransformable = false;

4
runtime/program/kernel_info_from_patchtokens.cpp
View File

@ -74,6 +74,10 @@ void populateKernelInfoArg(KernelInfo &dstKernelInfo, KernelArgInfo &dstKernelIn
dstKernelInfoArg.offsetArraySize = getOffset(src.metadata.image.arraySize);
dstKernelInfoArg.offsetNumSamples = getOffset(src.metadata.image.numSamples);
dstKernelInfoArg.offsetNumMipLevels = getOffset(src.metadata.image.numMipLevels);
dstKernelInfoArg.offsetFlatBaseOffset = getOffset(src.metadata.image.flatBaseOffset);
dstKernelInfoArg.offsetFlatWidth = getOffset(src.metadata.image.flatWidth);
dstKernelInfoArg.offsetFlatHeight = getOffset(src.metadata.image.flatHeight);
dstKernelInfoArg.offsetFlatPitch = getOffset(src.metadata.image.flatPitch);
break;
case PatchTokenBinary::ArgObjectType::Sampler:
dstKernelInfoArg.offsetSamplerSnapWa = getOffset(src.metadata.sampler.coordinateSnapWaRequired);

4
unit_tests/fixtures/kernel_arg_fixture.cpp
View File

@ -34,6 +34,10 @@ void KernelImageArgTest::SetUp() {
pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector.push_back(kernelArgPatchInfo);
pKernelInfo->kernelArgInfo[0].offsetImgWidth = 0x4;
pKernelInfo->kernelArgInfo[0].offsetFlatBaseOffset = 0x8;
pKernelInfo->kernelArgInfo[0].offsetFlatWidth = 0x10;
pKernelInfo->kernelArgInfo[0].offsetFlatHeight = 0x18;
pKernelInfo->kernelArgInfo[0].offsetFlatPitch = 0x24;
pKernelInfo->kernelArgInfo[0].offsetNumSamples = 0x3c;
offsetNumMipLevelsImage0 = 0x40;
pKernelInfo->kernelArgInfo[0].offsetNumMipLevels = offsetNumMipLevelsImage0;

24
unit_tests/kernel/kernel_image_arg_tests.cpp
View File

@ -50,6 +50,30 @@ TEST_F(KernelImageArgTest, GIVENkernelWithImageArgsWHENcheckDifferentScenariosTH
EXPECT_EQ(objectId, *crossThreadData);
}
TEST_F(KernelImageArgTest, givenKernelWithFlatImageTokensWhenArgIsSetThenPatchAllParams) {
size_t imageWidth = image->getImageDesc().image_width;
size_t imageHeight = image->getImageDesc().image_height;
size_t imageRowPitch = image->getImageDesc().image_row_pitch;
uint64_t imageBaseAddress = image->getGraphicsAllocation()->getGpuAddress();
cl_mem memObj = image.get();
pKernel->setArg(0, sizeof(memObj), &memObj);
auto crossThreadData = reinterpret_cast<uint32_t *>(pKernel->getCrossThreadData());
auto offsetFlatBaseOffset = ptrOffset(crossThreadData, pKernel->getKernelInfo().kernelArgInfo[0].offsetFlatBaseOffset);
EXPECT_EQ(imageBaseAddress, *reinterpret_cast<uint64_t *>(offsetFlatBaseOffset));
auto offsetFlatWidth = ptrOffset(crossThreadData, pKernel->getKernelInfo().kernelArgInfo[0].offsetFlatWidth);
EXPECT_EQ(imageWidth - 1, *offsetFlatWidth);
auto offsetFlatHeight = ptrOffset(crossThreadData, pKernel->getKernelInfo().kernelArgInfo[0].offsetFlatHeight);
EXPECT_EQ(imageHeight - 1, *offsetFlatHeight);
auto offsetFlatPitch = ptrOffset(crossThreadData, pKernel->getKernelInfo().kernelArgInfo[0].offsetFlatPitch);
EXPECT_EQ(imageRowPitch - 1, *offsetFlatPitch);
}
TEST_F(KernelImageArgTest, givenKernelWithValidOffsetNumMipLevelsWhenImageArgIsSetThenCrossthreadDataIsProperlyPatched) {
MockImageBase image;
image.imageDesc.num_mip_levels = 7U;

46
unit_tests/program/kernel_data.cpp
View File

@ -784,6 +784,52 @@ TEST_F(KernelDataTest, DATA_PARAMETER_IMAGE_NUM_MIP_LEVELS) {
EXPECT_EQ(offsetNumMipLevels, pKernelInfo->kernelArgInfo[argumentNumber].offsetNumMipLevels);
}
TEST_F(KernelDataTest, givenFlatImageDataParamTokenWhenDecodingThenSetAllOffsets) {
uint32_t argumentNumber = 1;
uint32_t alignment = 16;
auto testToken = [&](iOpenCL::DATA_PARAMETER_TOKEN token, uint32_t offsetToken) {
{
// reset program
if (pKernelData) {
alignedFree(pKernelData);
}
program = std::make_unique<MockProgram>(*pContext->getDevice(0)->getExecutionEnvironment(), pContext, false);
}
SPatchDataParameterBuffer dataParameterToken;
dataParameterToken.Token = PATCH_TOKEN_DATA_PARAMETER_BUFFER;
dataParameterToken.Size = sizeof(SPatchDataParameterBuffer);
dataParameterToken.Type = token;
dataParameterToken.ArgumentNumber = argumentNumber;
dataParameterToken.Offset = offsetToken;
dataParameterToken.DataSize = sizeof(uint32_t);
dataParameterToken.SourceOffset = alignment;
dataParameterToken.LocationIndex = 0x0;
dataParameterToken.LocationIndex2 = 0x0;
pPatchList = &dataParameterToken;
patchListSize = dataParameterToken.Size;
buildAndDecode();
EXPECT_EQ(0U, pKernelInfo->patchInfo.dataParameterBuffersKernelArgs.size());
ASSERT_EQ(2U, pKernelInfo->kernelArgInfo.size());
};
testToken(iOpenCL::DATA_PARAMETER_TOKEN::DATA_PARAMETER_FLAT_IMAGE_BASEOFFSET, 10u);
EXPECT_EQ(10u, pKernelInfo->kernelArgInfo[argumentNumber].offsetFlatBaseOffset);
testToken(iOpenCL::DATA_PARAMETER_TOKEN::DATA_PARAMETER_FLAT_IMAGE_WIDTH, 14u);
EXPECT_EQ(14u, pKernelInfo->kernelArgInfo[argumentNumber].offsetFlatWidth);
testToken(iOpenCL::DATA_PARAMETER_TOKEN::DATA_PARAMETER_FLAT_IMAGE_HEIGHT, 16u);
EXPECT_EQ(16u, pKernelInfo->kernelArgInfo[argumentNumber].offsetFlatHeight);
testToken(iOpenCL::DATA_PARAMETER_TOKEN::DATA_PARAMETER_FLAT_IMAGE_PITCH, 18u);
EXPECT_EQ(18u, pKernelInfo->kernelArgInfo[argumentNumber].offsetFlatPitch);
}
TEST_F(KernelDataTest, DATA_PARAMETER_IMAGE_DATA_TYPE) {
uint32_t argumentNumber = 1;
uint32_t alignment = 16;