Mineplay/Fledasty
1
0
Fork 0
Code Issues 5 Pull requests 1 Projects 1 Releases Packages Wiki Activity Actions

perf(stack): changed stack to be defined using macros to improve performance

Browse source
This commit is contained in:
Mineplay 2025-06-17 14:46:06 -05:00
parent 27fd969f01
commit 5f4e0c1f2d
4 changed files with 94 additions and 160 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

102
Include/Fledasty/Core/Stack.h
View file

@ -25,26 +25,90 @@
#include <stddef.h>
#include <stdbool.h>
#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 { \
size_t size, capacity; \
type *buffer; \
} FledastyStack_##type; \
\
FledastyError fledasty_stack_##type##_free(FledastyStack_##type *current_stack); \
\
FledastyError fledasty_stack_##type##_push(FledastyStack_##type *current_stack, type value); \
\
FledastyError fledasty_stack_##type##_clear(FledastyStack_##type *current_stack); \
FledastyError fledasty_stack_##type##_shrink_to_fit(FledastyStack_##type *current_stack); \
\
static inline type fledasty_stack_##type##_pop(FledastyStack_##type *current_stack) { return (current_stack != NULL && current_stack->size > 0) ? current_stack->buffer[--current_stack->size] : 0; } \
static inline type fledasty_stack_##type##_peek(const FledastyStack_##type *current_stack) { return (current_stack != NULL && current_stack->size > 0) ? current_stack->buffer[current_stack->size - 1] : 0; } \
static inline bool fledasty_stack_##type##_is_empty(const FledastyStack_##type *current_stack) { return current_stack == NULL || current_stack->size == 0; }
typedef struct {
size_t size, capacity;
size_t element_byte_size;
unsigned char *buffer;
} FledastyStack;
FledastyError fledasty_stack_initialize(FledastyStack *new_stack, void *values, const size_t values_size, const size_t element_byte_size);
FledastyError fledasty_stack_destroy(FledastyStack *current_stack);
FledastyError fledasty_stack_push(FledastyStack *current_stack, void *value);
void *fledasty_stack_pop(FledastyStack *current_stack);
FledastyError fledasty_stack_clear(FledastyStack *current_stack);
FledastyError fledasty_stack_shrink_to_fit(FledastyStack *current_stack);
static inline void *fledasty_stack_peek(const FledastyStack *current_stack) { return (current_stack == NULL) ? NULL : current_stack->buffer + ((current_stack->size - 1) * current_stack->element_byte_size); }
static inline bool fledasty_stack_is_empty(const FledastyStack *current_stack) { return current_stack == NULL || current_stack->size == 0; }
#define FLEDASTY_STACK_IMPLEMENT(type) \
FledastyError fledasty_stack_##type##_free(FledastyStack_##type *current_stack) { \
if (current_stack == NULL) { \
return FLEDASTY_ERROR_INVALID_POINTER; \
} \
\
if (hallocy_free(current_stack->buffer) != HALLOCY_ERROR_NONE) { \
return FLEDASTY_ERROR_FAILED_ALLOCATION; \
} \
\
current_stack->size = 0; \
current_stack->capacity = 0; \
current_stack->buffer = NULL; \
\
return FLEDASTY_ERROR_NONE; \
} \
\
FledastyError fledasty_stack_##type##_push(FledastyStack_##type *current_stack, type value) { \
if (current_stack == NULL) { \
return FLEDASTY_ERROR_INVALID_POINTER; \
} \
\
if (current_stack->size == current_stack->capacity) { \
current_stack->capacity += current_stack->capacity ? current_stack->capacity : 16; \
current_stack->buffer = (type*)hallocy_realloc(current_stack->buffer, current_stack->capacity * sizeof(type)); \
\
if (current_stack->buffer == NULL) { \
return FLEDASTY_ERROR_FAILED_ALLOCATION; \
} \
} \
\
current_stack->buffer[current_stack->size++] = value; \
return FLEDASTY_ERROR_NONE; \
} \
\
FledastyError fledasty_stack_##type##_clear(FledastyStack_##type *current_stack) { \
if (current_stack == NULL) { \
return FLEDASTY_ERROR_INVALID_POINTER; \
} \
\
current_stack->size = 0; \
return FLEDASTY_ERROR_NONE; \
} \
\
FledastyError fledasty_stack_##type##_shrink_to_fit(FledastyStack_##type *current_stack) { \
if (current_stack == NULL) { \
return FLEDASTY_ERROR_INVALID_POINTER; \
} \
\
current_stack->capacity = (current_stack->size == 0) ? 10 : current_stack->size; \
type *shrinked_buffer = (type*)hallocy_malloc(current_stack->capacity * sizeof(type)); \
if (shrinked_buffer == NULL) { \
return FLEDASTY_ERROR_FAILED_ALLOCATION; \
} \
\
hallocy_copy_memory(shrinked_buffer, current_stack->buffer, current_stack->size * sizeof(type)); \
if (hallocy_free(current_stack->buffer) != HALLOCY_ERROR_NONE) { \
return FLEDASTY_ERROR_FAILED_ALLOCATION; \
} \
\
current_stack->buffer = shrinked_buffer; \
return FLEDASTY_ERROR_NONE; \
}
#endif

