Add flags param to umfPoolCreate

benchmark/ubench.c

@@ -205,7 +205,7 @@ UBENCH_EX(simple, disjoint_pool_with_os_memory_provider) {
 
     umf_memory_pool_handle_t disjoint_pool;
     umf_result = umfPoolCreate(&UMF_DISJOINT_POOL_OPS, os_memory_provider,
-                               &disjoint_memory_pool_params, &disjoint_pool);
+                               &disjoint_memory_pool_params, 0, &disjoint_pool);
     if (umf_result != UMF_RESULT_SUCCESS) {
         exit(-1);
     }
@@ -242,7 +242,7 @@ UBENCH_EX(simple, jemalloc_pool_with_os_memory_provider) {
 
     umf_memory_pool_handle_t jemalloc_pool;
     umf_result = umfPoolCreate(&UMF_JEMALLOC_POOL_OPS, os_memory_provider, NULL,
-                               &jemalloc_pool);
+                               0, &jemalloc_pool);
     if (umf_result != UMF_RESULT_SUCCESS) {
         exit(-1);
     }
@@ -279,7 +279,7 @@ UBENCH_EX(simple, scalable_pool_with_os_memory_provider) {
 
     umf_memory_pool_handle_t scalable_pool;
     umf_result = umfPoolCreate(&UMF_SCALABLE_POOL_OPS, os_memory_provider, NULL,
-                               &scalable_pool);
+                               0, &scalable_pool);
     if (umf_result != UMF_RESULT_SUCCESS) {
         exit(-1);
     }

include/umf/memory_pool.h

@@ -30,17 +30,32 @@ struct umf_memory_pool_ops_t;
 ///
 typedef struct umf_memory_pool_ops_t umf_memory_pool_ops_t;
 
+/// @brief Supported pool creation flags
+typedef uint32_t umf_pool_create_flags_t;
+typedef enum umf_pool_create_flag_t {
+    UMF_POOL_CREATE_FLAG_NONE = 0,
+    UMF_POOL_CREATE_FLAG_OWN_PROVIDER =
+        (1
+         << 0), ///< pool will own the specified provider and destroy it in umfPoolDestroy
+    /// @cond
+    UMF_POOL_CREATE_FLAG_FORCE_UINT32 = 0x7fffffff
+    /// @endcond
+
+} umf_pool_create_flag_t;
+
 ///
 /// @brief Creates new memory pool.
 /// @param ops instance of umf_memory_pool_ops_t
 /// @param provider memory provider that will be used for coarse-grain allocations.
 /// @param params pointer to pool-specific parameters
+/// @param flags a combination of umf_pool_create_flag_t
 /// @param hPool [out] handle to the newly created memory pool
 /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
 UMF_EXPORT umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
                                       umf_memory_provider_handle_t provider,
                                       void *params,
+                                      umf_pool_create_flags_t flags,
                                       umf_memory_pool_handle_t *hPool);
 
 ///

src/memory_pool.c

@@ -15,33 +15,16 @@
 #include <assert.h>
 #include <stdlib.h>
 
-umf_result_t umfPoolCreateEx(const umf_memory_pool_ops_t *pool_ops,
-                             void *pool_params,
-                             const umf_memory_provider_ops_t *provider_ops,
-                             void *provider_params,
-                             umf_memory_pool_handle_t *hPool) {
-    if (!pool_ops || !provider_ops || !hPool) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    umf_memory_provider_handle_t provider = NULL;
-    umf_result_t ret =
-        umfMemoryProviderCreate(provider_ops, provider_params, &provider);
+umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
+                           umf_memory_provider_handle_t provider, void *params,
+                           umf_pool_create_flags_t flags,
+                           umf_memory_pool_handle_t *hPool) {
+    umf_result_t ret = umfPoolCreateInternal(ops, provider, params, hPool);
     if (ret != UMF_RESULT_SUCCESS) {
         return ret;
     }
-    assert(provider != NULL);
-
-    umf_memory_pool_handle_t pool = NULL;
-    ret = umfPoolCreate(pool_ops, provider, pool_params, &pool);
-    if (ret != UMF_RESULT_SUCCESS) {
-        umfMemoryProviderDestroy(provider);
-        return ret;
-    }
-    assert(pool != NULL);
-
-    pool->own_provider = true;
-    *hPool = pool;
+    assert(*hPool != NULL);
+    (*hPool)->own_provider = (flags & UMF_POOL_CREATE_FLAG_OWN_PROVIDER);
 
     return UMF_RESULT_SUCCESS;
 }

src/memory_pool_default.c

@@ -14,9 +14,10 @@
 #include <assert.h>
 #include <stdlib.h>
 
-umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
-                           umf_memory_provider_handle_t provider, void *params,
-                           umf_memory_pool_handle_t *hPool) {
+umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
+                                   umf_memory_provider_handle_t provider,
+                                   void *params,
+                                   umf_memory_pool_handle_t *hPool) {
     if (!ops || !provider || !hPool) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }

src/memory_pool_internal.h

@@ -31,10 +31,10 @@ typedef struct umf_memory_pool_t {
     bool own_provider;
 } umf_memory_pool_t;
 
