Refactor Level Zero and CUDA tests

Author: vinser52

src/utils/utils_level_zero.cpp

@@ -344,12 +344,6 @@ int utils_ze_get_drivers(uint32_t *drivers_num_,
     ze_driver_handle_t *drivers = NULL;
     uint32_t drivers_num = 0;
 
-    ret = utils_ze_init_level_zero();
-    if (ret != 0) {
-        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
-        goto init_fail;
-    }
-
     ze_result = libze_ops.zeDriverGet(&drivers_num, NULL);
     if (ze_result != ZE_RESULT_SUCCESS) {
         fprintf(stderr, "zeDriverGet() failed!\n");
@@ -386,7 +380,6 @@ int utils_ze_get_drivers(uint32_t *drivers_num_,
         *drivers_ = NULL;
     }
 
-init_fail:
     return ret;
 }
 
@@ -397,12 +390,6 @@ int utils_ze_get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
     uint32_t devices_num = 0;
     ze_device_handle_t *devices = NULL;
 
-    ret = utils_ze_init_level_zero();
-    if (ret != 0) {
-        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
-        goto init_fail;
-    }
-
     ze_result = libze_ops.zeDeviceGet(driver, &devices_num, NULL);
     if (ze_result != ZE_RESULT_SUCCESS) {
         fprintf(stderr, "zeDeviceGet() failed!\n");
@@ -438,7 +425,7 @@ int utils_ze_get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
         free(devices);
         devices = NULL;
     }
-init_fail:
+
     return ret;
 }
 

src/utils/utils_level_zero.h

@@ -16,7 +16,6 @@
 extern "C" {
 #endif
 
-int utils_ze_init_level_zero(void);
 int utils_ze_init_level_zero(void);
 
 int utils_ze_get_drivers(uint32_t *drivers_num_, ze_driver_handle_t **drivers_);

test/common/ipc_common.c

@@ -127,8 +127,7 @@ int run_consumer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
     umf_result =
         umfMemoryProviderCreate(provider_ops, provider_params, &provider);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr,
-                "[consumer] ERROR: creating OS memory provider failed\n");
+        fprintf(stderr, "[consumer] ERROR: creating memory provider failed\n");
         return -1;
     }
 
