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

@@ -98,7 +98,7 @@ jobs:
       run: >
         UMF_LOG="level:warning;flush:debug;output:stderr;pid:no"
         LD_LIBRARY_PATH=${{github.workspace}}/latest_version/build/lib/
-        ctest --verbose
+        ctest --verbose -E test_disjoint_pool
 
     # Browse all folders in the examples directory, build them using the 
     # latest UMF version, and run them, excluding those in the exclude list.
@@ -221,9 +221,18 @@ jobs:
     - name: Run "tag" UMF tests with latest UMF libs (warnings enabled)
       working-directory: ${{github.workspace}}/tag_version/build
       run: |
-        $env:UMF_LOG="level:warning;flush:debug;output:stderr;pid:no" 
+        $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
+        # test_disjoint_pool tests also internals and we want to skip them during compatibility check
+        ctest -C Debug --verbose -E test_disjoint_pool
+
+    - name: Run disabled tests individually with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      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
+        # Run the test_disjoint_pool with the latest UMF libs, excluding disjoint pool internals
+        ./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.
@@ -364,7 +373,16 @@ jobs:
       run: >
         UMF_LOG="level:warning;flush:debug;output:stderr;pid:no"
         LD_LIBRARY_PATH=${{github.workspace}}/latest_version/build/lib/
-        ctest --verbose
+        # test_disjoint_pool tests also internals and we want to skip them during compatibility check
+        ctest --verbose -E test_disjoint_pool
+
+    - name: Run disabled tests individually with latest UMF libs (warnings enabled)
+      working-directory: ${{github.workspace}}/tag_version/build
+      run: >
+        UMF_LOG="level:warning;flush:debug;output:stderr;pid:no"
+        LD_LIBRARY_PATH=${{github.workspace}}/tag_version/build/lib/
+        # Run the test_disjoint_pool with the latest UMF libs, excluding disjoint pool internals
+        ./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_ops.h

@@ -36,6 +36,9 @@ typedef struct umf_memory_pool_ops_t {
 
     ///
     /// @brief Initializes memory pool.
+    /// /details
+    /// * The memory pool implementation *must* allocate the memory pool structure
+    ///        and return it by the \p pool parameter.
     /// @param provider memory provider that will be used for coarse-grain allocations.
     /// @param params pool-specific params, or NULL for defaults
     /// @param pool [out] returns pointer to the pool
@@ -185,7 +188,23 @@ typedef struct umf_memory_pool_ops_t {
     /// @return UMF_RESULT_SUCCESS on success or appropriate error code on
     ///         failure.
     ///
+
     umf_result_t (*ext_trim_memory)(void *pool, size_t minBytesToKeep);
+    ///
+    /// @brief Post-initializes and set up memory pool.
+    ///
+    /// \details
+    /// * This function must be implemented if the pool/provider supports CTL that overrides defaults
+    /// * This function *must* be called after the memory pool has been allocated in initialize function
+    ///        and is used to perform any additional setup required by the memory pool.
+    /// * This function *may* be used to set up any additional resources required by the memory pool.
+    /// * This function *may* be used to set up default values for the memory pool parameters set up by CTL.
+    ///
+    /// @param pool pointer to the pool
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure
+    ///
+    umf_result_t (*ext_post_initialize)(void *pool);
+
 } umf_memory_pool_ops_t;
 
 #ifdef __cplusplus

include/umf/memory_provider_ops.h

@@ -21,7 +21,7 @@ extern "C" {
 /// @brief Version of the Memory Provider ops structure.
 /// NOTE: This is equal to the latest UMF version, in which the ops structure
 /// has been modified.
-#define UMF_PROVIDER_OPS_VERSION_CURRENT UMF_MAKE_VERSION(1, 0)
+#define UMF_PROVIDER_OPS_VERSION_CURRENT UMF_MAKE_VERSION(1, 1)
 
 ///
 /// @brief This structure comprises function pointers used by corresponding
@@ -278,6 +278,14 @@ typedef struct umf_memory_provider_ops_t {
                             const char *name, void *arg, size_t size,
                             umf_ctl_query_type_t queryType, va_list args);
 
+    ///
+    /// @brief Post-initializes memory provider.
+    /// @param params provider-specific params, or NULL for defaults
+    /// @param provider pointer to the provider
+    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+    ///
+    umf_result_t (*ext_post_initialize)(const void *params, void *provider);
+
 } umf_memory_provider_ops_t;
 
 #ifdef __cplusplus

src/memory_pool.c

@@ -219,6 +219,12 @@ static umf_result_t umfDefaultTrimMemory(void *provider,
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
+static umf_result_t
+umfDefaultExtPostInitialize(void *pool) {
+    (void)pool;
+    return UMF_RESULT_SUCCESS;
+}
+
 // 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;
@@ -251,7 +257,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 "
@@ -303,13 +308,17 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
         pool->ops.ext_trim_memory = umfDefaultTrimMemory;
     }
 
+    if (NULL == pool->ops.ext_post_initialize) {
+        pool->ops.ext_post_initialize = umfDefaultExtPostInitialize;
+    }
+
     if (NULL == utils_mutex_init(&pool->lock)) {
         LOG_ERR("Failed to initialize mutex for pool");
         ret = UMF_RESULT_ERROR_UNKNOWN;
         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;
     }
@@ -335,7 +344,15 @@ static umf_result_t umfPoolCreateInternal(const umf_memory_pool_ops_t *ops,
         }
     }
 
