src/Core/e_memory.c - master - Zamar_Terrier/TigorEngine

src/Core/e_memory.c
653 строки14 KB
Zamar_Terrier
Офигенное обновление движка
31 июл 2026, 21:03
31 июл 2026, 21:031682686
#include "Core/e_memory.h"

#include "tigor.h"

extern TEngine engine;

ChildStack *alloc_memory_head = NULL;

typedef enum
{
    TIGOR_ALLOC_TYPE_DATA,
    TIGOR_ALLOC_TYPE_BUFFER,
    TIGOR_ALLOC_TYPE_PIPELINE,
    TIGOR_ALLOC_TYPE_DESCRIPTOR
} AllocType;

typedef struct
{
    uint32_t size;
    size_t count;
    void *parent;
    char *name;
    void *ptr;
} AllocObj;

void InitMemory()
{
    alloc_memory_head = (ChildStack *)calloc(1, sizeof(ChildStack));
}

int32_t alloc_counter = 0;
uint32_t biggest_size = 0;

ChildStack *StackInit(char *name)
{
    ChildStack *header = calloc(1, sizeof(ChildStack));

    int len = strlen(name);
    header->flags = TIGOR_CHILD_STACK_FLAG_IS_HEAD;
    header->name = calloc(len + 1, sizeof(char));
    memcpy(header->name, name, len);
    header->name[len] = '\0';

    return header;
}

void *StackNewElementWD(ChildStack *header, uint32_t size, void (*destroyer)(void *))
{

    void *object = calloc(1, size);
    memset(object, 0, size);

    if (header->node == NULL)
    {
        header->next = calloc(1, sizeof(ChildStack));
        header->node = object;
        header->destroyer = destroyer;
    }
    else
    {

        ChildStack *child = header;
        ChildStack *before = NULL;

        while (child->next != NULL)
        {
            child->before = before;
            before = child;
            child = child->next;
        }

        child->next = calloc(1, sizeof(ChildStack));
        child->node = object;
        child->destroyer = destroyer;
    }

    return object;
}

void *StackNewElement(ChildStack *header, uint32_t size)
{

    void *object = calloc(1, size);

    if (header->node == NULL)
    {
        header->next = calloc(1, sizeof(ChildStack));
        header->node = object;
    }
    else
    {

        ChildStack *child = header;
        ChildStack *before = NULL;

        while (child->next != NULL)
        {
            child->before = before;
            before = child;
            child = child->next;
        }

        child->next = calloc(1, sizeof(ChildStack));
        child->node = object;
    }

    return object;
}

void *StackGetElement(ChildStack *header, uint32_t indx)
{

    uint32_t counter = 0;

    ChildStack *child = header;

    while (child->next != NULL)
    {
        if (child->node != NULL && counter == indx)
        {
            return child->node;
        }

        child = child->next;

        counter++;
    }

    return NULL;
}

uint32_t StackGetSize(ChildStack *header)
{

    uint32_t counter = 0;

    ChildStack *child = header;

    while (child->next != NULL)
    {
        child = child->next;

        counter++;
    }

    return counter;
}

int StackDeleteElement(ChildStack **header, void *obj, void (*deleter)(void *))
{
    if (obj == NULL || header == NULL || *header == NULL)
        return 1;

    ChildStack *child = *header;
    ChildStack *before = NULL;
    ChildStack *find = NULL;

    while (child != NULL)
    {
        if (child->node == obj)
        {
            find = child;
            break;
        }
        before = child;
        child = child->next;
    }

    if (find == NULL)
    {
        printf("Can't find that memory %p!\n", obj);
        return 1;
    }

    if (deleter != NULL)
        deleter(find->node);
    else if (find->destroyer != NULL)
        find->destroyer(find->node);

    free(find->node);
    find->node = NULL;

    if (before != NULL)
    {
        before->next = find->next;
    }
    else
    {
        // Удаляем головной элемент
        *header = find->next;
    }

    free(find);
    return 0;
}

void StackClear(ChildStack *header, void (*deleter)(void *), int output)
{
    if (header == NULL)
        return;
    ChildStack *child = header;
    uint32_t counter = 0;
    char *name = NULL;

    while (child != NULL)
    {
        ChildStack *next = child->next;
        if (child->node != NULL)
        {
            if (deleter != NULL)
                deleter(child->node);
            else if (child->destroyer != NULL)
                child->destroyer(child->node);
            free(child->node);
        }
        if (child->flags & TIGOR_CHILD_STACK_FLAG_IS_HEAD)
        {
            name = child->name; // Сохраняем указатель, но НЕ освобождаем его отдельно, если он часть структуры
        }
        else
        {
            counter++;
        }
        free(child);
        child = next;
    }
    if (counter > 0 && output && name != NULL)
    {
        printf("%s was automatic free %i times!\n", name, counter);
    }
    // free(name) УДАЛЕН, так как name был частью структуры child, которая уже освобождена
}

