diff --git a/test/ipcAPI.cpp b/test/ipcAPI.cpp index aa22f353dc..4298963088 100644 --- a/test/ipcAPI.cpp +++ b/test/ipcAPI.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2023-2024 Intel Corporation +// Copyright (C) 2023-2025 Intel Corporation // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // This file contains tests for UMF pool API @@ -115,5 +115,6 @@ HostMemoryAccessor hostMemoryAccessor; INSTANTIATE_TEST_SUITE_P(umfIpcTestSuite, umfIpcTest, ::testing::Values(ipcTestParams{ - umfProxyPoolOps(), nullptr, &IPC_MOCK_PROVIDER_OPS, - nullptr, &hostMemoryAccessor})); + umfProxyPoolOps(), nullptr, nullptr, + &IPC_MOCK_PROVIDER_OPS, nullptr, nullptr, + &hostMemoryAccessor})); diff --git a/test/ipcFixtures.hpp b/test/ipcFixtures.hpp index fd5260d1be..28369b2734 100644 --- a/test/ipcFixtures.hpp +++ b/test/ipcFixtures.hpp @@ -1,4 +1,4 @@ -// 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 @@ -46,23 +46,36 @@ class HostMemoryAccessor : public MemoryAccessor { } }; +typedef void *(*pfnPoolParamsCreate)(); +typedef umf_result_t (*pfnPoolParamsDestroy)(void *); + +typedef void *(*pfnProviderParamsCreate)(); +typedef umf_result_t (*pfnProviderParamsDestroy)(void *); + // ipcTestParams: -// pool_ops, pool_params, provider_ops, provider_params, memoryAccessor +// pool_ops, pfnPoolParamsCreate,pfnPoolParamsDestroy, +// provider_ops, pfnProviderParamsCreate, pfnProviderParamsDestroy, +// memoryAccessor using ipcTestParams = - std::tuple; + std::tuple; struct umfIpcTest : umf_test::test, ::testing::WithParamInterface { umfIpcTest() {} void SetUp() override { test::SetUp(); - auto [pool_ops, pool_params, provider_ops, provider_params, accessor] = + auto [pool_ops, pool_params_create, pool_params_destroy, provider_ops, + provider_params_create, provider_params_destroy, accessor] = this->GetParam(); poolOps = pool_ops; - poolParams = pool_params; + poolParamsCreate = pool_params_create; + poolParamsDestroy = pool_params_destroy; providerOps = provider_ops; - providerParams = provider_params; + providerParamsCreate = provider_params_create; + providerParamsDestroy = provider_params_destroy; memAccessor = accessor; } @@ -74,10 +87,19 @@ struct umfIpcTest : umf_test::test, umf_memory_provider_handle_t hProvider = NULL; umf_memory_pool_handle_t hPool = NULL; + void *providerParams = nullptr; + if (providerParamsCreate) { + providerParams = providerParamsCreate(); + } + auto ret = umfMemoryProviderCreate(providerOps, providerParams, &hProvider); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + if (providerParamsDestroy) { + providerParamsDestroy(providerParams); + } + auto trace = [](void *trace_context, const char *name) { stats_type *stat = static_cast(trace_context); if (std::strcmp(name, "alloc") == 0) { @@ -96,10 +118,19 @@ struct umfIpcTest : umf_test::test, umf_memory_provider_handle_t hTraceProvider = traceProviderCreate(hProvider, true, (void *)&stat, trace); + void *poolParams = nullptr; + if (poolParamsCreate) { + poolParams = poolParamsCreate(); + } + ret = umfPoolCreate(poolOps, hTraceProvider, poolParams, UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + if (poolParamsDestroy) { + poolParamsDestroy(poolParams); + } + return umf::pool_unique_handle_t(hPool, &umfPoolDestroy); } @@ -118,10 +149,14 @@ struct umfIpcTest : umf_test::test, static constexpr int NTHREADS = 10; stats_type stat; MemoryAccessor *memAccessor = nullptr; + umf_memory_pool_ops_t *poolOps = nullptr; - void *poolParams = nullptr; + pfnPoolParamsCreate poolParamsCreate = nullptr; + pfnPoolParamsDestroy poolParamsDestroy = nullptr; + umf_memory_provider_ops_t *providerOps = nullptr; - void *providerParams = nullptr; + pfnProviderParamsCreate providerParamsCreate = nullptr; + pfnProviderParamsDestroy providerParamsDestroy = nullptr; }; TEST_P(umfIpcTest, GetIPCHandleSize) { diff --git a/test/memoryPoolAPI.cpp b/test/memoryPoolAPI.cpp index 0a45bfbe53..e2455fe85e 100644 --- a/test/memoryPoolAPI.cpp +++ b/test/memoryPoolAPI.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2023-2024 Intel Corporation +// Copyright (C) 2023-2025 Intel Corporation // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // This file contains tests for UMF pool API @@ -295,15 +295,17 @@ TEST_F(tagTest, SetAndGetInvalidPool) { INSTANTIATE_TEST_SUITE_P( mallocPoolTest, umfPoolTest, - ::testing::Values(poolCreateExtParams{&MALLOC_POOL_OPS, nullptr, - &UMF_NULL_PROVIDER_OPS, nullptr}, - poolCreateExtParams{umfProxyPoolOps(), nullptr, - &BA_GLOBAL_PROVIDER_OPS, nullptr})); + ::testing::Values(poolCreateExtParams{&MALLOC_POOL_OPS, nullptr, nullptr, + &UMF_NULL_PROVIDER_OPS, nullptr, + nullptr}, + poolCreateExtParams{umfProxyPoolOps(), nullptr, nullptr, + &BA_GLOBAL_PROVIDER_OPS, nullptr, + nullptr})); INSTANTIATE_TEST_SUITE_P(mallocMultiPoolTest, umfMultiPoolTest, ::testing::Values(poolCreateExtParams{ - umfProxyPoolOps(), nullptr, - &BA_GLOBAL_PROVIDER_OPS, nullptr})); + umfProxyPoolOps(), nullptr, nullptr, + &BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr})); INSTANTIATE_TEST_SUITE_P(umfPoolWithCreateFlagsTest, umfPoolWithCreateFlagsTest, ::testing::Values(0, diff --git a/test/poolFixtures.hpp b/test/poolFixtures.hpp index bd97ac1fa6..d9a5410c0d 100644 --- a/test/poolFixtures.hpp +++ b/test/poolFixtures.hpp @@ -19,17 +19,30 @@ #include "../malloc_compliance_tests.hpp" -using poolCreateExtParams = std::tuple; +typedef void *(*pfnPoolParamsCreate)(); +typedef umf_result_t (*pfnPoolParamsDestroy)(void *); + +typedef void *(*pfnProviderParamsCreate)(); +typedef umf_result_t (*pfnProviderParamsDestroy)(void *); + +using poolCreateExtParams = + std::tuple; umf::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams params) { - auto [pool_ops, pool_params, provider_ops, provider_params] = params; + auto [pool_ops, poolParamsCreate, poolParamsDestroy, provider_ops, + providerParamsCreate, providerParamsDestroy] = params; umf_memory_provider_handle_t upstream_provider = nullptr; umf_memory_provider_handle_t provider = nullptr; umf_memory_pool_handle_t hPool = nullptr; umf_result_t ret; + void *provider_params = NULL; + if (providerParamsCreate) { + provider_params = providerParamsCreate(); + } ret = umfMemoryProviderCreate(provider_ops, provider_params, &upstream_provider); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); @@ -37,11 +50,27 @@ umf::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams params) { provider = upstream_provider; + void *pool_params = NULL; + if (poolParamsCreate) { + pool_params = poolParamsCreate(); + } + + // NOTE: we set the UMF_POOL_CREATE_FLAG_OWN_PROVIDER flag here so the pool + // will destroy the provider when it is destroyed ret = umfPoolCreate(pool_ops, provider, pool_params, UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); EXPECT_NE(hPool, nullptr); + // we do not need params anymore + if (poolParamsDestroy) { + poolParamsDestroy(pool_params); + } + + if (providerParamsDestroy) { + providerParamsDestroy(provider_params); + } + return umf::pool_unique_handle_t(hPool, &umfPoolDestroy); } diff --git a/test/pools/disjoint_pool.cpp b/test/pools/disjoint_pool.cpp index c254400db3..cd480ac3a0 100644 --- a/test/pools/disjoint_pool.cpp +++ b/test/pools/disjoint_pool.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2023-2024 Intel Corporation +// Copyright (C) 2023-2025 Intel Corporation // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception @@ -11,16 +11,12 @@ #include "provider_null.h" #include "provider_trace.h" -using disjoint_params_unique_handle_t = - std::unique_ptr; - static constexpr size_t DEFAULT_DISJOINT_SLAB_MIN_SIZE = 4096; static constexpr size_t DEFAULT_DISJOINT_MAX_POOLABLE_SIZE = 4096; static constexpr size_t DEFAULT_DISJOINT_CAPACITY = 4; static constexpr size_t DEFAULT_DISJOINT_MIN_BUCKET_SIZE = 64; -disjoint_params_unique_handle_t poolConfig() { +void *defaultPoolConfig() { umf_disjoint_pool_params_handle_t config = nullptr; umf_result_t res = umfDisjointPoolParamsCreate(&config); if (res != UMF_RESULT_SUCCESS) { @@ -50,8 +46,12 @@ disjoint_params_unique_handle_t poolConfig() { throw std::runtime_error("Failed to set min bucket size"); } - return disjoint_params_unique_handle_t(config, - &umfDisjointPoolParamsDestroy); + return config; +} + +umf_result_t poolConfigDestroy(void *config) { + return umfDisjointPoolParamsDestroy( + static_cast(config)); } using umf_test::test; @@ -83,17 +83,21 @@ TEST_F(test, freeErrorPropagation) { provider_handle = providerUnique.get(); // force all allocations to go to memory provider - disjoint_params_unique_handle_t params = poolConfig(); - umf_result_t retp = - umfDisjointPoolParamsSetMaxPoolableSize(params.get(), 0); + umf_disjoint_pool_params_handle_t params; + umf_result_t retp = umfDisjointPoolParamsCreate(¶ms); + EXPECT_EQ(retp, UMF_RESULT_SUCCESS); + retp = umfDisjointPoolParamsSetMaxPoolableSize(params, 0); EXPECT_EQ(retp, UMF_RESULT_SUCCESS); umf_memory_pool_handle_t pool = NULL; - retp = umfPoolCreate(umfDisjointPoolOps(), provider_handle, params.get(), 0, - &pool); + retp = + umfPoolCreate(umfDisjointPoolOps(), provider_handle, params, 0, &pool); EXPECT_EQ(retp, UMF_RESULT_SUCCESS); auto poolHandle = umf_test::wrapPoolUnique(pool); + retp = umfDisjointPoolParamsDestroy(params); + EXPECT_EQ(retp, UMF_RESULT_SUCCESS); + static constexpr size_t size = 1024; void *ptr = umfPoolMalloc(pool, size); @@ -114,12 +118,12 @@ TEST_F(test, sharedLimits) { struct memory_provider : public umf_test::provider_base_t { umf_result_t alloc(size_t size, size_t, void **ptr) noexcept { - *ptr = malloc(size); + *ptr = umf_ba_global_alloc(size); numAllocs++; return UMF_RESULT_SUCCESS; } umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept { - ::free(ptr); + umf_ba_global_free(ptr); numFrees++; return UMF_RESULT_SUCCESS; } @@ -130,9 +134,9 @@ TEST_F(test, sharedLimits) { static constexpr size_t SlabMinSize = 1024; static constexpr size_t MaxSize = 4 * SlabMinSize; - disjoint_params_unique_handle_t config = poolConfig(); - umf_result_t ret = - umfDisjointPoolParamsSetSlabMinSize(config.get(), SlabMinSize); + umf_disjoint_pool_params_handle_t params = + (umf_disjoint_pool_params_handle_t)defaultPoolConfig(); + umf_result_t ret = umfDisjointPoolParamsSetSlabMinSize(params, SlabMinSize); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); auto limits = @@ -141,7 +145,7 @@ TEST_F(test, sharedLimits) { umfDisjointPoolSharedLimitsCreate(MaxSize), &umfDisjointPoolSharedLimitsDestroy); - ret = umfDisjointPoolParamsSetSharedLimits(config.get(), limits.get()); + ret = umfDisjointPoolParamsSetSharedLimits(params, limits.get()); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); auto provider = @@ -149,16 +153,19 @@ TEST_F(test, sharedLimits) { umf_memory_pool_handle_t pool1 = NULL; umf_memory_pool_handle_t pool2 = NULL; - ret = umfPoolCreate(umfDisjointPoolOps(), provider.get(), - (void *)config.get(), 0, &pool1); + ret = + umfPoolCreate(umfDisjointPoolOps(), provider.get(), params, 0, &pool1); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); auto poolHandle1 = umf_test::wrapPoolUnique(pool1); - ret = umfPoolCreate(umfDisjointPoolOps(), provider.get(), - (void *)config.get(), 0, &pool2); + ret = + umfPoolCreate(umfDisjointPoolOps(), provider.get(), params, 0, &pool2); EXPECT_EQ(ret, UMF_RESULT_SUCCESS); auto poolHandle2 = umf_test::wrapPoolUnique(pool2); + ret = umfDisjointPoolParamsDestroy(params); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + EXPECT_EQ(0, numAllocs); EXPECT_EQ(0, numFrees); @@ -243,23 +250,24 @@ TEST_F(test, disjointPoolInvalidBucketSize) { umfDisjointPoolParamsDestroy(params); } -disjoint_params_unique_handle_t defaultPoolConfig = poolConfig(); INSTANTIATE_TEST_SUITE_P(disjointPoolTests, umfPoolTest, ::testing::Values(poolCreateExtParams{ - umfDisjointPoolOps(), - (void *)defaultPoolConfig.get(), - &BA_GLOBAL_PROVIDER_OPS, nullptr})); + umfDisjointPoolOps(), defaultPoolConfig, + poolConfigDestroy, &BA_GLOBAL_PROVIDER_OPS, + nullptr, nullptr})); + +void *memProviderParams() { return (void *)&DEFAULT_DISJOINT_CAPACITY; } INSTANTIATE_TEST_SUITE_P( disjointPoolTests, umfMemTest, ::testing::Values(std::make_tuple( - poolCreateExtParams{ - umfDisjointPoolOps(), (void *)defaultPoolConfig.get(), - &MOCK_OUT_OF_MEM_PROVIDER_OPS, (void *)&DEFAULT_DISJOINT_CAPACITY}, + poolCreateExtParams{umfDisjointPoolOps(), defaultPoolConfig, + poolConfigDestroy, &MOCK_OUT_OF_MEM_PROVIDER_OPS, + memProviderParams, nullptr}, static_cast(DEFAULT_DISJOINT_CAPACITY) / 2))); INSTANTIATE_TEST_SUITE_P(disjointMultiPoolTests, umfMultiPoolTest, ::testing::Values(poolCreateExtParams{ - umfDisjointPoolOps(), - (void *)defaultPoolConfig.get(), - &BA_GLOBAL_PROVIDER_OPS, nullptr})); + umfDisjointPoolOps(), defaultPoolConfig, + poolConfigDestroy, &BA_GLOBAL_PROVIDER_OPS, + nullptr, nullptr})); diff --git a/test/pools/jemalloc_coarse_devdax.cpp b/test/pools/jemalloc_coarse_devdax.cpp index 72906e625b..53d2a41b37 100644 --- a/test/pools/jemalloc_coarse_devdax.cpp +++ b/test/pools/jemalloc_coarse_devdax.cpp @@ -1,4 +1,4 @@ -// 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 @@ -7,18 +7,20 @@ #include "pool_coarse.hpp" -using devdax_params_unique_handle_t = - std::unique_ptr; - -devdax_params_unique_handle_t create_devdax_params() { +bool devDaxEnvSet() { char *path = getenv("UMF_TESTS_DEVDAX_PATH"); char *size = getenv("UMF_TESTS_DEVDAX_SIZE"); if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) { - return devdax_params_unique_handle_t( - nullptr, &umfDevDaxMemoryProviderParamsDestroy); + return false; } + return true; +} + +void *createDevDaxParams() { + char *path = getenv("UMF_TESTS_DEVDAX_PATH"); + char *size = getenv("UMF_TESTS_DEVDAX_SIZE"); + umf_devdax_memory_provider_params_handle_t params = NULL; umf_result_t res = umfDevDaxMemoryProviderParamsCreate(¶ms, path, atol(size)); @@ -27,17 +29,16 @@ devdax_params_unique_handle_t create_devdax_params() { "Failed to create DevDax Memory Provider params"); } - return devdax_params_unique_handle_t(params, - &umfDevDaxMemoryProviderParamsDestroy); + return params; } -auto devdaxParams = create_devdax_params(); - static std::vector poolParamsList = - devdaxParams.get() ? std::vector{poolCreateExtParams{ - umfJemallocPoolOps(), nullptr, - umfDevDaxMemoryProviderOps(), devdaxParams.get()}} - : std::vector{}; + devDaxEnvSet() + ? std::vector{poolCreateExtParams{ + umfJemallocPoolOps(), nullptr, nullptr, + umfDevDaxMemoryProviderOps(), createDevDaxParams, + (pfnProviderParamsDestroy)umfDevDaxMemoryProviderParamsDestroy}} + : std::vector{}; INSTANTIATE_TEST_SUITE_P(jemallocCoarseDevDaxTest, umfPoolTest, ::testing::ValuesIn(poolParamsList)); diff --git a/test/pools/jemalloc_coarse_file.cpp b/test/pools/jemalloc_coarse_file.cpp index 68a602df64..dcd03898ee 100644 --- a/test/pools/jemalloc_coarse_file.cpp +++ b/test/pools/jemalloc_coarse_file.cpp @@ -1,4 +1,4 @@ -// 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 @@ -7,25 +7,25 @@ #include "pool_coarse.hpp" -using file_params_unique_handle_t = - std::unique_ptr; - -file_params_unique_handle_t get_file_params_default(char *path) { +void *getFileParamsDefault() { umf_file_memory_provider_params_handle_t file_params = NULL; - umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path); + umf_result_t res = + umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH); if (res != UMF_RESULT_SUCCESS) { throw std::runtime_error( "Failed to create File Memory Provider params"); } - return file_params_unique_handle_t(file_params, - &umfFileMemoryProviderParamsDestroy); + return file_params; } -file_params_unique_handle_t fileParams = get_file_params_default(FILE_PATH); +umf_result_t destroyFileParams(void *params) { + return umfFileMemoryProviderParamsDestroy( + (umf_file_memory_provider_params_handle_t)params); +} INSTANTIATE_TEST_SUITE_P(jemallocCoarseFileTest, umfPoolTest, ::testing::Values(poolCreateExtParams{ - umfJemallocPoolOps(), nullptr, - umfFileMemoryProviderOps(), fileParams.get()})); + umfJemallocPoolOps(), nullptr, nullptr, + umfFileMemoryProviderOps(), getFileParamsDefault, + destroyFileParams})); diff --git a/test/pools/jemalloc_pool.cpp b/test/pools/jemalloc_pool.cpp index 86784d919f..e282be3161 100644 --- a/test/pools/jemalloc_pool.cpp +++ b/test/pools/jemalloc_pool.cpp @@ -15,21 +15,26 @@ using os_params_unique_handle_t = std::unique_ptr; -os_params_unique_handle_t createOsMemoryProviderParams() { +void *createOsMemoryProviderParams() { umf_os_memory_provider_params_handle_t params = nullptr; umf_result_t res = umfOsMemoryProviderParamsCreate(¶ms); if (res != UMF_RESULT_SUCCESS) { throw std::runtime_error("Failed to create os memory provider params"); } - return os_params_unique_handle_t(params, &umfOsMemoryProviderParamsDestroy); + return params; } -auto defaultParams = createOsMemoryProviderParams(); -INSTANTIATE_TEST_SUITE_P(jemallocPoolTest, umfPoolTest, - ::testing::Values(poolCreateExtParams{ - umfJemallocPoolOps(), nullptr, - umfOsMemoryProviderOps(), defaultParams.get()})); +umf_result_t destroyOsMemoryProviderParams(void *params) { + return umfOsMemoryProviderParamsDestroy( + (umf_os_memory_provider_params_handle_t)params); +} + +INSTANTIATE_TEST_SUITE_P( + jemallocPoolTest, umfPoolTest, + ::testing::Values(poolCreateExtParams{ + umfJemallocPoolOps(), nullptr, nullptr, umfOsMemoryProviderOps(), + createOsMemoryProviderParams, destroyOsMemoryProviderParams})); // this test makes sure that jemalloc does not use // memory provider to allocate metadata (and hence @@ -41,17 +46,41 @@ TEST_F(test, metadataNotAllocatedUsingProvider) { // set coarse grain allocations to PROT_NONE so that we can be sure // jemalloc does not touch any of the allocated memory - umf_os_memory_provider_params_handle_t params = nullptr; - umf_result_t res = umfOsMemoryProviderParamsCreate(¶ms); - ASSERT_EQ(res, UMF_RESULT_SUCCESS); - res = umfOsMemoryProviderParamsSetProtection(params, UMF_PROTECTION_NONE); - ASSERT_EQ(res, UMF_RESULT_SUCCESS); - auto pool = poolCreateExtUnique( - {umfJemallocPoolOps(), nullptr, umfOsMemoryProviderOps(), params}); + auto providerParamsCreate = []() { + umf_os_memory_provider_params_handle_t params = nullptr; + umf_result_t res = umfOsMemoryProviderParamsCreate(¶ms); + if (res != UMF_RESULT_SUCCESS) { + throw std::runtime_error( + "Failed to create OS Memory Provider params"); + } + res = + umfOsMemoryProviderParamsSetProtection(params, UMF_PROTECTION_NONE); + if (res != UMF_RESULT_SUCCESS) { + throw std::runtime_error( + "Failed to set OS Memory Provider params protection"); + } + return (void *)params; + }; + + auto providerParamsDestroy = [](void *params) { + umf_result_t res = umfOsMemoryProviderParamsDestroy( + (umf_os_memory_provider_params_handle_t)params); + if (res != UMF_RESULT_SUCCESS) { + throw std::runtime_error( + "Failed to destroy OS Memory Provider params"); + } + return res; + }; - res = umfOsMemoryProviderParamsDestroy(params); - ASSERT_EQ(res, UMF_RESULT_SUCCESS); + auto pool = poolCreateExtUnique({ + umfJemallocPoolOps(), + nullptr, + nullptr, + umfOsMemoryProviderOps(), + (pfnProviderParamsCreate)providerParamsCreate, + (pfnProviderParamsDestroy)providerParamsDestroy, + }); std::vector> allocs; for (size_t i = 0; i < numAllocs; i++) { diff --git a/test/pools/pool_base_alloc.cpp b/test/pools/pool_base_alloc.cpp index 752d9f01e2..ca931bcec3 100644 --- a/test/pools/pool_base_alloc.cpp +++ b/test/pools/pool_base_alloc.cpp @@ -47,5 +47,5 @@ umf_memory_pool_ops_t BA_POOL_OPS = umf::poolMakeCOps(); INSTANTIATE_TEST_SUITE_P(baPool, umfPoolTest, ::testing::Values(poolCreateExtParams{ - &BA_POOL_OPS, nullptr, - &umf_test::BASE_PROVIDER_OPS, nullptr})); + &BA_POOL_OPS, nullptr, nullptr, + &umf_test::BASE_PROVIDER_OPS, nullptr, nullptr})); diff --git a/test/pools/scalable_coarse_devdax.cpp b/test/pools/scalable_coarse_devdax.cpp index 970f45ef92..86c5804022 100644 --- a/test/pools/scalable_coarse_devdax.cpp +++ b/test/pools/scalable_coarse_devdax.cpp @@ -1,4 +1,4 @@ -// 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 @@ -7,18 +7,20 @@ #include "pool_coarse.hpp" -using devdax_params_unique_handle_t = - std::unique_ptr; - -devdax_params_unique_handle_t create_devdax_params() { +bool devDaxEnvSet() { char *path = getenv("UMF_TESTS_DEVDAX_PATH"); char *size = getenv("UMF_TESTS_DEVDAX_SIZE"); if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) { - return devdax_params_unique_handle_t( - nullptr, &umfDevDaxMemoryProviderParamsDestroy); + return false; } + return true; +} + +void *createDevDaxParams() { + char *path = getenv("UMF_TESTS_DEVDAX_PATH"); + char *size = getenv("UMF_TESTS_DEVDAX_SIZE"); + umf_devdax_memory_provider_params_handle_t params = NULL; umf_result_t res = umfDevDaxMemoryProviderParamsCreate(¶ms, path, atol(size)); @@ -27,17 +29,20 @@ devdax_params_unique_handle_t create_devdax_params() { "Failed to create DevDax Memory Provider params"); } - return devdax_params_unique_handle_t(params, - &umfDevDaxMemoryProviderParamsDestroy); + return params; } -auto devdaxParams = create_devdax_params(); +umf_result_t destroyDevDaxParams(void *params) { + return umfDevDaxMemoryProviderParamsDestroy( + (umf_devdax_memory_provider_params_handle_t)params); +} static std::vector poolParamsList = - devdaxParams.get() ? std::vector{poolCreateExtParams{ - umfScalablePoolOps(), nullptr, - umfDevDaxMemoryProviderOps(), devdaxParams.get()}} - : std::vector{}; + devDaxEnvSet() ? std::vector{poolCreateExtParams{ + umfScalablePoolOps(), nullptr, nullptr, + umfDevDaxMemoryProviderOps(), createDevDaxParams, + destroyDevDaxParams}} + : std::vector{}; INSTANTIATE_TEST_SUITE_P(scalableCoarseDevDaxTest, umfPoolTest, ::testing::ValuesIn(poolParamsList)); diff --git a/test/pools/scalable_coarse_file.cpp b/test/pools/scalable_coarse_file.cpp index 30134f5eba..a5fd5b46a6 100644 --- a/test/pools/scalable_coarse_file.cpp +++ b/test/pools/scalable_coarse_file.cpp @@ -1,4 +1,4 @@ -// 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 @@ -7,25 +7,25 @@ #include "pool_coarse.hpp" -using file_params_unique_handle_t = - std::unique_ptr; - -file_params_unique_handle_t get_file_params_default(char *path) { +void *getFileParamsDefault() { umf_file_memory_provider_params_handle_t file_params = NULL; - umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path); + umf_result_t res = + umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH); if (res != UMF_RESULT_SUCCESS) { throw std::runtime_error( "Failed to create File Memory Provider params"); } - return file_params_unique_handle_t(file_params, - &umfFileMemoryProviderParamsDestroy); + return file_params; } -file_params_unique_handle_t fileParams = get_file_params_default(FILE_PATH); +umf_result_t destroyFileParams(void *params) { + return umfFileMemoryProviderParamsDestroy( + (umf_file_memory_provider_params_handle_t)params); +} INSTANTIATE_TEST_SUITE_P(scalableCoarseFileTest, umfPoolTest, ::testing::Values(poolCreateExtParams{ - umfScalablePoolOps(), nullptr, - umfFileMemoryProviderOps(), fileParams.get()})); + umfScalablePoolOps(), nullptr, nullptr, + umfFileMemoryProviderOps(), getFileParamsDefault, + destroyFileParams})); diff --git a/test/pools/scalable_pool.cpp b/test/pools/scalable_pool.cpp index ce55923d9a..14cf5f3059 100644 --- a/test/pools/scalable_pool.cpp +++ b/test/pools/scalable_pool.cpp @@ -9,25 +9,26 @@ #include "poolFixtures.hpp" #include "provider.hpp" -using os_params_unique_handle_t = - std::unique_ptr; - -os_params_unique_handle_t createOsMemoryProviderParams() { +void *createOsMemoryProviderParams() { umf_os_memory_provider_params_handle_t params = nullptr; umf_result_t res = umfOsMemoryProviderParamsCreate(¶ms); if (res != UMF_RESULT_SUCCESS) { throw std::runtime_error("Failed to create os memory provider params"); } - return os_params_unique_handle_t(params, &umfOsMemoryProviderParamsDestroy); + return params; +} + +umf_result_t destroyOsMemoryProviderParams(void *params) { + return umfOsMemoryProviderParamsDestroy( + (umf_os_memory_provider_params_handle_t)params); } -auto defaultParams = createOsMemoryProviderParams(); -INSTANTIATE_TEST_SUITE_P(scalablePoolTest, umfPoolTest, - ::testing::Values(poolCreateExtParams{ - umfScalablePoolOps(), nullptr, - umfOsMemoryProviderOps(), defaultParams.get()})); +INSTANTIATE_TEST_SUITE_P( + scalablePoolTest, umfPoolTest, + ::testing::Values(poolCreateExtParams{ + umfScalablePoolOps(), nullptr, nullptr, umfOsMemoryProviderOps(), + createOsMemoryProviderParams, destroyOsMemoryProviderParams})); using scalablePoolParams = std::tuple; struct umfScalablePoolParamsTest diff --git a/test/provider_devdax_memory_ipc.cpp b/test/provider_devdax_memory_ipc.cpp index ed4f1a5f8d..47b389c95f 100644 --- a/test/provider_devdax_memory_ipc.cpp +++ b/test/provider_devdax_memory_ipc.cpp @@ -1,4 +1,4 @@ -// 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 @@ -15,16 +15,21 @@ using umf_test::test; -using devdax_params_unique_handle_t = - std::unique_ptr; +bool devDaxEnvSet() { + char *path = getenv("UMF_TESTS_DEVDAX_PATH"); + char *size = getenv("UMF_TESTS_DEVDAX_SIZE"); + if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) { + return false; + } -devdax_params_unique_handle_t create_devdax_params() { + return true; +} + +void *defaultDevDaxParamsCreate() { char *path = getenv("UMF_TESTS_DEVDAX_PATH"); char *size = getenv("UMF_TESTS_DEVDAX_SIZE"); if (path == nullptr || path[0] == 0 || size == nullptr || size[0] == 0) { - return devdax_params_unique_handle_t( - nullptr, &umfDevDaxMemoryProviderParamsDestroy); + return nullptr; } umf_devdax_memory_provider_params_handle_t params = NULL; @@ -35,32 +40,34 @@ devdax_params_unique_handle_t create_devdax_params() { "Failed to create DevDax Memory Provider params"); } - return devdax_params_unique_handle_t(params, - &umfDevDaxMemoryProviderParamsDestroy); + return params; } -auto defaultDevDaxParams = create_devdax_params(); +umf_result_t defaultDevDaxParamsDestroy(void *params) { + return umfDevDaxMemoryProviderParamsDestroy( + (umf_devdax_memory_provider_params_handle_t)params); +} HostMemoryAccessor hostAccessor; static std::vector getIpcProxyPoolTestParamsList(void) { std::vector ipcProxyPoolTestParamsList = {}; - if (!defaultDevDaxParams.get()) { + if (!devDaxEnvSet()) { // return empty list to skip the test return ipcProxyPoolTestParamsList; } ipcProxyPoolTestParamsList = { - {umfProxyPoolOps(), nullptr, umfDevDaxMemoryProviderOps(), - defaultDevDaxParams.get(), &hostAccessor}, + {umfProxyPoolOps(), nullptr, nullptr, umfDevDaxMemoryProviderOps(), + defaultDevDaxParamsCreate, defaultDevDaxParamsDestroy, &hostAccessor}, #ifdef UMF_POOL_JEMALLOC_ENABLED - {umfJemallocPoolOps(), nullptr, umfDevDaxMemoryProviderOps(), - defaultDevDaxParams.get(), &hostAccessor}, + {umfJemallocPoolOps(), nullptr, nullptr, umfDevDaxMemoryProviderOps(), + defaultDevDaxParamsCreate, defaultDevDaxParamsDestroy, &hostAccessor}, #endif #ifdef UMF_POOL_SCALABLE_ENABLED - {umfScalablePoolOps(), nullptr, umfDevDaxMemoryProviderOps(), - defaultDevDaxParams.get(), &hostAccessor}, + {umfScalablePoolOps(), nullptr, nullptr, umfDevDaxMemoryProviderOps(), + defaultDevDaxParamsCreate, defaultDevDaxParamsDestroy, &hostAccessor}, #endif }; diff --git a/test/provider_file_memory_ipc.cpp b/test/provider_file_memory_ipc.cpp index 70c1acd8f5..90623a1793 100644 --- a/test/provider_file_memory_ipc.cpp +++ b/test/provider_file_memory_ipc.cpp @@ -1,4 +1,4 @@ -// 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 @@ -17,13 +17,10 @@ using umf_test::test; #define FILE_PATH ((char *)"tmp_file") -using file_params_unique_handle_t = - std::unique_ptr; - -file_params_unique_handle_t get_file_params_shared(char *path) { +void *createFileParamsShared() { umf_file_memory_provider_params_handle_t file_params = NULL; - umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path); + umf_result_t res = + umfFileMemoryProviderParamsCreate(&file_params, FILE_PATH); if (res != UMF_RESULT_SUCCESS) { throw std::runtime_error( "Failed to create File Memory Provider params"); @@ -37,20 +34,21 @@ file_params_unique_handle_t get_file_params_shared(char *path) { "Memory Provider params"); } - return file_params_unique_handle_t(file_params, - &umfFileMemoryProviderParamsDestroy); + return file_params; } -file_params_unique_handle_t file_params_shared = - get_file_params_shared(FILE_PATH); +umf_result_t destroyFileParamsShared(void *params) { + return umfFileMemoryProviderParamsDestroy( + (umf_file_memory_provider_params_handle_t)params); +} -file_params_unique_handle_t get_file_params_fsdax(char *path) { +void *createFileParamsFSDAX() { umf_file_memory_provider_params_handle_t file_params = NULL; - umf_result_t res = umfFileMemoryProviderParamsCreate(&file_params, path); + umf_result_t res = umfFileMemoryProviderParamsCreate( + &file_params, getenv("UMF_TESTS_FSDAX_PATH")); if (res != UMF_RESULT_SUCCESS) { //test will be skipped. - return file_params_unique_handle_t(nullptr, - &umfFileMemoryProviderParamsDestroy); + return nullptr; } res = umfFileMemoryProviderParamsSetVisibility(file_params, @@ -61,12 +59,13 @@ file_params_unique_handle_t get_file_params_fsdax(char *path) { "Memory Provider params"); } - return file_params_unique_handle_t(file_params, - &umfFileMemoryProviderParamsDestroy); + return file_params; } -file_params_unique_handle_t file_params_fsdax = - get_file_params_fsdax(getenv("UMF_TESTS_FSDAX_PATH")); +umf_result_t destroyFileParamsFSDAX(void *params) { + return umfFileMemoryProviderParamsDestroy( + (umf_file_memory_provider_params_handle_t)params); +} HostMemoryAccessor hostAccessor; @@ -75,12 +74,12 @@ static std::vector ipcManyPoolsTestParamsList = { // {umfProxyPoolOps(), nullptr, umfFileMemoryProviderOps(), // file_params_shared.get(), &hostAccessor}, #ifdef UMF_POOL_JEMALLOC_ENABLED - {umfJemallocPoolOps(), nullptr, umfFileMemoryProviderOps(), - file_params_shared.get(), &hostAccessor}, + {umfJemallocPoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(), + createFileParamsShared, destroyFileParamsShared, &hostAccessor}, #endif #ifdef UMF_POOL_SCALABLE_ENABLED - {umfScalablePoolOps(), nullptr, umfFileMemoryProviderOps(), - file_params_shared.get(), &hostAccessor}, + {umfScalablePoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(), + createFileParamsShared, destroyFileParamsShared, &hostAccessor}, #endif }; @@ -98,12 +97,12 @@ static std::vector getIpcFsDaxTestParamsList(void) { // {umfProxyPoolOps(), nullptr, umfFileMemoryProviderOps(), // file_params_fsdax.get(), &hostAccessor}, #ifdef UMF_POOL_JEMALLOC_ENABLED - {umfJemallocPoolOps(), nullptr, umfFileMemoryProviderOps(), - file_params_fsdax.get(), &hostAccessor}, + {umfJemallocPoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(), + createFileParamsFSDAX, destroyFileParamsFSDAX, &hostAccessor}, #endif #ifdef UMF_POOL_SCALABLE_ENABLED - {umfScalablePoolOps(), nullptr, umfFileMemoryProviderOps(), - file_params_fsdax.get(), &hostAccessor}, + {umfScalablePoolOps(), nullptr, nullptr, umfFileMemoryProviderOps(), + createFileParamsFSDAX, destroyFileParamsFSDAX, &hostAccessor}, #endif }; diff --git a/test/provider_os_memory.cpp b/test/provider_os_memory.cpp index 9544a6feda..ddc44548e7 100644 --- a/test/provider_os_memory.cpp +++ b/test/provider_os_memory.cpp @@ -10,7 +10,7 @@ #include #include -#if (defined UMF_POOL_DISJOINT_ENABLED) +#ifdef UMF_POOL_DISJOINT_ENABLED #include #endif #ifdef UMF_POOL_JEMALLOC_ENABLED @@ -407,11 +407,7 @@ TEST_P(umfProviderTest, close_ipc_handle_wrong_visibility) { GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest); -using os_params_unique_handle_t = - std::unique_ptr; - -os_params_unique_handle_t osMemoryProviderParamsShared() { +void *createOsMemoryProviderParamsShared() { umf_os_memory_provider_params_handle_t params = nullptr; umf_result_t res = umfOsMemoryProviderParamsCreate(¶ms); if (res != UMF_RESULT_SUCCESS) { @@ -422,18 +418,19 @@ os_params_unique_handle_t osMemoryProviderParamsShared() { throw std::runtime_error("Failed to set protection"); } - return os_params_unique_handle_t(params, &umfOsMemoryProviderParamsDestroy); + return params; +} + +umf_result_t destroyOsMemoryProviderParamsShared(void *params) { + return umfOsMemoryProviderParamsDestroy( + static_cast(params)); } -auto os_params = osMemoryProviderParamsShared(); HostMemoryAccessor hostAccessor; -#if (defined UMF_POOL_DISJOINT_ENABLED) -using disjoint_params_unique_handle_t = - std::unique_ptr; +#ifdef UMF_POOL_DISJOINT_ENABLED -disjoint_params_unique_handle_t disjointPoolParams() { +void *createDisjointPoolParams() { umf_disjoint_pool_params_handle_t params = nullptr; umf_result_t res = umfDisjointPoolParamsCreate(¶ms); if (res != UMF_RESULT_SUCCESS) { @@ -460,19 +457,25 @@ disjoint_params_unique_handle_t disjointPoolParams() { throw std::runtime_error("Failed to set min bucket size"); } - return disjoint_params_unique_handle_t(params, - &umfDisjointPoolParamsDestroy); + return params; } -disjoint_params_unique_handle_t disjointParams = disjointPoolParams(); + +umf_result_t destroyDisjointPoolParams(void *params) { + return umfDisjointPoolParamsDestroy( + static_cast(params)); +} + #endif static std::vector ipcTestParamsList = { -#if (defined UMF_POOL_DISJOINT_ENABLED) - {umfDisjointPoolOps(), disjointParams.get(), umfOsMemoryProviderOps(), - os_params.get(), &hostAccessor}, +#ifdef UMF_POOL_DISJOINT_ENABLED + {umfDisjointPoolOps(), createDisjointPoolParams, destroyDisjointPoolParams, + umfOsMemoryProviderOps(), createOsMemoryProviderParamsShared, + destroyOsMemoryProviderParamsShared, &hostAccessor}, #endif #ifdef UMF_POOL_JEMALLOC_ENABLED - {umfJemallocPoolOps(), nullptr, umfOsMemoryProviderOps(), os_params.get(), + {umfJemallocPoolOps(), nullptr, nullptr, umfOsMemoryProviderOps(), + createOsMemoryProviderParamsShared, destroyOsMemoryProviderParamsShared, &hostAccessor}, #endif }; diff --git a/test/providers/provider_cuda.cpp b/test/providers/provider_cuda.cpp index 8a7fdd28aa..ff0fca5502 100644 --- a/test/providers/provider_cuda.cpp +++ b/test/providers/provider_cuda.cpp @@ -52,47 +52,35 @@ CUDATestHelper::CUDATestHelper() { } } -using cuda_params_unique_handle_t = - std::unique_ptr; - -cuda_params_unique_handle_t +umf_cuda_memory_provider_params_handle_t create_cuda_prov_params(CUcontext context, CUdevice device, umf_usm_memory_type_t memory_type) { umf_cuda_memory_provider_params_handle_t params = nullptr; umf_result_t res = umfCUDAMemoryProviderParamsCreate(¶ms); if (res != UMF_RESULT_SUCCESS) { - return cuda_params_unique_handle_t(nullptr, - &umfCUDAMemoryProviderParamsDestroy); + return nullptr; } res = umfCUDAMemoryProviderParamsSetContext(params, context); if (res != UMF_RESULT_SUCCESS) { umfCUDAMemoryProviderParamsDestroy(params); - return cuda_params_unique_handle_t(nullptr, - &umfCUDAMemoryProviderParamsDestroy); - ; + return nullptr; } res = umfCUDAMemoryProviderParamsSetDevice(params, device); if (res != UMF_RESULT_SUCCESS) { umfCUDAMemoryProviderParamsDestroy(params); - return cuda_params_unique_handle_t(nullptr, - &umfCUDAMemoryProviderParamsDestroy); - ; + return nullptr; } res = umfCUDAMemoryProviderParamsSetMemoryType(params, memory_type); if (res != UMF_RESULT_SUCCESS) { umfCUDAMemoryProviderParamsDestroy(params); - return cuda_params_unique_handle_t(nullptr, - &umfCUDAMemoryProviderParamsDestroy); - ; + return nullptr; } - return cuda_params_unique_handle_t(params, - &umfCUDAMemoryProviderParamsDestroy); + return params; } class CUDAMemoryAccessor : public MemoryAccessor { @@ -126,8 +114,11 @@ class CUDAMemoryAccessor : public MemoryAccessor { CUcontext hContext_; }; +typedef void *(*pfnProviderParamsCreate)(); +typedef umf_result_t (*pfnProviderParamsDestroy)(void *); + using CUDAProviderTestParams = - std::tuple; struct umfCUDAProviderTest @@ -137,17 +128,31 @@ struct umfCUDAProviderTest void SetUp() override { test::SetUp(); - auto [cuda_params, cu_context, memory_type, accessor] = - this->GetParam(); - params = cuda_params; + 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(); + } + paramsDestroy = params_destroy; + memAccessor = accessor; expected_context = cu_context; expected_memory_type = memory_type; } - void TearDown() override { test::TearDown(); } + void TearDown() override { + if (paramsDestroy) { + paramsDestroy(params); + } + + test::TearDown(); + } umf_cuda_memory_provider_params_handle_t params; + pfnProviderParamsDestroy paramsDestroy = nullptr; + MemoryAccessor *memAccessor = nullptr; CUcontext expected_context; umf_usm_memory_type_t expected_memory_type; @@ -327,23 +332,27 @@ TEST_P(umfCUDAProviderTest, multiContext) { ret = create_context(device, &ctx2); ASSERT_EQ(ret, 0); - cuda_params_unique_handle_t params1 = + umf_cuda_memory_provider_params_handle_t params1 = create_cuda_prov_params(ctx1, device, UMF_MEMORY_TYPE_HOST); ASSERT_NE(params1, nullptr); umf_memory_provider_handle_t provider1; umf_result_t umf_result = umfMemoryProviderCreate( - umfCUDAMemoryProviderOps(), params1.get(), &provider1); + umfCUDAMemoryProviderOps(), params1, &provider1); ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS); ASSERT_NE(provider1, nullptr); + umf_result = umfCUDAMemoryProviderParamsDestroy(params1); + ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS); - cuda_params_unique_handle_t params2 = + umf_cuda_memory_provider_params_handle_t params2 = create_cuda_prov_params(ctx2, device, UMF_MEMORY_TYPE_HOST); ASSERT_NE(params2, nullptr); umf_memory_provider_handle_t provider2; - umf_result = umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), - params2.get(), &provider2); + umf_result = umfMemoryProviderCreate(umfCUDAMemoryProviderOps(), params2, + &provider2); ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS); ASSERT_NE(provider2, nullptr); + umf_result = umfCUDAMemoryProviderParamsDestroy(params2); + ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS); // use the providers // allocate from 1, then from 2, then free 1, then free 2 @@ -384,30 +393,40 @@ TEST_P(umfCUDAProviderTest, multiContext) { CUDATestHelper cudaTestHelper; -cuda_params_unique_handle_t cuParams_device_memory = create_cuda_prov_params( - cudaTestHelper.get_test_context(), cudaTestHelper.get_test_device(), - UMF_MEMORY_TYPE_DEVICE); -cuda_params_unique_handle_t cuParams_shared_memory = create_cuda_prov_params( - cudaTestHelper.get_test_context(), cudaTestHelper.get_test_device(), - UMF_MEMORY_TYPE_SHARED); -cuda_params_unique_handle_t cuParams_host_memory = create_cuda_prov_params( - cudaTestHelper.get_test_context(), cudaTestHelper.get_test_device(), - UMF_MEMORY_TYPE_HOST); +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{cuParams_device_memory.get(), + CUDAProviderTestParams{createCuParamsDeviceMemory, destroyCuParams, cudaTestHelper.get_test_context(), UMF_MEMORY_TYPE_DEVICE, &cuAccessor}, - CUDAProviderTestParams{cuParams_shared_memory.get(), + CUDAProviderTestParams{createCuParamsSharedMemory, destroyCuParams, cudaTestHelper.get_test_context(), UMF_MEMORY_TYPE_SHARED, &hostAccessor}, - CUDAProviderTestParams{cuParams_host_memory.get(), + CUDAProviderTestParams{createCuParamsHostMemory, destroyCuParams, cudaTestHelper.get_test_context(), UMF_MEMORY_TYPE_HOST, &hostAccessor})); diff --git a/test/providers/provider_level_zero.cpp b/test/providers/provider_level_zero.cpp index 78b5e4847a..cdf620acef 100644 --- a/test/providers/provider_level_zero.cpp +++ b/test/providers/provider_level_zero.cpp @@ -1,4 +1,4 @@ -// 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 @@ -61,11 +61,7 @@ LevelZeroTestHelper::LevelZeroTestHelper() { } } -using level_zero_params_unique_handle_t = - std::unique_ptr; - -level_zero_params_unique_handle_t +umf_level_zero_memory_provider_params_handle_t create_level_zero_prov_params(ze_context_handle_t context, ze_device_handle_t device, umf_usm_memory_type_t memory_type) { @@ -73,36 +69,28 @@ create_level_zero_prov_params(ze_context_handle_t context, umf_result_t res = umfLevelZeroMemoryProviderParamsCreate(¶ms); if (res != UMF_RESULT_SUCCESS) { - return level_zero_params_unique_handle_t( - nullptr, &umfLevelZeroMemoryProviderParamsDestroy); + return nullptr; } res = umfLevelZeroMemoryProviderParamsSetContext(params, context); if (res != UMF_RESULT_SUCCESS) { umfLevelZeroMemoryProviderParamsDestroy(params); - return level_zero_params_unique_handle_t( - nullptr, &umfLevelZeroMemoryProviderParamsDestroy); - ; + return nullptr; } res = umfLevelZeroMemoryProviderParamsSetDevice(params, device); if (res != UMF_RESULT_SUCCESS) { umfLevelZeroMemoryProviderParamsDestroy(params); - return level_zero_params_unique_handle_t( - nullptr, &umfLevelZeroMemoryProviderParamsDestroy); - ; + return nullptr; } res = umfLevelZeroMemoryProviderParamsSetMemoryType(params, memory_type); if (res != UMF_RESULT_SUCCESS) { umfLevelZeroMemoryProviderParamsDestroy(params); - return level_zero_params_unique_handle_t( - nullptr, &umfLevelZeroMemoryProviderParamsDestroy); - ; + return nullptr; } - return level_zero_params_unique_handle_t( - params, &umfLevelZeroMemoryProviderParamsDestroy); + return params; } struct LevelZeroProviderInit @@ -237,8 +225,11 @@ class LevelZeroMemoryAccessor : public MemoryAccessor { ze_context_handle_t hContext_; }; +typedef void *(*pfnProviderParamsCreate)(); +typedef umf_result_t (*pfnProviderParamsDestroy)(void *); + using LevelZeroProviderTestParams = - std::tuple; struct umfLevelZeroProviderTest @@ -248,8 +239,16 @@ struct umfLevelZeroProviderTest void SetUp() override { test::SetUp(); - auto [l0_params, ze_context, memory_type, accessor] = this->GetParam(); - params = l0_params; + auto [params_create, params_destroy, ze_context, memory_type, + accessor] = 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; @@ -273,9 +272,17 @@ struct umfLevelZeroProviderTest ASSERT_NE(zeMemoryTypeExpected, ZE_MEMORY_TYPE_UNKNOWN); } - void TearDown() override { test::TearDown(); } + void TearDown() override { + if (paramsDestroy) { + paramsDestroy(params); + } + + test::TearDown(); + } umf_level_zero_memory_provider_params_handle_t params; + pfnProviderParamsDestroy paramsDestroy = nullptr; + MemoryAccessor *memAccessor = nullptr; ze_context_handle_t hContext = nullptr; ze_memory_type_t zeMemoryTypeExpected = ZE_MEMORY_TYPE_UNKNOWN; @@ -418,17 +425,27 @@ TEST_P(umfLevelZeroProviderTest, levelZeroProviderNullParams) { // TODO add tests that mixes Level Zero Memory Provider and Disjoint Pool -level_zero_params_unique_handle_t l0Params_device_memory = - create_level_zero_prov_params(l0TestHelper.get_test_context(), - l0TestHelper.get_test_device(), - UMF_MEMORY_TYPE_DEVICE); -level_zero_params_unique_handle_t l0Params_shared_memory = - create_level_zero_prov_params(l0TestHelper.get_test_context(), - l0TestHelper.get_test_device(), - UMF_MEMORY_TYPE_SHARED); -level_zero_params_unique_handle_t l0Params_host_memory = - create_level_zero_prov_params(l0TestHelper.get_test_context(), nullptr, - UMF_MEMORY_TYPE_HOST); +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(), @@ -439,13 +456,13 @@ HostMemoryAccessor hostAccessor; INSTANTIATE_TEST_SUITE_P( umfLevelZeroProviderTestSuite, umfLevelZeroProviderTest, ::testing::Values( - LevelZeroProviderTestParams{l0Params_device_memory.get(), + LevelZeroProviderTestParams{createL0ParamsDeviceMemory, destroyL0Params, l0TestHelper.get_test_context(), UMF_MEMORY_TYPE_DEVICE, &l0Accessor}, - LevelZeroProviderTestParams{l0Params_shared_memory.get(), + LevelZeroProviderTestParams{createL0ParamsSharedMemory, destroyL0Params, l0TestHelper.get_test_context(), UMF_MEMORY_TYPE_SHARED, &hostAccessor}, - LevelZeroProviderTestParams{l0Params_host_memory.get(), + LevelZeroProviderTestParams{createL0ParamsHostMemory, destroyL0Params, l0TestHelper.get_test_context(), UMF_MEMORY_TYPE_HOST, &hostAccessor})); @@ -454,9 +471,9 @@ INSTANTIATE_TEST_SUITE_P( #ifdef _WIN32 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(umfIpcTest); #else -INSTANTIATE_TEST_SUITE_P(umfLevelZeroProviderTestSuite, umfIpcTest, - ::testing::Values(ipcTestParams{ - umfProxyPoolOps(), nullptr, - umfLevelZeroMemoryProviderOps(), - l0Params_device_memory.get(), &l0Accessor})); +INSTANTIATE_TEST_SUITE_P( + umfLevelZeroProviderTestSuite, umfIpcTest, + ::testing::Values(ipcTestParams{ + umfProxyPoolOps(), nullptr, nullptr, umfLevelZeroMemoryProviderOps(), + createL0ParamsDeviceMemory, destroyL0Params, &l0Accessor})); #endif