Use libcoarse in the devdax provider

Signed-off-by: Lukasz Dorau <lukasz.dorau@intel.com>

Author: ldorau

src/provider/provider_devdax_memory.c

@@ -58,6 +58,7 @@ umf_result_t umfDevDaxMemoryProviderParamsSetProtection(
 #else // !defined(_WIN32) && !defined(UMF_NO_HWLOC)
 
 #include "base_alloc_global.h"
+#include "coarse.h"
 #include "libumf.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
@@ -74,6 +75,7 @@ typedef struct devdax_memory_provider_t {
     size_t offset;       // offset in the file used for memory mapping
     utils_mutex_t lock;  // lock of ptr and offset
     unsigned protection; // combination of OS-specific protection flags
+    coarse_t *coarse;    // coarse library handle
 } devdax_memory_provider_t;
 
 // DevDax Memory provider settings struct
@@ -133,6 +135,12 @@ devdax_translate_params(umf_devdax_memory_provider_params_t *in_params,
     return UMF_RESULT_SUCCESS;
 }
 
+static umf_result_t devdax_allocation_split_cb(void *provider, void *ptr,
+                                               size_t totalSize,
+                                               size_t firstSize);
+static umf_result_t devdax_allocation_merge_cb(void *provider, void *lowPtr,
+                                               void *highPtr, size_t totalSize);
+
 static umf_result_t devdax_initialize(void *params, void **provider) {
     umf_result_t ret;
 
@@ -161,21 +169,42 @@ static umf_result_t devdax_initialize(void *params, void **provider) {
 
     memset(devdax_provider, 0, sizeof(*devdax_provider));
 
-    ret = devdax_translate_params(in_params, devdax_provider);
+    coarse_params_t coarse_params = {0};
+    coarse_params.provider = devdax_provider;
+    coarse_params.page_size = DEVDAX_PAGE_SIZE_2MB;
+    // The alloc callback is not available in case of the devdax provider
+    // because it is a fixed-size memory provider
+    // and the entire devdax memory is added as a single block
+    // to the coarse library.
+    coarse_params.cb.alloc = NULL;
+    coarse_params.cb.free = NULL; // not available for the devdax provider
+    coarse_params.cb.split = devdax_allocation_split_cb;
+    coarse_params.cb.merge = devdax_allocation_merge_cb;
+
+    coarse_t *coarse = NULL;
+    ret = coarse_new(&coarse_params, &coarse);
     if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("coarse_new() failed");
         goto err_free_devdax_provider;
     }
 
+    devdax_provider->coarse = coarse;
+
+    ret = devdax_translate_params(in_params, devdax_provider);
+    if (ret != UMF_RESULT_SUCCESS) {
+        goto err_coarse_delete;
+    }
+
     devdax_provider->size = in_params->size;
     if (utils_copy_path(in_params->path, devdax_provider->path, PATH_MAX)) {
-        goto err_free_devdax_provider;
+        goto err_coarse_delete;
     }
 
     int fd = utils_devdax_open(in_params->path);
     if (fd == -1) {
         LOG_ERR("cannot open the device DAX: %s", in_params->path);
         ret = UMF_RESULT_ERROR_INVALID_ARGUMENT;
-        goto err_free_devdax_provider;
+        goto err_coarse_delete;
     }
 
     bool is_dax = false;
@@ -189,23 +218,26 @@ static umf_result_t devdax_initialize(void *params, void **provider) {
         LOG_PDEBUG("mapping the devdax failed (path=%s, size=%zu)",
                    in_params->path, devdax_provider->size);
         ret = UMF_RESULT_ERROR_UNKNOWN;
-        goto err_free_devdax_provider;
+        goto err_coarse_delete;
     }
 
     if (!is_dax) {
         LOG_ERR("mapping the devdax with MAP_SYNC failed: %s", in_params->path);
         ret = UMF_RESULT_ERROR_UNKNOWN;
-
-        if (devdax_provider->base) {
-            utils_munmap(devdax_provider->base, devdax_provider->size);
-        }
-
-        goto err_free_devdax_provider;
+        goto err_unmap_devdax;
     }
 
     LOG_DEBUG("devdax memory mapped (path=%s, size=%zu, addr=%p)",
               in_params->path, devdax_provider->size, devdax_provider->base);
 
+    // add the entire devdax memory as a single block
+    ret = coarse_add_memory_fixed(coarse, devdax_provider->base,
+                                  devdax_provider->size);
+    if (ret != UMF_RESULT_SUCCESS) {
+        LOG_ERR("adding memory block failed");
+        goto err_unmap_devdax;
+    }
+
     if (utils_mutex_init(&devdax_provider->lock) == NULL) {
         LOG_ERR("lock init failed");
         ret = UMF_RESULT_ERROR_UNKNOWN;
@@ -217,7 +249,11 @@ static umf_result_t devdax_initialize(void *params, void **provider) {
     return UMF_RESULT_SUCCESS;
 
 err_unmap_devdax:
-    utils_munmap(devdax_provider->base, devdax_provider->size);
+    if (devdax_provider->base) {
+        utils_munmap(devdax_provider->base, devdax_provider->size);
+    }
+err_coarse_delete:
+    coarse_delete(devdax_provider->coarse);
 err_free_devdax_provider:
     umf_ba_global_free(devdax_provider);
     return ret;
@@ -227,78 +263,15 @@ static void devdax_finalize(void *provider) {
     devdax_memory_provider_t *devdax_provider = provider;
     utils_mutex_destroy_not_free(&devdax_provider->lock);
     utils_munmap(devdax_provider->base, devdax_provider->size);
+    coarse_delete(devdax_provider->coarse);
     umf_ba_global_free(devdax_provider);
 }
 
-static int devdax_alloc_aligned(size_t length, size_t alignment, void *base,
-                                size_t size, utils_mutex_t *lock,
-                                void **out_addr, size_t *offset) {
-    assert(out_addr);
-
-    if (utils_mutex_lock(lock)) {
-        LOG_ERR("locking file offset failed");
-        return -1;
-    }
-
-    uintptr_t ptr = (uintptr_t)base + *offset;
-    uintptr_t rest_of_div = alignment ? (ptr % alignment) : 0;
-
-    if (alignment > 0 && rest_of_div > 0) {
-        ptr += alignment - rest_of_div;
-    }
-
-    size_t new_offset = ptr - (uintptr_t)base + length;
-
-    if (new_offset > size) {
-        utils_mutex_unlock(lock);
-        LOG_ERR("cannot allocate more memory than the device DAX size: %zu",
-                size);
-        return -1;
-    }
-
-    *offset = new_offset;
-    *out_addr = (void *)ptr;
-
-    utils_mutex_unlock(lock);
-
-    return 0;
-}
-
 static umf_result_t devdax_alloc(void *provider, size_t size, size_t alignment,
                                  void **resultPtr) {
-    int ret;
-
-    // alignment must be a power of two and a multiple or a divider of the page size
-    if (alignment && ((alignment & (alignment - 1)) ||
-                      ((alignment % DEVDAX_PAGE_SIZE_2MB) &&
-                       (DEVDAX_PAGE_SIZE_2MB % alignment)))) {
-        LOG_ERR("wrong alignment: %zu (not a power of 2 or a multiple or a "
-                "divider of the page size (%zu))",
-                alignment, DEVDAX_PAGE_SIZE_2MB);
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
-    if (IS_NOT_ALIGNED(alignment, DEVDAX_PAGE_SIZE_2MB)) {
-        alignment = ALIGN_UP(alignment, DEVDAX_PAGE_SIZE_2MB);
-    }
-
     devdax_memory_provider_t *devdax_provider =
         (devdax_memory_provider_t *)provider;
-
-    void *addr = NULL;
-    errno = 0;
-    ret = devdax_alloc_aligned(size, alignment, devdax_provider->base,
-                               devdax_provider->size, &devdax_provider->lock,
-                               &addr, &devdax_provider->offset);
-    if (ret) {
-        devdax_store_last_native_error(UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED, 0);
-        LOG_ERR("memory allocation failed");
-        return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
-    }
-
-    *resultPtr = addr;
-
-    return UMF_RESULT_SUCCESS;
+    return coarse_alloc(devdax_provider->coarse, size, alignment, resultPtr);
 }
 
 static void devdax_get_last_native_error(void *provider, const char **ppMessage,
@@ -384,6 +357,14 @@ static const char *devdax_get_name(void *provider) {
 static umf_result_t devdax_allocation_split(void *provider, void *ptr,
                                             size_t totalSize,
                                             size_t firstSize) {
+    devdax_memory_provider_t *devdax_provider =
+        (devdax_memory_provider_t *)provider;
+    return coarse_split(devdax_provider->coarse, ptr, totalSize, firstSize);
+}
+
+static umf_result_t devdax_allocation_split_cb(void *provider, void *ptr,
+                                               size_t totalSize,
+                                               size_t firstSize) {
     (void)provider;
     (void)ptr;
     (void)totalSize;
@@ -393,6 +374,14 @@ static umf_result_t devdax_allocation_split(void *provider, void *ptr,
 
 static umf_result_t devdax_allocation_merge(void *provider, void *lowPtr,
                                             void *highPtr, size_t totalSize) {
+    devdax_memory_provider_t *devdax_provider =
+        (devdax_memory_provider_t *)provider;
+    return coarse_merge(devdax_provider->coarse, lowPtr, highPtr, totalSize);
+}
+
+static umf_result_t devdax_allocation_merge_cb(void *provider, void *lowPtr,
+                                               void *highPtr,
+                                               size_t totalSize) {
     (void)provider;
     (void)lowPtr;
     (void)highPtr;

test/provider_devdax_memory.cpp

@@ -237,30 +237,29 @@ TEST_P(umfProviderTest, purge_force) {
 
 TEST_P(umfProviderTest, alloc_page64_align_page_minus_1_WRONG_ALIGNMENT_1) {
     test_alloc_failure(provider.get(), page_plus_64, page_size - 1,
-                       UMF_RESULT_ERROR_INVALID_ARGUMENT, 0);
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
 }
 
 TEST_P(umfProviderTest, alloc_page64_align_one_half_pages_WRONG_ALIGNMENT_2) {
     test_alloc_failure(provider.get(), page_plus_64,
                        page_size + (page_size / 2),
-                       UMF_RESULT_ERROR_INVALID_ARGUMENT, 0);
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
 }
 
 TEST_P(umfProviderTest, alloc_page64_WRONG_ALIGNMENT_3_pages) {
     test_alloc_failure(provider.get(), page_plus_64, 3 * page_size,
-                       UMF_RESULT_ERROR_INVALID_ARGUMENT, 0);
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
 }
 
 TEST_P(umfProviderTest, alloc_3_pages_WRONG_ALIGNMENT_3_pages) {
     test_alloc_failure(provider.get(), 3 * page_size, 3 * page_size,
-                       UMF_RESULT_ERROR_INVALID_ARGUMENT, 0);
+                       UMF_RESULT_ERROR_INVALID_ALIGNMENT, 0);
 }
 
 TEST_P(umfProviderTest, alloc_WRONG_SIZE) {
     size_t size = (size_t)(-1) & ~(page_size - 1);
     test_alloc_failure(provider.get(), size, 0,
-                       UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC,
-                       UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED);
+                       UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY, 0);
 }
 
 // other positive tests