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
|
/*
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/unit_test/mocks/mock_device.h"
#include "opencl/test/unit_test/mocks/mock_cl_device.h"
#include "opencl/test/unit_test/mocks/mock_context.h"
#include "opencl/test/unit_test/mocks/mock_kernel.h"
#include "gtest/gtest.h"
using namespace NEO;
class PatchedKernelTest : public ::testing::Test {
public:
void SetUp() override {
device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
context.reset(new MockContext(device.get()));
program.reset(Program::createBuiltInFromSource("FillBufferBytes", context.get(), context->getDevices(), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
cl_device_id clDevice = device.get();
program->build(1, &clDevice, nullptr, nullptr, nullptr, false);
kernel.reset(Kernel::create(program.get(), *program->getKernelInfo("FillBufferBytes"), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
}
void TearDown() override {
context.reset();
}
std::unique_ptr<MockContext> context;
std::unique_ptr<MockClDevice> device;
std::unique_ptr<Program> program;
std::unique_ptr<Kernel> kernel;
cl_int retVal = CL_SUCCESS;
};
TEST_F(PatchedKernelTest, givenKernelWithoutPatchedArgsWhenIsPatchedIsCalledThenReturnsFalse) {
EXPECT_FALSE(kernel->isPatched());
}
TEST_F(PatchedKernelTest, givenKernelWithAllArgsSetWithBufferWhenIsPatchedIsCalledThenReturnsTrue) {
auto buffer = clCreateBuffer(context.get(), CL_MEM_READ_ONLY, sizeof(int), nullptr, &retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
auto argsNum = kernel->getKernelArgsNumber();
for (uint32_t i = 0; i < argsNum; i++) {
kernel->setArg(i, buffer);
}
EXPECT_TRUE(kernel->isPatched());
clReleaseMemObject(buffer);
}
TEST_F(PatchedKernelTest, givenKernelWithoutAllArgsSetWhenIsPatchedIsCalledThenReturnsFalse) {
auto buffer = clCreateBuffer(context.get(), CL_MEM_READ_ONLY, sizeof(int), nullptr, &retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
auto argsNum = kernel->getKernelArgsNumber();
for (uint32_t i = 0; i < argsNum; i++) {
kernel->setArg(0, buffer);
}
EXPECT_FALSE(kernel->isPatched());
clReleaseMemObject(buffer);
}
TEST_F(PatchedKernelTest, givenKernelWithAllArgsSetWithSvmAllocWhenIsPatchedIsCalledThenReturnsTrue) {
auto argsNum = kernel->getKernelArgsNumber();
for (uint32_t i = 0; i < argsNum; i++) {
kernel->setArgSvmAlloc(0, nullptr, nullptr);
}
EXPECT_FALSE(kernel->isPatched());
for (uint32_t i = 0; i < argsNum; i++) {
kernel->setArgSvmAlloc(i, nullptr, nullptr);
}
EXPECT_TRUE(kernel->isPatched());
}
TEST_F(PatchedKernelTest, givenKernelWithAllArgsSetWithSvmWhenIsPatchedIsCalledThenReturnsTrue) {
uint32_t size = sizeof(int);
auto argsNum = kernel->getKernelArgsNumber();
for (uint32_t i = 0; i < argsNum; i++) {
kernel->setArgSvm(0, size, nullptr, nullptr, 0u);
}
EXPECT_FALSE(kernel->isPatched());
for (uint32_t i = 0; i < argsNum; i++) {
kernel->setArgSvm(i, size, nullptr, nullptr, 0u);
}
EXPECT_TRUE(kernel->isPatched());
}
TEST_F(PatchedKernelTest, givenKernelWithOneArgumentToPatchWhichIsNonzeroIndexedWhenThatArgumentIsSetThenKernelIsPatched) {
uint32_t size = sizeof(int);
MockKernelWithInternals mockKernel(*device.get(), context.get());
EXPECT_EQ(0u, mockKernel.kernelInfo.argumentsToPatchNum);
mockKernel.kernelInfo.storeKernelArgPatchInfo(1, 0, 0, 0, 0);
EXPECT_EQ(1u, mockKernel.kernelInfo.argumentsToPatchNum);
mockKernel.kernelInfo.storeKernelArgPatchInfo(1, 0, 0, 0, 0);
EXPECT_EQ(1u, mockKernel.kernelInfo.argumentsToPatchNum);
kernel.reset(mockKernel.mockKernel);
kernel->initialize();
EXPECT_FALSE(kernel->Kernel::isPatched());
kernel->setArgSvm(1, size, nullptr, nullptr, 0u);
EXPECT_TRUE(kernel->Kernel::isPatched());
kernel.release();
}
|
