Remove the disable_provider_free parameter of jemalloc pool

Remove the disable_provider_free parameter of jemalloc pool.
Replace it with the Coarse provider in the example.

Fixes: #904

Signed-off-by: Lukasz Dorau <[email protected]>

Author: ldorau

README.md

@@ -188,9 +188,7 @@ It can be used when large memory mappings are needed.
 
 The DevDax memory provider does not support the free operation
 (`umfMemoryProviderFree()` always returns `UMF_RESULT_ERROR_NOT_SUPPORTED`),
-so it should be used with a pool manager that will take over
-the managing of the provided memory - for example the jemalloc pool
-with the `disable_provider_free` parameter set to true.
+so it should be always used with the Coarse provider.
 
 ##### Requirements
 
@@ -203,9 +201,7 @@ A memory provider that provides memory by mapping a regular, extendable file.
 
 The file memory provider does not support the free operation
 (`umfMemoryProviderFree()` always returns `UMF_RESULT_ERROR_NOT_SUPPORTED`),
-so it should be used with a pool manager that will take over
-the managing of the provided memory - for example the jemalloc pool
-with the `disable_provider_free` parameter set to true.
+so it should be always used with the Coarse provider.
 
 IPC API requires the `UMF_MEM_MAP_SHARED` memory `visibility` mode
 (`UMF_RESULT_ERROR_INVALID_ARGUMENT` is returned otherwise).

examples/dram_and_fsdax/dram_and_fsdax.c

@@ -10,6 +10,7 @@
 #include <string.h>
 
 #include <umf/memory_provider.h>
+#include <umf/providers/provider_coarse.h>
 #include <umf/providers/provider_file_memory.h>
 #include <umf/providers/provider_os_memory.h>
 
@@ -60,20 +61,32 @@ static umf_memory_pool_handle_t create_fsdax_pool(const char *path) {
         return NULL;
     }
 
+    coarse_memory_provider_params_t coarse_params;
+    // make sure there are no undefined members - prevent a UB
+    memset(&coarse_params, 0, sizeof(coarse_params));
+    coarse_params.upstream_memory_provider = provider_fsdax;
+    coarse_params.destroy_upstream_memory_provider = true;
+    coarse_params.immediate_init_from_upstream = true;
+    coarse_params.init_buffer = NULL;
+    coarse_params.init_buffer_size = 8 * 1024 * 1024; // == 8 MB
+
+    umf_memory_provider_handle_t coarse_memory_provider;
+    umf_result = umfMemoryProviderCreate(
+        umfCoarseMemoryProviderOps(), &coarse_params, &coarse_memory_provider);
+    if (umf_result != UMF_RESULT_SUCCESS) {
+        fprintf(stderr, "Failed to create the Coarse provider");
+        return NULL;
+    }
+
     // Create an FSDAX memory pool
     //
     // The file memory provider does not support the free operation
     // (`umfMemoryProviderFree()` always returns `UMF_RESULT_ERROR_NOT_SUPPORTED`),
-    // so it should be used with a pool manager that will take over
-    // the managing of the provided memory - for example the jemalloc pool
-    // with the `disable_provider_free` parameter set to true.
-    umf_jemalloc_pool_params_t pool_params;
-    pool_params.disable_provider_free = true;
+    // so it should be always used with the Coarse provider.
 
     // Create an FSDAX memory pool
-    umf_result =
-        umfPoolCreate(umfJemallocPoolOps(), provider_fsdax, &pool_params,
-                      UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &pool_fsdax);
+    umf_result = umfPoolCreate(umfJemallocPoolOps(), provider_fsdax, NULL,
+                               UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &pool_fsdax);
     if (umf_result != UMF_RESULT_SUCCESS) {
         fprintf(stderr, "Failed to create an FSDAX memory pool!\n");
         umfMemoryProviderDestroy(provider_fsdax);

include/umf/pools/pool_jemalloc.h

@@ -19,7 +19,8 @@ extern "C" {
 
 /// @brief Configuration of Jemalloc Pool
 typedef struct umf_jemalloc_pool_params_t {
-    /// Set to true if umfMemoryProviderFree() should never be called.
+    /// DEPRECATED and unused, will be removed in the next release,
+    /// the Coarse provider should be used instead
     bool disable_provider_free;
 } umf_jemalloc_pool_params_t;
 

src/pool/pool_jemalloc.c

@@ -37,8 +37,6 @@
 typedef struct jemalloc_memory_pool_t {
     umf_memory_provider_handle_t provider;
     unsigned int arena_index; // index of jemalloc arena
-    // set to true if umfMemoryProviderFree() should never be called
-    bool disable_provider_free;
 } jemalloc_memory_pool_t;
 
 static __TLS umf_result_t TLS_last_allocation_error;
@@ -82,9 +80,7 @@ static void *arena_extent_alloc(extent_hooks_t *extent_hooks, void *new_addr,
     }
 
     if (new_addr != NULL && ptr != new_addr) {
-        if (!pool->disable_provider_free) {
-            umfMemoryProviderFree(pool->provider, ptr, size);
-        }
+        umfMemoryProviderFree(pool->provider, ptr, size);
         return NULL;
     }
 
@@ -118,10 +114,6 @@ static void arena_extent_destroy(extent_hooks_t *extent_hooks, void *addr,
 
     jemalloc_memory_pool_t *pool = get_pool_by_arena_index(arena_ind);
 
-    if (pool->disable_provider_free) {
-        return;
-    }
-
     umf_result_t ret;
     ret = umfMemoryProviderFree(pool->provider, addr, size);
     if (ret != UMF_RESULT_SUCCESS) {
@@ -144,10 +136,6 @@ static bool arena_extent_dalloc(extent_hooks_t *extent_hooks, void *addr,
 
     jemalloc_memory_pool_t *pool = get_pool_by_arena_index(arena_ind);
 
-    if (pool->disable_provider_free) {
-        return true; // opt-out from deallocation
-    }
-
     umf_result_t ret;
     ret = umfMemoryProviderFree(pool->provider, addr, size);
     if (ret != UMF_RESULT_SUCCESS) {
@@ -416,12 +404,6 @@ static umf_result_t op_initialize(umf_memory_provider_handle_t provider,
 
     pool->provider = provider;
 
-    if (je_params) {
-        pool->disable_provider_free = je_params->disable_provider_free;
-    } else {
-        pool->disable_provider_free = false;
-    }
-
     unsigned arena_index;
     err = je_mallctl("arenas.create", (void *)&arena_index, &unsigned_size,
                      NULL, 0);