Skip to content

Commit 80880eb

Browse files
lukaszstolarczuklukaszstolarczuk
authored
Merge pull request #824 from vinser52/svinogra_gpu_tests
Add additional tests for CUDA and L0 providers
2 parents 1b3d694 + e524922 commit 80880eb

File tree

3 files changed

+159
-19
lines changed

3 files changed

+159
-19
lines changed

‎test/ipcFixtures.hpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -69,8 +69,8 @@ struct umfIpcTest : umf_test::test,
6969
umf::pool_unique_handle_t makePool() {
7070
// TODO: The function is similar to poolCreateExt function
7171
// from memoryPool.hpp
72-
umf_memory_provider_handle_t hProvider;
73-
umf_memory_pool_handle_t hPool;
72+
umf_memory_provider_handle_t hProvider = NULL;
73+
umf_memory_pool_handle_t hPool = NULL;
7474

7575
auto ret =
7676
umfMemoryProviderCreate(providerOps, providerParams, &hProvider);

‎test/providers/provider_cuda.cpp

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -125,6 +125,43 @@ TEST_P(umfCUDAProviderTest, basic) {
125125
umfMemoryProviderDestroy(provider);
126126
}
127127

128+
TEST_P(umfCUDAProviderTest, getPageSize) {
129+
umf_memory_provider_handle_t provider = nullptr;
130+
umf_result_t umf_result =
131+
umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), &params, &provider);
132+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
133+
ASSERT_NE(provider, nullptr);
134+
135+
size_t recommendedPageSize = 0;
136+
umf_result = umfMemoryProviderGetRecommendedPageSize(provider, 0,
137+
&recommendedPageSize);
138+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
139+
ASSERT_GE(recommendedPageSize, 0);
140+
141+
size_t minPageSize = 0;
142+
umf_result =
143+
umfMemoryProviderGetMinPageSize(provider, nullptr, &minPageSize);
144+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
145+
ASSERT_GE(minPageSize, 0);
146+
147+
ASSERT_GE(recommendedPageSize, minPageSize);
148+
149+
umfMemoryProviderDestroy(provider);
150+
}
151+
152+
TEST_P(umfCUDAProviderTest, getName) {
153+
umf_memory_provider_handle_t provider = nullptr;
154+
umf_result_t umf_result =
155+
umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), &params, &provider);
156+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
157+
ASSERT_NE(provider, nullptr);
158+
159+
const char *name = umfMemoryProviderGetName(provider);
160+
ASSERT_STREQ(name, "CUDA");
161+
162+
umfMemoryProviderDestroy(provider);
163+
}
164+
128165
TEST_P(umfCUDAProviderTest, allocInvalidSize) {
129166
CUcontext expected_current_context = get_current_context();
130167
// create CUDA provider
@@ -152,6 +189,32 @@ TEST_P(umfCUDAProviderTest, allocInvalidSize) {
152189
umfMemoryProviderDestroy(provider);
153190
}
154191

192+
TEST_P(umfCUDAProviderTest, providerCreateInvalidArgs) {
193+
umf_memory_provider_handle_t provider = nullptr;
194+
umf_result_t umf_result =
195+
umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), nullptr, &provider);
196+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
197+
198+
umf_result = umfMemoryProviderCreate(nullptr, &params, nullptr);
199+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
200+
}
201+
202+
TEST_P(umfCUDAProviderTest, getPageSizeInvalidArgs) {
203+
umf_memory_provider_handle_t provider = nullptr;
204+
umf_result_t umf_result =
205+
umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), &params, &provider);
206+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
207+
ASSERT_NE(provider, nullptr);
208+
209+
umf_result = umfMemoryProviderGetMinPageSize(provider, nullptr, nullptr);
210+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
211+
212+
umf_result = umfMemoryProviderGetRecommendedPageSize(provider, 0, nullptr);
213+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
214+
215+
umfMemoryProviderDestroy(provider);
216+
}
217+
155218
// TODO add tests that mixes CUDA Memory Provider and Disjoint Pool
156219

157220
cuda_memory_provider_params_t cuParams_device_memory =

‎test/providers/provider_level_zero.cpp

Lines changed: 94 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -141,14 +141,9 @@ struct umfLevelZeroProviderTest
141141

142142
auto [l0_params, accessor] = this->GetParam();
143143
params = l0_params;
144-
hDevice = (ze_device_handle_t)params.level_zero_device_handle;
144+
memAccessor = accessor;
145145
hContext = (ze_context_handle_t)params.level_zero_context_handle;
146146

147-
if (params.memory_type == UMF_MEMORY_TYPE_HOST) {
148-
ASSERT_EQ(hDevice, nullptr);
149-
} else {
150-
ASSERT_NE(hDevice, nullptr);
151-
}
152147
ASSERT_NE(hContext, nullptr);
153148

154149
switch (params.memory_type) {
@@ -167,21 +162,14 @@ struct umfLevelZeroProviderTest
167162
}
168163

169164
ASSERT_NE(zeMemoryTypeExpected, ZE_MEMORY_TYPE_UNKNOWN);
170-
171-
memAccessor = accessor;
172165
}
173166

