add post-initialize function to pools and providers

Split between initialize and post-initialize function is necessary
for properly handling CTL defaults.

Author: KFilipek

.github/workflows/reusable_compatibility.yml

@@ -102,8 +102,16 @@ jobs:
         UMF_LOG: level:warning;flush:debug;output:stderr;pid:no
         LD_LIBRARY_PATH: ${{github.workspace}}/latest_version/build/lib/
       run: |
-        ctest --verbose -E "test_memoryProvider"
+        ctest --verbose -E "test_memoryProvider|test_disjoint_pool"
+
+    - name: Run disabled tests individually with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      env:
+        UMF_LOG: level:warning;flush:debug;output:stderr;pid:no
+        LD_LIBRARY_PATH: ${{github.workspace}}/latest_version/build/lib/
+      run: |
         test/test_memoryProvider --gtest_filter="-*Trace"
+        test/test_disjoint_pool --gtest_filter="-test.internals"
 
     # Browse all folders in the examples directory, build them using the 
     # latest UMF version, and run them, excluding those in the exclude list.
@@ -228,10 +236,12 @@ jobs:
       env:
         UMF_LOG: level:warning;flush:debug;output:stderr;pid:no
       run: |
+        $env:UMF_LOG="level:warning;flush:debug;output:stderr;pid:no"
         cp ${{github.workspace}}/latest_version/build/bin/Debug/umf.dll ${{github.workspace}}/tag_version/build/bin/Debug/umf.dll
-        ctest -C Debug --verbose -E "test_memoryProvider"
+        ctest -C Debug --verbose -E "test_memoryProvider|test_disjoint_pool"
         $env:Path = "${{github.workspace}}/tag_version/build/bin/Debug;${{env.VCPKG_BIN_PATH}};$env:Path"
         test/Debug/test_memoryProvider.exe --gtest_filter="-*Trace"
+        test/Debug/test_disjoint_pool.exe --gtest_filter="-test.internals"
 
     # Browse all folders in the examples directory, build them using the 
     # latest UMF version, and run them, excluding those in the exclude list.
@@ -373,8 +383,16 @@ jobs:
         UMF_LOG: level:warning;flush:debug;output:stderr;pid:no
         LD_LIBRARY_PATH: ${{github.workspace}}/latest_version/build/lib/
       run: |
-        ctest --verbose -E "test_memoryProvider"
+        ctest --verbose -E "test_memoryProvider|test_disjoint_pool"
+
+    - name: Run disabled tests individually with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      env:
+        UMF_LOG: level:warning;flush:debug;output:stderr;pid:no
+        LD_LIBRARY_PATH: ${{github.workspace}}/latest_version/build/lib/
+      run: |
         test/test_memoryProvider --gtest_filter="-*Trace"
+        test/test_disjoint_pool --gtest_filter="-test.internals"
 
     # Browse all folders in the examples directory, build them using the 
     # latest UMF version, and run them, excluding those in the exclude list.

include/umf/memory_pool.h

