Add base allocator

Add a MT-safe fixed-size-pool base allocator.

Signed-off-by: Lukasz Dorau <[email protected]>

Author: ldorau

.github/workflows/.spellcheck-conf.toml

@@ -1,3 +1,3 @@
 [default]
-# Don't correct the "ASSERTne" word
-extend-ignore-words-re = ["ASSER", "Tne"]
+# Don't correct the following words:
+extend-ignore-words-re = ["ASSER", "Tne", "ba", "BA"]

src/CMakeLists.txt

@@ -9,6 +9,7 @@ add_subdirectory(utils)
 set(UMF_LIBS umf_utils)
 
 set(UMF_SOURCES
+    base_alloc/base_alloc.c
     memory_pool.c
     memory_provider.c
     memory_provider_get_last_failed.c
@@ -19,14 +20,17 @@ set(UMF_SOURCES
 )
 
 set(UMF_SOURCES_LINUX
+    base_alloc/base_alloc_linux.c
     provider/provider_tracking_linux.c
 )
 
 set(UMF_SOURCES_WINDOWS
+    base_alloc/base_alloc_windows.c
     provider/provider_tracking_windows.c
 )
 
 set(UMF_SOURCES_MACOSX
+    base_alloc/base_alloc_linux.c
     provider/provider_tracking_linux.c
 )
 

src/base_alloc/base_alloc.c

@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <assert.h>
+
+#include "base_alloc.h"
+#include "base_alloc_internal.h"
+#include "utils_common.h"
+#include "utils_concurrency.h"
+
+// minimum size of a single pool of the base allocator,
+#define MINIMUM_POOL_SIZE (ba_os_get_page_size())
+
+// minimum number of chunks used to calculate the size of pools
+#define MINIMUM_CHUNK_COUNT (128)
+
+// alignment of the base allocator
+#define MEMORY_ALIGNMENT (8)
+
+typedef struct ba_mem_chunk_t ba_mem_chunk_t;
+
+// memory chunk of size 'chunk_size'
+struct ba_mem_chunk_t {
+    ba_mem_chunk_t *next;
+};
+
+struct umf_ba_pool_meta_t {
+    // address of the beginning of this pool (allocated region)
+    umf_ba_pool_t *pool_addr;
+    // address of the beginning of the next pool (a list of allocated pools to be freed in umf_ba_destroy())
+    umf_ba_pool_t *next_pool;
+
+    // the following fields are set and used only in the main (the first) pool
+    size_t pool_size; // size of each pool (argument of each ba_os_alloc() call)
+    size_t pool_usable_size;   // usable size of each pool
+    size_t chunk_size;         // size of all memory chunks in this pool
+    os_mutex_t *free_lock;     // lock of free_list
+    ba_mem_chunk_t *free_list; // list of free chunks
+};
+
+struct umf_ba_pool_t {
+    struct umf_ba_pool_meta_t metadata;
+    char data[];
+};
+
+// ba_divide_memory_into_chunks - divide given memory into chunks of chunk_size and add them to the free_list
+static void ba_divide_memory_into_chunks(umf_ba_pool_t *pool, void *ptr,
+                                         size_t size) {
+    assert(pool->metadata.free_list == NULL);
+    assert(size > pool->metadata.chunk_size);
+
+    char *pool_memory = ptr;
+    size_t size_left = size;
+
+    ba_mem_chunk_t *current_chunk = (ba_mem_chunk_t *)pool_memory;
+    ba_mem_chunk_t *prev_chunk = current_chunk;
+
+    while (size_left >= pool->metadata.chunk_size) {
+        current_chunk = (ba_mem_chunk_t *)pool_memory;
+        prev_chunk->next = current_chunk;
+
+        pool_memory += pool->metadata.chunk_size;
+        size_left -= pool->metadata.chunk_size;
+        prev_chunk = current_chunk;
+    }
+
+    current_chunk->next = NULL;
+    pool->metadata.free_list = ptr; // address of the first chunk
+}
+
+umf_ba_pool_t *umf_ba_create(size_t size) {
+    size_t chunk_size = align_size(size, MEMORY_ALIGNMENT);
+    size_t mutex_size = align_size(util_mutex_get_size(), MEMORY_ALIGNMENT);
+    size_t metadata_size = offsetof(struct umf_ba_pool_t, data);
+    size_t pool_size =
+        metadata_size + mutex_size + (MINIMUM_CHUNK_COUNT * chunk_size);
+    if (pool_size < MINIMUM_POOL_SIZE) {
+        pool_size = MINIMUM_POOL_SIZE;
+    }
+
+    pool_size = align_size(pool_size, ba_os_get_page_size());
+
+    umf_ba_pool_t *pool = (umf_ba_pool_t *)ba_os_alloc(pool_size);
+    if (!pool) {
+        return NULL;
+    }
+
+    pool->metadata.pool_addr = pool;
+    pool->metadata.pool_size = pool_size;
+    pool->metadata.pool_usable_size = pool_size - metadata_size;
+    pool->metadata.next_pool = NULL; // this is the only pool now
+    pool->metadata.chunk_size = chunk_size;
+
+    char *pool_memory = (char *)&pool->data;
+    size_t size_left = pool->metadata.pool_usable_size;
+
+    // allocate and init free_lock
+    pool->metadata.free_lock = util_mutex_init(pool_memory);
+    if (!pool->metadata.free_lock) {
+        return NULL;
+    }
+
+    pool_memory += mutex_size; // free_lock is here
+    size_left -= mutex_size;   // for free_lock
+
+    pool->metadata.free_list = NULL;
+    ba_divide_memory_into_chunks(pool, pool_memory, size_left);
+
+    return pool;
+}
+
+void *umf_ba_alloc(umf_ba_pool_t *pool) {
+    util_mutex_lock(pool->metadata.free_lock);
+    if (pool->metadata.free_list == NULL) {
+        umf_ba_pool_t *new_pool =
+            (umf_ba_pool_t *)ba_os_alloc(pool->metadata.pool_size);
+        if (!new_pool) {
+            util_mutex_unlock(pool->metadata.free_lock);
+            return NULL;
+        }
+
+        // add the new pool to the list of pools
+        new_pool->metadata.pool_addr = new_pool;
+        new_pool->metadata.next_pool = pool->metadata.next_pool;
+        pool->metadata.next_pool = new_pool;
+
+        ba_divide_memory_into_chunks(pool, &new_pool->data,
+                                     pool->metadata.pool_usable_size);
+    }
+
+    ba_mem_chunk_t *chunk = pool->metadata.free_list;
+    pool->metadata.free_list = pool->metadata.free_list->next;
+    util_mutex_unlock(pool->metadata.free_lock);
+
+    return chunk;
+}
+
+void umf_ba_free(umf_ba_pool_t *pool, void *ptr) {
+    if (ptr == NULL) {
+        return;
+    }
+
+    ba_mem_chunk_t *chunk = (ba_mem_chunk_t *)ptr;
+
+    util_mutex_lock(pool->metadata.free_lock);
+    chunk->next = pool->metadata.free_list;
+    pool->metadata.free_list = chunk;
+    util_mutex_unlock(pool->metadata.free_lock);
+}
+
+void umf_ba_destroy(umf_ba_pool_t *pool) {
+    size_t size = pool->metadata.pool_size;
+    umf_ba_pool_t *current_pool;
+    umf_ba_pool_t *next_pool = pool->metadata.next_pool;
+    while (next_pool) {
+        current_pool = next_pool;
+        next_pool = next_pool->metadata.next_pool;
+        ba_os_free(current_pool->metadata.pool_addr, size);
+    }
+
+    util_mutex_destroy_not_free(pool->metadata.free_lock);
+    ba_os_free(pool, size);
+}

src/base_alloc/base_alloc.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+/* A MT-safe fixed-size-pool base allocator */
+
+#ifndef UMF_BASE_ALLOC_H
+#define UMF_BASE_ALLOC_H 1
+
+#include <stddef.h>
+
+typedef struct umf_ba_pool_t umf_ba_pool_t;
+
+umf_ba_pool_t *umf_ba_create(size_t size);
+void *umf_ba_alloc(umf_ba_pool_t *pool);
+void umf_ba_free(umf_ba_pool_t *pool, void *ptr);
+void umf_ba_destroy(umf_ba_pool_t *pool);
+
+#endif /* UMF_BASE_ALLOC_H */

src/base_alloc/base_alloc_internal.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#ifndef UMF_BASE_ALLOC_INTERNAL_H
+#define UMF_BASE_ALLOC_INTERNAL_H 1
+
+#include <stddef.h>
+
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
+void *ba_os_alloc(size_t size);
+void ba_os_free(void *ptr, size_t size);
+size_t ba_os_get_page_size(void);
+
+#endif /* UMF_BASE_ALLOC_INTERNAL_H */

src/base_alloc/base_alloc_linux.c

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+#include "base_alloc.h"
+
+void *ba_os_alloc(size_t size) {
+    return mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
+                -1, 0);
+}
+
+void ba_os_free(void *ptr, size_t size) { munmap(ptr, size); }
+
+size_t ba_os_get_page_size(void) { return sysconf(_SC_PAGE_SIZE); }