1
Src/Algorithms/Hashing.c
View file

@ -23,7 +23,6 @@
#include "../../Include/Fledasty/Algorithms/Hashing.h"
#include <Hallocy/Core/Memory.h>
#include <stdint.h>
static inline uint32_t fledasty_rolt_32(const uint32_t key, const uint32_t rotation) { return (key << rotation) | (key >> (32 - rotation)); }
static inline uint64_t fledasty_rolt_64(uint64_t key, const uint64_t rotation) { return (key << rotation) | (key >> (64 - rotation)); }

127
Src/Core/Stack.c
View file

@ -1,127 +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: Stack.c
* Description:
* This file contains the functions for modifying the stack. It includes functions
* to Push, Pop, Peek and check if empty.
*
* Author: Mineplay
* -----------------------------------------------------------------------------
*/
#include "../../Include/Fledasty/Core/Stack.h"
#include <Hallocy/Core/Allocator.h>
#include <Hallocy/Core/Memory.h>
#include <Hallocy/Utils/Error.h>
FledastyError fledasty_stack_initialize(FledastyStack *new_stack, void *values, const size_t values_size, const size_t element_byte_size) {
if (new_stack == NULL) {
return FLEDASTY_ERROR_INVALID_POINTER;
}
new_stack->element_byte_size = element_byte_size;
if (values == NULL || values_size == 0) {
new_stack->size = 0;
new_stack->capacity = 10;
new_stack->buffer = (unsigned char*)hallocy_malloc(new_stack->capacity * element_byte_size);
if (new_stack->buffer == NULL) {
return FLEDASTY_ERROR_FAILED_ALLOCATION;
}
} else {
new_stack->size = values_size;
new_stack->capacity = new_stack->size + new_stack->size;
new_stack->buffer = (unsigned char*)hallocy_malloc(new_stack->capacity * element_byte_size);
if (new_stack->buffer == NULL) {
return FLEDASTY_ERROR_FAILED_ALLOCATION;
}
hallocy_copy_memory(new_stack->buffer, values, values_size * element_byte_size);
}
return FLEDASTY_ERROR_NONE;
}
FledastyError fledasty_stack_destroy(FledastyStack *current_stack) {
if (current_stack == NULL) {
return FLEDASTY_ERROR_INVALID_POINTER;
}
if (hallocy_free(current_stack->buffer) != HALLOCY_ERROR_NONE) {
return FLEDASTY_ERROR_FAILED_ALLOCATION;
}
current_stack->buffer = NULL;
return FLEDASTY_ERROR_NONE;
}
FledastyError fledasty_stack_push(FledastyStack *current_stack, void *value) {
if (current_stack == NULL || value == NULL) {
return FLEDASTY_ERROR_INVALID_POINTER;
}
if (current_stack->size == current_stack->capacity) {
current_stack->capacity += current_stack->capacity;
current_stack->buffer = (unsigned char*)hallocy_realloc(current_stack->buffer, current_stack->capacity * current_stack->element_byte_size);
if (current_stack->buffer == NULL) {
return FLEDASTY_ERROR_FAILED_ALLOCATION;
}
}
hallocy_copy_memory(current_stack->buffer + (current_stack->size * current_stack->element_byte_size), value, current_stack->element_byte_size);
current_stack->size += 1;
return FLEDASTY_ERROR_NONE;
}
void *fledasty_stack_pop(FledastyStack *current_stack) {
if (current_stack == NULL) {
return NULL;
}
current_stack->size -= 1;
return current_stack->buffer + (current_stack->size * current_stack->element_byte_size);
}
FledastyError fledasty_stack_clear(FledastyStack *current_stack) {
if (current_stack == NULL) {
return FLEDASTY_ERROR_INVALID_POINTER;
}
current_stack->size = 0;
return FLEDASTY_ERROR_NONE;
}
FledastyError fledasty_stack_shrink_to_fit(FledastyStack *current_stack) {
if (current_stack == NULL) {
return FLEDASTY_ERROR_INVALID_POINTER;
}
current_stack->capacity = (current_stack->size == 0) ? 10 : current_stack->size;
unsigned char *shrinked_buffer = (unsigned char*)hallocy_malloc(current_stack->capacity * current_stack->element_byte_size);
if (shrinked_buffer == NULL) {
return FLEDASTY_ERROR_FAILED_ALLOCATION;
}
hallocy_copy_memory(shrinked_buffer, current_stack->buffer, current_stack->size * current_stack->element_byte_size);
if (hallocy_free(current_stack->buffer) != HALLOCY_ERROR_NONE) {
return FLEDASTY_ERROR_FAILED_ALLOCATION;
}
current_stack->buffer = shrinked_buffer;
return FLEDASTY_ERROR_NONE;
}

