Implement advanced malloc features (#31)

## Description

Implement advanced malloc features.

## Issues

<!-- use if this PR fully resolves the issue -->

Closes #29 

<!-- use if this PR is linked but should not close the issue -->

Related: #<issue-number>

## Testing

<!-- Steps or notes on how reviewers can verify. -->

Author: felixnagele

include/malloc_from_scratch/memory_internal.h

@@ -22,13 +22,22 @@ inline size_t total_memory_allocated = 0;
 inline pthread_mutex_t allocator_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 constexpr size_t BLOCK_METADATA_SIZE = sizeof(MemoryBlock);
-constexpr size_t MIN_BLOCK_SIZE = 16;
+constexpr size_t BLOCK_SIZE = 16;
+constexpr size_t CHUNK_SIZE = 65536;
 
+// malloc
+void* increaseHeap(size_t size);
+MemoryBlock* findLargeEnoughFreeMemoryBlock(MemoryBlock** block_list_head, size_t size);
+void* splitFreeMemoryBlockIfPossible(MemoryBlock* new_block, size_t size);
+void* getMemoryBlockSplitAddress(MemoryBlock* new_block, size_t size);
 void insertMemoryBlockAtEnd(MemoryBlock** block_list_head, MemoryBlock* new_block);
+
+// helpers
 void* getPayloadAddress(MemoryBlock* block);
 MemoryBlock* getMetadata(void* payload_address);
-void* increaseHeap(size_t size);
-void* decreaseHeap(MemoryBlock* block_heap_end, size_t size);
+MemoryBlock* getMemoryBlockFromAddress(void* address);
+size_t getSizeOfAllocatedMemoryBlock(MemoryBlock* block);
+void* getErrorCodeInVoidPtr(size_t error_code);
 
 } // namespace internal
 } // namespace mem

src/malloc.cpp

@@ -1,6 +1,7 @@
 #include "malloc_from_scratch/memory_allocator.h"
 #include "malloc_from_scratch/memory_internal.h"
 
+#include <cstdlib>
 #include <unistd.h>
 
 namespace mem
@@ -15,28 +16,117 @@ void* malloc(size_t size)
 
     internal::total_memory_allocated += size;
 
-    size_t total_size = sizeof(internal::MemoryBlock) + size;
+    internal::MemoryBlock* found_block =
+        internal::findLargeEnoughFreeMemoryBlock(&internal::block_list_head, size);
 
-    void* new_memory_allocation = internal::increaseHeap(total_size);
-    if (new_memory_allocation == NULL)
+    if (found_block != nullptr)
+    {
+        void* return_address = internal::splitFreeMemoryBlockIfPossible(found_block, size);
+        return return_address;
+    }
+
+    bool is_frame_used = false;
+    size_t total_size = 0;
+    if (size < internal::CHUNK_SIZE)
     {
-        return NULL;
+        total_size = internal::BLOCK_METADATA_SIZE + internal::CHUNK_SIZE;
+        is_frame_used = true;
+    }
+    else
+    {
+        total_size = internal::BLOCK_METADATA_SIZE + size;
+        is_frame_used = false;
     }
 
-    internal::MemoryBlock* new_block =
-        reinterpret_cast<internal::MemoryBlock*>(new_memory_allocation);
-    new_block->size_ = size;
-    new_block->allocated_ = 1;
-    new_block->next_ = nullptr;
+    void* new_memory_allocation = internal::increaseHeap(total_size);
+    if (new_memory_allocation == nullptr)
+    {
+        return nullptr;
+    }
 