-UMF_EXPORT umf_result_t
-umfPoolCreateEx(const umf_memory_pool_ops_t *pool_ops, void *pool_params,
-                const umf_memory_provider_ops_t *provider_ops,
-                void *provider_params, umf_memory_pool_handle_t *hPool);
+umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
+                                   umf_memory_provider_handle_t provider,
+                                   void *params,
+                                   umf_memory_pool_handle_t *hPool);
 
 #ifdef __cplusplus
 }

src/memory_pool_tracking.c

@@ -16,9 +16,10 @@
 #include <assert.h>
 #include <stdlib.h>
 
-umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
-                           umf_memory_provider_handle_t provider, void *params,
-                           umf_memory_pool_handle_t *hPool) {
+umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
+                                   umf_memory_provider_handle_t provider,
+                                   void *params,
+                                   umf_memory_pool_handle_t *hPool) {
     if (!ops || !provider || !hPool) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }

test/CMakeLists.txt

@@ -66,8 +66,6 @@ add_umf_test(NAME memoryPool
              SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp)
 add_umf_test(NAME memoryProvider
              SRCS memoryProviderAPI.cpp)
-add_umf_test(NAME memory_pool_internal
-             SRCS memory_pool_internal.cpp)
 
 if(UMF_BUILD_LIBUMF_POOL_DISJOINT)
     add_umf_test(NAME disjointPool

test/c_api/disjoint_pool.c

@@ -13,7 +13,7 @@ void test_disjoint_pool_default_params(void) {
     umf_result_t retp;
     umf_memory_pool_handle_t pool = NULL;
     umf_disjoint_pool_params_t params = umfDisjointPoolParamsDefault();
-    retp = umfPoolCreate(&UMF_DISJOINT_POOL_OPS, provider, &params, &pool);
+    retp = umfPoolCreate(&UMF_DISJOINT_POOL_OPS, provider, &params, 0, &pool);
 
     UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
 
@@ -31,7 +31,7 @@ void test_disjoint_pool_shared_limits(void) {
         umfDisjointPoolSharedLimitsCreate(1024);
     params.SharedLimits = limits;
 
-    retp = umfPoolCreate(&UMF_DISJOINT_POOL_OPS, provider, &params, &pool);
+    retp = umfPoolCreate(&UMF_DISJOINT_POOL_OPS, provider, &params, 0, &pool);
 
     UT_ASSERTeq(retp, UMF_RESULT_SUCCESS);
 

test/common/pool.hpp

@@ -31,7 +31,7 @@ umf_memory_pool_handle_t
 createPoolChecked(umf_memory_pool_ops_t *ops,
                   umf_memory_provider_handle_t hProvider, void *params) {
     umf_memory_pool_handle_t hPool;
-    auto ret = umfPoolCreate(ops, hProvider, params, &hPool);
+    auto ret = umfPoolCreate(ops, hProvider, params, 0, &hPool);
     EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
     return hPool;
 }

test/common/test_helpers.c

@@ -66,7 +66,7 @@ tracePoolCreate(umf_memory_pool_handle_t hUpstreamPool,
 
     umf_memory_pool_handle_t hPool;
     umf_result_t ret =
-        umfPoolCreate(&UMF_TRACE_POOL_OPS, providerDesc, &params, &hPool);
+        umfPoolCreate(&UMF_TRACE_POOL_OPS, providerDesc, &params, 0, &hPool);
 
     (void)ret; /* silence unused variable warning */
     assert(ret == UMF_RESULT_SUCCESS);

test/memoryPoolAPI.cpp

@@ -7,6 +7,7 @@
 #include "poolFixtures.hpp"
 #include "provider.hpp"
 #include "provider_null.h"
+#include "provider_trace.h"
 #include "test_helpers.h"
 
 #include "umf/memory_provider.h"
@@ -101,7 +102,7 @@ TEST_F(test, memoryPoolWithCustomProvider) {
     umf_memory_pool_ops_t pool_ops = umf::poolMakeCOps<pool, void>();
 
     umf_memory_pool_handle_t hPool;
-    auto ret = umfPoolCreate(&pool_ops, hProvider, nullptr, &hPool);
+    auto ret = umfPoolCreate(&pool_ops, hProvider, nullptr, 0, &hPool);
     ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
     ASSERT_NE(hPool, nullptr);
 
@@ -133,28 +134,116 @@ INSTANTIATE_TEST_SUITE_P(mallocMultiPoolTest, umfMultiPoolTest,
                              &PROXY_POOL_OPS, nullptr, &MALLOC_PROVIDER_OPS,
                              nullptr}));
 
-////////////////// Negative test cases /////////////////
+struct umfPoolCreateFlagsTest
+    : umf_test::test,
+      ::testing::WithParamInterface<umf_pool_create_flags_t> {
+    void SetUp() override {
+        test::SetUp();
+        flags = this->GetParam();
+    }
+    umf_pool_create_flags_t flags;
+};
+
+TEST_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsTestSuccess) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t ret =
+        umfMemoryProviderCreate(&UMF_NULL_PROVIDER_OPS, nullptr, &provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    umf_memory_pool_handle_t pool = nullptr;
+    ret = umfPoolCreate(&PROXY_POOL_OPS, provider, nullptr, flags, &pool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(pool, nullptr);
+
+    umfPoolDestroy(pool);
 
-TEST_F(test, poolCreateNullOps) {
+    if (!(flags & UMF_POOL_CREATE_FLAG_OWN_PROVIDER)) {
+        umfMemoryProviderDestroy(provider);
+    }
+}
+
+TEST_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsCountProviderCalls) {
     auto nullProvider = umf_test::wrapProviderUnique(nullProviderCreate());
-    umf_memory_provider_handle_t hProvider = nullProvider.get();
 
-    umf_memory_pool_handle_t hPool;
-    auto ret = umfPoolCreate(nullptr, hProvider, nullptr, &hPool);
+    static std::unordered_map<std::string, size_t> providerCalls;
+    providerCalls.clear();
+    auto traceCb = [](const char *name) { providerCalls[name]++; };
+
+    umf_provider_trace_params_t provider_params = {nullProvider.get(), traceCb};
+
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t ret = umfMemoryProviderCreate(&UMF_TRACE_PROVIDER_OPS,
+                                               &provider_params, &provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    umf_memory_pool_handle_t pool = nullptr;
+    ret = umfPoolCreate(&PROXY_POOL_OPS, provider, nullptr, flags, &pool);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(pool, nullptr);
+
+    size_t provider_call_count = 0;
+
+    umfPoolMalloc(pool, 0);
+    ASSERT_EQ(providerCalls["alloc"], 1);
+    ASSERT_EQ(providerCalls.size(), ++provider_call_count);
+
+    umfPoolFree(pool, 0);
+    ASSERT_EQ(providerCalls["free"], 1);
+    ASSERT_EQ(providerCalls.size(), ++provider_call_count);
+
+    umfPoolCalloc(pool, 0, 0);
+    ASSERT_EQ(providerCalls["alloc"], 2);
+    ASSERT_EQ(providerCalls.size(), provider_call_count);
+
+    umfPoolAlignedMalloc(pool, 0, 0);
+    ASSERT_EQ(providerCalls["alloc"], 3);
+    ASSERT_EQ(providerCalls.size(), provider_call_count);
+
+    umfPoolDestroy(pool);
+
+    if (!(flags & UMF_POOL_CREATE_FLAG_OWN_PROVIDER)) {
+        umfMemoryProviderDestroy(provider);
+    }
+}
+
+INSTANTIATE_TEST_SUITE_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsTest,
+                         ::testing::Values(0,
+                                           UMF_POOL_CREATE_FLAG_OWN_PROVIDER));
+
+////////////////// Negative test cases /////////////////
+
+TEST_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsNullOps) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t ret =
+        umfMemoryProviderCreate(&UMF_NULL_PROVIDER_OPS, nullptr, &provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
+
+    umf_memory_pool_handle_t pool = nullptr;
+    ret = umfPoolCreate(nullptr, provider, nullptr, flags, &pool);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfMemoryProviderDestroy(provider);
 }
 
-TEST_F(test, poolCreateNullPoolHandle) {
-    auto nullProvider = umf_test::wrapProviderUnique(nullProviderCreate());
-    umf_memory_provider_handle_t hProvider = nullProvider.get();
+TEST_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsNullPoolHandle) {
+    umf_memory_provider_handle_t provider = nullptr;
+    umf_result_t ret =
+        umfMemoryProviderCreate(&UMF_NULL_PROVIDER_OPS, nullptr, &provider);
+    ASSERT_EQ(ret, UMF_RESULT_SUCCESS);
+    ASSERT_NE(provider, nullptr);
 
-    auto ret = umfPoolCreate(&PROXY_POOL_OPS, hProvider, nullptr, nullptr);
+    ret = umfPoolCreate(&PROXY_POOL_OPS, provider, nullptr, flags, nullptr);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+
+    umfMemoryProviderDestroy(provider);
 }
 
-TEST_F(test, memoryPoolInvalidProvidersNullptr) {
+TEST_P(umfPoolCreateFlagsTest, umfPoolCreateFlagsInvalidProviders) {
     umf_memory_pool_handle_t hPool;
-    auto ret = umfPoolCreate(&MALLOC_POOL_OPS, nullptr, nullptr, &hPool);
+    auto ret = umfPoolCreate(&MALLOC_POOL_OPS, nullptr, nullptr, flags, &hPool);
     ASSERT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
 }
 
@@ -182,8 +271,8 @@ TEST_P(poolInitializeTest, errorPropagation) {
     umf_memory_pool_ops_t pool_ops = umf::poolMakeCOps<pool, umf_result_t>();
 
     umf_memory_pool_handle_t hPool;
-    auto ret =
-        umfPoolCreate(&pool_ops, hProvider, (void *)&this->GetParam(), &hPool);
+    auto ret = umfPoolCreate(&pool_ops, hProvider, (void *)&this->GetParam(), 0,
+                             &hPool);
     ASSERT_EQ(ret, this->GetParam());
 }