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

Add logic to detect if kernel is using only images as arguments.

Browse Source 
Change-Id: Ia897a1838761c452c36c3f7821149b5867c3cd70
This commit is contained in:
Mrozek, Michal
2018-08-07 09:49:47 +02:00
committed by sys_ocldev
parent 8123c8b08f
commit dfd331c568
3 changed files with 58 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
runtime/kernel/kernel.cpp
View File

@@ -309,6 +309,8 @@ cl_int Kernel::initialize() {
// resolve the new kernel info to account for kernel handlers // resolve the new kernel info to account for kernel handlers
// I think by this time we have decoded the binary and know the number of args etc. // I think by this time we have decoded the binary and know the number of args etc.
// double check this assumption // double check this assumption
bool usingBuffers = false;
bool usingImages = false;
auto numArgs = kernelInfo.kernelArgInfo.size(); auto numArgs = kernelInfo.kernelArgInfo.size();
kernelArguments.resize(numArgs); kernelArguments.resize(numArgs);
slmSizes.resize(numArgs); slmSizes.resize(numArgs);
@@ -330,11 +332,13 @@ cl_int Kernel::initialize() {
} else if ((argInfo.typeStr.find("*") != std::string::npos) || argInfo.isBuffer) { } else if ((argInfo.typeStr.find("*") != std::string::npos) || argInfo.isBuffer) {
kernelArgHandlers[i] = &Kernel::setArgBuffer; kernelArgHandlers[i] = &Kernel::setArgBuffer;
kernelArguments[i].type = BUFFER_OBJ; kernelArguments[i].type = BUFFER_OBJ;
usingBuffers = true;
this->auxTranslationRequired |= !kernelInfo.kernelArgInfo[i].pureStatefulBufferAccess && this->auxTranslationRequired |= !kernelInfo.kernelArgInfo[i].pureStatefulBufferAccess &&
getDevice().getHardwareInfo().capabilityTable.ftrRenderCompressedBuffers; getDevice().getHardwareInfo().capabilityTable.ftrRenderCompressedBuffers;
} else if (argInfo.isImage) { } else if (argInfo.isImage) {
kernelArgHandlers[i] = &Kernel::setArgImage; kernelArgHandlers[i] = &Kernel::setArgImage;
kernelArguments[i].type = IMAGE_OBJ; kernelArguments[i].type = IMAGE_OBJ;
usingImages = true;
DEBUG_BREAK_IF(argInfo.typeStr.find("image") == std::string::npos); DEBUG_BREAK_IF(argInfo.typeStr.find("image") == std::string::npos);
} else if (argInfo.isSampler) { } else if (argInfo.isSampler) {
kernelArgHandlers[i] = &Kernel::setArgSampler; kernelArgHandlers[i] = &Kernel::setArgSampler;
@@ -348,6 +352,10 @@ cl_int Kernel::initialize() {
} }
} }
if (usingImages && !usingBuffers) {
usingImagesOnly = true;
}
if (isParentKernel) { if (isParentKernel) {
program->allocateBlockPrivateSurfaces(); program->allocateBlockPrivateSurfaces();
} }

4
runtime/kernel/kernel.h
View File

@@ -380,6 +380,9 @@ class Kernel : public BaseObject<_cl_kernel> {
} }
std::vector<PatchInfoData> &getPatchInfoDataList() { return patchInfoDataList; }; std::vector<PatchInfoData> &getPatchInfoDataList() { return patchInfoDataList; };
bool usesOnlyImages() const {
return usingImagesOnly;
}
protected: protected:
struct ObjectCounts { struct ObjectCounts {
@@ -489,6 +492,7 @@ class Kernel : public BaseObject<_cl_kernel> {
GraphicsAllocation *kernelReflectionSurface; GraphicsAllocation *kernelReflectionSurface;
bool usingSharedObjArgs; bool usingSharedObjArgs;
bool usingImagesOnly = false;
bool auxTranslationRequired = false; bool auxTranslationRequired = false;
uint32_t patchedArgumentsNum = 0; uint32_t patchedArgumentsNum = 0;
uint32_t startOffset = 0; uint32_t startOffset = 0;

46
unit_tests/kernel/kernel_tests.cpp
View File

@@ -1626,6 +1626,52 @@ HWTEST_F(KernelResidencyTest, givenKernelWhenMakeResidentIsCalledThenKernelIsaIs
memoryManager->freeGraphicsMemory(pKernelInfo->kernelAllocation); memoryManager->freeGraphicsMemory(pKernelInfo->kernelAllocation);
} }
TEST(KernelImageDetectionTests, givenKernelWithImagesOnlyWhenItIsAskedIfItHasImagesOnlyThenTrueIsReturned) {
auto device = std::make_unique<MockDevice>(*platformDevices[0]);
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
pKernelInfo->kernelArgInfo.resize(3);
pKernelInfo->kernelArgInfo[2].isImage = true;
pKernelInfo->kernelArgInfo[1].isMediaBlockImage = true;
pKernelInfo->kernelArgInfo[0].isMediaImage = true;
MockProgram program;
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *pKernelInfo, *device));
EXPECT_FALSE(kernel->usesOnlyImages());
kernel->initialize();
EXPECT_TRUE(kernel->usesOnlyImages());
}
TEST(KernelImageDetectionTests, givenKernelWithImagesAndBuffersWhenItIsAskedIfItHasImagesOnlyThenFalseIsReturned) {
auto device = std::make_unique<MockDevice>(*platformDevices[0]);
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
pKernelInfo->kernelArgInfo.resize(3);
pKernelInfo->kernelArgInfo[2].isImage = true;
pKernelInfo->kernelArgInfo[1].isBuffer = true;
pKernelInfo->kernelArgInfo[0].isMediaImage = true;
MockProgram program;
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *pKernelInfo, *device));
EXPECT_FALSE(kernel->usesOnlyImages());
kernel->initialize();
EXPECT_FALSE(kernel->usesOnlyImages());
}
TEST(KernelImageDetectionTests, givenKernelWithNoImagesWhenItIsAskedIfItHasImagesOnlyThenFalseIsReturned) {
auto device = std::make_unique<MockDevice>(*platformDevices[0]);
std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
pKernelInfo->kernelArgInfo.resize(1);
pKernelInfo->kernelArgInfo[0].isBuffer = true;
MockProgram program;
std::unique_ptr<MockKernel> kernel(new MockKernel(&program, *pKernelInfo, *device));
EXPECT_FALSE(kernel->usesOnlyImages());
kernel->initialize();
EXPECT_FALSE(kernel->usesOnlyImages());
}
HWTEST_F(KernelResidencyTest, test_MakeArgsResidentCheckImageFromImage) { HWTEST_F(KernelResidencyTest, test_MakeArgsResidentCheckImageFromImage) {
ASSERT_NE(nullptr, pDevice); ASSERT_NE(nullptr, pDevice);