@@ -43,7 +43,7 @@ typedef enum umf_pool_create_flag_t {
 /// @brief Type for combinations of pool creation flags
 typedef uint32_t umf_pool_create_flags_t;
 
-///
+/// @anchor umfPoolCreate
 /// @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.

include/umf/memory_pool_ops.h

@@ -191,6 +191,7 @@ typedef struct umf_memory_pool_ops_t {
     ///         failure.
     ///
     umf_result_t (*ext_trim_memory)(void *pool, size_t minBytesToKeep);
+
 } umf_memory_pool_ops_t;
 
 #ifdef __cplusplus

include/umf/memory_provider_ops.h

@@ -307,6 +307,7 @@ typedef struct umf_memory_provider_ops_t {
         void *provider, const void *ptr,
         umf_memory_property_id_t memory_property_id, void *property_value);
 
+    ///
     /// @brief Retrieve size of the provider-specific properties of the memory
     ///        allocation.
     /// \details

src/memory_pool.c

@@ -10,6 +10,7 @@
 #include <assert.h>
 #include <stdint.h>
 #include <string.h>
+#include <stdarg.h>
 
 #include <umf/base.h>
 #include <umf/memory_pool.h>
@@ -372,6 +373,20 @@ static umf_result_t umfDefaultTrimMemory(void *provider,
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
+static umf_result_t umfPoolPostInitialize(const umf_memory_pool_ops_t *ops,
+                                          void *pool_priv, ...) {
+    va_list args;
+    va_start(args, pool_priv);
+    umf_result_t ret = ops->ext_ctl(pool_priv, CTL_QUERY_PROGRAMMATIC,
+                                    "post_initialize", NULL, 0,
+                                    CTL_QUERY_RUNNABLE, args);
+    va_end(args);
+    if (ret == UMF_RESULT_ERROR_INVALID_ARGUMENT) {
+        ret = UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+    return ret;
+}
+
 // logical sum (OR) of all umf_pool_create_flags_t flags
 static const umf_pool_create_flags_t UMF_POOL_CREATE_FLAG_ALL =
     UMF_POOL_CREATE_FLAG_OWN_PROVIDER | UMF_POOL_CREATE_FLAG_DISABLE_TRACKING;
@@ -393,7 +408,6 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
     }
 
     umf_result_t ret = UMF_RESULT_SUCCESS;
-
     umf_memory_pool_ops_t compatible_ops;
     if (ops->version != UMF_POOL_OPS_VERSION_CURRENT) {
         LOG_WARN("Memory Pool ops version \"%d\" is different than the current "
@@ -402,8 +416,8 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
 
         // Create a new ops compatible structure with the current version
         memset(&compatible_ops, 0, sizeof(compatible_ops));
-        if (UMF_MINOR_VERSION(ops->version) == 0) {
-            LOG_INFO("Detected 1.0 version of Memory Pool ops, "
+        if (ops->version < UMF_MAKE_VERSION(1, 1)) {
+            LOG_INFO("Detected 1.0 version or below of Memory Pool ops, "
                      "upgrading to current version");
             memcpy(&compatible_ops, ops,
                    offsetof(umf_memory_pool_ops_t, ext_trim_memory));
@@ -451,7 +465,7 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
         goto err_lock_init;
     }
 
-    ret = ops->initialize(pool->provider, params, &pool->pool_priv);
+    ret = pool->ops.initialize(pool->provider, params, &pool->pool_priv);
     if (ret != UMF_RESULT_SUCCESS) {
         goto err_pool_init;
     }
@@ -467,6 +481,12 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
 
     ctl_default_apply(pool_default_list, pname, ops->ext_ctl, pool->pool_priv);
 
+    ret = umfPoolPostInitialize(ops, pool->pool_priv);
+    if (ret != UMF_RESULT_SUCCESS && ret != UMF_RESULT_ERROR_NOT_SUPPORTED) {
+        LOG_ERR("Failed to post-initialize pool");
+        goto err_pool_init;
+    }
+
     *hPool = pool;
     pools_by_name_add(pool);
 

src/memory_provider.c

@@ -12,6 +12,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdarg.h>
 
 #include <umf/base.h>
 #include <umf/memory_provider.h>
@@ -205,6 +206,7 @@ void assignOpsExtDefaults(umf_memory_provider_ops_t *ops) {
         ops->ext_get_allocation_properties_size =
             umfDefaultGetAllocationPropertiesSize;
     }
+
 }
 
 void assignOpsIpcDefaults(umf_memory_provider_ops_t *ops) {
@@ -229,6 +231,20 @@ void assignOpsIpcDefaults(umf_memory_provider_ops_t *ops) {
     }
 }
 
+static umf_result_t umfProviderPostInitialize(umf_memory_provider_ops_t *ops,
+                                              void *provider_priv, ...) {
+    va_list args;
+    va_start(args, provider_priv);
+    umf_result_t ret = ops->ext_ctl(provider_priv, CTL_QUERY_PROGRAMMATIC,
+                                    "post_initialize", NULL, 0,
+                                    CTL_QUERY_RUNNABLE, args);
+    va_end(args);
+    if (ret == UMF_RESULT_ERROR_INVALID_ARGUMENT) {
+        ret = UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+    return ret;
+}
+
 #define CHECK_OP(ops, fn)                                                      \
     if (!(ops)->fn) {                                                          \
         LOG_ERR("missing function pointer: %s\n", #fn);                        \
@@ -338,6 +354,12 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
         ctl_default_apply(provider_default_list, pname, provider->ops.ext_ctl,
                           provider->provider_priv);
     }
+    ret = umfProviderPostInitialize(&provider->ops, provider_priv);
+    if (ret != UMF_RESULT_SUCCESS && ret != UMF_RESULT_ERROR_NOT_SUPPORTED) {
+        LOG_ERR("Failed to post-initialize provider");
+        umf_ba_global_free(provider);
+        return ret;
+    }
 
     *hProvider = provider;
 

src/pool/pool_disjoint.c

@@ -33,6 +33,17 @@ static char *DEFAULT_NAME = "disjoint";
 struct ctl disjoint_ctl_root;
 static UTIL_ONCE_FLAG ctl_initialized = UTIL_ONCE_FLAG_INIT;
 
+umf_result_t disjoint_pool_post_initialize(void *ppPool);
+static umf_result_t CTL_RUNNABLE_HANDLER(post_initialize)(
+    void *ctx, umf_ctl_query_source_t source, void *arg, size_t size,
+    umf_ctl_index_utlist_t *indexes) {
+    (void)source;
+    (void)arg;
+    (void)size;
+    (void)indexes;
+    return disjoint_pool_post_initialize(ctx);
+}
+
 // Disable name ctl for 1.0 release
 #if 0
 static umf_result_t CTL_READ_HANDLER(name)(void *ctx,
@@ -326,6 +337,13 @@ static void initialize_disjoint_ctl(void) {
     // TODO: this is hack. Need some way to register module as node with argument
     disjoint_ctl_root.root[disjoint_ctl_root.first_free - 1].arg =
         &CTL_ARG(buckets);
+    disjoint_ctl_root.root[disjoint_ctl_root.first_free++] =
+        (umf_ctl_node_t){
+            .name = "post_initialize",
+            .type = CTL_NODE_LEAF,
+            .runnable_cb =
+                CTL_RUNNABLE_HANDLER(post_initialize),
+        };
 }
 
 umf_result_t disjoint_pool_ctl(void *hPool,
@@ -930,6 +948,14 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
     disjoint_pool->provider = provider;
     disjoint_pool->params = *dp_params;
 
+    *ppPool = (void *)disjoint_pool;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t disjoint_pool_post_initialize(void *ppPool) {
+    disjoint_pool_t *disjoint_pool = (disjoint_pool_t *)ppPool;
+
     disjoint_pool->known_slabs = critnib_new(free_slab, NULL);
     if (disjoint_pool->known_slabs == NULL) {
         goto err_free_disjoint_pool;
@@ -988,13 +1014,11 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
     }
 
     umf_result_t ret = umfMemoryProviderGetMinPageSize(
-        provider, NULL, &disjoint_pool->provider_min_page_size);
+        disjoint_pool->provider, NULL, &disjoint_pool->provider_min_page_size);
     if (ret != UMF_RESULT_SUCCESS) {
         disjoint_pool->provider_min_page_size = 0;
     }
 
-    *ppPool = (void *)disjoint_pool;
-
     return UMF_RESULT_SUCCESS;
 
 err_free_buckets:
@@ -1013,7 +1037,6 @@ umf_result_t disjoint_pool_initialize(umf_memory_provider_handle_t provider,
 
 err_free_disjoint_pool:
     umf_ba_global_free(disjoint_pool);
-
     return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
 }