perf(queue): changed queue to be defined using macros to improve performance
This commit is contained in:
parent
5f4e0c1f2d
commit
2bfd6ddb4c
4 changed files with 140 additions and 198 deletions
|
|
@ -25,27 +25,135 @@
|
|||
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
#include <Hallocy/Core/Allocator.h>
|
||||
#include <Hallocy/Core/Memory.h>
|
||||
#include <Hallocy/Utils/Error.h>
|
||||
|
||||
#include "../Utils/Error.h"
|
||||
|
||||
typedef struct {
|
||||
size_t size, capacity;
|
||||
size_t head, tail;
|
||||
#define FLEDASTY_QUEUE_DEFINE(type) \
|
||||
typedef struct { \
|
||||
size_t size, capacity; \
|
||||
size_t head, tail; \
|
||||
type *buffer; \
|
||||
} FledastyQueue_##type; \
|
||||
\
|
||||
FledastyError fledasty_queue_##type##_free(FledastyQueue_##type *current_queue); \
|
||||
\
|
||||
FledastyError fledasty_queue_##type##_push(FledastyQueue_##type *current_queue, type value); \
|
||||
type fledasty_queue_##type##_pop(FledastyQueue_##type *current_queue); \
|
||||
\
|
||||
FledastyError fledasty_queue_##type##_clear(FledastyQueue_##type *current_queue); \
|
||||
FledastyError fledasty_queue_##type##_shrink_to_fit(FledastyQueue_##type *current_queue); \
|
||||
\
|
||||
static inline type fledasty_queue_##type##_peek(const FledastyQueue_##type *current_queue) { return (current_queue != NULL && current_queue->size > 0) ? current_queue->buffer[current_queue->size - 1] : 0; } \
|
||||
static inline bool fledasty_queue_##type##_is_empty(const FledastyQueue_##type *current_queue) { return current_queue == NULL || current_queue->size == 0; }
|
||||
|
||||
size_t element_byte_size;
|
||||
unsigned char *buffer;
|
||||
} FledastyQueue;
|
||||
|
||||
FledastyError fledasty_queue_initialize(FledastyQueue *new_queue, void *values, const size_t values_size, const size_t element_byte_size);
|
||||
FledastyError fledasty_queue_destroy(FledastyQueue *current_queue);
|
||||
|
||||
FledastyError fledasty_queue_push(FledastyQueue *current_queue, void *value);
|
||||
void *fledasty_queue_pop(FledastyQueue *current_queue);
|
||||
|
||||
FledastyError fledasty_queue_clear(FledastyQueue *current_queue);
|
||||
FledastyError fledasty_queue_shrink_to_fit(FledastyQueue *current_queue);
|
||||
|
||||
static inline void *fledasty_queue_peek(const FledastyQueue *current_queue) { return (current_queue == NULL) ? NULL : current_queue->buffer + (current_queue->head * current_queue->element_byte_size); }
|
||||
static inline bool fledasty_queue_is_empty(const FledastyQueue *current_queue) { return current_queue == NULL || current_queue->size == 0; }
|
||||
#define FLEDASTY_QUEUE_IMPLEMENT(type) \
|
||||
FledastyError fledasty_queue_##type##_free(FledastyQueue_##type *current_queue) { \
|
||||
if (current_queue == NULL) { \
|
||||
return FLEDASTY_ERROR_INVALID_POINTER; \
|
||||
} \
|
||||
\
|
||||
if (hallocy_free(current_queue->buffer) != HALLOCY_ERROR_NONE) { \
|
||||
return FLEDASTY_ERROR_FAILED_ALLOCATION; \
|
||||
} \
|
||||
\
|
||||
current_queue->size = 0; \
|
||||
current_queue->capacity = 0; \
|
||||
current_queue->buffer = NULL; \
|
||||
\
|
||||
return FLEDASTY_ERROR_NONE; \
|
||||
} \
|
||||
\
|
||||
FledastyError fledasty_queue_##type##_push(FledastyQueue_##type *current_queue, type value) { \
|
||||
if (current_queue == NULL) { \
|
||||
return FLEDASTY_ERROR_INVALID_POINTER; \
|
||||
} \
|
||||
\
|
||||
if (current_queue->size == current_queue->capacity) { \
|
||||
current_queue->capacity += current_queue->capacity ? current_queue->capacity : 16; \
|
||||
current_queue->buffer = (type*)hallocy_realloc(current_queue->buffer, current_queue->capacity * sizeof(type)); \
|
||||
\
|
||||
if (current_queue->buffer == NULL) { \
|
||||
return FLEDASTY_ERROR_FAILED_ALLOCATION; \
|
||||
} \
|
||||
\
|
||||
if (current_queue->tail < current_queue->head) { \
|
||||
size_t head_size = current_queue->size - current_queue->tail; \
|
||||
\
|
||||
hallocy_move_memory(current_queue->buffer, current_queue->buffer + current_queue->head, head_size * sizeof(type)); \
|
||||
hallocy_move_memory(current_queue->buffer + head_size, current_queue->buffer, current_queue->tail * sizeof(type)); \
|
||||
} else { \
|
||||
hallocy_move_memory(current_queue->buffer, current_queue->buffer + current_queue->head, current_queue->size * sizeof(type)); \
|
||||
} \
|
||||
\
|
||||
current_queue->head = 0; \
|
||||
current_queue->tail = current_queue->size; \
|
||||
} \
|
||||
\
|
||||
current_queue->buffer[current_queue->tail++] = value; \
|
||||
if (current_queue->tail >= current_queue->capacity) { \
|
||||
current_queue->tail = 0; \
|
||||
} \
|
||||
\
|
||||
current_queue->size += 1; \
|
||||
return FLEDASTY_ERROR_NONE; \
|
||||
} \
|
||||
\
|
||||
type fledasty_queue_##type##_pop(FledastyQueue_##type *current_queue) { \
|
||||
if (current_queue == NULL || current_queue->size == 0) { \
|
||||
return 0; \
|
||||
} \
|
||||
\
|
||||
current_queue->size -= 1; \
|
||||
current_queue->head += 1; \
|
||||
if (current_queue->head == current_queue->capacity) { \
|
||||
current_queue->head = 0; \
|
||||
} \
|
||||
\
|
||||
return current_queue->buffer[current_queue->head - 1]; \
|
||||
} \
|
||||
\
|
||||
FledastyError fledasty_queue_##type##_clear(FledastyQueue_##type *current_queue) { \
|
||||
if (current_queue == NULL) { \
|
||||
return FLEDASTY_ERROR_INVALID_POINTER; \
|
||||
} \
|
||||
\
|
||||
current_queue->size = 0; \
|
||||
return FLEDASTY_ERROR_NONE; \
|
||||
} \
|
||||
\
|
||||
FledastyError fledasty_queue_##type##_shrink_to_fit(FledastyQueue_##type *current_queue) { \
|
||||
if (current_queue == NULL) { \
|
||||
return FLEDASTY_ERROR_INVALID_POINTER; \
|
||||
} \
|
||||
\
|
||||
size_t new_capacity = (current_queue->size == 0) ? 16 : current_queue->size; \
|
||||
type *shrinked_buffer = (type*)hallocy_malloc(new_capacity * sizeof(type)); \
|
||||
if (shrinked_buffer == NULL) { \
|
||||
return FLEDASTY_ERROR_FAILED_ALLOCATION; \
|
||||
} \
|
||||
\
|
||||
if (current_queue->tail < current_queue->head) { \
|
||||
size_t head_size = current_queue->size - current_queue->tail; \
|
||||
\
|
||||
hallocy_copy_memory(shrinked_buffer, current_queue->buffer + current_queue->head, head_size * sizeof(type)); \
|
||||
hallocy_copy_memory(shrinked_buffer + head_size, current_queue->buffer, current_queue->tail * sizeof(type)); \
|
||||
} else { \
|
||||
hallocy_copy_memory(shrinked_buffer, current_queue->buffer + current_queue->head, current_queue->size * sizeof(type)); \
|
||||
} \
|
||||
\
|
||||
if (hallocy_free(current_queue->buffer) != HALLOCY_ERROR_NONE) { \
|
||||
return FLEDASTY_ERROR_FAILED_ALLOCATION; \
|
||||
} \
|
||||
\
|
||||
current_queue->head = 0; \
|
||||
current_queue->tail = current_queue->size; \
|
||||
current_queue->capacity = new_capacity; \
|
||||
current_queue->buffer = shrinked_buffer; \
|
||||
\
|
||||
return FLEDASTY_ERROR_NONE; \
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -28,7 +28,8 @@
|
|||
#include <Hallocy/Core/Allocator.h>
|
||||
#include <Hallocy/Core/Memory.h>
|
||||
#include <Hallocy/Utils/Error.h>
|
||||
#include <Fledasty/Utils/Error.h>
|
||||
|
||||
#include "../Utils/Error.h"
|
||||
|
||||
#define FLEDASTY_STACK_DEFINE(type) \
|
||||
typedef struct { \
|
||||
|
|
|
|||
165
Src/Core/Queue.c
165
Src/Core/Queue.c
|
|
@ -1,165 +0,0 @@
|
|||
/*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* -----------------------------------------------------------------------------
|
||||
* File: Queue.c
|
||||
* Description:
|
||||
* This file contains the functions for modifying the queue. It includes functions
|
||||
* to Push, Pop, Peek and check if empty.
|
||||
*
|
||||
* Author: Mineplay
|
||||
* -----------------------------------------------------------------------------
|
||||
*/
|
||||
#include "../../Include/Fledasty/Core/Queue.h"
|
||||
|
||||
#include <Hallocy/Core/Allocator.h>
|
||||
#include <Hallocy/Core/Memory.h>
|
||||
#include <Hallocy/Utils/Error.h>
|
||||
|
||||
FledastyError fledasty_queue_initialize(FledastyQueue *new_queue, void *values, const size_t values_size, const size_t element_byte_size) {
|
||||
if (new_queue == NULL) {
|
||||
return FLEDASTY_ERROR_INVALID_POINTER;
|
||||
}
|
||||
|
||||
new_queue->head = 0;
|
||||
new_queue->element_byte_size = element_byte_size;
|
||||
if (values == NULL || values_size == 0) {
|
||||
new_queue->size = 0;
|
||||
new_queue->capacity = 10;
|
||||
|
||||
new_queue->buffer = (unsigned char*)hallocy_malloc(new_queue->capacity * element_byte_size);
|
||||
if (new_queue->buffer == NULL) {
|
||||
return FLEDASTY_ERROR_FAILED_ALLOCATION;
|
||||
}
|
||||
} else {
|
||||
new_queue->size = values_size;
|
||||
new_queue->capacity = new_queue->size + new_queue->size;
|
||||
|
||||
new_queue->buffer = (unsigned char*)hallocy_malloc(new_queue->capacity * element_byte_size);
|
||||
if (new_queue->buffer == NULL) {
|
||||
return FLEDASTY_ERROR_FAILED_ALLOCATION;
|
||||
}
|
||||
|
||||
hallocy_copy_memory(new_queue->buffer, values, values_size * element_byte_size);
|
||||
}
|
||||
|
||||
new_queue->tail = new_queue->size;
|
||||
return FLEDASTY_ERROR_NONE;
|
||||
}
|
||||
|
||||
FledastyError fledasty_queue_destroy(FledastyQueue *current_queue) {
|
||||
if (current_queue == NULL) {
|
||||
return FLEDASTY_ERROR_INVALID_POINTER;
|
||||
}
|
||||
|
||||
if (hallocy_free(current_queue->buffer) != HALLOCY_ERROR_NONE) {
|
||||
return FLEDASTY_ERROR_FAILED_ALLOCATION;
|
||||
}
|
||||
|
||||
current_queue->buffer = NULL;
|
||||
return FLEDASTY_ERROR_NONE;
|
||||
}
|
||||
|
||||
FledastyError fledasty_queue_push(FledastyQueue *current_queue, void *value) {
|
||||
if (current_queue == NULL || value == NULL) {
|
||||
return FLEDASTY_ERROR_INVALID_POINTER;
|
||||
}
|
||||
|
||||
if (current_queue->size == current_queue->capacity) {
|
||||
current_queue->capacity += current_queue->capacity;
|
||||
|
||||
current_queue->buffer = (unsigned char*)hallocy_realloc(current_queue->buffer, current_queue->capacity * current_queue->element_byte_size);
|
||||
if (current_queue->buffer == NULL) {
|
||||
return FLEDASTY_ERROR_FAILED_ALLOCATION;
|
||||
}
|
||||
|
||||
if (current_queue->tail < current_queue->head) {
|
||||
size_t head_size = (current_queue->size - current_queue->tail) * current_queue->element_byte_size;
|
||||
|
||||
hallocy_move_memory(current_queue->buffer, current_queue->buffer + (current_queue->head * current_queue->element_byte_size), head_size);
|
||||
hallocy_move_memory(current_queue->buffer + head_size, current_queue->buffer, current_queue->tail * current_queue->element_byte_size);
|
||||
} else {
|
||||
hallocy_move_memory(current_queue->buffer, current_queue->buffer + (current_queue->head * current_queue->element_byte_size), current_queue->size * current_queue->element_byte_size);
|
||||
}
|
||||
|
||||
current_queue->head = 0;
|
||||
current_queue->tail = current_queue->size;
|
||||
}
|
||||
|
||||
hallocy_copy_memory(current_queue->buffer + (current_queue->tail * current_queue->element_byte_size), value, current_queue->element_byte_size);
|
||||
|
||||
current_queue->size += 1;
|
||||
current_queue->tail += 1;
|
||||
if (current_queue->tail >= current_queue->capacity) {
|
||||
current_queue->tail = 0;
|
||||
}
|
||||
|
||||
return FLEDASTY_ERROR_NONE;
|
||||
}
|
||||
|
||||
void *fledasty_queue_pop(FledastyQueue *current_queue) {
|
||||
if (current_queue == NULL || current_queue->size == 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void *value_address = current_queue->buffer + (current_queue->head * current_queue->element_byte_size);
|
||||
|
||||
current_queue->size -= 1;
|
||||
current_queue->head += 1;
|
||||
if (current_queue->head == current_queue->capacity) {
|
||||
current_queue->head = 0;
|
||||
}
|
||||
|
||||
return value_address;
|
||||
}
|
||||
|
||||
FledastyError fledasty_queue_clear(FledastyQueue *current_queue) {
|
||||
if (current_queue == NULL) {
|
||||
return FLEDASTY_ERROR_INVALID_POINTER;
|
||||
}
|
||||
|
||||
current_queue->size = 0;
|
||||
return FLEDASTY_ERROR_NONE;
|
||||
}
|
||||
|
||||
FledastyError fledasty_queue_shrink_to_fit(FledastyQueue *current_queue) {
|
||||
if (current_queue == NULL) {
|
||||
return FLEDASTY_ERROR_INVALID_POINTER;
|
||||
}
|
||||
|
||||
size_t new_capacity = (current_queue->size == 0) ? 10 : current_queue->size;
|
||||
unsigned char *shrinked_buffer = (unsigned char*)hallocy_malloc(new_capacity);
|
||||
if (shrinked_buffer == NULL) {
|
||||
return FLEDASTY_ERROR_FAILED_ALLOCATION;
|
||||
}
|
||||
|
||||
if (current_queue->tail < current_queue->head) {
|
||||
size_t head_size = (current_queue->size - current_queue->tail) * current_queue->element_byte_size;
|
||||
|
||||
hallocy_copy_memory(shrinked_buffer, current_queue->buffer + (current_queue->head * current_queue->element_byte_size), head_size);
|
||||
hallocy_copy_memory(shrinked_buffer + head_size, current_queue->buffer, current_queue->tail * current_queue->element_byte_size);
|
||||
} else {
|
||||
hallocy_copy_memory(shrinked_buffer, current_queue->buffer + (current_queue->head * current_queue->element_byte_size), current_queue->size * current_queue->element_byte_size);
|
||||
}
|
||||
|
||||
if (hallocy_free(current_queue->buffer) != HALLOCY_ERROR_NONE) {
|
||||
return FLEDASTY_ERROR_FAILED_ALLOCATION;
|
||||
}
|
||||
|
||||
current_queue->head = 0;
|
||||
current_queue->tail = current_queue->size;
|
||||
current_queue->capacity = new_capacity;
|
||||
current_queue->buffer = shrinked_buffer;
|
||||
|
||||
return FLEDASTY_ERROR_NONE;
|
||||
}
|
||||
26
Tests/Main.c
26
Tests/Main.c
|
|
@ -33,34 +33,32 @@
|
|||
FLEDASTY_STACK_DEFINE(int)
|
||||
FLEDASTY_STACK_IMPLEMENT(int)
|
||||
|
||||
FLEDASTY_QUEUE_DEFINE(int)
|
||||
FLEDASTY_QUEUE_IMPLEMENT(int)
|
||||
|
||||
static inline size_t integer_hash_function(const void *key) { return *(int*)key; }
|
||||
|
||||
int main() {
|
||||
FledastyQueue test_queue;
|
||||
fledasty_queue_initialize(&test_queue, (int[]){11, 12, 13, 14, 15}, 5, sizeof(int));
|
||||
|
||||
FledastyQueue_int test_queue = { 0, 0, 0, 0, NULL };
|
||||
for (int i = 0; i < 10; i += 1) {
|
||||
fledasty_queue_push(&test_queue, &i);
|
||||
fledasty_queue_int_push(&test_queue, i);
|
||||
}
|
||||
|
||||
fledasty_queue_shrink_to_fit(&test_queue);
|
||||
fledasty_queue_int_shrink_to_fit(&test_queue);
|
||||
printf("Queue schrinked to fit %s\n", (test_queue.capacity == test_queue.size) ? "succeeded" : "failed");
|
||||
int test = 0;
|
||||
fledasty_queue_push(&test_queue, &test);
|
||||
int *peeked_queue_data = (int*)fledasty_queue_peek(&test_queue);
|
||||
printf("Queue peeked: %d\n", *peeked_queue_data);
|
||||
fledasty_queue_int_push(&test_queue, 0);
|
||||
printf("Queue peeked: %d\n", fledasty_queue_int_peek(&test_queue));
|
||||
|
||||
for (int i = test_queue.size; i > 0; i -= 1) {
|
||||
int *popped_data = (int*)fledasty_queue_pop(&test_queue);
|
||||
printf("Queue popped: %d\n", *popped_data);
|
||||
printf("Queue popped: %d\n", fledasty_queue_int_pop(&test_queue));
|
||||
}
|
||||
|
||||
fledasty_queue_clear(&test_queue);
|
||||
if (fledasty_queue_is_empty(&test_queue)) {
|
||||
fledasty_queue_int_clear(&test_queue);
|
||||
if (fledasty_queue_int_is_empty(&test_queue)) {
|
||||
printf("Queue is empty\n");
|
||||
}
|
||||
|
||||
fledasty_queue_destroy(&test_queue);
|
||||
fledasty_queue_int_free(&test_queue);
|
||||
|
||||
FledastyStack_int test_stack = { 0, 0, NULL };
|
||||
for (int i = 0; i < 10; i += 1) {
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue