Skip to content

Commit 7f1a540

Browse files
author
Alexander Batashev
authored
[SYCL][NFC] Add unit tests for info::kernel_device_specific::private_… (#3091)
1 parent 5be0fad commit 7f1a540

File tree

3 files changed

+168
-17
lines changed

3 files changed

+168
-17
lines changed

‎sycl/unittests/kernel-and-program/CMakeLists.txt

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
add_sycl_unittest_with_device(KernelAndProgramTests OBJECT
22
Cache.cpp
33
KernelRelease.cpp
4+
KernelInfo.cpp
45
)

‎sycl/unittests/kernel-and-program/KernelInfo.cpp

Lines changed: 144 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,144 @@
1+
//==-------------- KernelInfo.cpp --- kernel info unit test ----------------==//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
9+
#include <CL/sycl.hpp>
10+
#include <detail/context_impl.hpp>
11+
#include <gtest/gtest.h>
12+
#include <helpers/PiMock.hpp>
13+
14+
using namespace sycl;
15+
16+
namespace {
17+
struct TestCtx {
18+
TestCtx(context &Ctx) : Ctx{Ctx} {};
19+
20+
context &Ctx;
21+
bool PrivateMemSizeCalled = false;
22+
};
23+
} // namespace
24+
25+
static std::unique_ptr<TestCtx> TestContext;
26+
27+
static pi_result redefinedKernelGetGroupInfo(pi_kernel kernel, pi_device device,
28+
pi_kernel_group_info param_name,
29+
size_t param_value_size,
30+
void *param_value,
31+
size_t *param_value_size_ret) {
32+
if (param_name == PI_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE) {
33+
TestContext->PrivateMemSizeCalled = true;
34+
}
35+
36+
return PI_SUCCESS;
37+
}
38+
39+
static pi_result redefinedProgramCreateWithSource(pi_context context,
40+
pi_uint32 count,
41+
const char **strings,
42+
const size_t *lengths,
43+
pi_program *ret_program) {
44+
return PI_SUCCESS;
45+
}
46+
47+
static pi_result
48+
redefinedProgramBuild(pi_program program, pi_uint32 num_devices,
49+
const pi_device *device_list, const char *options,
50+
void (*pfn_notify)(pi_program program, void *user_data),
51+
void *user_data) {
52+
return PI_SUCCESS;
53+
}
54+
55+
static pi_result redefinedKernelCreate(pi_program program,
56+
const char *kernel_name,
57+
pi_kernel *ret_kernel) {
58+
return PI_SUCCESS;
59+
}
60+
61+
static pi_result redefinedKernelRetain(pi_kernel kernel) { return PI_SUCCESS; }
62+
63+
static pi_result redefinedKernelRelease(pi_kernel kernel) { return PI_SUCCESS; }
64+
65+
static pi_result redefinedKernelGetInfo(pi_kernel kernel,
66+
pi_kernel_info param_name,
67+
size_t param_value_size,
68+
void *param_value,
69+
size_t *param_value_size_ret) {
70+
EXPECT_EQ(param_name, PI_KERNEL_INFO_CONTEXT)
71+
<< "Unexpected kernel info requested";
72+
auto *Result = reinterpret_cast<RT::PiContext *>(param_value);
73+
RT::PiContext PiCtx =
74+
detail::getSyclObjImpl(TestContext->Ctx)->getHandleRef();
75+
*Result = PiCtx;
76+
return PI_SUCCESS;
77+
}
78+
79+
static pi_result redefinedKernelSetExecInfo(pi_kernel kernel,
80+
pi_kernel_exec_info param_name,
81+
size_t param_value_size,
82+
const void *param_value) {
83+
return PI_SUCCESS;
84+
}
85+
86+
class KernelInfoTest : public ::testing::Test {
87+
public:
88+
KernelInfoTest() : Plt{default_selector()} {}
89+
90+
protected:
91+
void SetUp() override {
92+
if (Plt.is_host()) {
93+
std::clog << "This test is only supported on non-host platforms.\n";
94+
std::clog << "Current platform is "
95+
<< Plt.get_info<info::platform::name>();
96+
return;
97+
}
98+
99+
Mock = std::make_unique<unittest::PiMock>(Plt);
100+
101+
Mock->redefine<detail::PiApiKind::piKernelGetGroupInfo>(
102+
redefinedKernelGetGroupInfo);
103+
Mock->redefine<detail::PiApiKind::piclProgramCreateWithSource>(
104+
redefinedProgramCreateWithSource);
105+
Mock->redefine<detail::PiApiKind::piProgramBuild>(redefinedProgramBuild);
106+
Mock->redefine<detail::PiApiKind::piKernelCreate>(redefinedKernelCreate);
107+
Mock->redefine<detail::PiApiKind::piKernelRetain>(redefinedKernelRetain);
108+
Mock->redefine<detail::PiApiKind::piKernelRelease>(redefinedKernelRelease);
109+
Mock->redefine<detail::PiApiKind::piKernelGetInfo>(redefinedKernelGetInfo);
110+
Mock->redefine<detail::PiApiKind::piKernelSetExecInfo>(
111+
redefinedKernelSetExecInfo);
112+
}
113+
114+
protected:
115+
platform Plt;
116+
std::unique_ptr<unittest::PiMock> Mock;
117+
};
118+
119+
TEST_F(KernelInfoTest, GetPrivateMemUsage) {
120+
if (Plt.is_host()) {
121+
return;
122+
}
123+
124+
context Ctx{Plt};
125+
program Prg{Ctx};
126+
TestContext.reset(new TestCtx(Ctx));
127+
128+
Prg.build_with_source("");
129+
130+
kernel Ker = Prg.get_kernel("");
131+
132+
Ker.get_info<info::kernel_device_specific::private_mem_size>(
133+
Ctx.get_devices()[0]);
134+
EXPECT_EQ(TestContext->PrivateMemSizeCalled, true)
135+
<< "Expect piKernelGetGroupInfo to be "
136+
<< "called with PI_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE";
137+
138+
TestContext->PrivateMemSizeCalled = false;
139+
Ker.get_work_group_info<info::kernel_work_group::private_mem_size>(
140+
Ctx.get_devices()[0]);
141+
EXPECT_EQ(TestContext->PrivateMemSizeCalled, true)
142+
<< "Expect piKernelGetGroupInfo to be "
143+
<< "called with PI_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE";
144+
}

‎sycl/unittests/kernel-and-program/KernelRelease.cpp

Lines changed: 23 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -16,49 +16,55 @@
1616

1717
using namespace cl::sycl;
1818

19+
namespace {
1920
struct TestCtx {
2021
TestCtx(context &Ctx) : Ctx{Ctx} {};
2122

2223
context &Ctx;
2324
int KernelReferenceCount = 0;
2425
};
26+
} // namespace
2527

26-
std::unique_ptr<TestCtx> TestContext;
28+
static std::unique_ptr<TestCtx> TestContext;
2729

28-
pi_result redefinedProgramCreateWithSource(pi_context context, pi_uint32 count,
29-
const char **strings,
30-
const size_t *lengths,
31-
pi_program *ret_program) {
30+
static pi_result redefinedProgramCreateWithSource(pi_context context,
31+
pi_uint32 count,
32+
const char **strings,
33+
const size_t *lengths,
34+
pi_program *ret_program) {
3235
return PI_SUCCESS;
3336
}
3437

35-
pi_result
38+
static pi_result
3639
redefinedProgramBuild(pi_program program, pi_uint32 num_devices,
3740
const pi_device *device_list, const char *options,
3841
void (*pfn_notify)(pi_program program, void *user_data),
3942
void *user_data) {
4043
return PI_SUCCESS;
4144
}
4245

43-
pi_result redefinedKernelCreate(pi_program program, const char *kernel_name,
44-
pi_kernel *ret_kernel) {
46+
static pi_result redefinedKernelCreate(pi_program program,
47+
const char *kernel_name,
48+
pi_kernel *ret_kernel) {
4549
TestContext->KernelReferenceCount = 1;
4650
return PI_SUCCESS;
4751
}
4852

49-
pi_result redefinedKernelRetain(pi_kernel kernel) {
53+
static pi_result redefinedKernelRetain(pi_kernel kernel) {
5054
++TestContext->KernelReferenceCount;
5155
return PI_SUCCESS;
5256
}
5357

54-
pi_result redefinedKernelRelease(pi_kernel kernel) {
58+
static pi_result redefinedKernelRelease(pi_kernel kernel) {
5559
--TestContext->KernelReferenceCount;
5660
return PI_SUCCESS;
5761
}
5862

59-
pi_result redefinedKernelGetInfo(pi_kernel kernel, pi_kernel_info param_name,
60-
size_t param_value_size, void *param_value,
61-
size_t *param_value_size_ret) {
63+
static pi_result redefinedKernelGetInfo(pi_kernel kernel,
64+
pi_kernel_info param_name,
65+
size_t param_value_size,
66+
void *param_value,
67+
size_t *param_value_size_ret) {
6268
EXPECT_EQ(param_name, PI_KERNEL_INFO_CONTEXT)
6369
<< "Unexpected kernel info requested";
6470
auto *Result = reinterpret_cast<RT::PiContext *>(param_value);
@@ -68,10 +74,10 @@ pi_result redefinedKernelGetInfo(pi_kernel kernel, pi_kernel_info param_name,
6874
return PI_SUCCESS;
6975
}
7076

71-
pi_result redefinedKernelSetExecInfo(pi_kernel kernel,
72-
pi_kernel_exec_info param_name,
73-
size_t param_value_size,
74-
const void *param_value) {
77+
static pi_result redefinedKernelSetExecInfo(pi_kernel kernel,
78+
pi_kernel_exec_info param_name,
79+
size_t param_value_size,
80+
const void *param_value) {
7581
return PI_SUCCESS;
7682
}
7783

0 commit comments

Comments
 (0)