From f6a8686b2c209b0e25cd64a587d6e9fb55200ec4 Mon Sep 17 00:00:00 2001 From: Andrew Opalach Date: Mon, 31 Mar 2025 17:47:38 -0400 Subject: all: Revert and add some style changes Signed-off-by: Andrew Opalach --- src/array.c | 194 +++++++++++++++++++++++------------------------------- src/lib.c | 56 +++++----------- src/ring_buffer.c | 40 ++++------- 3 files changed, 108 insertions(+), 182 deletions(-) (limited to 'src') diff --git a/src/array.c b/src/array.c index 0019a63..46d7951 100644 --- a/src/array.c +++ b/src/array.c @@ -14,118 +14,91 @@ #define al_array_init(array) ((array).count = 0, (array).alloc = 0, (array).data = NULL) -#define al_array_offset(array, n) ((array).data + (n)) #define al_array_at(array, i) ((array).data[i]) #define al_array_last(array) al_array_at(array, (array).count - 1) +#define al_array_offset(array, n) ((array).data + (n)) #define al_array_item_size(array) sizeof(*(array).data) // NOLINT(bugprone-sizeof-expression) #define al_array_reserve(array, count) \ ((array).alloc = _al_array_reserve((void **)&(array).data, (array).alloc, ((count) * al_array_item_size(array)))) -#define al_array_clone(dest, src) \ -AL_MACRO_WRAP \ -{ \ - al_array_init(dest); \ - al_array_reserve(dest, (src).count); \ - (dest).count = (src).count; \ - al_memcpy(al_array_offset(dest, 0), al_array_offset(src, 0), \ - al_array_item_size(dest) * (dest).count); \ -} AL_MACRO_END - -#define al_array_copy(dest, src) \ -AL_MACRO_WRAP \ -{ \ - al_array_reserve(dest, (src).count); \ - (dest).count = (src).count; \ - al_memcpy(al_array_offset(dest, 0), al_array_offset(src, 0), \ - al_array_item_size(dest) * (dest).count); \ -} AL_MACRO_END - -#define al_array_push(array, item) \ -AL_MACRO_WRAP \ -{ \ - al_array_reserve(array, (array).count + 1); \ - __typeof__(item) v = item; \ - (void)((array).data == &v); \ - al_array_at(array, (array).count++) = v; \ -} AL_MACRO_END - -#define al_array_insert(array, i, item) \ -AL_MACRO_WRAP \ -{ \ - al_array_reserve(array, (array).count + 1); \ - if (i != (array).count - 1) { \ - al_memmove(al_array_offset(array, i + 1), al_array_offset(array, i), \ - al_array_item_size(array) * ((array).count - i)); \ - } \ - (array).count++; \ - __typeof__(item) v = item; \ - (void)((array).data == &v); \ - al_array_at(array, i) = v; \ -} AL_MACRO_END +#define al_array_copy(dest, src) \ + do { \ + al_array_reserve(dest, (src).count); \ + (dest).count = (src).count; \ + al_memcpy(al_array_offset(dest, 0), al_array_offset(src, 0), \ + al_array_item_size(dest) * (dest).count); \ + } while (0) + +#define al_array_push(array, item) \ + do { \ + al_array_reserve(array, (array).count + 1); \ + al_array_at(array, (array).count++) = item; \ + } while (0) + +#define al_array_insert(array, i, item) \ + do { \ + al_array_reserve(array, (array).count + 1); \ + if (i != (array).count - 1) { \ + al_memmove(al_array_offset(array, i + 1), al_array_offset(array, i), \ + al_array_item_size(array) * ((array).count - i)); \ + } \ + (array).count++; \ + al_array_at(array, i) = item; \ + } while (0) #define al_array_pop(array) al_array_at(array, --(array).count) -#define al_array_pop_at(array, i, r) \ -AL_MACRO_WRAP \ -{ \ - r = al_array_at(array, i); \ - al_array_remove_at(array, i); \ -} AL_MACRO_END - -#define al_array_remove(array, elem) \ -AL_MACRO_WRAP \ -{ \ - for (u32 i = 0; i < (array).count; i++) { \ - if (al_array_at(array, i) == elem) { \ - al_array_remove_at(array, i); \ - break; \ - } \ - } \ -} AL_MACRO_END - -#define al_array_remove_checked(array, elem, removed) \ -AL_MACRO_WRAP \ -{ \ - removed = false; \ - for (u32 i = 0; i < (array).count; i++) { \ - if (al_array_at(array, i) == elem) { \ - al_array_remove_at(array, i); \ - removed = true; \ - break; \ - } \ - } \ -} AL_MACRO_END - -#define al_array_remove_all(array, elem) \ -AL_MACRO_WRAP \ -{ \ - for (u32 i = (array).count; i-- > 0;) { \ - if (al_array_at(array, i) == elem) { \ - al_array_remove_at(array, i); \ - } \ - } \ -} AL_MACRO_END - -#define al_array_remove_at(array, i) \ -AL_MACRO_WRAP \ -{ \ - if (i == (array).count - 1) { \ - (array).count--; \ - } else { \ - al_memmove(al_array_offset(array, i), al_array_offset(array, i + 1), \ - al_array_item_size(array) * (--(array).count - i)); \ - } \ -} AL_MACRO_END - -#define al_array_remove_range(array, start, end) \ -AL_MACRO_WRAP \ -{ \ - if (end != (array).count) { \ - al_memmove(al_array_offset(array, start), al_array_offset(array, end), \ - al_array_item_size(array) * ((array).count - end)); \ - } \ - (array).count -= end - start; \ -} AL_MACRO_END +#define al_array_pop_at(array, i, r) \ + do { \ + r = al_array_at(array, i); \ + al_array_remove_at(array, i); \ + } while (0) + +#define al_array_remove_at(array, i) \ + do { \ + if (i == (array).count - 1) { \ + (array).count--; \ + } else { \ + al_memmove(al_array_offset(array, i), al_array_offset(array, i + 1), \ + al_array_item_size(array) * (--(array).count - i)); \ + } \ + } while (0) + +#define al_array_remove_range(array, start, end) \ + do { \ + if (end != (array).count) { \ + al_memmove(al_array_offset(array, start), al_array_offset(array, end), \ + al_array_item_size(array) * ((array).count - end)); \ + } \ + (array).count -= end - start; \ + } while (0) + +#ifdef AL_HAVE_GNU_EXTENSIONS +#define al_array_remove(array, elem) \ + ({ \ + bool removed = false; \ + for (u32 i = 0; i < (array).count; i++) { \ + if (al_array_at(array, i) == elem) { \ + al_array_remove_at(array, i); \ + removed = true; \ + break; \ + } \ + } \ + removed; \ + }) + +#define al_array_remove_all(array, elem) \ + ({ \ + bool removed = false; \ + for (u32 i = (array).count; i-- > 0;) { \ + if (al_array_at(array, i) == elem) { \ + al_array_remove_at(array, i); \ + removed = true; \ + } \ + } \ + removed; \ + }) +#endif #ifdef AL_USE_STDLIB #define al_array_sort(array, type, cmp) AL_STDLIB_QSORT((array).data, type, (array).count, cmp) @@ -149,17 +122,12 @@ AL_MACRO_WRAP for (u32 i = (array).count; (i-- > 0 && (item = al_array_offset(array, i), 1));) #define al_array_remove_at_iter(array, i) \ -AL_MACRO_WRAP \ -{ \ - al_array_remove_at(array, i); \ - i--; \ -} AL_MACRO_END - -AL_UNUSED_FUNCTION_PUSH + do { \ + al_array_remove_at(array, i); \ + i--; \ + } while (0) static inline u32 _al_array_reserve(void **ptr, u32 prev_size, u32 size) { - return al_default_growing_allocation(ptr, prev_size, size, AL_ARRAY_MALLOC, AL_ARRAY_REALLOC); + return al_growing_allocation(ptr, prev_size, size, AL_ARRAY_MALLOC, AL_ARRAY_REALLOC); } - -AL_UNUSED_FUNCTION_POP diff --git a/src/lib.c b/src/lib.c index 9641976..96a43fe 100644 --- a/src/lib.c +++ b/src/lib.c @@ -1,11 +1,13 @@ #include "../include/al/lib.h" -// https://forum.vcfed.org/index.php?threads/c-item-size-check-at-compile-time.1244920/ -#define AL_ASSERT_TYPE_SIZE(type, size) \ - typedef char type##__size_test[(!!(sizeof(type) == size)) * 2 - 1] - AL_ASSERT_TYPE_SIZE(int, 4); AL_ASSERT_TYPE_SIZE(unsigned, 4); +#if defined AL_WE_64BIT +AL_ASSERT_TYPE_SIZE(intptr_t, 8); +#elif defined AL_WE_32BIT +AL_ASSERT_TYPE_SIZE(long, 4); +AL_ASSERT_TYPE_SIZE(intptr_t, 4); +#endif #ifdef AL_MEMORY_TRACKING static void *(*_al_malloc)(size_t) = NULL; @@ -61,51 +63,34 @@ void al_malloc_close(void) void *al_malloc(size_t n) { al_printf("**al_malloc(%zu)\n", n); - void *ptr = _al_malloc(n); - _al_malloc_lock(); - total_changed_by(n); current_changed_by(n); - al_array_push(allocations, ((struct al_alloc_t){ ptr, n })); - _al_malloc_unlock(); - return ptr; } void *al_calloc(size_t n, size_t size) { al_printf("**al_calloc(%zu, %zu)\n", n, size); - void *ptr = _al_calloc(n, size); - size_t real_size = n * size; - _al_malloc_lock(); - total_changed_by(real_size); current_changed_by(real_size); - al_array_push(allocations, ((struct al_alloc_t){ ptr, real_size })); - _al_malloc_unlock(); - return ptr; } void *al_realloc(void *ptr, size_t n) { al_printf("**al_realloc(%p, %zu)\n", ptr, n); - void *new_ptr = _al_realloc(ptr, n); - _al_malloc_lock(); - total_changed_by(n); - if (!ptr) { current_changed_by(n); al_array_push(allocations, ((struct al_alloc_t){ ptr, n })); @@ -121,18 +106,14 @@ void *al_realloc(void *ptr, size_t n) } } } - _al_malloc_unlock(); - return new_ptr; } void al_free(void *ptr) { al_printf("**al_free(%p)\n", ptr); - _al_malloc_lock(); - bool found = false; struct al_alloc_t *alloc; al_array_foreach_ptr(allocations, i, alloc) { @@ -144,9 +125,7 @@ void al_free(void *ptr) } } al_assert(found); - _al_malloc_unlock(); - _al_free(ptr); } @@ -155,18 +134,12 @@ s32 al_posix_memalign(void **ptr, size_t alignment, size_t n) { size_t real_size = (n + alignment) - ((n + alignment) % alignment); al_printf("**al_posix_memalign(%zu, %zu(%zu))\n", alignment, n, real_size); - s32 result = _al_posix_memalign(ptr, alignment, n); - _al_malloc_lock(); - total_changed_by(real_size); current_changed_by(real_size); - al_array_push(allocations, ((struct al_alloc_t){ *ptr, real_size })); - _al_malloc_unlock(); - return result; } #endif @@ -174,11 +147,9 @@ s32 al_posix_memalign(void **ptr, size_t alignment, size_t n) void al_malloc_stats(size_t *current, size_t *peak, size_t *total) { _al_malloc_lock(); - *current = current_alloc; *peak = peak_alloc; *total = total_alloc; - _al_malloc_unlock(); } @@ -203,15 +174,18 @@ void al_set_alloc(void *(*malloc_func)(size_t), void *(*calloc_func)(size_t, siz u32 al_grow_step = 0x3fff; // 0b11111111111111 -u32 al_default_growing_allocation(void **ptr, u32 prev_size, u32 size, +u32 al_growing_allocation(void **ptr, u32 prev_size, u32 size, void *(*malloc_func)(size_t), void *(*realloc_func)(void *, size_t)) { if (size <= prev_size) return prev_size; - al_assert(size > 0); - size = size < al_grow_step ? al_next_power_of_two(size) : - al_add_wrap(size, al_grow_step, MAX_ALLOC_32) & ~al_grow_step; - // This should only happen after wrapping around MAX_ALLOC_32 (zero all possible bits). + al_assert(size > 0); + if (size < al_grow_step) { + size = al_next_power_of_two(size); + } else { + size = al_u32_add_wrap(size, al_grow_step, MAX_ALLOC_32) & ~al_grow_step; + } + // size can only be 0 after wrapping around MAX_ALLOC_32 (zero all possible bits). if (size == 0) size = MAX_ALLOC_32; *ptr = (!*ptr) ? malloc_func(size) : realloc_func(*ptr, size); @@ -220,7 +194,7 @@ u32 al_default_growing_allocation(void **ptr, u32 prev_size, u32 size, return size; } -size_t al_page_size = 0x1000; +size_t al_page_size = 0x1000; // 4096 void al_set_page_size(size_t size) { al_assert(size > 0); diff --git a/src/ring_buffer.c b/src/ring_buffer.c index ded0138..b1c2fe5 100644 --- a/src/ring_buffer.c +++ b/src/ring_buffer.c @@ -3,7 +3,6 @@ #include "../include/al/macros.h" // https://github.com/MusicPlayerDaemon/MPD/blob/master/src/util/RingBuffer.hxx -// // This is no longer an implementation of a "contiguous" ring buffer but I used this as reference. // Wrapping is handled in read() and write(). // https://andrea.lattuada.me/blog/2019/the-design-and-implementation-of-a-lock-free-ring-buffer-with-contiguous-reservations.html @@ -17,9 +16,7 @@ void al_ring_buffer_init(struct al_ring_buffer *buf, u8 *data, ptrdiff_t length) static inline u8 *previous(struct al_ring_buffer *buf, u8 *ptr) { - if (ptr == buf->start) { - ptr = buf->end; - } + if (ptr == buf->start) ptr = buf->end; return --ptr; } @@ -42,7 +39,7 @@ u8 *al_ring_buffer_write_chunk(struct al_ring_buffer *buf, ptrdiff_t *size) { u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_ACQUIRE); u8 *rp = previous(buf, al_atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED)); - *size = (wp <= rp ? rp : buf->end) - wp; + *size = ((wp <= rp) ? rp : buf->end) - wp; return wp; } @@ -62,7 +59,7 @@ u8 *al_ring_buffer_read_chunk(struct al_ring_buffer *buf, ptrdiff_t *size) { u8 *rp = al_atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE); u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED); - *size = (rp <= wp ? wp : buf->end) - rp; + *size = ((rp <= wp) ? wp : buf->end) - rp; return rp; } @@ -76,14 +73,12 @@ ptrdiff_t al_ring_buffer_write(struct al_ring_buffer *buf, u8 *data, ptrdiff_t n u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_ACQUIRE); u8 *rp = previous(buf, al_atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED)); - ptrdiff_t size, wrap; - - size = MIN((wp <= rp ? rp : buf->end) - wp, n); + ptrdiff_t size = MIN(((wp <= rp) ? rp : buf->end) - wp, n); al_memcpy(wp, data, (size_t)size); wp += size; if (wp >= buf->end) { - wrap = MIN(rp - buf->start, n - size); + ptrdiff_t wrap = MIN(rp - buf->start, n - size); al_memcpy(buf->start, data + size, (size_t)wrap); wp = buf->start + wrap; size += wrap; @@ -99,14 +94,12 @@ ptrdiff_t al_ring_buffer_read(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t n) u8 *rp = al_atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE); u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED); - ptrdiff_t size, wrap; - - size = MIN((rp <= wp ? wp : buf->end) - rp, n); + ptrdiff_t size = MIN(((rp <= wp) ? wp : buf->end) - rp, n); al_memcpy(ptr, rp, (size_t)size); rp += size; if (rp >= buf->end) { - wrap = MIN(wp - buf->start, n - size); + ptrdiff_t wrap = MIN(wp - buf->start, n - size); al_memcpy(ptr + size, buf->start, (size_t)wrap); rp = buf->start + wrap; size += wrap; @@ -122,20 +115,14 @@ ptrdiff_t al_ring_buffer_peek(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t off u8 *rp = al_atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED); u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED); - ptrdiff_t size, wrap; - + ptrdiff_t size; if (rp <= wp) { rp += offset; - size = MIN(wp - rp, n); - if (size < 0) { - return 0; - } - + if (size < 0) return 0; al_memcpy(ptr, rp, (size_t)size); } else { rp += offset; - size = MIN(buf->end - rp, n); if (size > 0) { al_memcpy(ptr, rp, (size_t)size); @@ -145,8 +132,7 @@ ptrdiff_t al_ring_buffer_peek(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t off rp = buf->start - size; size = 0; } - - wrap = MIN(wp - rp, n); + ptrdiff_t wrap = MIN(wp - rp, n); if (wrap > 0) { al_memcpy(ptr + size, rp, (size_t)wrap); size += wrap; @@ -161,13 +147,11 @@ ptrdiff_t al_ring_buffer_discard(struct al_ring_buffer *buf, ptrdiff_t n) u8 *rp = al_atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE); u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED); - ptrdiff_t discard, wrap; - - discard = MIN((rp <= wp ? wp : buf->end) - rp, n); + ptrdiff_t discard = MIN(((rp <= wp) ? wp : buf->end) - rp, n); rp += discard; if (rp >= buf->end) { - wrap = MIN(wp - buf->start, n - discard); + ptrdiff_t wrap = MIN(wp - buf->start, n - discard); rp = buf->start + wrap; discard += wrap; } -- cgit v1.2.3-101-g0448