Add the umfPoolCreateEx internal function

It creates a pool that owns a memory provider generated from the
provided provider operations.

Author: kswiecicki

src/memory_pool.c

@@ -15,6 +15,37 @@
 #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 (!hPool) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_memory_provider_handle_t provider = NULL;
+    umf_result_t ret =
+        umfMemoryProviderCreate(provider_ops, provider_params, &provider);
+    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;
+
+    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

@@ -30,6 +30,7 @@ umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
     assert(ops->version == UMF_VERSION_CURRENT);
 
     pool->provider = provider;
+    pool->own_provider = false;
 
     pool->ops = *ops;
     ret = ops->initialize(pool->provider, params, &pool->pool_priv);
@@ -44,6 +45,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

@@ -11,9 +11,12 @@
 #define UMF_MEMORY_POOL_INTERNAL_H 1
 
 #include <umf/base.h>
+#include <umf/memory_pool.h>
 #include <umf/memory_pool_ops.h>
 #include <umf/memory_provider.h>
 
+#include <stdbool.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -24,8 +27,16 @@ 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;
 
+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);
+
 #ifdef __cplusplus
 }
 #endif

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);
 }