1 /*
2 * Copyright (C) 2018-2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/test/common/fixtures/memory_management_fixture.h"
9 #include "shared/test/common/helpers/kernel_binary_helper.h"
10 #include "shared/test/common/test_macros/test.h"
11
12 #include "opencl/source/kernel/kernel.h"
13 #include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
14 #include "opencl/test/unit_test/mocks/mock_kernel.h"
15 #include "opencl/test/unit_test/mocks/mock_program.h"
16 #include "opencl/test/unit_test/program/program_tests.h"
17 #include "opencl/test/unit_test/program/program_with_source.h"
18
19 using namespace NEO;
20
21 class KernelArgInfoTest : public ProgramFromSourceTest {
22 public:
KernelArgInfoTest()23 KernelArgInfoTest() {
24 }
25
26 ~KernelArgInfoTest() override = default;
27
28 protected:
SetUp()29 void SetUp() override {
30 kbHelper = new KernelBinaryHelper("copybuffer", true);
31 ProgramFromSourceTest::SetUp();
32 ASSERT_NE(nullptr, pProgram);
33 ASSERT_EQ(CL_SUCCESS, retVal);
34
35 retVal = pProgram->build(
36 pProgram->getDevices(),
37 nullptr,
38 false);
39 ASSERT_EQ(CL_SUCCESS, retVal);
40
41 // create a kernel
42 pKernel = Kernel::create(
43 pProgram,
44 pProgram->getKernelInfoForKernel(kernelName),
45 *pPlatform->getClDevice(0),
46 &retVal);
47
48 ASSERT_EQ(CL_SUCCESS, retVal);
49 ASSERT_NE(nullptr, pKernel);
50 }
51
TearDown()52 void TearDown() override {
53 delete pKernel;
54 pKernel = nullptr;
55 ProgramFromSourceTest::TearDown();
56 delete kbHelper;
57 }
58
59 template <typename T>
queryArgInfo(cl_kernel_arg_info paramName,T & paramValue)60 void queryArgInfo(cl_kernel_arg_info paramName, T ¶mValue) {
61 size_t paramValueSize = 0;
62 size_t param_value_size_ret = 0;
63
64 // get size
65 retVal = pKernel->getArgInfo(
66 0,
67 paramName,
68 paramValueSize,
69 nullptr,
70 ¶m_value_size_ret);
71 EXPECT_NE(0u, param_value_size_ret);
72 ASSERT_EQ(CL_SUCCESS, retVal);
73
74 // get the name
75 paramValueSize = param_value_size_ret;
76
77 retVal = pKernel->getArgInfo(
78 0,
79 paramName,
80 paramValueSize,
81 ¶mValue,
82 nullptr);
83 ASSERT_EQ(CL_SUCCESS, retVal);
84 }
85
86 Kernel *pKernel = nullptr;
87 cl_int retVal = CL_SUCCESS;
88 KernelBinaryHelper *kbHelper = nullptr;
89 };
90
TEST_F(KernelArgInfoTest,GivenNullWhenGettingKernelInfoThenNullIsReturned)91 TEST_F(KernelArgInfoTest, GivenNullWhenGettingKernelInfoThenNullIsReturned) {
92 auto kernelInfo = this->pProgram->getKernelInfo(nullptr, 0);
93 EXPECT_EQ(nullptr, kernelInfo);
94 }
95
TEST_F(KernelArgInfoTest,GivenInvalidParametersWhenGettingKernelArgInfoThenValueSizeRetIsNotUpdated)96 TEST_F(KernelArgInfoTest, GivenInvalidParametersWhenGettingKernelArgInfoThenValueSizeRetIsNotUpdated) {
97 size_t paramValueSizeRet = 0x1234;
98
99 retVal = pKernel->getArgInfo(
100 0,
101 0,
102 0,
103 nullptr,
104 ¶mValueSizeRet);
105 EXPECT_EQ(CL_INVALID_VALUE, retVal);
106 EXPECT_EQ(0x1234u, paramValueSizeRet);
107 }
108
TEST_F(KernelArgInfoTest,GivenKernelArgAccessQualifierWhenQueryingArgInfoThenKernelArgAcessNoneIsReturned)109 TEST_F(KernelArgInfoTest, GivenKernelArgAccessQualifierWhenQueryingArgInfoThenKernelArgAcessNoneIsReturned) {
110 cl_kernel_arg_access_qualifier param_value = 0;
111 queryArgInfo<cl_kernel_arg_access_qualifier>(CL_KERNEL_ARG_ACCESS_QUALIFIER, param_value);
112 EXPECT_EQ(static_cast<cl_kernel_arg_access_qualifier>(CL_KERNEL_ARG_ACCESS_NONE), param_value);
113 }
114
TEST_F(KernelArgInfoTest,GivenKernelArgAddressQualifierWhenQueryingArgInfoThenKernelArgAddressGlobalIsReturned)115 TEST_F(KernelArgInfoTest, GivenKernelArgAddressQualifierWhenQueryingArgInfoThenKernelArgAddressGlobalIsReturned) {
116 cl_kernel_arg_address_qualifier param_value = 0;
117 queryArgInfo<cl_kernel_arg_address_qualifier>(CL_KERNEL_ARG_ADDRESS_QUALIFIER, param_value);
118 EXPECT_EQ(static_cast<cl_kernel_arg_address_qualifier>(CL_KERNEL_ARG_ADDRESS_GLOBAL), param_value);
119 }
120
TEST_F(KernelArgInfoTest,GivenKernelArgTypeQualifierWhenQueryingArgInfoThenKernelArgTypeNoneIsReturned)121 TEST_F(KernelArgInfoTest, GivenKernelArgTypeQualifierWhenQueryingArgInfoThenKernelArgTypeNoneIsReturned) {
122 cl_kernel_arg_type_qualifier param_value = 0;
123 queryArgInfo<cl_kernel_arg_type_qualifier>(CL_KERNEL_ARG_TYPE_QUALIFIER, param_value);
124 EXPECT_EQ(static_cast<cl_kernel_arg_type_qualifier>(CL_KERNEL_ARG_TYPE_NONE), param_value);
125 }
126
TEST_F(KernelArgInfoTest,GivenParamWhenGettingKernelTypeNameThenCorrectValueIsReturned)127 TEST_F(KernelArgInfoTest, GivenParamWhenGettingKernelTypeNameThenCorrectValueIsReturned) {
128 cl_kernel_arg_info paramName = CL_KERNEL_ARG_TYPE_NAME;
129 char *paramValue = nullptr;
130 size_t paramValueSize = 0;
131 size_t paramValueSizeRet = 0;
132
133 // get size
134 retVal = pKernel->getArgInfo(
135 0,
136 paramName,
137 paramValueSize,
138 nullptr,
139 ¶mValueSizeRet);
140 EXPECT_NE(0u, paramValueSizeRet);
141 ASSERT_EQ(CL_SUCCESS, retVal);
142
143 // allocate space for name
144 paramValue = new char[paramValueSizeRet];
145
146 // get the name
147 paramValueSize = paramValueSizeRet;
148
149 retVal = pKernel->getArgInfo(
150 0,
151 paramName,
152 paramValueSize,
153 paramValue,
154 nullptr);
155 ASSERT_EQ(CL_SUCCESS, retVal);
156 const char expectedString[] = "uint*";
157 auto result = strncmp(paramValue, expectedString, sizeof(expectedString));
158 EXPECT_EQ(0, result);
159 delete[] paramValue;
160 }
161
TEST_F(KernelArgInfoTest,GivenParamWhenGettingKernelArgNameThenCorrectValueIsReturned)162 TEST_F(KernelArgInfoTest, GivenParamWhenGettingKernelArgNameThenCorrectValueIsReturned) {
163 cl_kernel_arg_info paramName = CL_KERNEL_ARG_NAME;
164 char *paramValue = nullptr;
165 size_t paramValueSize = 0;
166 size_t paramValueSizeRet = 0;
167
168 // get size
169 retVal = pKernel->getArgInfo(
170 0,
171 paramName,
172 paramValueSize,
173 nullptr,
174 ¶mValueSizeRet);
175 EXPECT_NE(0u, paramValueSizeRet);
176 ASSERT_EQ(CL_SUCCESS, retVal);
177
178 // allocate space for name
179 paramValue = new char[paramValueSizeRet];
180
181 // get the name
182 paramValueSize = paramValueSizeRet;
183
184 retVal = pKernel->getArgInfo(
185 0,
186 paramName,
187 paramValueSize,
188 paramValue,
189 nullptr);
190 ASSERT_EQ(CL_SUCCESS, retVal);
191 EXPECT_EQ(0, strcmp(paramValue, "src"));
192 delete[] paramValue;
193 }
194