Skip to content

Commit 42adf1e

Browse files
bratpiorkabratpiorka
authored
Merge pull request #1055 from bratpiorka/rrudnick_test_params_refactor
do not use global ctor/dtor for test params
2 parents 4af372f + abf957f commit 42adf1e

17 files changed

+439
-283
lines changed

‎test/ipcAPI.cpp‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// Copyright (C) 2023-2024 Intel Corporation
1+
// Copyright (C) 2023-2025 Intel Corporation
22
// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
33
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
44
// This file contains tests for UMF pool API
@@ -115,5 +115,6 @@ HostMemoryAccessor hostMemoryAccessor;
115115

116116
INSTANTIATE_TEST_SUITE_P(umfIpcTestSuite, umfIpcTest,
117117
::testing::Values(ipcTestParams{
118-
umfProxyPoolOps(), nullptr, &IPC_MOCK_PROVIDER_OPS,
119-
nullptr, &hostMemoryAccessor}));
118+
umfProxyPoolOps(), nullptr, nullptr,
119+
&IPC_MOCK_PROVIDER_OPS, nullptr, nullptr,
120+
&hostMemoryAccessor}));

‎test/ipcFixtures.hpp‎

Lines changed: 44 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// Copyright (C) 2024 Intel Corporation
1+
// Copyright (C) 2024-2025 Intel Corporation
22
// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
33
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
44

@@ -46,23 +46,36 @@ class HostMemoryAccessor : public MemoryAccessor {
4646
}
4747
};
4848

49+
typedef void *(*pfnPoolParamsCreate)();
50+
typedef umf_result_t (*pfnPoolParamsDestroy)(void *);
51+
52+
typedef void *(*pfnProviderParamsCreate)();
53+
typedef umf_result_t (*pfnProviderParamsDestroy)(void *);
54+
4955
// ipcTestParams:
50-
// pool_ops, pool_params, provider_ops, provider_params, memoryAccessor
56+
// pool_ops, pfnPoolParamsCreate,pfnPoolParamsDestroy,
57+
// provider_ops, pfnProviderParamsCreate, pfnProviderParamsDestroy,
58+
// memoryAccessor
5159
using ipcTestParams =
52-
std::tuple<umf_memory_pool_ops_t *, void *, umf_memory_provider_ops_t *,
53-
void *, MemoryAccessor *>;
60+
std::tuple<umf_memory_pool_ops_t *, pfnPoolParamsCreate,
61+
pfnPoolParamsDestroy, umf_memory_provider_ops_t *,
62+
pfnProviderParamsCreate, pfnProviderParamsDestroy,
63+
MemoryAccessor *>;
5464

