Skip to content

Commit 15652ee

Browse files
igchorigchor
authored
Merge pull request #126 from igchor/pool_ext_flags
Add flags param to umfPoolCreate
2 parents e23fbd4 + 97ff91f commit 15652ee

14 files changed

+157
-177
lines changed

‎benchmark/ubench.c

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -205,7 +205,7 @@ UBENCH_EX(simple, disjoint_pool_with_os_memory_provider) {
205205

206206
umf_memory_pool_handle_t disjoint_pool;
207207
umf_result = umfPoolCreate(&UMF_DISJOINT_POOL_OPS, os_memory_provider,
208-
&disjoint_memory_pool_params, &disjoint_pool);
208+
&disjoint_memory_pool_params, 0, &disjoint_pool);
209209
if (umf_result != UMF_RESULT_SUCCESS) {
210210
exit(-1);
211211
}
@@ -242,7 +242,7 @@ UBENCH_EX(simple, jemalloc_pool_with_os_memory_provider) {
242242

243243
umf_memory_pool_handle_t jemalloc_pool;
244244
umf_result = umfPoolCreate(&UMF_JEMALLOC_POOL_OPS, os_memory_provider, NULL,
245-
&jemalloc_pool);
245+
0, &jemalloc_pool);
246246
if (umf_result != UMF_RESULT_SUCCESS) {
247247
exit(-1);
248248
}
@@ -279,7 +279,7 @@ UBENCH_EX(simple, scalable_pool_with_os_memory_provider) {
279279

280280
umf_memory_pool_handle_t scalable_pool;
281281
umf_result = umfPoolCreate(&UMF_SCALABLE_POOL_OPS, os_memory_provider, NULL,
282-
&scalable_pool);
282+
0, &scalable_pool);
283283
if (umf_result != UMF_RESULT_SUCCESS) {
284284
exit(-1);
285285
}

‎include/umf/memory_pool.h

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -30,17 +30,32 @@ struct umf_memory_pool_ops_t;
3030
///
3131
typedef struct umf_memory_pool_ops_t umf_memory_pool_ops_t;
3232

33+
/// @brief Supported pool creation flags
34+
typedef uint32_t umf_pool_create_flags_t;
35+
typedef enum umf_pool_create_flag_t {
36+
UMF_POOL_CREATE_FLAG_NONE = 0,
37+
UMF_POOL_CREATE_FLAG_OWN_PROVIDER =
38+
(1
39+
<< 0), ///< pool will own the specified provider and destroy it in umfPoolDestroy
40+
/// @cond
41+
UMF_POOL_CREATE_FLAG_FORCE_UINT32 = 0x7fffffff
42+
/// @endcond
43+
44+
} umf_pool_create_flag_t;
45+
3346
///
3447
/// @brief Creates new memory pool.
3548
/// @param ops instance of umf_memory_pool_ops_t
3649
/// @param provider memory provider that will be used for coarse-grain allocations.
3750
/// @param params pointer to pool-specific parameters
51+
/// @param flags a combination of umf_pool_create_flag_t
3852
/// @param hPool [out] handle to the newly created memory pool
3953
/// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
4054
///
4155
UMF_EXPORT umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
4256
umf_memory_provider_handle_t provider,
4357
void *params,
58+
umf_pool_create_flags_t flags,
4459
umf_memory_pool_handle_t *hPool);
4560

4661
///

‎src/memory_pool.c

Lines changed: 7 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -15,33 +15,16 @@
1515
#include <assert.h>
1616
#include <stdlib.h>
1717

