1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
/*
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/test_macros/test.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 <memory>
using namespace NEO;
class KernelArgInfoFixture {
public:
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);
}
void tearDown() {}
template <typename T>
cl_int queryArgInfo(cl_kernel_arg_info paramName, T ¶mValue) {
return kernel->getArgInfo(0, paramName, sizeof(T), ¶mValue, nullptr);
}
KernelInfo kernelInfo;
std::unique_ptr<MockClDevice> clDevice;
std::unique_ptr<MockProgram> program;
std::unique_ptr<MockKernel> kernel;
KernelDescriptor *kernelDescriptor;
};
using KernelArgInfoTest = Test<KernelArgInfoFixture>;
TEST_F(KernelArgInfoTest, GivenNullWhenGettingKernelInfoThenNullIsReturned) {
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, GivenInvalidParametersWhenGettingKernelArgInfoThenValueSizeRetIsNotUpdated) {
auto retVal = kernel->getArgInfo(0, 0, 0, nullptr, nullptr);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(KernelArgInfoTest, GivenKernelArgAccessQualifierWhenQueryingArgInfoThenKernelArgAcessNoneIsReturned) {
auto &argTraits = kernelDescriptor->payloadMappings.explicitArgs[0].getTraits();
argTraits.accessQualifier = KernelArgMetadata::AccessNone;
cl_kernel_arg_access_qualifier paramValue = 0;
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 &argTraits = kernelDescriptor->payloadMappings.explicitArgs[0].getTraits();
argTraits.addressQualifier = KernelArgMetadata::AddrGlobal;
cl_kernel_arg_address_qualifier paramValue = 0;
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;
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) {
const char expectedArgType[] = "uint*";
kernelDescriptor->explicitArgsExtendedMetadata.at(0).type = expectedArgType;
constexpr auto paramValueSize = sizeof(expectedArgType);
auto paramValue = std::make_unique<char[]>(paramValueSize);
auto retVal = kernel->getArgInfo(
0,
CL_KERNEL_ARG_TYPE_NAME,
paramValueSize,
paramValue.get(),
nullptr);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, strncmp(paramValue.get(), expectedArgType, sizeof(expectedArgType)));
}
TEST_F(KernelArgInfoTest, GivenParamWhenGettingKernelArgNameThenCorrectValueIsReturned) {
const char expectedArgName[] = "src";
kernelDescriptor->explicitArgsExtendedMetadata.at(0).argName = expectedArgName;
constexpr auto paramValueSize = sizeof(expectedArgName);
auto paramValue = std::make_unique<char[]>(paramValueSize);
auto retVal = kernel->getArgInfo(
0,
CL_KERNEL_ARG_NAME,
paramValueSize,
paramValue.get(),
nullptr);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, strcmp(paramValue.get(), expectedArgName));
}
|