5565
struct umfIpcTest : umf_test::test,
5666
::testing::WithParamInterface<ipcTestParams> {
5767
umfIpcTest() {}
5868
void SetUp() override {
5969
test::SetUp();
60-
auto [pool_ops, pool_params, provider_ops, provider_params, accessor] =
70+
auto [pool_ops, pool_params_create, pool_params_destroy, provider_ops,
71+
provider_params_create, provider_params_destroy, accessor] =
6172
this->GetParam();
6273
poolOps = pool_ops;
63-
poolParams = pool_params;
74+
poolParamsCreate = pool_params_create;
75+
poolParamsDestroy = pool_params_destroy;
6476
providerOps = provider_ops;
65-
providerParams = provider_params;
77+
providerParamsCreate = provider_params_create;
78+
providerParamsDestroy = provider_params_destroy;
6679
memAccessor = accessor;
6780
}
6881

@@ -74,10 +87,19 @@ struct umfIpcTest : umf_test::test,
7487
umf_memory_provider_handle_t hProvider = NULL;
7588
umf_memory_pool_handle_t hPool = NULL;
7689

90+
void *providerParams = nullptr;
91+
if (providerParamsCreate) {
92+
providerParams = providerParamsCreate();
93+
}
94+
7795
auto ret =
7896
umfMemoryProviderCreate(providerOps, providerParams, &hProvider);
7997
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
8098

99+
if (providerParamsDestroy) {
100+
providerParamsDestroy(providerParams);
101+
}
102+
81103
auto trace = [](void *trace_context, const char *name) {
82104
stats_type *stat = static_cast<stats_type *>(trace_context);
83105
if (std::strcmp(name, "alloc") == 0) {
@@ -96,10 +118,19 @@ struct umfIpcTest : umf_test::test,
96118
umf_memory_provider_handle_t hTraceProvider =
97119
traceProviderCreate(hProvider, true, (void *)&stat, trace);
98120

121+
void *poolParams = nullptr;
122+
if (poolParamsCreate) {
123+
poolParams = poolParamsCreate();
124+
}
125+
99126
ret = umfPoolCreate(poolOps, hTraceProvider, poolParams,
100127
UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
101128
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
102129

130+
if (poolParamsDestroy) {
131+
poolParamsDestroy(poolParams);
132+
}
133+
103134
return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
104135
}
105136

@@ -118,10 +149,14 @@ struct umfIpcTest : umf_test::test,
118149
static constexpr int NTHREADS = 10;
119150
stats_type stat;
120151
MemoryAccessor *memAccessor = nullptr;
152+
121153
umf_memory_pool_ops_t *poolOps = nullptr;
122-
void *poolParams = nullptr;
154+
pfnPoolParamsCreate poolParamsCreate = nullptr;
155+
pfnPoolParamsDestroy poolParamsDestroy = nullptr;
156+
123157
umf_memory_provider_ops_t *providerOps = nullptr;
124-
void *providerParams = nullptr;
158+
pfnProviderParamsCreate providerParamsCreate = nullptr;
159+
pfnProviderParamsDestroy providerParamsDestroy = nullptr;
125160
};
126161

127162
TEST_P(umfIpcTest, GetIPCHandleSize) {

‎test/memoryPoolAPI.cpp‎

Lines changed: 9 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// Copyright (C) 2023-2024 Intel Corporation
1+
// Copyright (C) 2023-2025 Intel Corporation
22
// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
33
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
44
// This file contains tests for UMF pool API
@@ -295,15 +295,17 @@ TEST_F(tagTest, SetAndGetInvalidPool) {
295295

296296
INSTANTIATE_TEST_SUITE_P(
297297
mallocPoolTest, umfPoolTest,
298-
::testing::Values(poolCreateExtParams{&MALLOC_POOL_OPS, nullptr,
299-
&UMF_NULL_PROVIDER_OPS, nullptr},
300-
poolCreateExtParams{umfProxyPoolOps(), nullptr,
301-
&BA_GLOBAL_PROVIDER_OPS, nullptr}));
298+
::testing::Values(poolCreateExtParams{&MALLOC_POOL_OPS, nullptr, nullptr,
299+
&UMF_NULL_PROVIDER_OPS, nullptr,
300+
nullptr},
301+
poolCreateExtParams{umfProxyPoolOps(), nullptr, nullptr,
302+
&BA_GLOBAL_PROVIDER_OPS, nullptr,
303+
nullptr}));
302304

303305
INSTANTIATE_TEST_SUITE_P(mallocMultiPoolTest, umfMultiPoolTest,
304306
::testing::Values(poolCreateExtParams{
305-
umfProxyPoolOps(), nullptr,
306-
&BA_GLOBAL_PROVIDER_OPS, nullptr}));
307+
umfProxyPoolOps(), nullptr, nullptr,
308+
&BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));
307309

308310
INSTANTIATE_TEST_SUITE_P(umfPoolWithCreateFlagsTest, umfPoolWithCreateFlagsTest,
309311
::testing::Values(0,

‎test/poolFixtures.hpp‎

Lines changed: 32 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -19,29 +19,58 @@
1919

2020
#include "../malloc_compliance_tests.hpp"
2121

22-
using poolCreateExtParams = std::tuple<umf_memory_pool_ops_t *, void *,
23-
umf_memory_provider_ops_t *, void *>;
22+
typedef void *(*pfnPoolParamsCreate)();
23+
typedef umf_result_t (*pfnPoolParamsDestroy)(void *);
24+
25+
typedef void *(*pfnProviderParamsCreate)();
26+
typedef umf_result_t (*pfnProviderParamsDestroy)(void *);
27+
28+
using poolCreateExtParams =
29+
std::tuple<umf_memory_pool_ops_t *, pfnPoolParamsCreate,
30+
pfnPoolParamsDestroy, umf_memory_provider_ops_t *,
31+
pfnProviderParamsCreate, pfnProviderParamsDestroy>;
2432

2533
umf::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams params) {
26-
auto [pool_ops, pool_params, provider_ops, provider_params] = params;
34+
auto [pool_ops, poolParamsCreate, poolParamsDestroy, provider_ops,
35+
providerParamsCreate, providerParamsDestroy] = params;
2736

2837
umf_memory_provider_handle_t upstream_provider = nullptr;
2938
umf_memory_provider_handle_t provider = nullptr;
3039
umf_memory_pool_handle_t hPool = nullptr;
3140
umf_result_t ret;
3241

42+
void *provider_params = NULL;
43+
if (providerParamsCreate) {
44+
provider_params = providerParamsCreate();
45+
}
3346
ret = umfMemoryProviderCreate(provider_ops, provider_params,
3447
&upstream_provider);
3548
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
3649
EXPECT_NE(upstream_provider, nullptr);
3750

3851
provider = upstream_provider;
3952

53+
void *pool_params = NULL;
54+
if (poolParamsCreate) {
55+
pool_params = poolParamsCreate();
56+
}
57+
58+
// NOTE: we set the UMF_POOL_CREATE_FLAG_OWN_PROVIDER flag here so the pool
59+
// will destroy the provider when it is destroyed
4060
ret = umfPoolCreate(pool_ops, provider, pool_params,
4161
UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
4262
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
4363
EXPECT_NE(hPool, nullptr);
4464

65+
// we do not need params anymore
66+
if (poolParamsDestroy) {
67+
poolParamsDestroy(pool_params);
68+
}
69+
70+
if (providerParamsDestroy) {
71+
providerParamsDestroy(provider_params);
72+
}
73+
4574
return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
4675
}
4776

‎test/pools/disjoint_pool.cpp‎

Lines changed: 38 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -11,16 +11,12 @@
1111
#include "provider_null.h"
1212
#include "provider_trace.h"
1313

14-
using disjoint_params_unique_handle_t =
15-
std::unique_ptr<umf_disjoint_pool_params_t,
16-
decltype(&umfDisjointPoolParamsDestroy)>;
17-
1814
static constexpr size_t DEFAULT_DISJOINT_SLAB_MIN_SIZE = 4096;
1915
static constexpr size_t DEFAULT_DISJOINT_MAX_POOLABLE_SIZE = 4096;
2016
static constexpr size_t DEFAULT_DISJOINT_CAPACITY = 4;
2117
static constexpr size_t DEFAULT_DISJOINT_MIN_BUCKET_SIZE = 64;
2218

23-
disjoint_params_unique_handle_t poolConfig() {
19+
void *defaultPoolConfig() {
2420
umf_disjoint_pool_params_handle_t config = nullptr;
2521
umf_result_t res = umfDisjointPoolParamsCreate(&config);
2622
if (res != UMF_RESULT_SUCCESS) {
@@ -50,8 +46,12 @@ disjoint_params_unique_handle_t poolConfig() {
5046
throw std::runtime_error("Failed to set min bucket size");
5147
}
5248

53-
return disjoint_params_unique_handle_t(config,
54-
&umfDisjointPoolParamsDestroy);
49+
return config;
50+
}
51+
52+
umf_result_t poolConfigDestroy(void *config) {
53+
return umfDisjointPoolParamsDestroy(
54+
static_cast<umf_disjoint_pool_params_handle_t>(config));
5555
}
5656

5757
using umf_test::test;
@@ -83,17 +83,21 @@ TEST_F(test, freeErrorPropagation) {
8383
provider_handle = providerUnique.get();
8484

8585
// force all allocations to go to memory provider
86-
disjoint_params_unique_handle_t params = poolConfig();
87-
umf_result_t retp =
88-
umfDisjointPoolParamsSetMaxPoolableSize(params.get(), 0);
86+
umf_disjoint_pool_params_handle_t params;
87+
umf_result_t retp = umfDisjointPoolParamsCreate(&params);
88+
EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
89+
retp = umfDisjointPoolParamsSetMaxPoolableSize(params, 0);
8990
EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
9091

9192
umf_memory_pool_handle_t pool = NULL;
92-
retp = umfPoolCreate(umfDisjointPoolOps(), provider_handle, params.get(), 0,
93-
&pool);
93+
retp =
94+
umfPoolCreate(umfDisjointPoolOps(), provider_handle, params, 0, &pool);
9495
EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
9596
auto poolHandle = umf_test::wrapPoolUnique(pool);
9697

98+
retp = umfDisjointPoolParamsDestroy(params);
99+
EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
100+
97101
static constexpr size_t size = 1024;
98102
void *ptr = umfPoolMalloc(pool, size);
99103

@@ -130,9 +134,9 @@ TEST_F(test, sharedLimits) {
130134
static constexpr size_t SlabMinSize = 1024;
131135
static constexpr size_t MaxSize = 4 * SlabMinSize;
132136

133-
disjoint_params_unique_handle_t config = poolConfig();
134-
umf_result_t ret =
135-
umfDisjointPoolParamsSetSlabMinSize(config.get(), SlabMinSize);
137+
umf_disjoint_pool_params_handle_t params =
138+
(umf_disjoint_pool_params_handle_t)defaultPoolConfig();
139+
umf_result_t ret = umfDisjointPoolParamsSetSlabMinSize(params, SlabMinSize);
136140
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
137141

138142
auto limits =
@@ -141,24 +145,27 @@ TEST_F(test, sharedLimits) {
141145
umfDisjointPoolSharedLimitsCreate(MaxSize),
142146
&umfDisjointPoolSharedLimitsDestroy);
143147

144-
ret = umfDisjointPoolParamsSetSharedLimits(config.get(), limits.get());
148+
ret = umfDisjointPoolParamsSetSharedLimits(params, limits.get());
145149
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
146150

147151
auto provider =
148152
wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));
149153

150154
umf_memory_pool_handle_t pool1 = NULL;
151155
umf_memory_pool_handle_t pool2 = NULL;
152-
ret = umfPoolCreate(umfDisjointPoolOps(), provider.get(),
153-
(void *)config.get(), 0, &pool1);
156+
ret =
157+
umfPoolCreate(umfDisjointPoolOps(), provider.get(), params, 0, &pool1);
154158
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
155159
auto poolHandle1 = umf_test::wrapPoolUnique(pool1);
156160

157-
ret = umfPoolCreate(umfDisjointPoolOps(), provider.get(),
158-
(void *)config.get(), 0, &pool2);
161+
ret =
162+
umfPoolCreate(umfDisjointPoolOps(), provider.get(), params, 0, &pool2);
159163
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
160164
auto poolHandle2 = umf_test::wrapPoolUnique(pool2);
161165

166+
ret = umfDisjointPoolParamsDestroy(params);
167+
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
168+
162169
EXPECT_EQ(0, numAllocs);
163170
EXPECT_EQ(0, numFrees);
164171

@@ -243,23 +250,24 @@ TEST_F(test, disjointPoolInvalidBucketSize) {
243250
umfDisjointPoolParamsDestroy(params);
244251
}
245252

246-
disjoint_params_unique_handle_t defaultPoolConfig = poolConfig();
247253
INSTANTIATE_TEST_SUITE_P(disjointPoolTests, umfPoolTest,
248254
::testing::Values(poolCreateExtParams{
249-
umfDisjointPoolOps(),
250-
(void *)defaultPoolConfig.get(),
251-
&BA_GLOBAL_PROVIDER_OPS, nullptr}));
255+
umfDisjointPoolOps(), defaultPoolConfig,
256+
poolConfigDestroy, &BA_GLOBAL_PROVIDER_OPS,
257+
nullptr, nullptr}));
258+
259+
void *memProviderParams() { return (void *)&DEFAULT_DISJOINT_CAPACITY; }
252260

253261
INSTANTIATE_TEST_SUITE_P(
254262
disjointPoolTests, umfMemTest,
255263
::testing::Values(std::make_tuple(
256-
poolCreateExtParams{
257-
umfDisjointPoolOps(), (void *)defaultPoolConfig.get(),
258-
&MOCK_OUT_OF_MEM_PROVIDER_OPS, (void *)&DEFAULT_DISJOINT_CAPACITY},
264+
poolCreateExtParams{umfDisjointPoolOps(), defaultPoolConfig,
265+
poolConfigDestroy, &MOCK_OUT_OF_MEM_PROVIDER_OPS,
266+
memProviderParams, nullptr},
259267
static_cast<int>(DEFAULT_DISJOINT_CAPACITY) / 2)));
260268

261269
INSTANTIATE_TEST_SUITE_P(disjointMultiPoolTests, umfMultiPoolTest,
262270
::testing::Values(poolCreateExtParams{
263-
umfDisjointPoolOps(),
264-
(void *)defaultPoolConfig.get(),
265-
&BA_GLOBAL_PROVIDER_OPS, nullptr}));
271+
umfDisjointPoolOps(), defaultPoolConfig,
272+
poolConfigDestroy, &BA_GLOBAL_PROVIDER_OPS,
273+
nullptr, nullptr}));

0 commit comments

Comments
 (0)