aws_customized_aligned_allocator

include/aws/common/allocator.h

@@ -228,6 +228,21 @@ size_t aws_small_block_allocator_page_size(struct aws_allocator *sba_allocator);
 AWS_COMMON_API
 size_t aws_small_block_allocator_page_size_available(struct aws_allocator *sba_allocator);
 
+/*
+ * Create an aligned allocator with customized alignment.
+ */
+AWS_COMMON_API
+struct aws_allocator *aws_customized_aligned_allocator_new(
+    struct aws_allocator *allocator,
+    size_t customized_alignment);
+
+/*
+ * Destroys a customized aligned allocator instance and frees its memory to the parent allocator. The parent
+ * allocator will otherwise be unaffected.
+ */
+AWS_COMMON_API
+void aws_customized_aligned_allocator_destroy(struct aws_allocator *aligned_alloc);
+
 AWS_EXTERN_C_END
 AWS_POP_SANE_WARNING_LEVEL
 

source/allocator.c

@@ -34,6 +34,11 @@ bool aws_allocator_is_valid(const struct aws_allocator *alloc) {
     return alloc && AWS_OBJECT_PTR_IS_READABLE(alloc) && alloc->mem_acquire && alloc->mem_release;
 }
 
+struct aws_aligned_allocator_impl {
+    struct aws_allocator *allocator;
+    size_t alignment_size;
+};
+
 static void *s_aligned_malloc(struct aws_allocator *allocator, size_t size) {
     (void)allocator;
     /* larger allocations should be aligned so that AVX and friends can avoid
@@ -46,9 +51,15 @@ static void *s_aligned_malloc(struct aws_allocator *allocator, size_t size) {
      * 8 byte alignment for <= page allocations on 32 bit systems
      *
      * We use PAGE_SIZE as the boundary because we are not aware of any allocations of
-     * this size or greater that are not data buffers
+     * this size or greater that are not data buffers.
+     *
+     * Unless there is a customized alignment size.
      */
-    const size_t alignment = sizeof(void *) * (size > (size_t)PAGE_SIZE ? 8 : 2);
+    size_t alignment = sizeof(void *) * (size > (size_t)PAGE_SIZE ? 8 : 2);
+    if (allocator->impl) {
+        struct aws_aligned_allocator_impl *impl = allocator->impl;
+        alignment = impl->alignment_size;
+    }
 #if !defined(_WIN32)
     void *result = NULL;
     int err = posix_memalign(&result, alignment, size);
@@ -168,6 +179,49 @@ struct aws_allocator *aws_aligned_allocator(void) {
     return &aligned_allocator;
 }
 
+struct aws_allocator *aws_customized_aligned_allocator_new(
+    struct aws_allocator *allocator,
+    size_t customized_alignment) {
+    if ((customized_alignment & (customized_alignment - 1)) != 0 || customized_alignment % sizeof(void *) != 0) {
+        /**
+         * the alignment must be a power of two and a multiple of sizeof(void *)
+         */
+        aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        return NULL;
+    }
+
+    struct aws_aligned_allocator_impl *aligned_alloc_impl = NULL;
+    struct aws_allocator *aligned_alloc = NULL;
+    aws_mem_acquire_many(
+        allocator,
+        2,
+        &aligned_alloc_impl,
+        sizeof(struct aws_aligned_allocator_impl),
+        &aligned_alloc,
+        sizeof(struct aws_allocator));
+
+    AWS_ZERO_STRUCT(*aligned_alloc_impl);
+    AWS_ZERO_STRUCT(*aligned_alloc);
+    /* copy the template vtable */
+    *aligned_alloc = aligned_allocator;
+    aligned_alloc->impl = aligned_alloc_impl;
+    aligned_alloc_impl->alignment_size = customized_alignment;
+    aligned_alloc_impl->allocator = allocator;
+    return aligned_alloc;
+}
+
+void aws_customized_aligned_allocator_destroy(struct aws_allocator *aligned_alloc) {
+    if (!aligned_alloc) {
+        return;
+    }
+    struct aws_aligned_allocator_impl *impl = aligned_alloc->impl;
+    if (!impl) {
+        return;
+    }
+    struct aws_allocator *allocator = impl->allocator;
+    aws_mem_release(allocator, impl);
+}
+
 void *aws_mem_acquire(struct aws_allocator *allocator, size_t size) {
     AWS_FATAL_PRECONDITION(allocator != NULL);
     AWS_FATAL_PRECONDITION(allocator->mem_acquire != NULL);

tests/CMakeLists.txt

@@ -327,6 +327,9 @@ add_test_case(default_threaded_reallocs)
 add_test_case(default_threaded_allocs_and_frees)
 add_test_case(aligned_threaded_reallocs)
 add_test_case(aligned_threaded_allocs_and_frees)
+add_test_case(customized_aligned_sanitize)
+add_test_case(customized_aligned_threaded_reallocs)
+add_test_case(customized_aligned_threaded_allocs_and_frees)
 
 add_test_case(test_memtrace_none)
 add_test_case(test_memtrace_count)

tests/alloc_test.c

@@ -350,7 +350,7 @@ static int s_default_threaded_allocs_and_frees(struct aws_allocator *allocator,
 AWS_TEST_CASE(default_threaded_allocs_and_frees, s_default_threaded_allocs_and_frees)
 
 /*
- * No align allocator tests.
+ * aligned allocator tests.
  */
 static int s_aligned_threaded_reallocs(struct aws_allocator *allocator, void *ctx) {
     (void)allocator;
@@ -381,3 +381,59 @@ static int s_aligned_threaded_allocs_and_frees(struct aws_allocator *allocator,
     return 0;
 }
 AWS_TEST_CASE(aligned_threaded_allocs_and_frees, s_aligned_threaded_allocs_and_frees)
+
+static int s_customized_aligned_sanitize(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+
+    struct aws_allocator *aligned_alloc = aws_customized_aligned_allocator_new(allocator, 1);
+    ASSERT_NULL(aligned_alloc);
+    ASSERT_UINT_EQUALS(aws_last_error(), AWS_ERROR_INVALID_ARGUMENT);
+
+    aligned_alloc = aws_customized_aligned_allocator_new(allocator, 3 * sizeof(void *));
+    ASSERT_NULL(aligned_alloc);
+    ASSERT_UINT_EQUALS(aws_last_error(), AWS_ERROR_INVALID_ARGUMENT);
+
+    size_t aligned_size = 1024;
+    aligned_alloc = aws_customized_aligned_allocator_new(allocator, aligned_size);
+    ASSERT_NOT_NULL(aligned_alloc);
+    void *test = aws_mem_acquire(aligned_alloc, sizeof(void *));
+    ASSERT_TRUE((uintptr_t)test % aligned_size == 0);
+    aws_mem_release(aligned_alloc, test);
+
+    aws_customized_aligned_allocator_destroy(aligned_alloc);
+
+    return 0;
+}
+AWS_TEST_CASE(customized_aligned_sanitize, s_customized_aligned_sanitize)
+
+static int s_customized_aligned_threaded_reallocs(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    srand(15);
+    struct aws_allocator *aligned_alloc = aws_customized_aligned_allocator_new(allocator, 512);
+
+    struct aws_allocator *alloc = aws_mem_tracer_new(aligned_alloc, NULL, AWS_MEMTRACE_STACKS, 8);
+
+    s_thread_test(alloc, s_threaded_realloc_worker, alloc);
+
+    aws_mem_tracer_destroy(alloc);
+    aws_customized_aligned_allocator_destroy(aligned_alloc);
+
+    return 0;
+}
+AWS_TEST_CASE(customized_aligned_threaded_reallocs, s_customized_aligned_threaded_reallocs)
+
+static int s_customized_aligned_threaded_allocs_and_frees(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    srand(99);
+    struct aws_allocator *aligned_alloc = aws_customized_aligned_allocator_new(allocator, 512);
+
+    struct aws_allocator *alloc = aws_mem_tracer_new(aligned_alloc, NULL, AWS_MEMTRACE_STACKS, 8);
+
+    s_thread_test(alloc, s_threaded_alloc_worker, alloc);
+
+    aws_mem_tracer_destroy(alloc);
+    aws_customized_aligned_allocator_destroy(aligned_alloc);
+
+    return 0;
+}
+AWS_TEST_CASE(customized_aligned_threaded_allocs_and_frees, s_customized_aligned_threaded_allocs_and_frees)