void StackDelete(ChildStack *header)
{
    free(header);
}

void VectorInit(CustomVector **vector, uint32_t elem_size, const char *name)
{
    (*vector) = (CustomVector *)calloc(1, sizeof(CustomVector));

    (*vector)->ptr = calloc(16, elem_size);
    (*vector)->array_size = 16;
    (*vector)->curr_size = 0;
    (*vector)->elem_size = elem_size;

    if (name != NULL)
    {
        memcpy((*vector)->name, name, strlen(name));
    }
}

void VectorInitWD(CustomVector **vector, uint32_t elem_size, const char *name, void (*destroyer)(void *))
{
    (*vector) = (CustomVector *)calloc(1, sizeof(CustomVector));

    (*vector)->ptr = calloc(64, elem_size);
    (*vector)->array_size = 64;
    (*vector)->curr_size = 0;
    (*vector)->elem_size = elem_size;
    (*vector)->destroyer = destroyer;

    if (name != NULL)
    {
        memcpy((*vector)->name, name, strlen(name));
    }
}

void VectorResize(CustomVector *vector, uint32_t size)
{

    if (vector->array_size >= size)
        return;

    uint32_t next_size = size;

    if (next_size > 4096)
    {
        while (next_size % 4096)
            next_size++;
    }

    vector->ptr = realloc(vector->ptr, next_size * vector->elem_size);
    vector->array_size = next_size;
}

void *VectorAdd(CustomVector *vector) {
    if (vector == NULL) return NULL;

    if (vector->curr_size + 1 >= vector->array_size) {
        uint32_t next_size = vector->array_size * 2;
        if (next_size > 4096) {
            while (next_size % 4096) next_size++;
        }
        VectorResize(vector, next_size);
        if (vector->ptr == NULL) return NULL;
    }

    char *point = (char *)vector->ptr;
    point += vector->curr_size * vector->elem_size;
    memset(point, 0, vector->elem_size);
    vector->curr_size++;
    return point;
}

void *VectorAddArray(CustomVector *vector, uint32_t size)
{
    if (vector == NULL)
        return NULL;

    if (vector->curr_size + size >= vector->array_size)
    {
        uint32_t next_size = vector->array_size * 2;

        while (next_size < size)
        {
            next_size = next_size * 2;
        }

        if (next_size > 4096)
        {
            while (next_size % 4096)
                next_size++;
        }

        VectorResize(vector, next_size);
    }

    char *point = vector->ptr;
    point += vector->curr_size * vector->elem_size;
    memset(point, 0, vector->elem_size * size);

    vector->curr_size += size;

    return point;
}

void VectorCopy(CustomVector *vector, void *obj)
{
    if (vector == NULL)
        return;

    if (vector->curr_size + 1 >= vector->array_size)
    {
        uint32_t next_size = vector->array_size * 2;

        if (next_size > 4096)
        {
            while (next_size % 4096)
                next_size++;
        }

        void *temp = calloc(next_size, vector->elem_size);
        memcpy(temp, vector->ptr, vector->array_size * vector->elem_size);
        free(vector->ptr);
        vector->ptr = temp;
        vector->array_size = next_size;
    }

    char *point = vector->ptr;
    memcpy(&point[vector->curr_size * vector->elem_size], obj, vector->elem_size);

    vector->curr_size++;
}

void VectorCopyArray(CustomVector *vector, void *obj, uint32_t size)
{
    if (vector == NULL)
        return;
    if (vector->curr_size + size > vector->array_size)
    {
        uint32_t next_size = vector->array_size * 2;
        while (next_size < vector->curr_size + size)
        {
            next_size = next_size * 2;
        }
        if (next_size > 4096)
        {
            while (next_size % 4096)
                next_size++;
        }
        void *temp = calloc(next_size, vector->elem_size);
        memcpy(temp, vector->ptr, vector->array_size * vector->elem_size);
        free(vector->ptr);
        vector->ptr = temp;
        vector->array_size = next_size;
    }
    char *point = (char *)vector->ptr;
    memcpy(&point[vector->curr_size * vector->elem_size], obj, vector->elem_size * size);
    vector->curr_size += size;
}

void VectorDelete(CustomVector *vector, void *obj)
{
    if (vector == NULL || obj == NULL)
        return;

    char *start = (char *)vector->ptr;
    int found_index = -1;

    for (uint32_t i = 0; i < vector->curr_size; i++)
    {
        if (start + (i * vector->elem_size) == (char *)obj)
        {
            found_index = i;
            break;
        }
    }

    if (found_index != -1)
    {
        if (vector->destroyer != NULL)
        {
            vector->destroyer(obj);
        }
        // Сдвигаем оставшиеся элементы влево
        if (found_index < (int)vector->curr_size - 1)
        {
            memmove(start + (found_index * vector->elem_size),
                    start + ((found_index + 1) * vector->elem_size),
                    (vector->curr_size - 1 - found_index) * vector->elem_size);
        }
        // Очищаем последний элемент (который теперь дублируется)
        memset(start + ((vector->curr_size - 1) * vector->elem_size), 0, vector->elem_size);
        vector->curr_size--;
    }
}

