diff --git a/src/provider/provider_level_zero.c b/src/provider/provider_level_zero.c index 8703e8fdc..86378769e 100644 --- a/src/provider/provider_level_zero.c +++ b/src/provider/provider_level_zero.c @@ -684,26 +684,6 @@ static umf_result_t ze_memory_provider_get_min_page_size(void *provider, return UMF_RESULT_SUCCESS; } -static umf_result_t ze_memory_provider_purge_lazy(void *provider, void *ptr, - size_t size) { - (void)provider; - (void)ptr; - (void)size; - - // TODO not supported yet - return UMF_RESULT_ERROR_NOT_SUPPORTED; -} - -static umf_result_t ze_memory_provider_purge_force(void *provider, void *ptr, - size_t size) { - (void)provider; - (void)ptr; - (void)size; - - // TODO not supported yet - return UMF_RESULT_ERROR_NOT_SUPPORTED; -} - static umf_result_t ze_memory_provider_get_recommended_page_size(void *provider, size_t size, size_t *pageSize) { @@ -725,32 +705,6 @@ static umf_result_t ze_memory_provider_get_name(void *provider, return UMF_RESULT_SUCCESS; } -static umf_result_t ze_memory_provider_allocation_merge(void *hProvider, - void *lowPtr, - void *highPtr, - size_t totalSize) { - (void)hProvider; - (void)lowPtr; - (void)highPtr; - (void)totalSize; - - // TODO not supported yet - return UMF_RESULT_ERROR_NOT_SUPPORTED; -} - -static umf_result_t ze_memory_provider_allocation_split(void *provider, - void *ptr, - size_t totalSize, - size_t firstSize) { - (void)provider; - (void)ptr; - (void)totalSize; - (void)firstSize; - - // TODO not supported yet - return UMF_RESULT_ERROR_NOT_SUPPORTED; -} - typedef struct ze_ipc_data_t { int pid; ze_ipc_mem_handle_t ze_handle; @@ -881,10 +835,10 @@ static umf_memory_provider_ops_t UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS = { .get_recommended_page_size = ze_memory_provider_get_recommended_page_size, .get_min_page_size = ze_memory_provider_get_min_page_size, .get_name = ze_memory_provider_get_name, - .ext_purge_lazy = ze_memory_provider_purge_lazy, - .ext_purge_force = ze_memory_provider_purge_force, - .ext_allocation_merge = ze_memory_provider_allocation_merge, - .ext_allocation_split = ze_memory_provider_allocation_split, + .ext_purge_lazy = NULL, + .ext_purge_force = NULL, + .ext_allocation_merge = NULL, + .ext_allocation_split = NULL, .ext_get_ipc_handle_size = ze_memory_provider_get_ipc_handle_size, .ext_get_ipc_handle = ze_memory_provider_get_ipc_handle, .ext_put_ipc_handle = ze_memory_provider_put_ipc_handle, diff --git a/test/provider_devdax_memory.cpp b/test/provider_devdax_memory.cpp index b22f4fa29..9242a5166 100644 --- a/test/provider_devdax_memory.cpp +++ b/test/provider_devdax_memory.cpp @@ -565,3 +565,49 @@ TEST_F(test, create_wrong_size_0) { ret = umfDevDaxMemoryProviderParamsDestroy(wrong_params); ASSERT_EQ(ret, UMF_RESULT_SUCCESS); } + +TEST_F(test, create_NULL_params) { + umf_memory_provider_handle_t hProvider = nullptr; + auto ret = umfMemoryProviderCreate(umfDevDaxMemoryProviderOps(), nullptr, + &hProvider); + ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); + ASSERT_EQ(hProvider, nullptr); +} + +TEST_F(test, params_NULL_name) { + umf_devdax_memory_provider_params_handle_t params = nullptr; + auto ret = + umfDevDaxMemoryProviderParamsCreate("/dev/dax0.0", 4096, ¶ms); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + ASSERT_NE(params, nullptr); + + ret = umfDevDaxMemoryProviderParamsSetName(params, nullptr); + ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); + + ret = umfDevDaxMemoryProviderParamsDestroy(params); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfDevDaxMemoryProviderParamsSetName(nullptr, "test"); + ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); +} + +TEST_F(test, get_NULL_name) { + umf_devdax_memory_provider_params_handle_t params = + defaultDevDaxParams.get(); + ASSERT_NE(params, nullptr); + + umf_memory_provider_handle_t hProvider = nullptr; + umf_result_t ret = umfMemoryProviderCreate(umfDevDaxMemoryProviderOps(), + params, &hProvider); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + ASSERT_NE(hProvider, nullptr); + + ret = umfMemoryProviderGetName(hProvider, NULL); + ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); + + ret = umfMemoryProviderDestroy(hProvider); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfDevDaxMemoryProviderParamsDestroy(params); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); +} diff --git a/test/provider_devdax_memory_not_impl.cpp b/test/provider_devdax_memory_not_impl.cpp index 8924efc4e..8dd15afbe 100644 --- a/test/provider_devdax_memory_not_impl.cpp +++ b/test/provider_devdax_memory_not_impl.cpp @@ -25,6 +25,9 @@ TEST_F(test, devdax_provider_not_implemented) { umf_result = umfDevDaxMemoryProviderParamsSetProtection(nullptr, 0); EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED); + umf_result = umfDevDaxMemoryProviderParamsSetName(params, "test"); + EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED); + const umf_memory_provider_ops_t *ops = umfDevDaxMemoryProviderOps(); EXPECT_EQ(ops, nullptr); } diff --git a/test/provider_file_memory.cpp b/test/provider_file_memory.cpp index c59223eb5..448794607 100644 --- a/test/provider_file_memory.cpp +++ b/test/provider_file_memory.cpp @@ -624,3 +624,65 @@ TEST_P(FileProviderParamsShared, IPC_file_not_exist) { umf_result = umfMemoryProviderFree(provider.get(), ptr, size); ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS); } + +TEST_F(test, create_NULL_params) { + umf_memory_provider_handle_t hProvider = nullptr; + auto ret = umfMemoryProviderCreate(umfFileMemoryProviderOps(), nullptr, + &hProvider); + ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); + ASSERT_EQ(hProvider, nullptr); +} + +TEST_F(test, params_NULL_name) { + umf_file_memory_provider_params_handle_t params = nullptr; + umf_result_t ret = umfFileMemoryProviderParamsCreate(FILE_PATH, ¶ms); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + ASSERT_NE(params, nullptr); + + ret = umfFileMemoryProviderParamsSetName(params, nullptr); + ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); + + ret = umfFileMemoryProviderParamsDestroy(params); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfFileMemoryProviderParamsSetName(nullptr, "test"); + ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); +} + +TEST_F(test, get_NULL_name) { + umf_file_memory_provider_params_handle_t params = nullptr; + umf_result_t ret = umfFileMemoryProviderParamsCreate(FILE_PATH, ¶ms); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + ASSERT_NE(params, nullptr); + + umf_memory_provider_handle_t hProvider = nullptr; + ret = + umfMemoryProviderCreate(umfFileMemoryProviderOps(), params, &hProvider); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + ASSERT_NE(hProvider, nullptr); + + ret = umfMemoryProviderGetName(hProvider, NULL); + ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT); + + ret = umfMemoryProviderDestroy(hProvider); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + + ret = umfFileMemoryProviderParamsDestroy(params); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); +} + +TEST_F(test, params_protection_flag) { + umf_file_memory_provider_params_handle_t params = nullptr; + umf_result_t ret = umfFileMemoryProviderParamsCreate(FILE_PATH, ¶ms); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + ASSERT_NE(params, nullptr); + + // test all valid combinations + for (unsigned protection = UMF_PROTECTION_NONE; + protection < (UMF_PROTECTION_MAX - 1) << 1; ++protection) { + ret = umfFileMemoryProviderParamsSetProtection(params, protection); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + } + + umfFileMemoryProviderParamsDestroy(params); +} diff --git a/test/provider_file_memory_not_impl.cpp b/test/provider_file_memory_not_impl.cpp index 84ae5ffdf..831611e80 100644 --- a/test/provider_file_memory_not_impl.cpp +++ b/test/provider_file_memory_not_impl.cpp @@ -28,6 +28,9 @@ TEST_F(test, file_provider_not_implemented) { umfFileMemoryProviderParamsSetVisibility(nullptr, UMF_MEM_MAP_PRIVATE); EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED); + umf_result = umfFileMemoryProviderParamsSetName(params, "test"); + EXPECT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED); + const umf_memory_provider_ops_t *ops = umfFileMemoryProviderOps(); EXPECT_EQ(ops, nullptr); } diff --git a/test/providers/provider_cuda.cpp b/test/providers/provider_cuda.cpp index 585868014..e3580b264 100644 --- a/test/providers/provider_cuda.cpp +++ b/test/providers/provider_cuda.cpp @@ -276,6 +276,10 @@ TEST_P(umfCUDAProviderTest, getName) { ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS); ASSERT_STREQ(name, "CUDA"); + // negative case - pass NULL as a name pointer + umf_result = umfMemoryProviderGetName(provider, nullptr); + ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT); + umfMemoryProviderDestroy(provider); } @@ -469,6 +473,12 @@ TEST_P(umfCUDAProviderTest, cudaProviderNullParams) { res = umfCUDAMemoryProviderParamsSetMemoryType(nullptr, expected_memory_type); EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT); + + res = umfCUDAMemoryProviderParamsSetAllocFlags(nullptr, 0); + EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT); + + res = umfCUDAMemoryProviderParamsSetName(nullptr, "test"); + EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT); } TEST_P(umfCUDAProviderTest, cudaProviderInvalidCreate) { diff --git a/test/providers/provider_cuda_not_impl.cpp b/test/providers/provider_cuda_not_impl.cpp index 9ddea2048..e5edf5579 100644 --- a/test/providers/provider_cuda_not_impl.cpp +++ b/test/providers/provider_cuda_not_impl.cpp @@ -29,6 +29,9 @@ TEST_F(test, cuda_provider_not_implemented) { result = umfCUDAMemoryProviderParamsSetAllocFlags(hParams, 0); ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED); + result = umfCUDAMemoryProviderParamsSetName(hParams, "test"); + ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED); + const umf_memory_provider_ops_t *ops = umfCUDAMemoryProviderOps(); ASSERT_EQ(ops, nullptr); } diff --git a/test/providers/provider_level_zero.cpp b/test/providers/provider_level_zero.cpp index 7aa3f048b..0c9b6505a 100644 --- a/test/providers/provider_level_zero.cpp +++ b/test/providers/provider_level_zero.cpp @@ -396,6 +396,10 @@ TEST_P(umfLevelZeroProviderTest, getName) { ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS); ASSERT_STREQ(name, "LEVEL_ZERO"); + // negative case - pass NULL as a name pointer + umf_result = umfMemoryProviderGetName(provider, nullptr); + ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT); + umfMemoryProviderDestroy(provider); } @@ -546,6 +550,12 @@ TEST_P(umfLevelZeroProviderTest, levelZeroProviderNullParams) { res = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(nullptr, 0); EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT); + + res = umfLevelZeroMemoryProviderParamsSetAllocFlags(nullptr, 0); + EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT); + + res = umfLevelZeroMemoryProviderParamsSetName(nullptr, "test"); + EXPECT_EQ(res, UMF_RESULT_ERROR_INVALID_ARGUMENT); } TEST_P(umfLevelZeroProviderTest, setDeviceOrdinalValid) { diff --git a/test/providers/provider_level_zero_not_impl.cpp b/test/providers/provider_level_zero_not_impl.cpp index dfbd4a2b2..301c86a2e 100644 --- a/test/providers/provider_level_zero_not_impl.cpp +++ b/test/providers/provider_level_zero_not_impl.cpp @@ -38,6 +38,9 @@ TEST_F(test, level_zero_provider_not_implemented) { result = umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(hParams, 0); ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED); + result = umfLevelZeroMemoryProviderParamsSetName(hParams, "test"); + ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED); + const umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps(); ASSERT_EQ(ops, nullptr); }