1/*
2 * Copyright (C) 2018-2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8#include "shared/source/device_binary_format/patchtokens_decoder.h"
9
10#include "opencl/test/unit_test/fixtures/kernel_work_group_info_fixture.h"
11
12using namespace NEO;
13
14namespace ULT {
15
16TEST_P(clGetKernelWorkGroupInfoTests, GivenValidParametersWhenGettingKernelWorkGroupInfoThenSuccessIsReturned) {
17
18    size_t paramValueSizeRet;
19    auto retVal = clGetKernelWorkGroupInfo(
20        kernel,
21        testedClDevice,
22        GetParam(),
23        0,
24        nullptr,
25        &paramValueSizeRet);
26
27    EXPECT_EQ(CL_SUCCESS, retVal);
28    EXPECT_NE(0u, paramValueSizeRet);
29}
30
31TEST_F(clGetKernelWorkGroupInfoTest, GivenInvalidDeviceWhenGettingWorkGroupInfoFromSingleDeviceKernelThenInvalidDeviceErrorIsReturned) {
32
33    size_t paramValueSizeRet;
34    auto retVal = clGetKernelWorkGroupInfo(
35        pMultiDeviceKernel,
36        reinterpret_cast<cl_device_id>(pKernel),
37        CL_KERNEL_WORK_GROUP_SIZE,
38        0,
39        nullptr,
40        &paramValueSizeRet);
41
42    EXPECT_EQ(CL_INVALID_DEVICE, retVal);
43}
44
45TEST_F(clGetKernelWorkGroupInfoTest, GivenNullDeviceWhenGettingWorkGroupInfoFromSingleDeviceKernelThenSuccessIsReturned) {
46
47    size_t paramValueSizeRet;
48    auto retVal = clGetKernelWorkGroupInfo(
49        pMultiDeviceKernel,
50        nullptr,
51        CL_KERNEL_WORK_GROUP_SIZE,
52        0,
53        nullptr,
54        &paramValueSizeRet);
55
56    EXPECT_EQ(CL_SUCCESS, retVal);
57}
58
59TEST_F(clGetKernelWorkGroupInfoTest, GivenNullDeviceWhenGettingWorkGroupInfoFromMultiDeviceKernelThenInvalidDeviceErrorIsReturned) {
60
61    size_t paramValueSizeRet;
62    MockUnrestrictiveContext context;
63    auto mockProgram = std::make_unique<MockProgram>(&context, false, context.getDevices());
64    std::unique_ptr<MultiDeviceKernel> pMultiDeviceKernel(
65        MockMultiDeviceKernel::create<MockKernel>(mockProgram.get(), MockKernel::toKernelInfoContainer(pKernel->getKernelInfo(), context.getDevice(0)->getRootDeviceIndex())));
66
67    retVal = clGetKernelWorkGroupInfo(
68        pMultiDeviceKernel.get(),
69        nullptr,
70        CL_KERNEL_WORK_GROUP_SIZE,
71        0,
72        nullptr,
73        &paramValueSizeRet);
74
75    EXPECT_EQ(CL_INVALID_DEVICE, retVal);
76}
77TEST_F(clGetKernelWorkGroupInfoTests, GivenKernelRequiringScratchSpaceWhenGettingKernelWorkGroupInfoThenCorrectSpillMemSizeIsReturned) {
78    size_t paramValueSizeRet;
79    cl_ulong param_value;
80    auto pDevice = castToObject<ClDevice>(testedClDevice);
81
82    MockKernelWithInternals mockKernel(*pDevice);
83    mockKernel.kernelInfo.setPerThreadScratchSize(1024, 0);
84
85    cl_ulong scratchSpaceSize = static_cast<cl_ulong>(mockKernel.mockKernel->getScratchSize());
86    EXPECT_EQ(scratchSpaceSize, 1024u);
87
88    retVal = clGetKernelWorkGroupInfo(
89        mockKernel.mockMultiDeviceKernel,
90        pDevice,
91        CL_KERNEL_SPILL_MEM_SIZE_INTEL,
92        sizeof(cl_ulong),
93        &param_value,
94        &paramValueSizeRet);
95
96    EXPECT_EQ(retVal, CL_SUCCESS);
97    EXPECT_EQ(paramValueSizeRet, sizeof(cl_ulong));
98    EXPECT_EQ(param_value, scratchSpaceSize);
99}
100
101using matcher = IsWithinProducts<IGFX_SKYLAKE, IGFX_DG1>;
102HWTEST2_F(clGetKernelWorkGroupInfoTests, givenKernelHavingPrivateMemoryAllocationWhenAskedForPrivateAllocationSizeThenProperSizeIsReturned, matcher) {
103    size_t paramValueSizeRet;
104    cl_ulong param_value;
105    auto pDevice = castToObject<ClDevice>(testedClDevice);
106
107    MockKernelWithInternals mockKernel(*pDevice);
108    mockKernel.kernelInfo.setPrivateMemory(1024, false, 0, 0, 0);
109
110    retVal = clGetKernelWorkGroupInfo(
111        mockKernel.mockMultiDeviceKernel,
112        pDevice,
113        CL_KERNEL_PRIVATE_MEM_SIZE,
114        sizeof(cl_ulong),
115        &param_value,
116        &paramValueSizeRet);
117
118    EXPECT_EQ(CL_SUCCESS, retVal);
119    EXPECT_EQ(sizeof(cl_ulong), paramValueSizeRet);
120    EXPECT_EQ(1024U, param_value);
121}
122
123TEST_F(clGetKernelWorkGroupInfoTests, givenKernelNotHavingPrivateMemoryAllocationWhenAskedForPrivateAllocationSizeThenZeroIsReturned) {
124    size_t paramValueSizeRet;
125    cl_ulong param_value;
126    auto pDevice = castToObject<ClDevice>(testedClDevice);
127
128    MockKernelWithInternals mockKernel(*pDevice);
129
130    retVal = clGetKernelWorkGroupInfo(
131        mockKernel.mockMultiDeviceKernel,
132        pDevice,
133        CL_KERNEL_PRIVATE_MEM_SIZE,
134        sizeof(cl_ulong),
135        &param_value,
136        &paramValueSizeRet);
137
138    EXPECT_EQ(retVal, CL_SUCCESS);
139    EXPECT_EQ(paramValueSizeRet, sizeof(cl_ulong));
140    EXPECT_EQ(param_value, 0u);
141}
142
143static cl_kernel_work_group_info paramNames[] = {
144    CL_KERNEL_WORK_GROUP_SIZE,
145    CL_KERNEL_COMPILE_WORK_GROUP_SIZE,
146    CL_KERNEL_LOCAL_MEM_SIZE,
147    CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE,
148    CL_KERNEL_SPILL_MEM_SIZE_INTEL,
149    CL_KERNEL_PRIVATE_MEM_SIZE};
150
151INSTANTIATE_TEST_CASE_P(
152    api,
153    clGetKernelWorkGroupInfoTests,
154    testing::ValuesIn(paramNames));
155} // namespace ULT
156