INITIAL COMMIT
This commit is contained in:
@@ -0,0 +1,108 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "queue.h"
|
||||
#include "../array/array.h"
|
||||
#include "../../common/assert/assert.h"
|
||||
#include "../../common/misc/misc_utils.h"
|
||||
#include <string.h>
|
||||
|
||||
void _queue_push(GenericQueue *queue, void *item, u64 item_size) {
|
||||
wapp_debug_assert(queue != NULL, "`queue` should not be NULL");
|
||||
wapp_runtime_assert(item_size == wapp_array_item_size(queue->items), "Invalid type");
|
||||
|
||||
u64 capacity = wapp_array_capacity(queue->items);
|
||||
if (queue->count >= capacity) { return; }
|
||||
|
||||
u64 index = (queue->back)++;
|
||||
_array_set(queue->items, index, item, item_size);
|
||||
++(queue->count);
|
||||
|
||||
if (queue->back >= capacity) {
|
||||
queue->back = 0;
|
||||
}
|
||||
}
|
||||
|
||||
GenericQueue *_queue_push_alloc(const Allocator *allocator, GenericQueue *queue, void *item, u64 item_size) {
|
||||
wapp_debug_assert(allocator != NULL && queue != NULL && item != NULL,
|
||||
"`allocator`, `queue` and `item` should not be NULL");
|
||||
wapp_runtime_assert(item_size == wapp_array_item_size(queue->items), "Invalid type");
|
||||
|
||||
GenericQueue *output = queue;
|
||||
|
||||
u64 capacity = wapp_array_capacity(queue->items);
|
||||
|
||||
// NOTE (Abdelrahman): Extracted into variable to fix MSVC error
|
||||
b8 queue_full = queue->count >= capacity;
|
||||
if (queue_full) {
|
||||
u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(capacity * 2);
|
||||
u64 array_size = _array_calc_alloc_size(new_capacity, item_size);
|
||||
u64 alloc_size = sizeof(GenericQueue) + array_size;
|
||||
void *buffer = wapp_mem_allocator_alloc(allocator, alloc_size);
|
||||
if (!buffer) {
|
||||
goto RETURN_QUEUE_PUSH_ALLOC;
|
||||
}
|
||||
|
||||
memset((void *)buffer, 0, alloc_size);
|
||||
|
||||
output = (GenericQueue *)buffer;
|
||||
output->items = _array_from_preallocated_buffer((void *)(output + 1), array_size, ARRAY_INIT_FILLED, item_size);
|
||||
|
||||
// NOTE (Abdelrahman): When the queue is full, the front and back indices should
|
||||
// always be the same
|
||||
u64 front_count = capacity - queue->front;
|
||||
u64 back_count = queue->back;
|
||||
void *copy_boundary = (void *)((uptr)(queue->items) + (queue->front * item_size));
|
||||
|
||||
memcpy(output->items, copy_boundary, front_count * item_size);
|
||||
|
||||
/**
|
||||
* NOTE (Abdelrahman): Since this is a ring buffer, the elements at the beginning of the array
|
||||
* aren't always the ones at the front of the queue. When that's the case, the memcpy above
|
||||
* will only copy a subset of the elements. This is why we need to copy the remaining ones.
|
||||
*
|
||||
* Example: Take a queue that looks like this with a capacity of 5 elements
|
||||
*
|
||||
* 0 1 | 2 3 4
|
||||
* ---------------|-----------------------
|
||||
* | * | * | * | * | * |
|
||||
* ---------------|-----------------------
|
||||
* |
|
||||
* queue_front = 2
|
||||
* queue_back = 2
|
||||
*
|
||||
* In this case, the first memcpy will only copy elements 2-4. The memcpy below will be
|
||||
* responsible for copying elements 0-1.
|
||||
*/
|
||||
b8 items_left_to_copy = back_count > 0;
|
||||
if (items_left_to_copy) {
|
||||
void *back_copy_dst = (void *)((uptr)(output->items) + (front_count * item_size));
|
||||
memcpy(back_copy_dst, queue->items, back_count * item_size);
|
||||
}
|
||||
|
||||
output->front = 0;
|
||||
output->back = front_count + back_count;
|
||||
output->count = queue->count;
|
||||
}
|
||||
|
||||
_queue_push(output, item, item_size);
|
||||
|
||||
RETURN_QUEUE_PUSH_ALLOC:
|
||||
return output;
|
||||
}
|
||||
|
||||
void *_queue_pop(GenericQueue *queue, u64 item_size) {
|
||||
wapp_debug_assert(queue != NULL, "`queue` should not be NULL");
|
||||
wapp_runtime_assert(item_size == wapp_array_item_size(queue->items), "Invalid type");
|
||||
|
||||
if (queue->count == 0) { return NULL; }
|
||||
|
||||
u64 index = (queue->front)++;
|
||||
--(queue->count);
|
||||
|
||||
u64 capacity = wapp_array_capacity(queue->items);
|
||||
if (queue->front >= capacity) {
|
||||
queue->front = 0;
|
||||
}
|
||||
|
||||
return _array_get(queue->items, index, item_size);
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef QUEUE_H
|
||||
#define QUEUE_H
|
||||
|
||||
#include "../array/array.h"
|
||||
#include "../mem/allocator/mem_allocator.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/platform/platform.h"
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
typedef struct {
|
||||
GenericArray items;
|
||||
u64 front;
|
||||
u64 back;
|
||||
u64 count;
|
||||
} GenericQueue;
|
||||
|
||||
// NOTE (Abdelrahman): GenericQueue typedefs for readability
|
||||
typedef GenericQueue VoidPtrQueue;
|
||||
typedef GenericQueue C8Queue;
|
||||
typedef GenericQueue C16Queue;
|
||||
typedef GenericQueue C32Queue;
|
||||
typedef GenericQueue U8Queue;
|
||||
typedef GenericQueue U16Queue;
|
||||
typedef GenericQueue U32Queue;
|
||||
typedef GenericQueue U64Queue;
|
||||
typedef GenericQueue B8Queue;
|
||||
typedef GenericQueue I8Queue;
|
||||
typedef GenericQueue I16Queue;
|
||||
typedef GenericQueue I32Queue;
|
||||
typedef GenericQueue I64Queue;
|
||||
typedef GenericQueue F32Queue;
|
||||
typedef GenericQueue F64Queue;
|
||||
typedef GenericQueue F128Queue;
|
||||
typedef GenericQueue UptrQueue;
|
||||
typedef GenericQueue IptrQueue;
|
||||
typedef GenericQueue Str8Queue;
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
#define wapp_queue(TYPE, CAPACITY) ([&]() { \
|
||||
wapp_persist GenericArray arr = wapp_array_with_capacity(TYPE, CAPACITY, ARRAY_INIT_FILLED); \
|
||||
wapp_persist GenericQueue queue = { \
|
||||
arr, \
|
||||
0, \
|
||||
0, \
|
||||
0, \
|
||||
}; \
|
||||
\
|
||||
return queue; \
|
||||
}())
|
||||
#define wapp_queue_alloc(TYPE, ALLOCATOR_PTR, CAPACITY) ([&]() { \
|
||||
wapp_persist GenericQueue queue = { \
|
||||
wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, ARRAY_INIT_FILLED), \
|
||||
0, \
|
||||
0, \
|
||||
0, \
|
||||
}; \
|
||||
\
|
||||
return queue; \
|
||||
}())
|
||||
#else
|
||||
#define wapp_queue(TYPE, CAPACITY) ((GenericQueue){ \
|
||||
.items = wapp_array_with_capacity(TYPE, CAPACITY, ARRAY_INIT_FILLED), \
|
||||
.front = 0, \
|
||||
.back = 0, \
|
||||
.count = 0, \
|
||||
})
|
||||
#define wapp_queue_alloc(TYPE, ALLOCATOR_PTR, CAPACITY) ((GenericQueue){ \
|
||||
.items = wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, ARRAY_INIT_FILLED), \
|
||||
.front = 0, \
|
||||
.back = 0, \
|
||||
.count = 0, \
|
||||
})
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
#define wapp_queue_capacity(QUEUE_PTR) (wapp_array_capacity((QUEUE_PTR)->items))
|
||||
#define wapp_queue_item_size(QUEUE_PTR) (wapp_array_item_size((QUEUE_PTR)->items))
|
||||
#define wapp_queue_push(TYPE, QUEUE_PTR, VALUE_PTR) ( \
|
||||
_queue_push(QUEUE_PTR, VALUE_PTR, sizeof(TYPE)) \
|
||||
)
|
||||
#define wapp_queue_push_alloc(TYPE, ALLOCATOR_PTR, QUEUE_PTR, VALUE_PTR) ( \
|
||||
_queue_push_alloc(ALLOCATOR_PTR, QUEUE_PTR, VALUE_PTR, sizeof(TYPE)) \
|
||||
)
|
||||
#define wapp_queue_pop(TYPE, QUEUE_PTR) ( \
|
||||
(TYPE *)_queue_pop(QUEUE_PTR, sizeof(TYPE)) \
|
||||
)
|
||||
|
||||
void _queue_push(GenericQueue *queue, void *item, u64 item_size);
|
||||
GenericQueue *_queue_push_alloc(const Allocator *allocator, GenericQueue *queue, void *item, u64 item_size);
|
||||
void *_queue_pop(GenericQueue *queue, u64 item_size);
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
#endif // !QUEUE_H
|
||||
Reference in New Issue
Block a user