18-
umf_result_t umfPoolCreateEx(const umf_memory_pool_ops_t *pool_ops,
19-
void *pool_params,
20-
const umf_memory_provider_ops_t *provider_ops,
21-
void *provider_params,
22-
umf_memory_pool_handle_t *hPool) {
23-
if (!pool_ops || !provider_ops || !hPool) {
24-
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
25-
}
26-
27-
umf_memory_provider_handle_t provider = NULL;
28-
umf_result_t ret =
29-
umfMemoryProviderCreate(provider_ops, provider_params, &provider);
18+
umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
19+
umf_memory_provider_handle_t provider, void *params,
20+
umf_pool_create_flags_t flags,
21+
umf_memory_pool_handle_t *hPool) {
22+
umf_result_t ret = umfPoolCreateInternal(ops, provider, params, hPool);
3023
if (ret != UMF_RESULT_SUCCESS) {
3124
return ret;
3225
}
33-
assert(provider != NULL);
34-
35-
umf_memory_pool_handle_t pool = NULL;
36-
ret = umfPoolCreate(pool_ops, provider, pool_params, &pool);
37-
if (ret != UMF_RESULT_SUCCESS) {
38-
umfMemoryProviderDestroy(provider);
39-
return ret;
40-
}
41-
assert(pool != NULL);
42-
43-
pool->own_provider = true;
44-
*hPool = pool;
26+
assert(*hPool != NULL);
27+
(*hPool)->own_provider = (flags & UMF_POOL_CREATE_FLAG_OWN_PROVIDER);
4528

4629
return UMF_RESULT_SUCCESS;
4730
}

‎src/memory_pool_default.c

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,10 @@
1414
#include <assert.h>
1515
#include <stdlib.h>
1616

17-
umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
18-
umf_memory_provider_handle_t provider, void *params,
19-
umf_memory_pool_handle_t *hPool) {
17+
umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
18+
umf_memory_provider_handle_t provider,
19+
void *params,
20+
umf_memory_pool_handle_t *hPool) {
2021
if (!ops || !provider || !hPool) {
2122
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
2223
}

‎src/memory_pool_internal.h

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -31,10 +31,10 @@ typedef struct umf_memory_pool_t {
3131
bool own_provider;
3232
} umf_memory_pool_t;
3333

34-
UMF_EXPORT umf_result_t
35-
umfPoolCreateEx(const umf_memory_pool_ops_t *pool_ops, void *pool_params,
36-
const umf_memory_provider_ops_t *provider_ops,
37-
void *provider_params, umf_memory_pool_handle_t *hPool);
34+
umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
35+
umf_memory_provider_handle_t provider,
36+
void *params,
37+
umf_memory_pool_handle_t *hPool);
3838

3939
#ifdef __cplusplus
4040
}

‎src/memory_pool_tracking.c

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -16,9 +16,10 @@
1616
#include <assert.h>
1717
#include <stdlib.h>
1818

