Karutoh/CustomHeapManager
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: Karutoh:f341253aa8994f08b72fbdb683455b25bc782c1d
Branches Tags
Karutoh:main
Karutoh:gbowne1-mathfix
Karutoh:gbowne1-fixesimplmerge
..
compare: Karutoh:af512c99b6e5cff5052e7b94704d5ac1ef7e0013
Branches Tags
Karutoh:main
Karutoh:gbowne1-mathfix
Karutoh:gbowne1-fixesimplmerge

No commits in common. "f341253aa8994f08b72fbdb683455b25bc782c1d" and "af512c99b6e5cff5052e7b94704d5ac1ef7e0013" have entirely different histories.
f341253aa8 ... af512c99b6

1 changed files with 69 additions and 164 deletions
Show Stats Expand all files Collapse all files

185
main.c
View File

@ -1,11 +1,11 @@
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
#include <stdlib.h> #include <sys/syscall.h>
#define ALIGN16(s) (((s) + 15) & ~0x0F) #define ALIGN4(s) (((((s)-1)>>2)<<2)+4)
#define BLOCK_SIZE sizeof(struct block) #define BLOCK_SIZE sizeof(struct block)
#define MINIMUM_BLOCK_SIZE (sizeof(struct block) + 16) #define MINIMUM_BLOCK_SIZE 4
/// The memory block's header. /// The memory block's header.
struct block struct block
@ -28,12 +28,9 @@ struct block *extend_heap(size_t s)
if (s < MINIMUM_BLOCK_SIZE) if (s < MINIMUM_BLOCK_SIZE)
s = MINIMUM_BLOCK_SIZE; s = MINIMUM_BLOCK_SIZE;
struct block *b = (struct block *)sbrk(0); // Get the current break struct block* b = (struct block*)syscall(SYS_brk, NULL);
// Add the size of the block header to the requested size if ((void*)syscall(SYS_brk, (char*)(b + 1) + s) == (void*)-1)
s += BLOCK_SIZE;
if (sbrk(s) == (void *)-1) // Extend the break by s bytes
return NULL; return NULL;
b->size = s; b->size = s;
@ -67,57 +64,17 @@ struct block *find_first(size_t s)
/// @returns The new memory block. /// @returns The new memory block.
struct block* fragment_block(struct block* in, size_t s) struct block* fragment_block(struct block* in, size_t s)
{ {
// Calculate the size of the new block, including the block header size_t totalSize = BLOCK_SIZE + s;
size_t newBlockSize = s + BLOCK_SIZE; struct block* b = (struct block*)((char*)(in + 1) + (in->size - totalSize));
b->size = s;
b->prev = in;
b->next = in->next;
b->free = 0;
// Check if the current block can be split in->size -= totalSize;
if (in->size <= newBlockSize) in->next = b;
{
// Cannot split, return the original block
return in;
}
// Calculate the size of the remainder block return b;
size_t remainderSize = in->size - newBlockSize;
// Create the new block in the remainder space
struct block *newBlock = (struct block *)((char *)(in + 1) + s);
newBlock->size = remainderSize;
newBlock->prev = in;
newBlock->next = in->next;
newBlock->free = 1; // Set the new block as free
// Update the current block to reflect the reduced size
in->size = newBlockSize;
in->next = newBlock;
// Insert the new block into the linked list of blocks
if (newBlock->next)
{
newBlock->next->prev = newBlock;
}
return newBlock;
}
struct block *find_best_fit(size_t s)
{
struct block *current = first;
struct block *best_fit = NULL;
while (current)
{
if (current->free && current->size >= s)
{
if (best_fit && current->size < best_fit->size) // Check for NULL before comparison
{
{
best_fit = current;
}
}
current = current->next;
}
return best_fit;
}
} }
/// Will find or allocate a memory block. /// Will find or allocate a memory block.
@ -126,143 +83,91 @@ struct block *find_best_fit(size_t s)
/// @todo Fragmenting functionality. /// @todo Fragmenting functionality.
void* malloc(size_t size) void* malloc(size_t size)
{ {
if (size == 0)
{
return NULL;
}
size = ALIGN16(size); // First align the requested size
size_t total_size = size + BLOCK_SIZE; // Then add the size of the block header
struct block* b; struct block* b;
size = ALIGN4(size);
if (first) if (first)
{ {
b = find_best_fit(size); b = find_first(size);
if (!b) if (!b)
{ b = extend_heap(size);
b = extend_heap(total_size); else if (b->size > BLOCK_SIZE + size)
if (!b)
{
return NULL; // Check if heap extension failed
}
}
else if (b->size > total_size + MINIMUM_BLOCK_SIZE)
{
b = fragment_block(b, size); b = fragment_block(b, size);
} }
}
else else
{ {
b = extend_heap(total_size); b = extend_heap(size);
if (!b) if (!b)
{
return NULL; return NULL;
}
first = b; first = b;
} }
b->free = 0; // Mark the block as used return b + 1;
return (char *)b + BLOCK_SIZE; // Return a pointer to the usable memory
} }
void* realloc(void* ptr, size_t new_size) void* realloc(void* ptr, size_t new_size)
{ {
if (!ptr) if (!ptr)
{
return malloc(new_size); return malloc(new_size);
}
if (new_size == 0) if (!new_size)
{
free(ptr);
return NULL; return NULL;
}
struct block *b = (struct block *)((char *)ptr - BLOCK_SIZE); struct block* b = (struct block*)ptr - 1;
if (b->size >= new_size + BLOCK_SIZE) if (b->free)
{ return NULL;
return ptr; // The block is already big enough
}
void *new_ptr = malloc(new_size); if (b->size == new_size)
if (!new_ptr) return ptr;
{ else if (b->size > BLOCK_SIZE + new_size)
return NULL; // Allocation failed return fragment_block(b, new_size) + 1;
}
memcpy(new_ptr, ptr, b->size - BLOCK_SIZE); // Copy old data to new block, excluding the header size
free(ptr); // Free the old block
return new_ptr; return NULL;
} }
/// Will flag the provided memory as free and will defragment other blocks adjacent to it. /// Will flag the provided memory as free and will defragment other blocks adjacent to it.
/// @param [in] ptr The memory to flag as free. /// @param [in] ptr The memory to flag as free.
/// @note If all data after the provided memory is free, it will reduce the heap size. /// @note If all data after the provided memory is free, it will reduce the heap size.
void my_custom_free(void *ptr) void free(void* ptr)
{ {
if (!ptr) if (!ptr)
{
return; return;
}
struct block *b = (struct block *)((char *)ptr - BLOCK_SIZE); struct block* b = (struct block*)ptr - 1;
if (b->free) if (b->free)
{ return;
fprintf(stderr, "Double free detected at block %p.\n", ptr);
abort(); // Terminate the program immediately due to serious error
}
b->free = 1; b->free = 1;
// Coalesce free blocks
while (b->prev && b->prev->free) while (b->prev && b->prev->free)
{
// Merge with previous block
b->prev->size += BLOCK_SIZE + b->size;
b->prev->next = b->next;
b = b->prev; b = b->prev;
}
// If there is a next block and it's free, merge with it while (b->next && b->next->free)
if (b->next && b->next->free)
{ {
b->size += BLOCK_SIZE + b->next->size; b->size += BLOCK_SIZE + b->next->size;
b->next = b->next->next; b->next = b->next->next;
if (b->next)
{
b->next->prev = b;
}
} }
// After merging, update the 'last' pointer if necessary
if (!b->next) if (!b->next)
{ syscall(SYS_brk, b);
last = b;
} }
// Check if we can shrink the heap /// Retrieves the total heap usage in bytes.
if (b == last) /// @returns Usage in bytes.
size_t get_heap_size()
{ {
// Update 'last' to the previous block or NULL if there's no previous block if (!first || !last)
last = b->prev; return 0;
if (last)
{ return ((char*)last + last->size) - (char*)first;
last->next = NULL;
}
else
{
first = NULL;
}
// Reduce the program break to release the memory
sbrk(0 - (b->size + BLOCK_SIZE));
}
} }
int main() int main()
{ {
int *a = (int *)malloc(sizeof(int)); int* a = (int*)malloc(1);
int *b = (int *)malloc(sizeof(int)); int* b = (int*)malloc(1);
*a = 5; *a = 5;
*b = 12; *b = 12;