fix return codes in CUDA not impl ops

Author: bratpiorka

.github/workflows/pr_push.yml

@@ -17,85 +17,27 @@ permissions:
   packages: read
 
 jobs:
-  CodeChecks:
-    uses: ./.github/workflows/reusable_checks.yml
-  FastBuild:
-    name: Fast builds
-    needs: [CodeChecks]
-    uses: ./.github/workflows/reusable_fast.yml
-  Build:
-    name: Basic builds
-    needs: [FastBuild]
-    uses: ./.github/workflows/reusable_basic.yml
-  DevDax:
-    needs: [FastBuild]
-    uses: ./.github/workflows/reusable_dax.yml
-  MultiNuma:
-    needs: [FastBuild]
-    uses: ./.github/workflows/reusable_multi_numa.yml
   L0:
-    needs: [Build]
     uses: ./.github/workflows/reusable_gpu.yml
     with:
       provider: "LEVEL_ZERO"
       runner: "L0"
       shared_lib: "['ON']"
   L0-BMG:
-    needs: [Build]
     uses: ./.github/workflows/reusable_gpu.yml
     with:
       provider: "LEVEL_ZERO"
       runner: "L0-BMG"
       shared_lib: "['ON']"
       os: "['Ubuntu']"
   CUDA:
-    needs: [Build]
+
     uses: ./.github/workflows/reusable_gpu.yml
     with:
       provider: "CUDA"
       runner: "CUDA"
       shared_lib: "['ON']"
-  Sanitizers:
-    needs: [FastBuild]
-    uses: ./.github/workflows/reusable_sanitizers.yml
-  QEMU:
-    needs: [FastBuild]
-    uses: ./.github/workflows/reusable_qemu.yml
-    with:
-      short_run: true
-  ProxyLib:
-    needs: [Build]
-    uses: ./.github/workflows/reusable_proxy_lib.yml
-  Valgrind:
-    needs: [Build]
-    uses: ./.github/workflows/reusable_valgrind.yml
-  Coverage:
-    # total coverage (on upstream only)
-    if: github.repository == 'oneapi-src/unified-memory-framework'
-    needs: [Build, DevDax, L0, CUDA, MultiNuma, QEMU, ProxyLib]
-    uses: ./.github/workflows/reusable_coverage.yml
-    secrets: inherit
-    with:
-      trigger: "${{github.event_name}}"
-  Coverage_partial:
-    # partial coverage (on forks)
-    if: github.repository != 'oneapi-src/unified-memory-framework'
-    needs: [Build, QEMU, ProxyLib]
-    uses: ./.github/workflows/reusable_coverage.yml
-  CodeQL:
-    needs: [Build]
-    permissions:
-      contents: read
-      security-events: write
-    uses: ./.github/workflows/reusable_codeql.yml
-  Trivy:
-    needs: [Build]
-    permissions:
-      contents: read
-      security-events: write
-    uses: ./.github/workflows/reusable_trivy.yml
   Compatibility:
-    needs: [Build]
     uses: ./.github/workflows/reusable_compatibility.yml
     strategy:
       matrix:

src/provider/provider_cuda.c

@@ -711,47 +711,75 @@ 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;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }
 
 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;
 }

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);