Egor00f
7505baa105
кусок кода в `realloc`, провереющий на свободную ноду безсмысленен, т.к. в `free` в любом случае сливает освобождаемую ноду с предыдущей.
82 lines
2.9 KiB
C
82 lines
2.9 KiB
C
#ifndef _LIBC_STDLIB__MEM_
|
|
#define _LIBC_STDLIB__MEM_
|
|
|
|
#include <stddef.h>
|
|
|
|
struct mem_node {
|
|
size_t free; // Amount of free space in this node. When equal to size, the entire node is free.
|
|
|
|
size_t size; // Total size of this memory node.
|
|
|
|
struct mem_node* last; // Pointer to the previous memory node in the linked list.
|
|
struct mem_node* next; // Pointer to the next memory node in the linked list.
|
|
};
|
|
|
|
struct mem_block {
|
|
size_t size; // Size of the allocated memory block.
|
|
|
|
size_t a; // align to 8bytes
|
|
};
|
|
|
|
// Size of the blocks allocated by `_ksys_alloc`
|
|
#define ALLOC_BLOCK_SIZE 4096
|
|
|
|
// Macro to get a pointer to the user data area from a mem_node pointer.
|
|
// This is done by adding the size of the mem_node structure to the mem_node pointer.
|
|
#define GET_MEM_NODE_PTR(node) (char*)((char*)(node) + sizeof(struct mem_node))
|
|
|
|
// Macro to check if a memory node is completely free.
|
|
#define MEM_NODE_IS_FREE(node) (node->free == node->size)
|
|
|
|
// Macro to get the amount of used memory in a memory node.
|
|
#define GET_MEM_NODE_USED_MEM(node) (node->size - node->free)
|
|
|
|
// Macro to get a pointer to the mem_node structure from a user data pointer.
|
|
// This is done by subtracting the size of the mem_node structure from the user data pointer.
|
|
#define GET_MEM_NODE_HEADER(ptr) ((struct mem_node*)(((char*)ptr) - sizeof(struct mem_node)))
|
|
|
|
// Macro to check if two adjacent memory nodes are in the same block.
|
|
// Checks if the end of the left node's allocated space is the start of the right node.
|
|
#define MEM_NODES_ARE_IN_ONE_BLOCK(left, right) (GET_MEM_NODE_PTR(left) + ((struct mem_node*)left)->size == (char*)right)
|
|
|
|
// Macro to merge two adjacent memory nodes.
|
|
#define CHECK_SIDE_IN_OTHER_BLOCK(node, side) (side == NULL || ((side != NULL) && !MEM_NODES_ARE_IN_ONE_BLOCK(node, side)))
|
|
|
|
// align a value to a specified alignment.
|
|
// Ensures that the allocated memory is aligned to a certain boundary
|
|
inline size_t __mem_align(size_t value, size_t align)
|
|
{
|
|
return ((value + align - 1) & ~(align - 1));
|
|
}
|
|
|
|
#define __mem_default_align(value) __mem_align(value, 8)
|
|
|
|
inline struct mem_node* __mem_MERGE_MEM_NODES(struct mem_node* base, struct mem_node* addition)
|
|
{
|
|
// addition is free && nodes base and addition both in one block, else merge is impossible
|
|
if (MEM_NODE_IS_FREE(addition) && MEM_NODES_ARE_IN_ONE_BLOCK(base, addition)) {
|
|
// just change size
|
|
const size_t s = addition->size + sizeof(struct mem_node);
|
|
base->size += s;
|
|
base->free += s;
|
|
|
|
// and delete addition from list
|
|
if (addition->next != NULL) {
|
|
addition->next->last = base;
|
|
base->next = addition->next;
|
|
} else {
|
|
base->next = NULL;
|
|
}
|
|
return base;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// Static pointer to the first memory node in the linked list.
|
|
// This acts as the head of the memory pool.
|
|
static struct mem_node* __mem_node = NULL;
|
|
|
|
static struct mem_node* __last_biggest_mem_node = NULL;
|
|
|
|
#endif // _LIBC_STDLIB_MEM_
|