174-
void TearDown() override {
175-
int ret = destroy_context(hContext);
176-
ASSERT_EQ(ret, 0);
177-
test::TearDown();
178-
}
167+
void TearDown() override { test::TearDown(); }
179168

180169
level_zero_memory_provider_params_t params;
181-
ze_device_handle_t hDevice = nullptr;
170+
MemoryAccessor *memAccessor = nullptr;
182171
ze_context_handle_t hContext = nullptr;
183172
ze_memory_type_t zeMemoryTypeExpected = ZE_MEMORY_TYPE_UNKNOWN;
184-
MemoryAccessor *memAccessor = nullptr;
185173
};
186174

187175
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfLevelZeroProviderTest);
@@ -222,8 +210,97 @@ TEST_P(umfLevelZeroProviderTest, basic) {
222210
umfMemoryProviderDestroy(provider);
223211
}
224212

225-
// TODO add Level Zero Memory Provider specyfic tests
226-
// TODO add negative test and check for Level Zero native errors
213+
TEST_P(umfLevelZeroProviderTest, getPageSize) {
214+
umf_memory_provider_handle_t provider = nullptr;
215+
umf_result_t umf_result = umfMemoryProviderCreate(
216+
umfLevelZeroMemoryProviderOps(), &params, &provider);
217+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
218+
ASSERT_NE(provider, nullptr);
219+
220+
size_t recommendedPageSize = 0;
221+
umf_result = umfMemoryProviderGetRecommendedPageSize(provider, 0,
222+
&recommendedPageSize);
223+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
224+
ASSERT_GE(recommendedPageSize, 0);
225+
226+
size_t minPageSize = 0;
227+
umf_result =
228+
umfMemoryProviderGetMinPageSize(provider, nullptr, &minPageSize);
229+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
230+
ASSERT_GE(minPageSize, 0);
231+
232+
ASSERT_GE(recommendedPageSize, minPageSize);
233+
234+
umfMemoryProviderDestroy(provider);
235+
}
236+
237+
TEST_P(umfLevelZeroProviderTest, getName) {
238+
umf_memory_provider_handle_t provider = nullptr;
239+
umf_result_t umf_result = umfMemoryProviderCreate(
240+
umfLevelZeroMemoryProviderOps(), &params, &provider);
241+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
242+
ASSERT_NE(provider, nullptr);
243+
244+
const char *name = umfMemoryProviderGetName(provider);
245+
ASSERT_STREQ(name, "LEVEL_ZERO");
246+
247+
umfMemoryProviderDestroy(provider);
248+
}
249+
250+
TEST_P(umfLevelZeroProviderTest, allocInvalidSize) {
251+
umf_memory_provider_handle_t provider = nullptr;
252+
umf_result_t umf_result = umfMemoryProviderCreate(
253+
umfLevelZeroMemoryProviderOps(), &params, &provider);
254+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
255+
ASSERT_NE(provider, nullptr);
256+
257+
// try to alloc (int)-1
258+
void *ptr = nullptr;
259+
umf_result = umfMemoryProviderAlloc(provider, -1, 0, &ptr);
260+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC);
261+
const char *message;
262+
int32_t error;
263+
umfMemoryProviderGetLastNativeError(provider, &message, &error);
264+
ASSERT_EQ(error, ZE_RESULT_ERROR_UNSUPPORTED_SIZE);
265+
266+
// in case of size == 0 we should got INVALID_ARGUMENT error
267+
// NOTE: this is invalid only for the DEVICE or SHARED allocations
268+
if (params.memory_type != UMF_MEMORY_TYPE_HOST) {
269+
umf_result = umfMemoryProviderAlloc(provider, 0, 0, &ptr);
270+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC);
271+
umfMemoryProviderGetLastNativeError(provider, &message, &error);
272+
ASSERT_EQ(error, ZE_RESULT_ERROR_UNSUPPORTED_SIZE);
273+
}
274+
275+
umfMemoryProviderDestroy(provider);
276+
}
277+
278+
TEST_P(umfLevelZeroProviderTest, providerCreateInvalidArgs) {
279+
umf_memory_provider_handle_t provider = nullptr;
280+
umf_result_t umf_result = umfMemoryProviderCreate(
281+
umfLevelZeroMemoryProviderOps(), nullptr, &provider);
282+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
283+
284+
umf_result = umfMemoryProviderCreate(nullptr, &params, nullptr);
285+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
286+
}
287+
288+
TEST_P(umfLevelZeroProviderTest, getPageSizeInvalidArgs) {
289+
umf_memory_provider_handle_t provider = nullptr;
290+
umf_result_t umf_result = umfMemoryProviderCreate(
291+
umfLevelZeroMemoryProviderOps(), &params, &provider);
292+
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
293+
ASSERT_NE(provider, nullptr);
294+
295+
umf_result = umfMemoryProviderGetMinPageSize(provider, nullptr, nullptr);
296+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
297+
298+
umf_result = umfMemoryProviderGetRecommendedPageSize(provider, 0, nullptr);
299+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
300+
301+
umfMemoryProviderDestroy(provider);
302+
}
303+
227304
// TODO add tests that mixes Level Zero Memory Provider and Disjoint Pool
228305

229306
level_zero_memory_provider_params_t l0Params_device_memory =

0 commit comments

Comments
 (0)