src/base_alloc/base_alloc_windows.c

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <windows.h>
+
+void *ba_os_alloc(size_t size) {
+    return VirtualAlloc(NULL, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+}
+
+void ba_os_free(void *ptr, size_t size) { VirtualFree(ptr, 0, MEM_RELEASE); }
+
+size_t ba_os_get_page_size(void) { return 4096; /* TODO */ }
+
+//
+// TODO:
+// 1) implement ba_os_get_page_size()
+//

test/CMakeLists.txt

@@ -39,6 +39,7 @@ function(add_umf_test)
     target_include_directories(${TEST_TARGET_NAME} PRIVATE
         ${UMF_CMAKE_SOURCE_DIR}/include
         ${UMF_CMAKE_SOURCE_DIR}/src
+        ${UMF_CMAKE_SOURCE_DIR}/src/base_alloc
         ${UMF_TEST_DIR}/common
         ${UMF_TEST_DIR})
 
@@ -109,3 +110,11 @@ if(UMF_BUILD_OS_MEMORY_PROVIDER AND LINUX) # OS-specific functions are implement
                  SRCS provider_os_memory_config.cpp
                  LIBS umf_utils numa)
 endif()
+
+# TODO: add Windows tests
+if(LINUX)
+    # the base_alloc test uses linux pthreads
+    add_umf_test(NAME base_alloc
+                SRCS test_base_alloc.c
+                LIBS umf_utils)
+endif()

