feat(pools): Use default params when NULL is passed

Author: KFilipek

include/umf/memory_pool.h

@@ -47,7 +47,7 @@ typedef uint32_t umf_pool_create_flags_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 params pointer to pool-specific parameters, or NULL for defaults
 /// @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.

include/umf/memory_pool_ops.h

@@ -37,7 +37,7 @@ typedef struct umf_memory_pool_ops_t {
     /// @param providers array of memory providers that will be used for coarse-grain allocations.
     ///        Should contain at least one memory provider.
     /// @param numProvider number of elements in the providers array
-    /// @param params pool-specific params
+    /// @param params pool-specific params, or NULL for defaults
     /// @param pool [out] returns pointer to the pool
     /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
     ///

src/pool/pool_disjoint.c

@@ -647,17 +647,26 @@ static void free_slab(void *unused, void *slab) {
 umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
                                       const void *params, void **ppPool) {
     // TODO set defaults when user pass the NULL as params
-    if (!provider || !params || !ppPool) {
+    if (!provider || !ppPool) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    const umf_disjoint_pool_params_t *dp_params = params;
+    const umf_disjoint_pool_params_t *dp_params;
 
-    // min_bucket_size parameter must be a power of 2 for bucket sizes
-    // to generate correctly.
-    if (!dp_params->min_bucket_size ||
-        !IS_POWER_OF_2(dp_params->min_bucket_size)) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    // If params is NULL, use default values
+    umf_disjoint_pool_params_t default_params = {
+        .slab_min_size = 64 * 1024,           // 64KB default
+        .max_poolable_size = 2 * 1024 * 1024, // 2MB default
+        .capacity = 4,                        // default
+        .min_bucket_size = 8,                 // default
+        .cur_pool_size = 0,
+        .pool_trace = 0,
+        .shared_limits = NULL,
+        .name = "disjoint"};
+    if (!params) {
+        dp_params = &default_params;
+    } else {
+        dp_params = params;
     }
 
     disjoint_pool_t *disjoint_pool =

src/pool/pool_jemalloc.c

@@ -431,15 +431,20 @@ static umf_result_t op_initialize(umf_memory_provider_handle_t provider,
 
     extent_hooks_t *pHooks = &arena_extent_hooks;
     size_t unsigned_size = sizeof(unsigned);
-    int n_arenas_set_from_params = 0;
     int err;
-    const umf_jemalloc_pool_params_t *jemalloc_params = params;
+    const umf_jemalloc_pool_params_t *jemalloc_params;
 
-    size_t n_arenas = 0;
-    if (jemalloc_params) {
-        n_arenas = jemalloc_params->n_arenas;
-        n_arenas_set_from_params = 1;
+    // If params is NULL, use default values
+    umf_jemalloc_pool_params_t default_params = {.n_arenas =
+                                                     utils_get_num_cores() * 4};
+
+    if (!params) {
+        jemalloc_params = &default_params;
+    } else {
+        jemalloc_params = params;
     }
+    size_t n_arenas = jemalloc_params->n_arenas;
+    int n_arenas_set_from_params = (params != NULL);
 
     if (n_arenas == 0) {
         n_arenas = utils_get_num_cores() * 4;

src/pool/pool_scalable.c

@@ -275,6 +275,7 @@ static umf_result_t tbb_pool_initialize(umf_memory_provider_handle_t provider,
                                     .keep_all_memory = false,
                                     .reserved = 0};
 
+    // If params is provided, override defaults
     if (params) {
         const umf_scalable_pool_params_t *scalable_params = params;
         policy.granularity = scalable_params->granularity;