Implement basic malloc and add unit test for it (#21)

## Description

Implement basic malloc and add unit test for it.

## Issues

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

Closes #5 

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

Related: #<issue-number>

## Testing

malloc unit test

Author: felixnagele

include/malloc_from_scratch/memory_internal.h

@@ -11,18 +11,25 @@ namespace internal
 
 struct MemoryBlock
 {
-    size_t size;
-    bool allocated;
-    MemoryBlock* next;
+    size_t size_;
+    bool allocated_;
+    MemoryBlock* next_;
 };
 
-extern MemoryBlock* block_list_head;
-extern void* heap_start;
-extern pthread_mutex_t allocator_mutex;
+inline MemoryBlock* block_list_head = nullptr;
+inline void* heap_start = nullptr;
+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;
 
+void insertMemoryBlockAtEnd(MemoryBlock** block_list_head, MemoryBlock* new_block);
+void* getPayloadAddress(MemoryBlock* block);
+MemoryBlock* getMetadata(void* payload_address);
+void* increaseHeap(size_t size);
+void* decreaseHeap(MemoryBlock* block_heap_end, size_t size);
+
 } // namespace internal
 } // namespace mem
 

src/malloc.cpp

@@ -1,12 +1,91 @@
 #include "malloc_from_scratch/memory_allocator.h"
+#include "malloc_from_scratch/memory_internal.h"
+
+#include <unistd.h>
 
 namespace mem
 {
 
 void* malloc(size_t size)
 {
-    (void)size;
-    return nullptr;
+    if (internal::heap_start == nullptr)
+    {
+        internal::heap_start = sbrk(0);
+    }
+
+    internal::total_memory_allocated += size;
+
+    size_t total_size = sizeof(internal::MemoryBlock) + size;
+
+    void* new_memory_allocation = internal::increaseHeap(total_size);
+    if (new_memory_allocation == NULL)
+    {
+        return NULL;
+    }
+
+    internal::MemoryBlock* new_block =
+        reinterpret_cast<internal::MemoryBlock*>(new_memory_allocation);
+    new_block->size_ = size;
+    new_block->allocated_ = 1;
+    new_block->next_ = nullptr;
+
+    internal::insertMemoryBlockAtEnd(&internal::block_list_head, new_block);
+
+    return internal::getPayloadAddress(new_block);
+}
+
+namespace internal
+{
+
+void insertMemoryBlockAtEnd(MemoryBlock** block_list_head, MemoryBlock* new_block)
+{
+    if (*block_list_head == nullptr)
+    {
+        *block_list_head = new_block;
+    }
+    else
+    {
+        MemoryBlock* current = *block_list_head;
+        while (current->next_ != nullptr)
+        {
+            current = current->next_;
+        }
+        current->next_ = new_block;
+    }
+}
+
+void* getPayloadAddress(MemoryBlock* block)
+{
+    if (!block)
+    {
+        return nullptr;
+    }
+
+    return reinterpret_cast<void*>(reinterpret_cast<char*>(block) + BLOCK_METADATA_SIZE);
+}
+
+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)
+{
+    void* result = sbrk(static_cast<intptr_t>(size));
+    if (result == reinterpret_cast<void*>(-1))
+    {
+        return nullptr;
+    }
+
+    return result;
 }
 
+void* decreaseHeap(MemoryBlock* block_heap_end, size_t size) { return nullptr; }
+} // namespace internal
 } // namespace mem

tests/unit/test_malloc.cpp

@@ -0,0 +1,10 @@
+#include "malloc_from_scratch/memory_allocator.h"
+#include "test_utils.h"
+
+int main()
+{
+    void* ptr = mem::malloc(64);
+    ASSERT_NOT_NULL(ptr);
+
+    TEST_PASS();
+}