test/common/test_helpers.h

@@ -8,6 +8,7 @@
 
 #include <stdarg.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <umf/base.h>
 #include <umf/memory_pool.h>
 #include <umf/memory_provider_ops.h>

test/test_base_alloc.c

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+#include "base_alloc.h"
+#include "test_helpers.h"
+
+#define NTHREADS 10
+#define ITERATIONS 1000
+#define ALLOCATION_SIZE 16
+
+static void *start_routine(void *arg) {
+    unsigned char *ptrs[ITERATIONS];
+    umf_ba_pool_t *pool = (umf_ba_pool_t *)arg;
+
+    long TID = syscall(SYS_gettid);
+
+    for (int i = 0; i < ITERATIONS; i++) {
+        ptrs[i] = umf_ba_alloc(pool);
+        memset(ptrs[i], (i + TID) & 0xFF, ALLOCATION_SIZE);
+    }
+
+    for (int i = 0; i < ITERATIONS; i++) {
+        for (int k = 0; k < ALLOCATION_SIZE; k++) {
+            if (*(ptrs[i] + k) != ((i + TID) & 0xFF)) {
+                fprintf(stderr,
+                        "i = %i k = %i, *(ptrs[i] + k) = %i != ((i + TID) & "
+                        "0xFF) = %li\n",
+                        i, k, *(ptrs[i] + k), ((i + TID) & 0xFF));
+            }
+            assert(*(ptrs[i] + k) == ((i + TID) & 0xFF));
+        }
+        umf_ba_free(pool, ptrs[i]);
+    }
+
+    return NULL;
+}
+
+int main() {
+    pthread_t thread[NTHREADS];
+    umf_ba_pool_t *pool = umf_ba_create(ALLOCATION_SIZE);
+
+    for (int i = 0; i < NTHREADS; i++) {
+        int ret = pthread_create(&thread[i], NULL, start_routine, pool);
+        if (ret) {
+            fprintf(stderr, "pthread_create() failed!\n");
+            UT_ASSERTeq(ret, 0);
+        }
+    }
+
+    for (int i = 0; i < NTHREADS; i++) {
+        void *retval;
+        int ret = pthread_join(thread[i], &retval);
+        if (ret) {
+            fprintf(stderr, "pthread_join() failed!\n");
+            UT_ASSERTeq(ret, 0);
+        }
+    }
+
+    return 0;
+}