Add the umfPoolCreateOwning function

... that creates a pool owning the provided memory provider.

Author: kswiecicki

include/umf/memory_pool.h

@@ -141,6 +141,20 @@ umf_memory_pool_handle_t umfPoolByPtr(const void *ptr);
 umf_result_t umfPoolGetMemoryProvider(umf_memory_pool_handle_t hPool,
                                       umf_memory_provider_handle_t *hProvider);
 
+///
+/// \brief Creates a new memory pool that owns the provided memory provider. Upon the
+///        destruction of the memory pool, the associated memory provider will also be destroyed.
+/// \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 hPool [out] handle to the newly created memory pool
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+///
+enum umf_result_t umfPoolCreateOwning(const struct umf_memory_pool_ops_t *ops,
+                                      umf_memory_provider_handle_t provider,
+                                      void *params,
+                                      umf_memory_pool_handle_t *hPool);
+
 #ifdef __cplusplus
 }
 #endif

src/memory_pool.c

@@ -15,6 +15,22 @@
 #include <assert.h>
 #include <stdlib.h>
 
+enum umf_result_t umfPoolCreateOwning(const struct umf_memory_pool_ops_t *ops,
+                                      umf_memory_provider_handle_t provider,
+                                      void *params,
+                                      umf_memory_pool_handle_t *hPool) {
+    umf_memory_pool_handle_t pool = NULL;
+    enum umf_result_t ret = umfPoolCreate(ops, provider, params, &pool);
+    if (ret) {
+        return ret;
+    }
+
+    pool->own_provider = true;
+    *hPool = pool;
+
+    return UMF_RESULT_SUCCESS;
+}
+
 void *umfPoolMalloc(umf_memory_pool_handle_t hPool, size_t size) {
     return hPool->ops.malloc(hPool->pool_priv, size);
 }

src/memory_pool_default.c

@@ -44,6 +44,12 @@ umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
 
 void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
     hPool->ops.finalize(hPool->pool_priv);
+    if (hPool->own_provider) {
+        // Destroy associated memory provider.
+        umf_memory_provider_handle_t hProvider = NULL;
+        umfPoolGetMemoryProvider(hPool, &hProvider);
+        umfMemoryProviderDestroy(hProvider);
+    }
     free(hPool);
 }
 

src/memory_pool_internal.h

@@ -14,6 +14,8 @@
 #include <umf/memory_pool_ops.h>
 #include <umf/memory_provider.h>
 
+#include <stdbool.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -24,6 +26,8 @@ typedef struct umf_memory_pool_t {
 
     // Memory provider used by the pool.
     umf_memory_provider_handle_t provider;
+    // Tells whether memory provider is owned by the pool.
+    bool own_provider;
 } umf_memory_pool_t;
 
 #ifdef __cplusplus

src/memory_pool_tracking.c

@@ -36,6 +36,7 @@ umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
     if (ret != UMF_RESULT_SUCCESS) {
         goto err_provider_create;
     }
+    pool->own_provider = false;
 
     pool->ops = *ops;
     ret = ops->initialize(pool->provider, params, &pool->pool_priv);
@@ -56,6 +57,13 @@ umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
 
 void umfPoolDestroy(umf_memory_pool_handle_t hPool) {
     hPool->ops.finalize(hPool->pool_priv);
+    if (hPool->own_provider) {
+        // Destroy associated memory provider.
+        umf_memory_provider_handle_t hProvider = NULL;
+        umfPoolGetMemoryProvider(hPool, &hProvider);
+        umfMemoryProviderDestroy(hProvider);
+    }
+    // Destroy tracking provider.
     umfMemoryProviderDestroy(hPool->provider);
     free(hPool);
 }