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 &paramValue) {
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             &param_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             &paramValue,
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         &paramValueSizeRet);
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         &paramValueSizeRet);
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         &paramValueSizeRet);
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