+    ret =
+        pool->ops.ext_post_initialize(pool->pool_priv);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to post-initialize pool");
+        goto err_pool_init;
+    }
+
     *hPool = pool;
+
     LOG_INFO("Memory pool created: %p", (void *)pool);
     return UMF_RESULT_SUCCESS;
 

src/memory_provider.c

@@ -11,6 +11,7 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include <umf/base.h>
 #include <umf/memory_provider.h>
@@ -119,6 +120,13 @@ static umf_result_t umfDefaultCloseIPCHandle(void *provider, void *ptr,
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
+static umf_result_t umfDefaultPostInitialize(const void *params,
+                                             void *provider) {
+    (void)params;
+    (void)provider;
+    return UMF_RESULT_SUCCESS;
+}
+
 static umf_result_t
 umfDefaultCtlHandle(void *provider, umf_ctl_query_source_t operationType,
                     const char *name, void *arg, size_t size,
@@ -153,6 +161,10 @@ void assignOpsExtDefaults(umf_memory_provider_ops_t *ops) {
     if (!ops->ext_ctl) {
         ops->ext_ctl = umfDefaultCtlHandle;
     }
+
+    if (!ops->ext_post_initialize) {
+        ops->ext_post_initialize = umfDefaultPostInitialize;
+    }
 }
 
 void assignOpsIpcDefaults(umf_memory_provider_ops_t *ops) {
@@ -224,10 +236,24 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
+    umf_memory_provider_ops_t compatible_ops;
     if (ops->version != UMF_PROVIDER_OPS_VERSION_CURRENT) {
         LOG_WARN("Memory Provider ops version \"%d\" is different than the "
                  "current version \"%d\"",
                  ops->version, UMF_PROVIDER_OPS_VERSION_CURRENT);
+        memset(&compatible_ops, 0, sizeof(compatible_ops));
+        if (UMF_MINOR_VERSION(ops->version) == 0) {
+            LOG_INFO("Detected 1.0 version of Memory Pool ops, "
+                     "upgrading to current version");
+            memcpy(&compatible_ops, ops,
+                   offsetof(umf_memory_provider_ops_t, ext_post_initialize));
+        } else {
+            LOG_ERR("Memory Provider ops unknown version, which \"%d\" is not "
+                    "supported",
+                    ops->version);
+            return UMF_RESULT_ERROR_NOT_SUPPORTED;
+        }
+        ops = &compatible_ops;
     }
 
     umf_memory_provider_handle_t provider =
@@ -250,6 +276,14 @@ umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
 
     provider->provider_priv = provider_priv;
 
+    ret = provider->ops.ext_post_initialize(params, provider_priv);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("Failed to post-initialize provider");
+        provider->ops.finalize(provider_priv);
+        umf_ba_global_free(provider);
+        return ret;
+    }
+
     *hProvider = provider;
 
     return UMF_RESULT_SUCCESS;

src/pool/pool_disjoint.c

@@ -758,6 +758,15 @@ 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;
@@ -816,13 +825,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:
@@ -841,7 +848,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;
 }
 
@@ -1188,7 +1194,7 @@ static umf_memory_pool_ops_t UMF_DISJOINT_POOL_OPS = {
     .get_name = disjoint_pool_get_name,
     .ext_ctl = disjoint_pool_ctl,
     .ext_trim_memory = disjoint_pool_trim_memory,
-};
+    .ext_post_initialize = disjoint_pool_post_initialize};
 
 const umf_memory_pool_ops_t *umfDisjointPoolOps(void) {
     return &UMF_DISJOINT_POOL_OPS;