main.c

@@ -2,6 +2,7 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
+#include <string.h>
 
 #define ALIGN16(s) (((s) + 15) & ~0x0F)
 #define BLOCK_SIZE sizeof(struct block)
@@ -24,29 +25,32 @@ struct block *last = NULL;
 /// @returns The new memory block.
 struct block *extend_heap(size_t s)
 {
-	// Ensure the allocated size is at least the minimum block size
-	if (s < MINIMUM_BLOCK_SIZE)
-		s = MINIMUM_BLOCK_SIZE;
+    // Ensure the allocated size is at least the minimum block size
+    if (s < MINIMUM_BLOCK_SIZE)
+        s = MINIMUM_BLOCK_SIZE;
 
-	struct block *b = (struct block *)sbrk(0); // Get the current break
+    struct block *b = (struct block *)sbrk(0); // Get the current break
 
-	// Add the size of the block header to the requested size
-	s += BLOCK_SIZE;
+    // Attempt to extend the break by s bytes
+    void *new_break = sbrk(BLOCK_SIZE + s);
+    if (new_break == (void *)-1)
+    {
+        // Handle the error, e.g., by setting an error code or printing an error message
+        fprintf(stderr, "Failed to extend heap by %zu bytes.\n", s);
+        return NULL;
+    }
 
-	if (sbrk(s) == (void *)-1) // Extend the break by s bytes
-		return NULL;
+    b->size = s;
+    b->prev = last;
+    b->next = NULL;
+    b->free =  0;
 
-	b->size = s;
-	b->prev = last;
-	b->next = NULL;
-	b->free = 0;
+    if (last)
+        last->next = b;
 
-	if (last)
-		last->next = b;
+    last = b;
 
-	last = b;
-
-	return b;
+    return b;
 }
 
 /// Finds the first block that will fit the given size.
@@ -82,13 +86,13 @@ struct block *fragment_block(struct block *in, size_t s)
 
 	// Create the new block in the remainder space
 	struct block *newBlock = (struct block *)((char *)(in + 1) + s);
-	newBlock->size = remainderSize;
+	newBlock->size = remainderSize; // Subtract the size of the block header
 	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->size = newBlockSize; // Subtract the size of the block header
 	in->next = newBlock;
 
 	// Insert the new block into the linked list of blocks
@@ -107,17 +111,15 @@ struct block *find_best_fit(size_t s)
 	while (current)
 	{
 		if (current->free && current->size >= s)
-	{
-			if (best_fit && current->size < best_fit->size) // Check for NULL before comparison
 		{
+			if (best_fit == NULL || current->size < best_fit->size)
 			{
 				best_fit = current;
 			}
 		}
 		current = current->next;
 	}
-	return best_fit;
-	}
+	return best_fit; // This return statement is now outside the while loop
 }
 
 /// Will find or allocate a memory block.
@@ -199,82 +201,96 @@ void *realloc(void *ptr, size_t new_size)
 /// Will flag the provided memory as free and will defragment other blocks adjacent to it.
 /// @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.
-void my_custom_free(void *ptr)
+void free(void *ptr)
 {
-    if (!ptr)
-    {
-        return;
-    }
+	if (!ptr)
+	{
+		return;
+	}
 
-    struct block *b = (struct block *)((char *)ptr - BLOCK_SIZE);
-    if (b->free)
-    {
-        fprintf(stderr, "Double free detected at block %p.\n", ptr);
-        abort(); // Terminate the program immediately due to serious error
-    }
+	struct block *b = (struct block *)((char *)ptr - BLOCK_SIZE);
+	if (b->free)
+	{
+		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)
-    {
-        // Merge with previous block
-        b->prev->size += BLOCK_SIZE + b->size;
-        b->prev->next = b->next;
-        b = b->prev;
-    }
+	// Coalesce free blocks
+	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;
+	}
 
-    // If there is a next block and it's free, merge with it
-    if (b->next && b->next->free)
-    {
-        b->size += BLOCK_SIZE + b->next->size;
-        b->next = b->next->next;
-        if (b->next)
-        {
-            b->next->prev = b;
-        }
-    }
+	// If there is a next block and it's free, merge with it
+	if (b->next && b->next->free)
+	{
+		b->size += BLOCK_SIZE + b->next->size;
+		b->next = b->next->next;
+		if (b->next)
+		{
+			b->next->prev = b; // Update the prev pointer of the next block
+		}
+	}
 
-    // After merging, update the 'last' pointer if necessary
-    if (!b->next)
-    {
-        last = b;
-    }
+	// After merging, update the 'last' pointer if necessary
+	if (!b->next)
+	{
+		last = b;
+	}
 
-    // Check if we can shrink the heap
-    if (b == last)
-    {
-        // Update 'last' to the previous block or NULL if there's no previous block
-        last = b->prev;
-        if (last)
-        {
-            last->next = NULL;
-        }
-        else
-        {
-            first = NULL;
-        }
-        // Reduce the program break to release the memory
-        sbrk(0 - (b->size + BLOCK_SIZE));
-    }
+	// Check if we can shrink the heap
+	if (b == last)
+	{
+		// Update 'last' to the previous block or NULL if there's no previous block
+		last = b->prev;
+		if (last)
+		{
+			last->next = NULL;
+		}
+		else
+		{
+			first = NULL;
+		}
+		// Reduce the program break to release the memory
+		sbrk(0 - (b->size + BLOCK_SIZE));
+	}
+}
+
+size_t get_heap_size()
+{
+	size_t total_size = 0;
+	struct block *current = first;
+
+	while (current != NULL)
+	{
+		total_size += current->size;
+		current = current->next;
+	}
+
+	return total_size;
 }
 
 int main()
 {
 	int *a = (int *)malloc(sizeof(int));
 	int *b = (int *)malloc(sizeof(int));
+	int *c = (int *)malloc(sizeof(int)); // Allocate memory for c
 
 	*a = 5;
 	*b = 12;
 
-	printf("Test 1: %i\n", *a);
-	printf("Test 2: %i\n", *b);
-	printf("Heap Size: %zu Bytes\n", get_heap_size());
+	printf("Test  1: %i\n", *a);
+	printf("Test  2: %i\n", *b);
+	printf("Heap Size: %zu Bytes\n", get_heap_size()); // Assuming get_heap_size is implemented
 
-	free(a);
-	free(b);
-
-	int *c = (int *)malloc(sizeof(int));
+	free(a); // Free memory for a
+	free(b); // Free memory for b
+	free(c); // Free memory for c
 
 	return 0;
 }