memory_management.c

#include <stddef.h>
#include <stdio.h>
#include "memory_management.h"

void printFreeList()
{
	printf("Free List: ");
	struct Block *curr = freeList;
	while (curr != NULL)
	{
		printf("[%zu] -> ", curr->size);
		curr = curr->next;
	}
	printf("NULL\n");
}

// Global variable to keep track of the allocated memory blocks
void initialize()
{
	freeList = (Block *)heap;
	freeList->size = sizeof(heap) - sizeof(Block);
	freeList->judge = 0; // 0:free 1:uesd
	freeList->next = NULL;
}

void *_malloc(size_t size)
{
	// If the size of the request is zero, return NULL
	if (size == 0)
	{
		return NULL;
	}

	// Align to a multiple of the pointer size
	size = (size + sizeof(void *) - 1) & ~(sizeof(void *) - 1);

	// If freeList is empty, initialize it.
	if (freeList == NULL)
	{
		initialize();
	}

	Block *current = freeList;
	Block *previous = NULL;
	while (current != NULL)
	{
		if (current->size >= size)
		{
			// Finding the right sized block of memory
			if (current->size > size + sizeof(Block))
			{
				// Splitting memory blocks
				Block *newBlock = (Block *)((char *)current + size + sizeof(Block));
				newBlock->size = current->size - size - sizeof(Block);
				newBlock->next = current->next;
				newBlock->judge = 0;
				current->size = size;
				current->next = newBlock;
				current->judge = 1;
			}

			// Remove the found memory block from freeList
			if (previous == NULL)
			{
				freeList = current->next;
			}
			else
			{
				previous->next = current->next;
			}

			mergeBlocks();
			return (void *)((char *)current + sizeof(Block));
		}

		// Updating the pointer
		previous = current;
		current = current->next;
	}

	// Not enough memory blocks
	return NULL;SSS
}

void _free(void *ptr)
{
	if (ptr == NULL)
	{
		// If the pointer is NULL, no operation is performed
		printf("Error: No memory to free\n");
		return;
	}

	// Convert the pointer to the block header
	struct Block *block = (struct Block *)ptr - 1;
	
	if (block->judge == 0)
	{
		printf("Error: Wild pointer detected\n");
		return;
	}

	// Add the block back to the free list
	if (freeList == NULL || block < freeList)
	{
		// add the block to the beginning of freeList
		block->next = freeList;
		block->judge = 0;
		freeList = block;
	}
	else
	{
		// Find where the block should be inserted
		Block *current = freeList;
		while (current->next != NULL && current->next < block)
		{
			current = current->next;
		}
		block->judge = 0;
		block->next = current->next;
		current->next = block;
	}

	// Merge adjacent free memory blocksS
	mergeBlocks();
}
S
void mergeBlocks()
{
	// Iterate through the chain table and merge adjacent free memory blocks
	Block *current = freeList;
	Block *prev = NULL;
	while (current != NULL && current->next != NULL)
	{
		if ((char *)current + current->size + sizeof(Block) == (char *)current->next)
		{
			// Two neighboring blocks of memory are contiguous
			current->size += current->next->size + sizeof(Block);
			current->next = current->next->next;
		}
		else
		{
			// Move to the next block of memory
			current = current->next;
		}
	}
}