Add function to get pool name

Author: KFilipek

include/umf/memory_pool.h

@@ -165,6 +165,13 @@ umf_memory_pool_handle_t umfPoolByPtr(const void *ptr);
 umf_result_t umfPoolGetMemoryProvider(umf_memory_pool_handle_t hPool,
                                       umf_memory_provider_handle_t *hProvider);
 
+///
+/// @brief Retrieve name of a given memory \p pool.
+/// @param pool handle to the memory pool
+/// @return pointer to a string containing the name of the \p pool
+///
+const char *umfPoolGetName(umf_memory_pool_handle_t pool);
+
 ///
 /// @brief Set a custom tag on the memory pool that can be later retrieved using umfPoolGetTag.
 /// @param hPool specified memory pool

include/umf/memory_pool_ops.h

@@ -141,6 +141,13 @@ typedef struct umf_memory_pool_ops_t {
     ///
     umf_result_t (*ctl)(void *hPool, int operationType, const char *name,
                         void *arg, umf_ctl_query_type_t queryType);
+
+    ///
+    /// @brief Get the name of the memory pool.
+    /// @param pool pointer to the memory pool
+    /// @return name of the memory pool
+    ///
+    const char *(*get_name)(void *pool);
 } umf_memory_pool_ops_t;
 
 #ifdef __cplusplus

src/libumf.def

@@ -142,3 +142,4 @@ EXPORTS
     umfJemallocPoolParamsCreate
     umfJemallocPoolParamsDestroy
     umfJemallocPoolParamsSetNumArenas
+    umfPoolGetName

src/libumf.map

@@ -142,4 +142,5 @@ UMF_0.12 {
         umfJemallocPoolParamsCreate;
         umfJemallocPoolParamsDestroy;
         umfJemallocPoolParamsSetNumArenas;
+        umfPoolGetName;
 } UMF_0.11;

src/memory_pool.c

@@ -168,6 +168,11 @@ umf_result_t umfPoolGetMemoryProvider(umf_memory_pool_handle_t hPool,
     return UMF_RESULT_SUCCESS;
 }
 
+const char *umfPoolGetName(umf_memory_pool_handle_t pool) {
+    UMF_CHECK((pool != NULL), NULL);
+    return pool->ops.get_name(pool->pool_priv);
+}
+
 umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
                            umf_memory_provider_handle_t provider,
                            const void *params, umf_pool_create_flags_t flags,

src/pool/pool_disjoint.c

@@ -928,6 +928,11 @@ void disjoint_pool_finalize(void *pool) {
     umf_ba_global_free(hPool);
 }
 
+const char *disjoint_pool_get_name(void *pool) {
+    disjoint_pool_t *hPool = (disjoint_pool_t *)pool;
+    return hPool->params.name;
+}
+
 static umf_memory_pool_ops_t UMF_DISJOINT_POOL_OPS = {
     .version = UMF_VERSION_CURRENT,
     .initialize = disjoint_pool_initialize,
@@ -939,6 +944,7 @@ static umf_memory_pool_ops_t UMF_DISJOINT_POOL_OPS = {
     .malloc_usable_size = disjoint_pool_malloc_usable_size,
     .free = disjoint_pool_free,
     .get_last_allocation_error = disjoint_pool_get_last_allocation_error,
+    .get_name = disjoint_pool_get_name,
 };
 
 const umf_memory_pool_ops_t *umfDisjointPoolOps(void) {

test/pools/disjoint_pool.cpp

@@ -12,6 +12,8 @@
 #include "provider.hpp"
 #include "provider_null.h"
 #include "provider_trace.h"
+#include "umf/base.h"
+#include "umf/memory_pool.h"
 
 using umf_test::test;
 using namespace umf_test;
@@ -327,6 +329,54 @@ TEST_F(test, disjointPoolInvalidBucketSize) {
     umfDisjointPoolParamsDestroy(params);
 }
 
+TEST_F(test, disjointPoolName) {
+    umf_disjoint_pool_params_handle_t params = nullptr;
+    umf_result_t res = umfDisjointPoolParamsCreate(&params);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    umf_memory_provider_handle_t provider_handle = nullptr;
+    umf_memory_pool_handle_t pool = NULL;
+
+    struct memory_provider : public umf_test::provider_base_t {
+        umf_result_t expectedResult;
+        umf_result_t alloc(size_t size, size_t alignment, void **ptr) noexcept {
+            *ptr = umf_ba_global_aligned_alloc(size, alignment);
+            return UMF_RESULT_SUCCESS;
+        }
+
+        umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
+            // do the actual free only when we expect the success
+            if (expectedResult == UMF_RESULT_SUCCESS) {
+                umf_ba_global_free(ptr);
+            }
+            return expectedResult;
+        }
+
+        umf_result_t
+        get_min_page_size([[maybe_unused]] void *ptr,
+                          [[maybe_unused]] size_t *pageSize) noexcept {
+            *pageSize = 1024;
+            return UMF_RESULT_SUCCESS;
+        }
+    };
+    umf_memory_provider_ops_t provider_ops =
+        umf_test::providerMakeCOps<memory_provider, void>();
+
+    auto providerUnique =
+        wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));
+
+    provider_handle = providerUnique.get();
+
+    res =
+        umfPoolCreate(umfDisjointPoolOps(), provider_handle, params, 0, &pool);
+    EXPECT_EQ(res, UMF_RESULT_SUCCESS);
+    const char *name = umfPoolGetName(pool);
+    EXPECT_STREQ(name, "disjoint");
+
+    EXPECT_EQ(umfPoolGetName(nullptr), nullptr);
+    umfPoolDestroy(pool);
+    umfDisjointPoolParamsDestroy(params);
+}
+
 INSTANTIATE_TEST_SUITE_P(disjointPoolTests, umfPoolTest,
                          ::testing::Values(poolCreateExtParams{
                              umfDisjointPoolOps(), defaultDisjointPoolConfig,