19-
umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
20-
umf_memory_provider_handle_t provider, void *params,
21-
umf_memory_pool_handle_t *hPool) {
19+
umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
20+
umf_memory_provider_handle_t provider,
21+
void *params,
22+
umf_memory_pool_handle_t *hPool) {
2223
if (!ops || !provider || !hPool) {
2324
return UMF_RESULT_ERROR_INVALID_ARGUMENT;
2425
}

‎test/CMakeLists.txt

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -66,8 +66,6 @@ add_umf_test(NAME memoryPool
6666
SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp)
6767
add_umf_test(NAME memoryProvider
6868
SRCS memoryProviderAPI.cpp)
69-
add_umf_test(NAME memory_pool_internal
70-
SRCS memory_pool_internal.cpp)
7169

7270
if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
7371
add_umf_test(NAME disjointPool

‎test/c_api/disjoint_pool.c

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ void test_disjoint_pool_default_params(void) {
1313
umf_result_t retp;
1414
umf_memory_pool_handle_t pool = NULL;
1515
umf_disjoint_pool_params_t params = umfDisjointPoolParamsDefault();
16-
retp = umfPoolCreate(&UMF_DISJOINT_POOL_OPS, provider, &params, &pool);
16+
retp = umfPoolCreate(&UMF_DISJOINT_POOL_OPS, provider, &params, 0, &pool);
1717

1818
UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
1919

@@ -31,7 +31,7 @@ void test_disjoint_pool_shared_limits(void) {
3131
umfDisjointPoolSharedLimitsCreate(1024);
3232
params.SharedLimits = limits;
3333

34-
retp = umfPoolCreate(&UMF_DISJOINT_POOL_OPS, provider, &params, &pool);
34+
retp = umfPoolCreate(&UMF_DISJOINT_POOL_OPS, provider, &params, 0, &pool);
3535

3636
UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
3737

‎test/common/pool.hpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ umf_memory_pool_handle_t
3131
createPoolChecked(umf_memory_pool_ops_t *ops,
3232
umf_memory_provider_handle_t hProvider, void *params) {
3333
umf_memory_pool_handle_t hPool;
34-
auto ret = umfPoolCreate(ops, hProvider, params, &hPool);
34+
auto ret = umfPoolCreate(ops, hProvider, params, 0, &hPool);
3535
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
3636
return hPool;
3737
}

‎test/common/test_helpers.c

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -66,7 +66,7 @@ tracePoolCreate(umf_memory_pool_handle_t hUpstreamPool,
6666

6767
umf_memory_pool_handle_t hPool;
6868
umf_result_t ret =
69-
umfPoolCreate(&UMF_TRACE_POOL_OPS, providerDesc, &params, &hPool);
69+
umfPoolCreate(&UMF_TRACE_POOL_OPS, providerDesc, &params, 0, &hPool);
7070

7171
(void)ret; /* silence unused variable warning */
7272
assert(ret == UMF_RESULT_SUCCESS);

‎test/memoryPoolAPI.cpp

Lines changed: 103 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77
#include "poolFixtures.hpp"
88
#include "provider.hpp"
99
#include "provider_null.h"
10+
#include "provider_trace.h"
1011
#include "test_helpers.h"
1112

1213
#include "umf/memory_provider.h"
@@ -101,7 +102,7 @@ TEST_F(test, memoryPoolWithCustomProvider) {
101102
umf_memory_pool_ops_t pool_ops = umf::poolMakeCOps<pool, void>();
102103

103104
umf_memory_pool_handle_t hPool;
104-
auto ret = umfPoolCreate(&pool_ops, hProvider, nullptr, &hPool);
105+
auto ret = umfPoolCreate(&pool_ops, hProvider, nullptr, 0, &hPool);
105106
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
106107
ASSERT_NE(hPool, nullptr);
107108

@@ -133,28 +134,116 @@ INSTANTIATE_TEST_SUITE_P(mallocMultiPoolTest, umfMultiPoolTest,
133134
&PROXY_POOL_OPS, nullptr, &MALLOC_PROVIDER_OPS,
134135
nullptr}));
135136

136-
////////////////// Negative test cases /////////////////
137+
struct umfPoolCreateFlagsTest
138+
: umf_test::test,
139+
::testing::WithParamInterface<umf_pool_create_flags_t> {
140+
void SetUp() override {
141+
test::SetUp();
142+
flags = this->GetParam();
143+
}
144+
umf_pool_create_flags_t flags;
145+
};
146+
147+
TEST_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsTestSuccess) {
148+
umf_memory_provider_handle_t provider = nullptr;
149+
umf_result_t ret =
150+
umfMemoryProviderCreate(&UMF_NULL_PROVIDER_OPS, nullptr, &provider);
151+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
152+
ASSERT_NE(provider, nullptr);
153+
154+
umf_memory_pool_handle_t pool = nullptr;
155+
ret = umfPoolCreate(&PROXY_POOL_OPS, provider, nullptr, flags, &pool);
156+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
157+
ASSERT_NE(pool, nullptr);
158+
159+
umfPoolDestroy(pool);
137160

138-
TEST_F(test, poolCreateNullOps) {
161+
if (!(flags & UMF_POOL_CREATE_FLAG_OWN_PROVIDER)) {
162+
umfMemoryProviderDestroy(provider);
163+
}
164+
}
165+
166+
TEST_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsCountProviderCalls) {
139167
auto nullProvider = umf_test::wrapProviderUnique(nullProviderCreate());
140-
umf_memory_provider_handle_t hProvider = nullProvider.get();
141168

142-
umf_memory_pool_handle_t hPool;
143-
auto ret = umfPoolCreate(nullptr, hProvider, nullptr, &hPool);
169+
static std::unordered_map<std::string, size_t> providerCalls;
170+
providerCalls.clear();
171+
auto traceCb = [](const char *name) { providerCalls[name]++; };
172+
173+
umf_provider_trace_params_t provider_params = {nullProvider.get(), traceCb};
174+
175+
umf_memory_provider_handle_t provider = nullptr;
176+
umf_result_t ret = umfMemoryProviderCreate(&UMF_TRACE_PROVIDER_OPS,
177+
&provider_params, &provider);
178+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
179+
ASSERT_NE(provider, nullptr);
180+
181+
umf_memory_pool_handle_t pool = nullptr;
182+
ret = umfPoolCreate(&PROXY_POOL_OPS, provider, nullptr, flags, &pool);
183+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
184+
ASSERT_NE(pool, nullptr);
185+
186+
size_t provider_call_count = 0;
187+
188+
umfPoolMalloc(pool, 0);
189+
ASSERT_EQ(providerCalls["alloc"], 1);
190+
ASSERT_EQ(providerCalls.size(), ++provider_call_count);
191+
192+
umfPoolFree(pool, 0);
193+
ASSERT_EQ(providerCalls["free"], 1);
194+
ASSERT_EQ(providerCalls.size(), ++provider_call_count);
195+
196+
umfPoolCalloc(pool, 0, 0);
197+
ASSERT_EQ(providerCalls["alloc"], 2);
198+
ASSERT_EQ(providerCalls.size(), provider_call_count);
199+
200+
umfPoolAlignedMalloc(pool, 0, 0);
201+
ASSERT_EQ(providerCalls["alloc"], 3);
202+
ASSERT_EQ(providerCalls.size(), provider_call_count);
203+
204+
umfPoolDestroy(pool);
205+
206+
if (!(flags & UMF_POOL_CREATE_FLAG_OWN_PROVIDER)) {
207+
umfMemoryProviderDestroy(provider);
208+
}
209+
}
210+
211+
INSTANTIATE_TEST_SUITE_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsTest,
212+
::testing::Values(0,
213+
UMF_POOL_CREATE_FLAG_OWN_PROVIDER));
214+
215+
////////////////// Negative test cases /////////////////
216+
217+
TEST_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsNullOps) {
218+
umf_memory_provider_handle_t provider = nullptr;
219+
umf_result_t ret =
220+
umfMemoryProviderCreate(&UMF_NULL_PROVIDER_OPS, nullptr, &provider);
221+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
222+
ASSERT_NE(provider, nullptr);
223+
224+
umf_memory_pool_handle_t pool = nullptr;
225+
ret = umfPoolCreate(nullptr, provider, nullptr, flags, &pool);
144226
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
227+
228+
umfMemoryProviderDestroy(provider);
145229
}
146230

147-
TEST_F(test, poolCreateNullPoolHandle) {
148-
auto nullProvider = umf_test::wrapProviderUnique(nullProviderCreate());
149-
umf_memory_provider_handle_t hProvider = nullProvider.get();
231+
TEST_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsNullPoolHandle) {
232+
umf_memory_provider_handle_t provider = nullptr;
233+
umf_result_t ret =
234+
umfMemoryProviderCreate(&UMF_NULL_PROVIDER_OPS, nullptr, &provider);
235+
ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
236+
ASSERT_NE(provider, nullptr);
150237

151-
auto ret = umfPoolCreate(&PROXY_POOL_OPS, hProvider, nullptr, nullptr);
238+
ret = umfPoolCreate(&PROXY_POOL_OPS, provider, nullptr, flags, nullptr);
152239
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
240+
241+
umfMemoryProviderDestroy(provider);
153242
}
154243

155-
TEST_F(test, memoryPoolInvalidProvidersNullptr) {
244+
TEST_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsInvalidProviders) {
156245
umf_memory_pool_handle_t hPool;
157-
auto ret = umfPoolCreate(&MALLOC_POOL_OPS, nullptr, nullptr, &hPool);
246+
auto ret = umfPoolCreate(&MALLOC_POOL_OPS, nullptr, nullptr, flags, &hPool);
158247
ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
159248
}
160249

@@ -182,8 +271,8 @@ TEST_P(poolInitializeTest, errorPropagation) {
182271
umf_memory_pool_ops_t pool_ops = umf::poolMakeCOps<pool, umf_result_t>();
183272

184273
umf_memory_pool_handle_t hPool;
185-
auto ret =
186-
umfPoolCreate(&pool_ops, hProvider, (void *)&this->GetParam(), &hPool);
274+
auto ret = umfPoolCreate(&pool_ops, hProvider, (void *)&this->GetParam(), 0,
275+
&hPool);
187276
ASSERT_EQ(ret, this->GetParam());
188277
}
189278

0 commit comments

Comments
 (0)