@@ -347,8 +346,7 @@ int run_producer(int port, umf_memory_pool_ops_t *pool_ops, void *pool_params,
     umf_result =
         umfMemoryProviderCreate(provider_ops, provider_params, &provider);
     if (umf_result != UMF_RESULT_SUCCESS) {
-        fprintf(stderr,
-                "[producer] ERROR: creating OS memory provider failed\n");
+        fprintf(stderr, "[producer] ERROR: creating memory provider failed\n");
         return -1;
     }
 

test/ipcFixtures.hpp

@@ -21,6 +21,7 @@
 
 class MemoryAccessor {
   public:
+    virtual ~MemoryAccessor() = default;
     virtual void fill(void *ptr, size_t size, const void *pattern,
                       size_t pattern_size) = 0;
     virtual void copy(void *dst_ptr, void *src_ptr, size_t size) = 0;
@@ -162,6 +163,7 @@ struct umfIpcTest : umf_test::test,
 TEST_P(umfIpcTest, GetIPCHandleSize) {
     size_t size = 0;
     umf::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
 
     umf_result_t ret = umfPoolGetIPCHandleSize(pool.get(), &size);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
@@ -174,6 +176,8 @@ TEST_P(umfIpcTest, GetIPCHandleSizeInvalidArgs) {
     EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umf::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
     ret = umfPoolGetIPCHandleSize(pool.get(), nullptr);
     EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
@@ -190,6 +194,8 @@ TEST_P(umfIpcTest, GetIPCHandleInvalidArgs) {
     EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 
     umf::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
     ptr = umfPoolMalloc(pool.get(), SIZE);
     EXPECT_NE(ptr, nullptr);
 
@@ -213,6 +219,8 @@ TEST_P(umfIpcTest, BasicFlow) {
     constexpr size_t SIZE = 100;
     std::vector<int> expected_data(SIZE);
     umf::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
     int *ptr = (int *)umfPoolMalloc(pool.get(), SIZE * sizeof(int));
     EXPECT_NE(ptr, nullptr);
 
@@ -283,6 +291,7 @@ TEST_P(umfIpcTest, GetPoolByOpenedHandle) {
     void *openedPtrs[NUM_POOLS][NUM_ALLOCS];
     std::vector<umf::pool_unique_handle_t> pools_to_open;
     umf::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
 
     for (size_t i = 0; i < NUM_POOLS; ++i) {
         pools_to_open.push_back(makePool());
@@ -341,6 +350,8 @@ TEST_P(umfIpcTest, GetPoolByOpenedHandle) {
 TEST_P(umfIpcTest, AllocFreeAllocTest) {
     constexpr size_t SIZE = 64 * 1024;
     umf::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
+
     umf_ipc_handler_handle_t ipcHandler = nullptr;
 
     umf_result_t ret = umfPoolGetIPCHandler(pool.get(), &ipcHandler);
@@ -400,7 +411,9 @@ TEST_P(umfIpcTest, openInTwoIpcHandlers) {
     constexpr size_t SIZE = 100;
     std::vector<int> expected_data(SIZE);
     umf::pool_unique_handle_t pool1 = makePool();
+    ASSERT_NE(pool1.get(), nullptr);
     umf::pool_unique_handle_t pool2 = makePool();
+    ASSERT_NE(pool2.get(), nullptr);
     umf_ipc_handler_handle_t ipcHandler1 = nullptr;
     umf_ipc_handler_handle_t ipcHandler2 = nullptr;
 
@@ -465,6 +478,7 @@ TEST_P(umfIpcTest, ConcurrentGetPutHandles) {
     constexpr size_t ALLOC_SIZE = 100;
     constexpr size_t NUM_POINTERS = 100;
     umf::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
 
     for (size_t i = 0; i < NUM_POINTERS; ++i) {
         void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);
@@ -514,6 +528,7 @@ TEST_P(umfIpcTest, ConcurrentOpenCloseHandles) {
     constexpr size_t ALLOC_SIZE = 100;
     constexpr size_t NUM_POINTERS = 100;
     umf::pool_unique_handle_t pool = makePool();
+    ASSERT_NE(pool.get(), nullptr);
 
     for (size_t i = 0; i < NUM_POINTERS; ++i) {
         void *ptr = umfPoolMalloc(pool.get(), ALLOC_SIZE);

test/providers/ipc_level_zero_prov_consumer.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -27,7 +27,13 @@ int main(int argc, char *argv[]) {
     ze_device_handle_t hDevice = NULL;
     ze_context_handle_t hContext = NULL;
 
-    int ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
+    int ret = utils_ze_init_level_zero();
+    if (ret != 0) {
+        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
+        return -1;
+    }
+
+    ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
     if (ret != 0 || hDriver == NULL) {
         fprintf(stderr, "utils_ze_find_driver_with_gpu() failed!\n");
         return -1;

test/providers/ipc_level_zero_prov_producer.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -27,7 +27,13 @@ int main(int argc, char *argv[]) {
     ze_device_handle_t hDevice = NULL;
     ze_context_handle_t hContext = NULL;
 
-    int ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
+    int ret = utils_ze_init_level_zero();
+    if (ret != 0) {
+        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
+        return -1;
+    }
+
+    ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
     if (ret != 0 || hDriver == NULL) {
         fprintf(stderr, "utils_ze_find_driver_with_gpu() failed!\n");
         return -1;

test/providers/provider_cuda.cpp

@@ -83,6 +83,11 @@ create_cuda_prov_params(CUcontext context, CUdevice device,
     return params;
 }
 
+umf_result_t destroyCuParams(void *params) {
+    return umfCUDAMemoryProviderParamsDestroy(
+        (umf_cuda_memory_provider_params_handle_t)params);
+}
+
 class CUDAMemoryAccessor : public MemoryAccessor {
   public:
     CUDAMemoryAccessor(CUcontext hContext, CUdevice hDevice)
@@ -114,47 +119,62 @@ class CUDAMemoryAccessor : public MemoryAccessor {
     CUcontext hContext_;
 };
 
-typedef void *(*pfnProviderParamsCreate)();
-typedef umf_result_t (*pfnProviderParamsDestroy)(void *);
-
-using CUDAProviderTestParams =
-    std::tuple<pfnProviderParamsCreate, pfnProviderParamsDestroy, CUcontext,
-               umf_usm_memory_type_t, MemoryAccessor *>;
-
 struct umfCUDAProviderTest
     : umf_test::test,
-      ::testing::WithParamInterface<CUDAProviderTestParams> {
+      ::testing::WithParamInterface<umf_usm_memory_type_t> {
 
     void SetUp() override {
         test::SetUp();
 
-        auto [params_create, params_destroy, cu_context, memory_type,
-              accessor] = this->GetParam();
+        umf_usm_memory_type_t memory_type = this->GetParam();
 
         params = nullptr;
-        if (params_create) {
-            params = (umf_cuda_memory_provider_params_handle_t)params_create();
+        memAccessor = nullptr;
+        expected_context = cudaTestHelper.get_test_context();
+
+        ASSERT_NE(expected_context, nullptr);
+
+        switch (memory_type) {
+        case UMF_MEMORY_TYPE_DEVICE:
+            params = create_cuda_prov_params(cudaTestHelper.get_test_context(),
+                                             cudaTestHelper.get_test_device(),
+                                             memory_type);
+            memAccessor = std::make_unique<CUDAMemoryAccessor>(
+                cudaTestHelper.get_test_context(),
+                cudaTestHelper.get_test_device());
+            break;
+        case UMF_MEMORY_TYPE_SHARED:
+            params = create_cuda_prov_params(cudaTestHelper.get_test_context(),
+                                             cudaTestHelper.get_test_device(),
+                                             memory_type);
+            memAccessor = std::make_unique<HostMemoryAccessor>();
+            break;
+        case UMF_MEMORY_TYPE_HOST:
+            params = create_cuda_prov_params(cudaTestHelper.get_test_context(),
+                                             cudaTestHelper.get_test_device(),
+                                             memory_type);
+            memAccessor = std::make_unique<HostMemoryAccessor>();
+            break;
+        case UMF_MEMORY_TYPE_UNKNOWN:
+            break;
         }
-        paramsDestroy = params_destroy;
 
-        memAccessor = accessor;
-        expected_context = cu_context;
         expected_memory_type = memory_type;
     }
 
     void TearDown() override {
-        if (paramsDestroy) {
-            paramsDestroy(params);
+        if (params) {
+            destroyCuParams(params);
         }
 
         test::TearDown();
     }
 
-    umf_cuda_memory_provider_params_handle_t params;
-    pfnProviderParamsDestroy paramsDestroy = nullptr;
+    CUDATestHelper cudaTestHelper;
+    umf_cuda_memory_provider_params_handle_t params = nullptr;
 
-    MemoryAccessor *memAccessor = nullptr;
-    CUcontext expected_context;
+    std::unique_ptr<MemoryAccessor> memAccessor = nullptr;
+    CUcontext expected_context = nullptr;
     umf_usm_memory_type_t expected_memory_type;
 };
 
@@ -391,44 +411,10 @@ TEST_P(umfCUDAProviderTest, multiContext) {
 
 // TODO add tests that mixes CUDA Memory Provider and Disjoint Pool
 
-CUDATestHelper cudaTestHelper;
-
-void *createCuParamsDeviceMemory() {
-    return create_cuda_prov_params(cudaTestHelper.get_test_context(),
-                                   cudaTestHelper.get_test_device(),
-                                   UMF_MEMORY_TYPE_DEVICE);
-}
-void *createCuParamsSharedMemory() {
-    return create_cuda_prov_params(cudaTestHelper.get_test_context(),
-                                   cudaTestHelper.get_test_device(),
-                                   UMF_MEMORY_TYPE_SHARED);
-}
-void *createCuParamsHostMemory() {
-    return create_cuda_prov_params(cudaTestHelper.get_test_context(),
-                                   cudaTestHelper.get_test_device(),
-                                   UMF_MEMORY_TYPE_HOST);
-}
-
-umf_result_t destroyCuParams(void *params) {
-    return umfCUDAMemoryProviderParamsDestroy(
-        (umf_cuda_memory_provider_params_handle_t)params);
-}
-
-CUDAMemoryAccessor cuAccessor(cudaTestHelper.get_test_context(),
-                              cudaTestHelper.get_test_device());
-HostMemoryAccessor hostAccessor;
-INSTANTIATE_TEST_SUITE_P(
-    umfCUDAProviderTestSuite, umfCUDAProviderTest,
-    ::testing::Values(
-        CUDAProviderTestParams{createCuParamsDeviceMemory, destroyCuParams,
-                               cudaTestHelper.get_test_context(),
-                               UMF_MEMORY_TYPE_DEVICE, &cuAccessor},
-        CUDAProviderTestParams{createCuParamsSharedMemory, destroyCuParams,
-                               cudaTestHelper.get_test_context(),
-                               UMF_MEMORY_TYPE_SHARED, &hostAccessor},
-        CUDAProviderTestParams{createCuParamsHostMemory, destroyCuParams,
-                               cudaTestHelper.get_test_context(),
-                               UMF_MEMORY_TYPE_HOST, &hostAccessor}));
+INSTANTIATE_TEST_SUITE_P(umfCUDAProviderTestSuite, umfCUDAProviderTest,
+                         ::testing::Values(UMF_MEMORY_TYPE_DEVICE,
+                                           UMF_MEMORY_TYPE_SHARED,
+                                           UMF_MEMORY_TYPE_HOST));
 
 // TODO: add IPC API
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest);