diff --git a/src/utils/utils_level_zero.cpp b/src/utils/utils_level_zero.cpp index 40f906f43..02e961d49 100644 --- a/src/utils/utils_level_zero.cpp +++ b/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; } diff --git a/src/utils/utils_level_zero.h b/src/utils/utils_level_zero.h index d0f3fe154..00f55b351 100644 --- a/src/utils/utils_level_zero.h +++ b/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_); diff --git a/test/common/ipc_common.c b/test/common/ipc_common.c index 1590dd3c4..bf116a677 100644 --- a/test/common/ipc_common.c +++ b/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; } diff --git a/test/ipcFixtures.hpp b/test/ipcFixtures.hpp index 28369b273..cfe58a166 100644 --- a/test/ipcFixtures.hpp +++ b/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 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 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 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); diff --git a/test/providers/cuda_helpers.cpp b/test/providers/cuda_helpers.cpp index bed9906c0..c8bca6166 100644 --- a/test/providers/cuda_helpers.cpp +++ b/test/providers/cuda_helpers.cpp @@ -406,7 +406,7 @@ void init_cuda_once() { InitResult = init_cuda_lib(); } -int init_cuda() { +int init_cuda(void) { utils_init_once(&cuda_init_flag, init_cuda_once); return InitResult; @@ -415,12 +415,6 @@ int init_cuda() { int get_cuda_device(CUdevice *device) { CUdevice cuDevice = -1; - int ret = init_cuda(); - if (ret != 0) { - fprintf(stderr, "init_cuda() failed!\n"); - return ret; - } - CUresult res = libcu_ops.cuDeviceGet(&cuDevice, 0); if (res != CUDA_SUCCESS || cuDevice < 0) { return -1; @@ -433,12 +427,6 @@ int get_cuda_device(CUdevice *device) { int create_context(CUdevice device, CUcontext *context) { CUcontext cuContext = nullptr; - int ret = init_cuda(); - if (ret != 0) { - fprintf(stderr, "init_cuda() failed!\n"); - return ret; - } - CUresult res = libcu_ops.cuCtxCreate(&cuContext, 0, device); if (res != CUDA_SUCCESS || cuContext == nullptr) { return -1; diff --git a/test/providers/cuda_helpers.h b/test/providers/cuda_helpers.h index 65f4fbbf5..3d6572209 100644 --- a/test/providers/cuda_helpers.h +++ b/test/providers/cuda_helpers.h @@ -26,6 +26,8 @@ extern "C" { #endif +int init_cuda(void); + int get_cuda_device(CUdevice *device); int create_context(CUdevice device, CUcontext *context); diff --git a/test/providers/ipc_cuda_prov_consumer.c b/test/providers/ipc_cuda_prov_consumer.c index 1aeb5b15c..3d4a70707 100644 --- a/test/providers/ipc_cuda_prov_consumer.c +++ b/test/providers/ipc_cuda_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 @@ -25,7 +25,13 @@ int main(int argc, char *argv[]) { CUdevice hDevice = -1; CUcontext hContext = NULL; - int ret = get_cuda_device(&hDevice); + int ret = init_cuda(); + if (ret != 0) { + fprintf(stderr, "init_cuda() failed!\n"); + return -1; + } + + ret = get_cuda_device(&hDevice); if (ret != 0) { fprintf(stderr, "get_cuda_device() failed!\n"); return -1; diff --git a/test/providers/ipc_cuda_prov_producer.c b/test/providers/ipc_cuda_prov_producer.c index c2cd1d132..a7421da06 100644 --- a/test/providers/ipc_cuda_prov_producer.c +++ b/test/providers/ipc_cuda_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 @@ -25,7 +25,13 @@ int main(int argc, char *argv[]) { CUdevice hDevice = -1; CUcontext hContext = NULL; - int ret = get_cuda_device(&hDevice); + int ret = init_cuda(); + if (ret != 0) { + fprintf(stderr, "init_cuda() failed!\n"); + return -1; + } + + ret = get_cuda_device(&hDevice); if (ret != 0) { fprintf(stderr, "get_cuda_device() failed!\n"); return -1; diff --git a/test/providers/ipc_level_zero_prov_consumer.c b/test/providers/ipc_level_zero_prov_consumer.c index 8ec0648e4..5fb212881 100644 --- a/test/providers/ipc_level_zero_prov_consumer.c +++ b/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; diff --git a/test/providers/ipc_level_zero_prov_producer.c b/test/providers/ipc_level_zero_prov_producer.c index 2a8fedc37..e6ffcf2ed 100644 --- a/test/providers/ipc_level_zero_prov_producer.c +++ b/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; diff --git a/test/providers/provider_cuda.cpp b/test/providers/provider_cuda.cpp index ff0fca550..bacaacd6c 100644 --- a/test/providers/provider_cuda.cpp +++ b/test/providers/provider_cuda.cpp @@ -39,7 +39,13 @@ class CUDATestHelper { }; CUDATestHelper::CUDATestHelper() { - int ret = get_cuda_device(&hDevice_); + int ret = init_cuda(); + if (ret != 0) { + fprintf(stderr, "init_cuda() failed!\n"); + return; + } + + ret = get_cuda_device(&hDevice_); if (ret != 0) { fprintf(stderr, "get_cuda_device() failed!\n"); return; @@ -83,6 +89,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 +125,53 @@ class CUDAMemoryAccessor : public MemoryAccessor { CUcontext hContext_; }; -typedef void *(*pfnProviderParamsCreate)(); -typedef umf_result_t (*pfnProviderParamsDestroy)(void *); - -using CUDAProviderTestParams = - std::tuple; - struct umfCUDAProviderTest : umf_test::test, - ::testing::WithParamInterface { + ::testing::WithParamInterface { void SetUp() override { test::SetUp(); - auto [params_create, params_destroy, cu_context, memory_type, - accessor] = this->GetParam(); - - params = nullptr; - if (params_create) { - params = (umf_cuda_memory_provider_params_handle_t)params_create(); + umf_usm_memory_type_t memory_type = this->GetParam(); + + memAccessor = nullptr; + expected_context = cudaTestHelper.get_test_context(); + params = create_cuda_prov_params(cudaTestHelper.get_test_context(), + cudaTestHelper.get_test_device(), + memory_type); + ASSERT_NE(expected_context, nullptr); + + switch (memory_type) { + case UMF_MEMORY_TYPE_DEVICE: + + memAccessor = std::make_unique( + cudaTestHelper.get_test_context(), + cudaTestHelper.get_test_device()); + break; + case UMF_MEMORY_TYPE_SHARED: + case UMF_MEMORY_TYPE_HOST: + memAccessor = std::make_unique(); + 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 memAccessor = nullptr; + CUcontext expected_context = nullptr; umf_usm_memory_type_t expected_memory_type; }; @@ -391,44 +408,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); diff --git a/test/providers/provider_level_zero.cpp b/test/providers/provider_level_zero.cpp index af90aa72e..47b62cc94 100644 --- a/test/providers/provider_level_zero.cpp +++ b/test/providers/provider_level_zero.cpp @@ -42,7 +42,13 @@ class LevelZeroTestHelper { LevelZeroTestHelper::LevelZeroTestHelper() { uint32_t driver_idx = 0; - 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; + } + + 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; @@ -93,17 +99,22 @@ create_level_zero_prov_params(ze_context_handle_t context, return params; } +umf_result_t destroyL0Params(void *params) { + return umfLevelZeroMemoryProviderParamsDestroy( + static_cast(params)); +} + struct LevelZeroProviderInit : public test, - public ::testing::WithParamInterface {}; + public ::testing::WithParamInterface { + LevelZeroTestHelper l0TestHelper; +}; INSTANTIATE_TEST_SUITE_P(, LevelZeroProviderInit, ::testing::Values(UMF_MEMORY_TYPE_HOST, UMF_MEMORY_TYPE_DEVICE, UMF_MEMORY_TYPE_SHARED)); -LevelZeroTestHelper l0TestHelper; - TEST_P(LevelZeroProviderInit, FailNullContext) { umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps(); ASSERT_NE(ops, nullptr); @@ -156,12 +167,14 @@ TEST_P(LevelZeroProviderInit, FailNullDevice) { umfLevelZeroMemoryProviderParamsDestroy(hParams); } -TEST_F(test, FailNonNullDevice) { +TEST_F(LevelZeroProviderInit, FailNonNullDevice) { + if (GetParam() != UMF_MEMORY_TYPE_HOST) { + GTEST_SKIP() << "Host memory does not require device handle"; + } umf_memory_provider_ops_t *ops = umfLevelZeroMemoryProviderOps(); ASSERT_NE(ops, nullptr); - auto memory_type = UMF_MEMORY_TYPE_HOST; - + auto memory_type = GetParam(); umf_level_zero_memory_provider_params_handle_t hParams = nullptr; umf_result_t result = umfLevelZeroMemoryProviderParamsCreate(&hParams); ASSERT_EQ(result, UMF_RESULT_SUCCESS); @@ -225,44 +238,43 @@ class LevelZeroMemoryAccessor : public MemoryAccessor { ze_context_handle_t hContext_; }; -typedef void *(*pfnProviderParamsCreate)(); -typedef umf_result_t (*pfnProviderParamsDestroy)(void *); - -using LevelZeroProviderTestParams = - std::tuple; - struct umfLevelZeroProviderTest : umf_test::test, - ::testing::WithParamInterface { + ::testing::WithParamInterface { void SetUp() override { test::SetUp(); - auto [params_create, params_destroy, ze_context, memory_type, - accessor] = this->GetParam(); + umf_usm_memory_type_t memory_type = this->GetParam(); params = nullptr; - if (params_create) { - params = - (umf_level_zero_memory_provider_params_handle_t)params_create(); - } - paramsDestroy = params_destroy; - - memAccessor = accessor; - hContext = ze_context; + memAccessor = nullptr; + hContext = l0TestHelper.get_test_context(); ASSERT_NE(hContext, nullptr); switch (memory_type) { case UMF_MEMORY_TYPE_DEVICE: zeMemoryTypeExpected = ZE_MEMORY_TYPE_DEVICE; + params = create_level_zero_prov_params( + l0TestHelper.get_test_context(), l0TestHelper.get_test_device(), + memory_type); + memAccessor = std::make_unique( + l0TestHelper.get_test_context(), + l0TestHelper.get_test_device()); break; case UMF_MEMORY_TYPE_SHARED: zeMemoryTypeExpected = ZE_MEMORY_TYPE_SHARED; + params = create_level_zero_prov_params( + l0TestHelper.get_test_context(), l0TestHelper.get_test_device(), + memory_type); + memAccessor = std::make_unique(); break; case UMF_MEMORY_TYPE_HOST: zeMemoryTypeExpected = ZE_MEMORY_TYPE_HOST; + params = create_level_zero_prov_params( + l0TestHelper.get_test_context(), nullptr, memory_type); + memAccessor = std::make_unique(); break; case UMF_MEMORY_TYPE_UNKNOWN: zeMemoryTypeExpected = ZE_MEMORY_TYPE_UNKNOWN; @@ -273,17 +285,17 @@ struct umfLevelZeroProviderTest } void TearDown() override { - if (paramsDestroy) { - paramsDestroy(params); + if (params) { + destroyL0Params(params); } test::TearDown(); } - umf_level_zero_memory_provider_params_handle_t params; - pfnProviderParamsDestroy paramsDestroy = nullptr; + LevelZeroTestHelper l0TestHelper; + umf_level_zero_memory_provider_params_handle_t params = nullptr; - MemoryAccessor *memAccessor = nullptr; + std::unique_ptr memAccessor = nullptr; ze_context_handle_t hContext = nullptr; ze_memory_type_t zeMemoryTypeExpected = ZE_MEMORY_TYPE_UNKNOWN; }; @@ -470,47 +482,23 @@ TEST_P(umfLevelZeroProviderTest, setDeviceOrdinalValid) { // TODO add tests that mixes Level Zero Memory Provider and Disjoint Pool +INSTANTIATE_TEST_SUITE_P(umfLevelZeroProviderTestSuite, + umfLevelZeroProviderTest, + ::testing::Values(UMF_MEMORY_TYPE_DEVICE, + UMF_MEMORY_TYPE_SHARED, + UMF_MEMORY_TYPE_HOST)); + +LevelZeroTestHelper l0TestHelper; + void *createL0ParamsDeviceMemory() { return create_level_zero_prov_params(l0TestHelper.get_test_context(), l0TestHelper.get_test_device(), UMF_MEMORY_TYPE_DEVICE); } -void *createL0ParamsSharedMemory() { - return create_level_zero_prov_params(l0TestHelper.get_test_context(), - l0TestHelper.get_test_device(), - UMF_MEMORY_TYPE_SHARED); -} - -void *createL0ParamsHostMemory() { - return create_level_zero_prov_params(l0TestHelper.get_test_context(), - nullptr, UMF_MEMORY_TYPE_HOST); -} - -umf_result_t destroyL0Params(void *params) { - return umfLevelZeroMemoryProviderParamsDestroy( - static_cast(params)); -} - LevelZeroMemoryAccessor l0Accessor((ze_context_handle_t)l0TestHelper.get_test_context(), (ze_device_handle_t)l0TestHelper.get_test_device()); - -HostMemoryAccessor hostAccessor; - -INSTANTIATE_TEST_SUITE_P( - umfLevelZeroProviderTestSuite, umfLevelZeroProviderTest, - ::testing::Values( - LevelZeroProviderTestParams{createL0ParamsDeviceMemory, destroyL0Params, - l0TestHelper.get_test_context(), - UMF_MEMORY_TYPE_DEVICE, &l0Accessor}, - LevelZeroProviderTestParams{createL0ParamsSharedMemory, destroyL0Params, - l0TestHelper.get_test_context(), - UMF_MEMORY_TYPE_SHARED, &hostAccessor}, - LevelZeroProviderTestParams{createL0ParamsHostMemory, destroyL0Params, - l0TestHelper.get_test_context(), - UMF_MEMORY_TYPE_HOST, &hostAccessor})); - // TODO: it looks like there is some problem with IPC implementation in Level // Zero on windows. Issue: #494 #ifdef _WIN32