src/e_memory.c - master - Zamar_Terrier/TigorEngineWeb2

src/e_memory.c
665 строк14 KB
Ilia Zamaruev
wasi delete and make local mini stb lib
17 фев 2026, 16:41
17 фев 2026, 16:41f5863af
#include "e_memory.h"

#include "malloc.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)
        return 1;

    ChildStack *child = (*header), *last_header = NULL;
    ChildStack *find = NULL;
    ChildStack *before = NULL;

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

        before = child;
        child = child->next;
    }

    if(find == NULL){
        #ifndef NDEBUG
        //consoleLog("Can't find that memry 0x%x!\n", (uint32_t)find);
        #endif
        return 1;
    }

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

    free(find->node);
    find->node = NULL; 
    if(before != NULL)
        before->next = find->next;
    else{
        if(find == (*header)){
            find->next->name = find->name;
            find->next->flags = find->flags;
            (*header) = find->next;
        }else{
            last_header = (*header);
            (*header) = find->next;
            (*header)->name = last_header->name;
            (*header)->flags = last_header->flags;
        }
    }

    free(find);
    find = NULL;

    return 0;
}

void StackClear(ChildStack *header, void(*deleter)(void *), int output){
    
    if(header == NULL)
        return;

    ChildStack *next = NULL;
    ChildStack *before = NULL;
    ChildStack *child = header;
    
    uint32_t counter = 0;

    char *name = NULL;
       
    while(child != NULL){    
        
        if(child->node != NULL){            
            if(deleter != NULL)
                deleter(child->node);
            else if(child->destroyer != NULL)
                child->destroyer(child->node);

            free(child->node);
        }

        before = child;  
        child = child->next;

        if(before->flags & TIGOR_CHILD_STACK_FLAG_IS_HEAD)
            name = before->name;
        else
            counter++;
            

        free(before);
        before = NULL;
    }

    #ifndef NDEBUG
    if(counter > 0 && output)
        //consoleLog("%s was automatic free %i times!\n", name, counter);
    #endif

    free(name);
}

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);
    }

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

    vector->curr_size ++;

    return point;
}


void VectorAddExist(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 ++;
        }

        VectorResize(vector, next_size);
    }

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

    vector->curr_size ++;
}

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 + 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 * size);

    vector->curr_size += size;
}

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

    char *start = vector->ptr, *src_iter = vector->ptr, *next_iter = src_iter;

    int last = 0, iter = 0;
    
    if(next_iter == obj){
        memset(next_iter, 0, vector->elem_size);
        goto end;
    }

    if(vector->destroyer != NULL)
        vector->destroyer(obj);

    while(next_iter < start + vector->curr_size * vector->elem_size){
        if(next_iter != src_iter){
            memcpy(src_iter, next_iter, vector->elem_size);
        }
        next_iter += vector->elem_size;
        src_iter += vector->elem_size;

        if(next_iter == obj)
            next_iter += vector->elem_size;

        iter ++;
    }

    if(next_iter == obj)
        memset(next_iter, 0, vector->elem_size);
    else if(src_iter == obj){
        memset(src_iter, 0, vector->elem_size);
    }
end:

    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;
}

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

    memcpy(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){

    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;
    
    void *curr = NULL;

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

    while(child != NULL)
    {
        curr = child->node;
        
        if(curr != NULL){
            obj = curr;
            if(obj->ptr == data)
                break;
        }else
            break;

        before = child;
        child = child->next;
    }

    if(curr == NULL){
        #ifndef NDEBUG
        //consoleLog("Can't find that memory : 0x%x\n", (uint32_t)data);
        #endif
        return 1;
    }

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

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

        free(child);
        child = NULL;
    }
    return 0;
}

void ClearAllAllocatedMemory(){
    ChildStack *child = alloc_memory_head;
    ChildStack *before = NULL;
    AllocObj *obj = NULL;
    
    uint32_t counter = 0;
    
    if(child == NULL)
        return;

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

    while(child != NULL)
    {
        if(child->node != NULL)
            counter ++;

        if(child->node != NULL){
            obj = child->node;
            free(obj->ptr);
            if(obj->name != NULL){
                #ifndef NDEBUG
                //consoleLog("Object not free with name : %s\n", obj->name);
                #endif   

                free(obj->name);
            }
            free(child->node);
            child->node = NULL;
        }

        child = alloc_memory_head = child->next;

        free(before);
        before = NULL;
    }

    if(alloc_memory_head != NULL)
        free(alloc_memory_head);

    #ifndef NDEBUG
    /*if(counter > 0)
        consoleLog("Auto free allocated buffers count : %i\n", counter);*/
    #endif
}