void *VectorGetData(CustomVector *vector)
{

    if (vector == NULL)
        return NULL;

    return vector->ptr;
}

uint32_t VectorGetSize(CustomVector *vector)
{

    if (vector == NULL)
        return 0;

    return vector->curr_size;
}

uint32_t VectorGetCapacity(CustomVector *vector)
{

    if (vector == NULL)
        return 0;

    return vector->array_size;
}

void VectorClear(CustomVector *vector)
{
    if (vector == NULL)
        return;

    memset(vector->ptr, 0, vector->elem_size * vector->curr_size);
    vector->curr_size = 0;
}

void VectorDestroy(CustomVector *vector)
{

    if (vector == NULL)
        return;

    free(vector->ptr);
    free(vector);
}

void *MakeAlloc(AllocObj *obj)
{

    void *data = calloc(obj->count, obj->size);

    if (obj->size * obj->count > biggest_size)
        biggest_size = obj->size * obj->count;

    if (alloc_memory_head == NULL)
        InitMemory();

    obj->ptr = data;

    if (alloc_memory_head->node == NULL)
    {
        alloc_memory_head->next = calloc(1, sizeof(ChildStack));
        alloc_memory_head->node = obj;
    }
    else
    {

        ChildStack *child = alloc_memory_head;

        while (child->next != NULL)
        {
            child = child->next;
        }

        child->next = calloc(1, sizeof(ChildStack));
        child->node = obj;
    }

    alloc_counter++;

    return data;
}

void *AllocateMemoryN(size_t count, int32_t size, char *name)
{
    //printf("ALLOC: %s (%zu x %d)\n", name ? name : "unnamed", count, size);

    AllocObj *obj = calloc(1, sizeof(AllocObj));
    obj->size = size;
    obj->count = count;

    uint32_t len = strlen(name);
    obj->name = calloc(len + 1, sizeof(char));
    memcpy(obj->name, name, sizeof(char) * len);
    obj->name[len] = '\0';

    return MakeAlloc(obj);
}

void *AllocateMemoryP(size_t count, int32_t size, void *parent)
{

    AllocObj *obj = calloc(1, sizeof(AllocObj));
    obj->size = size;
    obj->count = count;
    obj->parent = parent;

    return MakeAlloc(obj);
}

void *AllocateMemory(size_t count, int32_t size)
{

    AllocObj *obj = calloc(1, sizeof(AllocObj));
    obj->size = size;
    obj->count = count;

    return MakeAlloc(obj);
}

uint32_t GetAllocatedMemoryCount()
{

    ChildStack *child = alloc_memory_head;

    uint32_t count = 0;

    while (child->next != NULL)
    {
        child = child->next;

        count++;
    }

    return count;
}

int FreeMemory(void *data)
{
    if (data == NULL)
        return 1;

    ChildStack *child = alloc_memory_head;
    ChildStack *before = NULL;

    while (child != NULL)
    {
        if (child->node != NULL)
        {
            AllocObj *obj = (AllocObj *)child->node;
            if (obj->ptr == data)
                break;
        }
        before = child;
        child = child->next;
    }

    if (child == NULL || child->node == NULL)
    {
        printf("Can't find that memory : %p\n", data);
        return 1;
    }

    AllocObj *obj = (AllocObj *)child->node;
    free(obj->ptr);
    if (obj->name != NULL){
        free(obj->name);
        obj->name = NULL;
    }
    free(child->node);
    child->node = NULL;

    if (before != NULL)
    {
        before->next = child->next;
    }
    else
    {
        alloc_memory_head = child->next;
    }

    free(child);
    return 0;
}

void ClearAllAllocatedMemory()
{
    ChildStack *child = alloc_memory_head;
    uint32_t counter = 0;

    if (child == NULL)
        return;

#ifndef NDEBUG
    printf("Allocating times : %i\n", alloc_counter);
    printf("Allocated count : %i\n", GetAllocatedMemoryCount());
    printf("Allocated biggest size is : %i\n", biggest_size);
#endif

    while (child != NULL)
    {
        ChildStack *next = child->next;
        if (child->node != NULL)
        {
            counter++;
            AllocObj *obj = (AllocObj *)child->node;
            free(obj->ptr);
            if (obj->name != NULL)
            {
#ifndef NDEBUG
                printf("Object not free with name : %s\n", obj->name);
#endif
                free(obj->name);
            }
            free(child->node);
        }
        free(child);
        child = next;
    }
    alloc_memory_head = NULL;

    if (counter > 0)
        printf("Auto free allocated buffers count : %i\n", counter);
}