24
Tests/Main.c
View file

@ -30,6 +30,9 @@
#include <Fledasty/Strings/UTF8String.h>
#include <Fledasty/Algorithms/Hashing.h>
FLEDASTY_STACK_DEFINE(int)
FLEDASTY_STACK_IMPLEMENT(int)
static inline size_t integer_hash_function(const void *key) { return *(int*)key; }
int main() {
@ -59,30 +62,25 @@ int main() {
fledasty_queue_destroy(&test_queue);
FledastyStack test_stack;
fledasty_stack_initialize(&test_stack, (int[]){ 11, 12, 13, 14, 15 }, 5, sizeof(int));
FledastyStack_int test_stack = { 0, 0, NULL };
for (int i = 0; i < 10; i += 1) {
fledasty_stack_push(&test_stack, &i);
fledasty_stack_int_push(&test_stack, i);
}
fledasty_stack_shrink_to_fit(&test_stack);
fledasty_stack_int_shrink_to_fit(&test_stack);
printf("Stack schrinked to fit %s\n", (test_stack.capacity == test_stack.size) ? "succeeded" : "failed");
int *peeked_stack_data = (int*)fledasty_stack_peek(&test_stack);
printf("Stack peeked: %d\n", *peeked_stack_data);
printf("Stack peeked: %d\n", fledasty_stack_int_peek(&test_stack));
for (int i = test_stack.size; i > 0; i -= 1) {
int *popped_data = (int*)fledasty_stack_pop(&test_stack);
printf("Stack popped: %d\n", *popped_data);
printf("Stack popped: %d\n", fledasty_stack_int_pop(&test_stack));
}
fledasty_stack_clear(&test_stack);
if (fledasty_stack_is_empty(&test_stack)) {
fledasty_stack_int_clear(&test_stack);
if (fledasty_stack_int_is_empty(&test_stack)) {
printf("Stack is empty\n");
}
fledasty_stack_destroy(&test_stack);
fledasty_stack_int_free(&test_stack);
FledastyDynamicArray test_dynamic_array;
fledasty_dynamic_array_initialize(&test_dynamic_array, (int[]){11, 12, 13, 14, 15}, 5, sizeof(int));