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

Use mock in KernelArgInfoTest

Browse Source 
Signed-off-by: Krystian Chmielewski <krystian.chmielewski@intel.com>
This commit is contained in:
Krystian Chmielewski
2022-11-03 16:50:55 +00:00
committed by Compute-Runtime-Automation
parent d72a5097b7
commit 78d75dee0f
3 changed files with 75 additions and 309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
opencl/source/program/program.h
View File

@ -290,7 +290,7 @@ class Program : public BaseObject<_cl_program> {
void notifyDebuggerWithDebugData(ClDevice *clDevice);
MOCKABLE_VIRTUAL void createDebugZebin(uint32_t rootDeviceIndex);
Debug::Segments getZebinSegments(uint32_t rootDeviceIndex);
void callPopulateZebinExtendedArgsMetadataOnce(uint32_t rootDeviceIndex);
MOCKABLE_VIRTUAL void callPopulateZebinExtendedArgsMetadataOnce(uint32_t rootDeviceIndex);
protected:
MOCKABLE_VIRTUAL cl_int createProgramFromBinary(const void *pBinary, size_t binarySize, ClDevice &clDevice);

372
opencl/test/unit_test/kernel/kernel_arg_info_tests.cpp
View File

@ -5,372 +5,128 @@
*
*/
#include "shared/test/common/fixtures/memory_management_fixture.h"
#include "shared/test/common/helpers/kernel_binary_helper.h"
#include "shared/test/common/test_macros/test.h"
#include <shared/test/common/mocks/mock_modules_zebin.h>
#include "opencl/source/kernel/kernel.h"
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
#include "opencl/test/unit_test/mocks/mock_cl_device.h"
#include "opencl/test/unit_test/mocks/mock_kernel.h"
#include "opencl/test/unit_test/mocks/mock_program.h"
#include "opencl/test/unit_test/program/program_tests.h"
#include "opencl/test/unit_test/program/program_with_source.h"
#include <memory>
using namespace NEO;
class KernelArgInfoTest : public ProgramFromSourceTest {
class KernelArgInfoFixture {
public:
KernelArgInfoTest() {
KernelArgInfoFixture(){};
void setUp() {
clDevice = std::make_unique<MockClDevice>(new MockDevice());
program = std::make_unique<MockProgram>(toClDeviceVector(*clDevice));
kernel = std::make_unique<MockKernel>(program.get(), kernelInfo, *clDevice);
kernelDescriptor = &kernelInfo.kernelDescriptor;
kernelDescriptor->payloadMappings.explicitArgs.resize(1);
kernelDescriptor->explicitArgsExtendedMetadata.resize(1);
}
~KernelArgInfoTest() override = default;
protected:
void SetUp() override {
kbHelper = new KernelBinaryHelper("copybuffer", true);
ProgramFromSourceTest::SetUp();
ASSERT_NE(nullptr, pProgram);
ASSERT_EQ(CL_SUCCESS, retVal);
retVal = pProgram->build(
pProgram->getDevices(),
nullptr,
false);
ASSERT_EQ(CL_SUCCESS, retVal);
// create a kernel
pKernel = Kernel::create(
pProgram,
pProgram->getKernelInfoForKernel(kernelName),
*pPlatform->getClDevice(0),
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_NE(nullptr, pKernel);
}
void TearDown() override {
delete pKernel;
pKernel = nullptr;
ProgramFromSourceTest::TearDown();
delete kbHelper;
}
void tearDown() {}
template <typename T>
void queryArgInfo(cl_kernel_arg_info paramName, T &paramValue) {
size_t paramValueSize = 0;
size_t paramValueSizeRet = 0;
// get size
retVal = pKernel->getArgInfo(
0,
paramName,
paramValueSize,
nullptr,
&paramValueSizeRet);
EXPECT_NE(0u, paramValueSizeRet);
ASSERT_EQ(CL_SUCCESS, retVal);
// get the name
paramValueSize = paramValueSizeRet;
retVal = pKernel->getArgInfo(
0,
paramName,
paramValueSize,
&paramValue,
nullptr);
ASSERT_EQ(CL_SUCCESS, retVal);
cl_int queryArgInfo(cl_kernel_arg_info paramName, T &paramValue) {
return kernel->getArgInfo(0, paramName, sizeof(T), &paramValue, nullptr);
}
Kernel *pKernel = nullptr;
cl_int retVal = CL_SUCCESS;
KernelBinaryHelper *kbHelper = nullptr;
KernelInfo kernelInfo;
std::unique_ptr<MockProgram> program;
std::unique_ptr<MockKernel> kernel;
std::unique_ptr<MockClDevice> clDevice;
KernelDescriptor *kernelDescriptor;
};
using KernelArgInfoTest = Test<KernelArgInfoFixture>;
TEST_F(KernelArgInfoTest, GivenNullWhenGettingKernelInfoThenNullIsReturned) {
auto kernelInfo = this->pProgram->getKernelInfo(nullptr, 0);
EXPECT_EQ(nullptr, kernelInfo);
auto retKernelInfo = program->getKernelInfo(nullptr, 0);
EXPECT_EQ(nullptr, retKernelInfo);
}
TEST_F(KernelArgInfoTest, GivenArgIndexBiggerThanNumberOfArgsThenErrorIsReturned) {
auto retVal = kernel->getArgInfo(1, 0, 0, nullptr, nullptr);
EXPECT_EQ(CL_INVALID_ARG_INDEX, retVal);
}
TEST_F(KernelArgInfoTest, GivenValidArgIndexThenExplicitArgsMetadataIsPopulated) {
kernel->getArgInfo(0, 0, 0, nullptr, nullptr);
EXPECT_TRUE(program->wasPopulateZebinExtendedArgsMetadataOnceCalled);
}
TEST_F(KernelArgInfoTest, GivenEmptyExplicitArgsMetadataThenAppropriateErrorIsReturned) {
kernelDescriptor->explicitArgsExtendedMetadata.resize(0);
auto retVal = kernel->getArgInfo(0, 0, 0, nullptr, nullptr);
EXPECT_EQ(CL_KERNEL_ARG_INFO_NOT_AVAILABLE, retVal);
}
TEST_F(KernelArgInfoTest, GivenInvalidParametersWhenGettingKernelArgInfoThenValueSizeRetIsNotUpdated) {
size_t paramValueSizeRet = 0x1234;
retVal = pKernel->getArgInfo(
0,
0,
0,
nullptr,
&paramValueSizeRet);
auto retVal = kernel->getArgInfo(0, 0, 0, nullptr, nullptr);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(0x1234u, paramValueSizeRet);
}
TEST_F(KernelArgInfoTest, GivenKernelArgAccessQualifierWhenQueryingArgInfoThenKernelArgAcessNoneIsReturned) {
auto &kernelDescriptor = const_cast<KernelDescriptor &>(pKernel->getDescriptor());
auto &argTraits = kernelDescriptor.payloadMappings.explicitArgs[0].getTraits();
auto &argTraits = kernelDescriptor->payloadMappings.explicitArgs[0].getTraits();
argTraits.accessQualifier = KernelArgMetadata::AccessNone;
cl_kernel_arg_access_qualifier paramValue = 0;
queryArgInfo<cl_kernel_arg_access_qualifier>(CL_KERNEL_ARG_ACCESS_QUALIFIER, paramValue);
auto retVal = queryArgInfo<cl_kernel_arg_access_qualifier>(CL_KERNEL_ARG_ACCESS_QUALIFIER, paramValue);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(static_cast<cl_kernel_arg_access_qualifier>(CL_KERNEL_ARG_ACCESS_NONE), paramValue);
}
TEST_F(KernelArgInfoTest, GivenKernelArgAddressQualifierWhenQueryingArgInfoThenKernelArgAddressGlobalIsReturned) {
auto &kernelDescriptor = const_cast<KernelDescriptor &>(pKernel->getDescriptor());
auto &argTraits = kernelDescriptor.payloadMappings.explicitArgs[0].getTraits();
auto &argTraits = kernelDescriptor->payloadMappings.explicitArgs[0].getTraits();
argTraits.addressQualifier = KernelArgMetadata::AddrGlobal;
cl_kernel_arg_address_qualifier paramValue = 0;
queryArgInfo<cl_kernel_arg_address_qualifier>(CL_KERNEL_ARG_ADDRESS_QUALIFIER, paramValue);
auto retVal = queryArgInfo<cl_kernel_arg_address_qualifier>(CL_KERNEL_ARG_ADDRESS_QUALIFIER, paramValue);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(static_cast<cl_kernel_arg_address_qualifier>(CL_KERNEL_ARG_ADDRESS_GLOBAL), paramValue);
}
TEST_F(KernelArgInfoTest, GivenKernelArgTypeQualifierWhenQueryingArgInfoThenKernelArgTypeNoneIsReturned) {
cl_kernel_arg_type_qualifier paramValue = 0;
queryArgInfo<cl_kernel_arg_type_qualifier>(CL_KERNEL_ARG_TYPE_QUALIFIER, paramValue);
auto retVal = queryArgInfo<cl_kernel_arg_type_qualifier>(CL_KERNEL_ARG_TYPE_QUALIFIER, paramValue);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(static_cast<cl_kernel_arg_type_qualifier>(CL_KERNEL_ARG_TYPE_NONE), paramValue);
}
TEST_F(KernelArgInfoTest, GivenParamWhenGettingKernelTypeNameThenCorrectValueIsReturned) {
cl_uint argInd = 0;
const char expectedArgType[] = "uint*";
auto &kernelDescriptor = const_cast<KernelDescriptor &>(pKernel->getDescriptor());
kernelDescriptor.explicitArgsExtendedMetadata.at(argInd).type = expectedArgType;
kernelDescriptor->explicitArgsExtendedMetadata.at(0).type = expectedArgType;
cl_kernel_arg_info paramName = CL_KERNEL_ARG_TYPE_NAME;
char *paramValue = nullptr;
size_t paramValueSize = 0;
size_t paramValueSizeRet = 0;
// get size
retVal = pKernel->getArgInfo(
argInd,
paramName,
paramValueSize,
nullptr,
&paramValueSizeRet);
EXPECT_NE(0u, paramValueSizeRet);
ASSERT_EQ(CL_SUCCESS, retVal);
// allocate space for name
paramValue = new char[paramValueSizeRet];
// get the name
paramValueSize = paramValueSizeRet;
retVal = pKernel->getArgInfo(
constexpr auto paramValueSize = sizeof(expectedArgType);
auto paramValue = std::make_unique<char[]>(paramValueSize);
auto retVal = kernel->getArgInfo(
0,
paramName,
CL_KERNEL_ARG_TYPE_NAME,
paramValueSize,
paramValue,
paramValue.get(),
nullptr);
ASSERT_EQ(CL_SUCCESS, retVal);
auto result = strncmp(paramValue, expectedArgType, sizeof(expectedArgType));
EXPECT_EQ(0, result);
delete[] paramValue;
EXPECT_EQ(0, strncmp(paramValue.get(), expectedArgType, sizeof(expectedArgType)));
}
TEST_F(KernelArgInfoTest, GivenParamWhenGettingKernelArgNameThenCorrectValueIsReturned) {
cl_uint argInd = 0;
const char expectedArgName[] = "src";
auto &kernelDescriptor = const_cast<KernelDescriptor &>(pKernel->getDescriptor());
kernelDescriptor.explicitArgsExtendedMetadata.at(argInd).argName = expectedArgName;
kernelDescriptor->explicitArgsExtendedMetadata.at(0).argName = expectedArgName;
cl_kernel_arg_info paramName = CL_KERNEL_ARG_NAME;
char *paramValue = nullptr;
size_t paramValueSize = 0;
size_t paramValueSizeRet = 0;
// get size
retVal = pKernel->getArgInfo(
argInd,
paramName,
paramValueSize,
nullptr,
&paramValueSizeRet);
EXPECT_NE(0u, paramValueSizeRet);
ASSERT_EQ(CL_SUCCESS, retVal);
// allocate space for name
paramValue = new char[paramValueSizeRet];
// get the name
paramValueSize = paramValueSizeRet;
retVal = pKernel->getArgInfo(
constexpr auto paramValueSize = sizeof(expectedArgName);
auto paramValue = std::make_unique<char[]>(paramValueSize);
auto retVal = kernel->getArgInfo(
0,
paramName,
CL_KERNEL_ARG_NAME,
paramValueSize,
paramValue,
paramValue.get(),
nullptr);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, strcmp(paramValue, expectedArgName));
delete[] paramValue;
}
TEST_F(KernelArgInfoTest, givenNonZebinBinaryAndNoExplicitArgsMetadataWhenQueryingArgsInfoThenReturnError) {
constexpr auto mockDeviceBinarySize = 0x10;
uint8_t mockDeviceBinary[mockDeviceBinarySize]{0};
auto &buildInfo = pProgram->buildInfos[rootDeviceIndex];
buildInfo.unpackedDeviceBinary.reset(reinterpret_cast<char *>(mockDeviceBinary));
buildInfo.unpackedDeviceBinarySize = mockDeviceBinarySize;
ASSERT_FALSE(NEO::isDeviceBinaryFormat<NEO::DeviceBinaryFormat::Zebin>(ArrayRef<uint8_t>::fromAny(mockDeviceBinary, mockDeviceBinarySize)));
auto &kernelDescriptor = const_cast<KernelDescriptor &>(pKernel->getDescriptor());
kernelDescriptor.explicitArgsExtendedMetadata.clear();
ASSERT_TRUE(kernelDescriptor.explicitArgsExtendedMetadata.empty());
retVal = pKernel->getArgInfo(
0,
CL_KERNEL_ARG_NAME,
0,
nullptr,
0);
EXPECT_EQ(CL_KERNEL_ARG_INFO_NOT_AVAILABLE, retVal);
buildInfo.unpackedDeviceBinary.release();
}
TEST_F(KernelArgInfoTest, givenZebinBinaryAndErrorOnRetrievingArgsMetadataFromKernelsMiscInfoWhenQueryingArgsInfoThenReturnError) {
ZebinTestData::ValidEmptyProgram zebin;
ASSERT_TRUE(isDeviceBinaryFormat<NEO::DeviceBinaryFormat::Zebin>(ArrayRef<const uint8_t>::fromAny(zebin.storage.data(), zebin.storage.size())));
auto &buildInfo = pProgram->buildInfos[rootDeviceIndex];
buildInfo.unpackedDeviceBinary.reset(reinterpret_cast<char *>(zebin.storage.data()));
buildInfo.unpackedDeviceBinarySize = zebin.storage.size();
ASSERT_EQ(std::string::npos, buildInfo.kernelMiscInfoPos);
auto &kernelDescriptor = const_cast<KernelDescriptor &>(pKernel->getDescriptor());
kernelDescriptor.explicitArgsExtendedMetadata.clear();
ASSERT_TRUE(kernelDescriptor.explicitArgsExtendedMetadata.empty());
retVal = pKernel->getArgInfo(
0,
CL_KERNEL_ARG_NAME,
0,
nullptr,
0);
EXPECT_EQ(CL_KERNEL_ARG_INFO_NOT_AVAILABLE, retVal);
buildInfo.unpackedDeviceBinary.release();
}
TEST_F(KernelArgInfoTest, givenZebinBinaryWithProperKernelsMiscInfoAndNoExplicitArgsMetadataWhenQueryingArgInfoThenRetrieveItFromKernelsMiscInfo) {
std::string zeInfo = R"===('
kernels:
- name: CopyBuffer
execution_env:
simd_size: 32
payload_arguments:
- arg_type: arg_bypointer
offset: 0
size: 0
arg_index: 0
addrmode: stateful
addrspace: global
access_type: readwrite
- arg_type: arg_bypointer
offset: 32
size: 8
arg_index: 0
addrmode: stateless
addrspace: global
access_type: readwrite
- arg_type: enqueued_local_size
offset: 40
size: 12
kernels_misc_info:
- name: CopyBuffer
args_info:
- index: 0
name: a
address_qualifier: __global
access_qualifier: NONE
type_name: 'int*;8'
type_qualifiers: NONE
)===";
std::vector<uint8_t> storage;
MockElfEncoder<> elfEncoder;
auto &elfHeader = elfEncoder.getElfFileHeader();
elfHeader.type = NEO::Elf::ET_ZEBIN_EXE;
elfHeader.machine = pProgram->getExecutionEnvironment().rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo()->platform.eProductFamily;
const uint8_t testKernelData[0x10] = {0u};
elfEncoder.appendSection(NEO::Elf::SHT_PROGBITS, NEO::Elf::SectionsNamesZebin::textPrefix.str() + "CopyBuffer", testKernelData);
elfEncoder.appendSection(NEO::Elf::SHT_ZEBIN_ZEINFO, NEO::Elf::SectionsNamesZebin::zeInfo, zeInfo);
storage = elfEncoder.encode();
elfHeader = *reinterpret_cast<NEO::Elf::ElfFileHeader<NEO::Elf::EI_CLASS_64> *>(storage.data());
auto &buildInfo = pProgram->buildInfos[rootDeviceIndex];
//set kernels_misc_info pos manually, as we are not invoking decodeZebin() or processProgramInfo() in this test
ProgramInfo programInfo;
setKernelMiscInfoPosition(zeInfo, programInfo);
buildInfo.kernelMiscInfoPos = programInfo.kernelMiscInfoPos;
buildInfo.unpackedDeviceBinary.reset(reinterpret_cast<char *>(storage.data()));
buildInfo.unpackedDeviceBinarySize = storage.size();
auto &kernelDescriptor = const_cast<KernelDescriptor &>(pKernel->getDescriptor());
kernelDescriptor.explicitArgsExtendedMetadata.clear();
ASSERT_TRUE(kernelDescriptor.explicitArgsExtendedMetadata.empty());
std::array<cl_kernel_arg_info, 5> paramNames = {
CL_KERNEL_ARG_NAME,
CL_KERNEL_ARG_ADDRESS_QUALIFIER,
CL_KERNEL_ARG_ACCESS_QUALIFIER,
CL_KERNEL_ARG_TYPE_NAME,
CL_KERNEL_ARG_TYPE_QUALIFIER,
};
cl_uint argInd = 0;
constexpr size_t maxParamValueSize{0x10};
size_t paramValueSize = 0;
size_t paramValueSizeRet = 0;
for (const auto &paramName : paramNames) {
char paramValue[maxParamValueSize]{0};
retVal = pKernel->getArgInfo(
argInd,
paramName,
paramValueSize,
nullptr,
&paramValueSizeRet);
EXPECT_NE(0u, paramValueSizeRet);
ASSERT_EQ(CL_SUCCESS, retVal);
ASSERT_LT(paramValueSizeRet, maxParamValueSize);
paramValueSize = paramValueSizeRet;
retVal = pKernel->getArgInfo(
argInd,
paramName,
paramValueSize,
paramValue,
nullptr);
ASSERT_EQ(CL_SUCCESS, retVal);
switch (paramName) {
case (CL_KERNEL_ARG_NAME):
EXPECT_EQ(0, strcmp(paramValue, "a"));
break;
case (CL_KERNEL_ARG_ADDRESS_QUALIFIER):
EXPECT_EQ(*(reinterpret_cast<cl_kernel_arg_address_qualifier *>(paramValue)), static_cast<cl_uint>(CL_KERNEL_ARG_ADDRESS_GLOBAL));
break;
case (CL_KERNEL_ARG_ACCESS_QUALIFIER):
EXPECT_EQ(*(reinterpret_cast<cl_kernel_arg_access_qualifier *>(paramValue)), static_cast<cl_uint>(CL_KERNEL_ARG_ACCESS_NONE));
break;
case (CL_KERNEL_ARG_TYPE_NAME):
EXPECT_EQ(0, strcmp(paramValue, "'int*;8'"));
break;
case (CL_KERNEL_ARG_TYPE_QUALIFIER):
EXPECT_EQ(*(reinterpret_cast<cl_kernel_arg_type_qualifier *>(paramValue)), static_cast<cl_ulong>(CL_KERNEL_ARG_TYPE_NONE));
break;
default:
ASSERT_TRUE(false);
break;
}
}
buildInfo.unpackedDeviceBinary.release();
EXPECT_EQ(0, strcmp(paramValue.get(), expectedArgName));
}

10
opencl/test/unit_test/mocks/mock_program.h
View File

@ -194,6 +194,14 @@ class MockProgram : public Program {
wasDebuggerNotified = true;
}
void callPopulateZebinExtendedArgsMetadataOnce(uint32_t rootDeviceIndex) override {
wasPopulateZebinExtendedArgsMetadataOnceCalled = true;
if (callBasePopulateZebinExtendedArgsMetadataOnce) {
return Program::callPopulateZebinExtendedArgsMetadataOnce(rootDeviceIndex);
}
}
std::vector<NEO::ExternalFunctionInfo> externalFunctions;
std::map<uint32_t, int> processGenBinaryCalledPerRootDevice;
std::map<uint32_t, int> replaceDeviceBinaryCalledPerRootDevice;
@ -204,6 +212,8 @@ class MockProgram : public Program {
bool wasProcessDebugDataCalled = false;
bool wasCreateDebugZebinCalled = false;
bool wasDebuggerNotified = false;
bool wasPopulateZebinExtendedArgsMetadataOnceCalled = false;
bool callBasePopulateZebinExtendedArgsMetadataOnce = false;
};
class MockProgramAppendKernelDebugOptions : public Program {