-    internal::insertMemoryBlockAtEnd(&internal::block_list_head, new_block);
+    internal::MemoryBlock* new_block = internal::getMemoryBlockFromAddress(new_memory_allocation);
+    if (is_frame_used)
+    {
+        new_block->size_ = internal::CHUNK_SIZE;
+        new_block->allocated_ = false;
+        new_block->next_ = nullptr;
+        internal::insertMemoryBlockAtEnd(&internal::block_list_head, new_block);
+        void* return_address = internal::splitFreeMemoryBlockIfPossible(new_block, size);
+        return return_address;
+    }
+    else
+    {
+        new_block->size_ = size;
+        new_block->allocated_ = true;
+        new_block->next_ = nullptr;
+        internal::insertMemoryBlockAtEnd(&internal::block_list_head, new_block);
+    }
 
     return internal::getPayloadAddress(new_block);
 }
 
 namespace internal
 {
 
+void* increaseHeap(size_t size)
+{
+    void* result = sbrk(static_cast<intptr_t>(size));
+    if (result == getErrorCodeInVoidPtr(-1) || result == getErrorCodeInVoidPtr(0))
+    {
+        exit(-1);
+    }
+
+    return result;
+}
+
+MemoryBlock* findLargeEnoughFreeMemoryBlock(MemoryBlock** block_list_head, size_t size)
+{
+    MemoryBlock* current = *block_list_head;
+    while (current != nullptr)
+    {
+        if (current->allocated_ == false && current->size_ >= size)
+        {
+            return current;
+        }
+        current = current->next_;
+    }
+    return nullptr;
+}
+
+void* splitFreeMemoryBlockIfPossible(MemoryBlock* new_block, size_t size)
+{
+    if (new_block == nullptr)
+    {
+        return nullptr;
+    }
+
+    size_t remaining_size = new_block->size_ - size;
+    char one_byte_payload_size_requirement = 1;
+    if (remaining_size >= BLOCK_METADATA_SIZE + one_byte_payload_size_requirement)
+    {
+        void* split_address = getMemoryBlockSplitAddress(new_block, size);
+        MemoryBlock* new_temp_block = getMemoryBlockFromAddress(split_address);
+        new_temp_block->size_ = remaining_size - BLOCK_METADATA_SIZE;
+        new_temp_block->allocated_ = false;
+        new_temp_block->next_ = new_block->next_;
+
+        new_block->size_ = size;
+        new_block->allocated_ = true;
+        new_block->next_ = new_temp_block;
+    }
+    else
+    {
+        new_block->allocated_ = true;
+    }
+
+    return getPayloadAddress(new_block);
+}
+
+void* getMemoryBlockSplitAddress(MemoryBlock* new_block, size_t size)
+{
+    return (reinterpret_cast<char*>(getPayloadAddress(new_block)) + size);
+}
+
 void insertMemoryBlockAtEnd(MemoryBlock** block_list_head, MemoryBlock* new_block)
 {
     if (*block_list_head == nullptr)
@@ -54,6 +144,7 @@ void insertMemoryBlockAtEnd(MemoryBlock** block_list_head, MemoryBlock* new_bloc
     }
 }
 
+// helpers
 void* getPayloadAddress(MemoryBlock* block)
 {
     if (!block)
@@ -66,26 +157,21 @@ void* getPayloadAddress(MemoryBlock* block)
 
 MemoryBlock* getMetadata(void* payload_address)
 {
-    if (!payload_address)
-    {
-        return nullptr;
-    }
-
     return reinterpret_cast<MemoryBlock*>(reinterpret_cast<char*>(payload_address) -
                                           BLOCK_METADATA_SIZE);
 }
 
-void* increaseHeap(size_t size)
+MemoryBlock* getMemoryBlockFromAddress(void* address)
 {
-    void* result = sbrk(static_cast<intptr_t>(size));
-    if (result == reinterpret_cast<void*>(-1))
-    {
-        return nullptr;
-    }
+    return reinterpret_cast<MemoryBlock*>(address);
+}
 
-    return result;
+size_t getSizeOfAllocatedMemoryBlock(MemoryBlock* block)
+{
+    return reinterpret_cast<size_t>(getPayloadAddress(block));
 }
 
-void* decreaseHeap(MemoryBlock* block_heap_end, size_t size) { return nullptr; }
+void* getErrorCodeInVoidPtr(size_t error_code) { return reinterpret_cast<void*>(error_code); }
+
 } // namespace internal
 } // namespace mem