Skip to content

Commit 1d1e9e8

Browse files
bratpiorkabratpiorka
committed
add missing negative provider tests
1 parent 047432a commit 1d1e9e8

9 files changed

+211
-50
lines changed

‎src/provider/provider_level_zero.c‎

Lines changed: 69 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@
1414
#include <umf/memory_provider_ops.h>
1515
#include <umf/providers/provider_level_zero.h>
1616

17+
#include "memory_provider_internal.h"
1718
#include "provider_ctl_stats_type.h"
1819
#include "provider_level_zero_internal.h"
1920
#include "utils_load_library.h"
@@ -32,6 +33,7 @@ void fini_ze_global_state(void) {
3233

3334
#include "base_alloc_global.h"
3435
#include "libumf.h"
36+
#include "provider_level_zero_internal.h"
3537
#include "utils_assert.h"
3638
#include "utils_common.h"
3739
#include "utils_concurrency.h"
@@ -684,26 +686,6 @@ static umf_result_t ze_memory_provider_get_min_page_size(void *provider,
684686
return UMF_RESULT_SUCCESS;
685687
}
686688

687-
static umf_result_t ze_memory_provider_purge_lazy(void *provider, void *ptr,
688-
size_t size) {
689-
(void)provider;
690-
(void)ptr;
691-
(void)size;
692-
693-
// TODO not supported yet
694-
return UMF_RESULT_ERROR_NOT_SUPPORTED;
695-
}
696-
697-
static umf_result_t ze_memory_provider_purge_force(void *provider, void *ptr,
698-
size_t size) {
699-
(void)provider;
700-
(void)ptr;
701-
(void)size;
702-
703-
// TODO not supported yet
704-
return UMF_RESULT_ERROR_NOT_SUPPORTED;
705-
}
706-
707689
static umf_result_t
708690
ze_memory_provider_get_recommended_page_size(void *provider, size_t size,
709691
size_t *pageSize) {
@@ -725,32 +707,6 @@ static umf_result_t ze_memory_provider_get_name(void *provider,
725707
return UMF_RESULT_SUCCESS;
726708
}
727709

728-
static umf_result_t ze_memory_provider_allocation_merge(void *hProvider,
729-
void *lowPtr,
730-
void *highPtr,
731-
size_t totalSize) {
732-
(void)hProvider;
733-
(void)lowPtr;
734-
(void)highPtr;
735-
(void)totalSize;
736-
737-
// TODO not supported yet
738-
return UMF_RESULT_ERROR_NOT_SUPPORTED;
739-
}
740-
741-
static umf_result_t ze_memory_provider_allocation_split(void *provider,
742-
void *ptr,
743-
size_t totalSize,
744-
size_t firstSize) {
745-
(void)provider;
746-
(void)ptr;
747-
(void)totalSize;
748-
(void)firstSize;
749-
750-
// TODO not supported yet
751-
return UMF_RESULT_ERROR_NOT_SUPPORTED;
752-
}
753-
754710
typedef struct ze_ipc_data_t {
755711
int pid;
756712
ze_ipc_mem_handle_t ze_handle;
@@ -871,6 +827,65 @@ static umf_result_t ze_ctl(void *hProvider,
871827
query_type, arg, size, args);
872828
}
873829

830+
static umf_result_t ze_memory_provider_get_allocation_properties(
831+
void *provider, const void *ptr,
832+
umf_memory_property_id_t memory_property_id, void *value,
833+
size_t max_property_size) {
834+
835+
// unused
836+
(void)max_property_size;
837+
(void)ptr;
838+
839+
struct ze_memory_provider_t *ze_provider =
840+
(struct ze_memory_provider_t *)provider;
841+
842+
switch (memory_property_id) {
843+
case UMF_MEMORY_PROPERTY_POINTER_TYPE:
844+
*(umf_usm_memory_type_t *)value =
845+
ze2umf_memory_type(ze_provider->memory_type);
846+
return UMF_RESULT_SUCCESS;
847+
848+
case UMF_MEMORY_PROPERTY_CONTEXT:
849+
*(ze_context_handle_t *)value = ze_provider->context;
850+
return UMF_RESULT_SUCCESS;
851+
852+
case UMF_MEMORY_PROPERTY_DEVICE:
853+
*(ze_device_handle_t *)value = ze_provider->device;
854+
return UMF_RESULT_SUCCESS;
855+
856+
default:
857+
break;
858+
}
859+
860+
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
861+
}
862+
863+
static umf_result_t ze_memory_provider_get_allocation_properties_size(
864+
void *provider, umf_memory_property_id_t memory_property_id, size_t *size) {
865+
866+
// unused
867+
(void)provider;
868+
869+
switch (memory_property_id) {
870+
case UMF_MEMORY_PROPERTY_POINTER_TYPE:
871+
*size = sizeof(umf_usm_memory_type_t);
872+
return UMF_RESULT_SUCCESS;
873+
874+
case UMF_MEMORY_PROPERTY_CONTEXT:
875+
*size = sizeof(ze_context_handle_t);
876+
return UMF_RESULT_SUCCESS;
877+
878+
case UMF_MEMORY_PROPERTY_DEVICE:
879+
*size = sizeof(ze_device_handle_t);
880+
return UMF_RESULT_SUCCESS;
881+
882+
default:
883+
break;
884+
}
885+
886+
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
887+
}
888+
874889
static umf_memory_provider_ops_t UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS = {
875890
.version = UMF_PROVIDER_OPS_VERSION_CURRENT,
876891
.initialize = ze_memory_provider_initialize,
@@ -881,16 +896,20 @@ static umf_memory_provider_ops_t UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS = {
881896
.get_recommended_page_size = ze_memory_provider_get_recommended_page_size,
882897
.get_min_page_size = ze_memory_provider_get_min_page_size,
883898
.get_name = ze_memory_provider_get_name,
884-
.ext_purge_lazy = ze_memory_provider_purge_lazy,
885-
.ext_purge_force = ze_memory_provider_purge_force,
886-
.ext_allocation_merge = ze_memory_provider_allocation_merge,
887-
.ext_allocation_split = ze_memory_provider_allocation_split,
899+
.ext_purge_lazy = NULL,
900+
.ext_purge_force = NULL,
901+
.ext_allocation_merge = NULL,
902+
.ext_allocation_split = NULL,
888903
.ext_get_ipc_handle_size = ze_memory_provider_get_ipc_handle_size,
889904
.ext_get_ipc_handle = ze_memory_provider_get_ipc_handle,
890905
.ext_put_ipc_handle = ze_memory_provider_put_ipc_handle,
891906
.ext_open_ipc_handle = ze_memory_provider_open_ipc_handle,
892907
.ext_close_ipc_handle = ze_memory_provider_close_ipc_handle,
893908
.ext_ctl = ze_ctl,
909+
.ext_get_allocation_properties =
910+
ze_memory_provider_get_allocation_properties,
911+
.ext_get_allocation_properties_size =
912+
ze_memory_provider_get_allocation_properties_size,
894913
};
895914

896915
const umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {

‎test/provider_devdax_memory.cpp‎

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -565,3 +565,51 @@ TEST_F(test, create_wrong_size_0) {
565565
ret = umfDevDaxMemoryProviderParamsDestroy(wrong_params);
566566
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
567567
}
568+
569+
TEST_F(test, create_NULL_params) {
570+
umf_memory_provider_handle_t hProvider = nullptr;
571+
auto ret = umfMemoryProviderCreate(umfDevDaxMemoryProviderOps(), nullptr,
572+
&hProvider);
573+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
574+
ASSERT_EQ(hProvider, nullptr);
575+
}
576+
577+
TEST_F(test, params_NULL_name) {
578+
umf_devdax_memory_provider_params_handle_t params = nullptr;
579+
auto ret =
580+
umfDevDaxMemoryProviderParamsCreate("/dev/dax0.0", 4096, &params);
581+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
582+
ASSERT_NE(params, nullptr);
583+
584+
ret = umfDevDaxMemoryProviderParamsSetName(params, nullptr);
585+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
586+
587+
ret = umfDevDaxMemoryProviderParamsDestroy(params);
588+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
589+
590+
ret = umfDevDaxMemoryProviderParamsSetName(nullptr, "test");
591+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
592+
}
593+
594+
TEST_F(test, get_NULL_name) {
595+
umf_devdax_memory_provider_params_handle_t params = nullptr;
596+
auto ret =
597+
umfDevDaxMemoryProviderParamsCreate("/dev/dax0.0", 4096, &params);
598+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
599+
ASSERT_NE(params, nullptr);
600+
601+
umf_memory_provider_handle_t hProvider = nullptr;
602+
ret = umfMemoryProviderCreate(umfDevDaxMemoryProviderOps(), params,
603+
&hProvider);
604+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
605+
ASSERT_NE(hProvider, nullptr);
606+
607+
ret = umfMemoryProviderGetName(hProvider, NULL);
608+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
609+
610+
ret = umfMemoryProviderDestroy(hProvider);
611+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
612+
613+
ret = umfDevDaxMemoryProviderParamsDestroy(params);
614+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
615+
}

‎test/provider_devdax_memory_not_impl.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,9 @@ TEST_F(test, devdax_provider_not_implemented) {
2525
umf_result = umfDevDaxMemoryProviderParamsSetProtection(nullptr, 0);
2626
EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
2727

28+
umf_result = umfDevDaxMemoryProviderParamsSetName(params, "test");
29+
EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
30+
2831
const umf_memory_provider_ops_t *ops = umfDevDaxMemoryProviderOps();
2932
EXPECT_EQ(ops, nullptr);
3033
}

‎test/provider_file_memory.cpp‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -624,3 +624,65 @@ TEST_P(FileProviderParamsShared, IPC_file_not_exist) {
624624
umf_result = umfMemoryProviderFree(provider.get(), ptr, size);
625625
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
626626
}
627+
628+
TEST_F(test, create_NULL_params) {
629+
umf_memory_provider_handle_t hProvider = nullptr;
630+
auto ret = umfMemoryProviderCreate(umfFileMemoryProviderOps(), nullptr,
631+
&hProvider);
632+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
633+
ASSERT_EQ(hProvider, nullptr);
634+
}
635+
636+
TEST_F(test, params_NULL_name) {
637+
umf_file_memory_provider_params_handle_t params = nullptr;
638+
umf_result_t ret = umfFileMemoryProviderParamsCreate(FILE_PATH, &params);
639+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
640+
ASSERT_NE(params, nullptr);
641+
642+
ret = umfFileMemoryProviderParamsSetName(params, nullptr);
643+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
644+
645+
ret = umfFileMemoryProviderParamsDestroy(params);
646+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
647+
648+
ret = umfFileMemoryProviderParamsSetName(nullptr, "test");
649+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
650+
}
651+
652+
TEST_F(test, get_NULL_name) {
653+
umf_file_memory_provider_params_handle_t params = nullptr;
654+
umf_result_t ret = umfFileMemoryProviderParamsCreate(FILE_PATH, &params);
655+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
656+
ASSERT_NE(params, nullptr);
657+
658+
umf_memory_provider_handle_t hProvider = nullptr;
659+
ret =
660+
umfMemoryProviderCreate(umfFileMemoryProviderOps(), params, &hProvider);
661+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
662+
ASSERT_NE(hProvider, nullptr);
663+
664+
ret = umfMemoryProviderGetName(hProvider, NULL);
665+
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
666+
667+
ret = umfMemoryProviderDestroy(hProvider);
668+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
669+
670+
ret = umfFileMemoryProviderParamsDestroy(params);
671+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
672+
}
673+
674+
TEST_F(test, params_protection_flag) {
675+
umf_file_memory_provider_params_handle_t params = nullptr;
676+
umf_result_t ret = umfFileMemoryProviderParamsCreate(FILE_PATH, &params);
677+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
678+
ASSERT_NE(params, nullptr);
679+
680+
// test all valid combinations
681+
for (unsigned protection = UMF_PROTECTION_NONE;
682+
protection < (UMF_PROTECTION_MAX - 1) << 1; ++protection) {
683+
ret = umfFileMemoryProviderParamsSetProtection(params, protection);
684+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
685+
}
686+
687+
umfFileMemoryProviderParamsDestroy(params);
688+
}

‎test/provider_file_memory_not_impl.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,9 @@ TEST_F(test, file_provider_not_implemented) {
2828
umfFileMemoryProviderParamsSetVisibility(nullptr, UMF_MEM_MAP_PRIVATE);
2929
EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
3030

31+
umf_result = umfFileMemoryProviderParamsSetName(params, "test");
32+
EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
33+
3134
const umf_memory_provider_ops_t *ops = umfFileMemoryProviderOps();
3235
EXPECT_EQ(ops, nullptr);
3336
}

‎test/providers/provider_cuda.cpp‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -276,6 +276,10 @@ TEST_P(umfCUDAProviderTest, getName) {
276276
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
277277
ASSERT_STREQ(name, "CUDA");
278278

279+
// negative case - pass NULL as a name pointer
280+
umf_result = umfMemoryProviderGetName(provider, nullptr);
281+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
282+
279283
umfMemoryProviderDestroy(provider);
280284
}
281285

@@ -469,6 +473,12 @@ TEST_P(umfCUDAProviderTest, cudaProviderNullParams) {
469473
res =
470474
umfCUDAMemoryProviderParamsSetMemoryType(nullptr, expected_memory_type);
471475
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
476+
477+
res = umfCUDAMemoryProviderParamsSetAllocFlags(nullptr, 0);
478+
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
479+
480+
res = umfCUDAMemoryProviderParamsSetName(nullptr, "test");
481+
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
472482
}
473483

474484
TEST_P(umfCUDAProviderTest, cudaProviderInvalidCreate) {

‎test/providers/provider_cuda_not_impl.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,9 @@ TEST_F(test, cuda_provider_not_implemented) {
2929
result = umfCUDAMemoryProviderParamsSetAllocFlags(hParams, 0);
3030
ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
3131

32+
result = umfCUDAMemoryProviderParamsSetName(hParams, "test");
33+
ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
34+
3235
const umf_memory_provider_ops_t *ops = umfCUDAMemoryProviderOps();
3336
ASSERT_EQ(ops, nullptr);
3437
}

‎test/providers/provider_level_zero.cpp‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -396,6 +396,10 @@ TEST_P(umfLevelZeroProviderTest, getName) {
396396
ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
397397
ASSERT_STREQ(name, "LEVEL_ZERO");
398398

399+
// negative case - pass NULL as a name pointer
400+
umf_result = umfMemoryProviderGetName(provider, nullptr);
401+
ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
402+
399403
umfMemoryProviderDestroy(provider);
400404
}
401405

@@ -546,6 +550,12 @@ TEST_P(umfLevelZeroProviderTest, levelZeroProviderNullParams) {
546550

547551
res = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(nullptr, 0);
548552
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
553+
554+
res = umfLevelZeroMemoryProviderParamsSetAllocFlags(nullptr, 0);
555+
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
556+
557+
res = umfLevelZeroMemoryProviderParamsSetName(nullptr, "test");
558+
EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT);
549559
}
550560

551561
TEST_P(umfLevelZeroProviderTest, setDeviceOrdinalValid) {

‎test/providers/provider_level_zero_not_impl.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,9 @@ TEST_F(test, level_zero_provider_not_implemented) {
3838
result = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(hParams, 0);
3939
ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
4040

41+
result = umfLevelZeroMemoryProviderParamsSetName(hParams, "test");
42+
ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
43+
4144
const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps();
4245
ASSERT_EQ(ops, nullptr);
4346
}

0 commit comments

Comments
 (0)