fix return codes in CUDA not impl ops

Author: bratpiorka

src/provider/provider_cuda.c

@@ -96,7 +96,7 @@ typedef CUipcMemHandle cu_ipc_data_t;
 
 static cu_ops_t g_cu_ops;
 static UTIL_ONCE_FLAG cu_is_initialized = UTIL_ONCE_FLAG_INIT;
-static bool Init_cu_global_state_failed;
+static bool Init_cu_global_state_failed = true;
 
 // forward decl needed for alloc
 static umf_result_t cu_memory_provider_free(void *provider, void *ptr,
@@ -146,7 +146,6 @@ static void init_cu_global_state(void) {
         utils_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_NO_LOAD);
     if (!lib_handle) {
         LOG_ERR("Failed to open CUDA shared library");
-        Init_cu_global_state_failed = true;
         return;
     }
 
@@ -189,10 +188,13 @@ static void init_cu_global_state(void) {
         !g_cu_ops.cuCtxSetCurrent || !g_cu_ops.cuIpcGetMemHandle ||
         !g_cu_ops.cuIpcOpenMemHandle || !g_cu_ops.cuIpcCloseMemHandle) {
         LOG_FATAL("Required CUDA symbols not found.");
-        Init_cu_global_state_failed = true;
         utils_close_library(lib_handle);
         return;
     }
+
+    // set "failed" flag to false (it is initialized to true)
+    Init_cu_global_state_failed = false;
+
     cu_lib_handle = lib_handle;
 }
 
@@ -244,6 +246,10 @@ umf_result_t umfCUDAMemoryProviderParamsCreate(
 
 umf_result_t umfCUDAMemoryProviderParamsDestroy(
     umf_cuda_memory_provider_params_handle_t hParams) {
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
     umf_ba_global_free(hParams);
 
     return UMF_RESULT_SUCCESS;
@@ -711,49 +717,77 @@ const umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void) {
 
 umf_result_t umfCUDAMemoryProviderParamsCreate(
     umf_cuda_memory_provider_params_handle_t *hParams) {
-    (void)hParams;
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *hParams = NULL;
     LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+
+    return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
 }
 
 umf_result_t umfCUDAMemoryProviderParamsDestroy(
     umf_cuda_memory_provider_params_handle_t hParams) {
-    (void)hParams;
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
 }
 
 umf_result_t umfCUDAMemoryProviderParamsSetContext(
     umf_cuda_memory_provider_params_handle_t hParams, void *hContext) {
-    (void)hParams;
     (void)hContext;
+
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
 }
 
 umf_result_t umfCUDAMemoryProviderParamsSetDevice(
     umf_cuda_memory_provider_params_handle_t hParams, int hDevice) {
-    (void)hParams;
     (void)hDevice;
+
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
 }
 
 umf_result_t umfCUDAMemoryProviderParamsSetMemoryType(
     umf_cuda_memory_provider_params_handle_t hParams,
     umf_usm_memory_type_t memoryType) {
-    (void)hParams;
     (void)memoryType;
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
 }
 
 umf_result_t umfCUDAMemoryProviderParamsSetAllocFlags(
     umf_cuda_memory_provider_params_handle_t hParams, unsigned int flags) {
-    (void)hParams;
     (void)flags;
+    if (!hParams) {
+        LOG_ERR("CUDA Memory Provider params handle is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     LOG_ERR("CUDA provider is disabled (UMF_BUILD_CUDA_PROVIDER is OFF)!");
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
 }
 
 const umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void) {

test/providers/provider_cuda_not_impl.cpp

@@ -11,23 +11,28 @@ using umf_test::test;
 TEST_F(test, cuda_provider_not_implemented) {
     umf_cuda_memory_provider_params_handle_t hParams = nullptr;
     umf_result_t result = umfCUDAMemoryProviderParamsCreate(&hParams);
-    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_NE(result, UMF_RESULT_SUCCESS); // note NE
+    ASSERT_EQ(hParams, nullptr);
 
+    // set hParams to non-null value
+    hParams = (umf_cuda_memory_provider_params_handle_t)0x1;
+
+    // when CUDA is not available, all operations should fail
     result = umfCUDAMemoryProviderParamsDestroy(hParams);
-    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_NE(result, UMF_RESULT_SUCCESS);
 
     result = umfCUDAMemoryProviderParamsSetContext(hParams, nullptr);
-    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_NE(result, UMF_RESULT_SUCCESS);
 
     result = umfCUDAMemoryProviderParamsSetDevice(hParams, 0);
-    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_NE(result, UMF_RESULT_SUCCESS);
 
     result = umfCUDAMemoryProviderParamsSetMemoryType(hParams,
                                                       UMF_MEMORY_TYPE_DEVICE);
-    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_NE(result, UMF_RESULT_SUCCESS);
 
     result = umfCUDAMemoryProviderParamsSetAllocFlags(hParams, 0);
-    ASSERT_EQ(result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+    ASSERT_NE(result, UMF_RESULT_SUCCESS);
 
     const umf_memory_provider_ops_t *ops = umfCUDAMemoryProviderOps();
     ASSERT_EQ(ops, nullptr);