Issues with Custom Memory Pool Implementation in C - Allocation and Deallocation Problems
I've been banging my head against this for hours. I'm optimizing some code but I'm not sure how to approach I'm working on a personal project and I'm working on a personal project and I'm working on a custom memory pool implementation in C for a small embedded system project aimed at optimizing dynamic memory usage..... The goal is to manage memory allocations for a set of fixed-size objects, but I'm running into problems with memory fragmentation and improper deallocations. My memory pool structure looks like this: ```c #define POOL_SIZE 1024 #define OBJECT_SIZE 64 typedef struct MemoryPool { char pool[POOL_SIZE]; int freeIndex; } MemoryPool; MemoryPool memPool; void initMemoryPool() { memPool.freeIndex = 0; } void* allocateObject() { if (memPool.freeIndex + OBJECT_SIZE > POOL_SIZE) { return NULL; // Out of memory } void* obj = &memPool.pool[memPool.freeIndex]; memPool.freeIndex += OBJECT_SIZE; return obj; } void deallocateObject(void* obj) { // Custom logic to mark the object as free (not implemented yet) } ``` After running the program, I noticed that the allocation function sometimes returns `NULL`, even though the pool should have enough space. I suspect the `freeIndex` is not being managed correctly during deallocation. However, I'm not marking the memory as free yet. I also attempted to print the `freeIndex` before and after allocations to ensure it’s incrementing correctly, but it seems to behave inconsistently. Additionally, when I try to deallocate an object, I get unpredictable behavior, including segmentation faults. I've implemented the `deallocateObject` function with a plan to simply reset the `freeIndex`, but this results in corrupted memory access if the pointer passed is not handled correctly. ```c int main() { initMemoryPool(); void *obj1 = allocateObject(); void *obj2 = allocateObject(); deallocateObject(obj1); // More allocations and deallocations... return 0; } ``` Does anyone have insights into how to properly implement freeing memory in a custom pool while avoiding fragmentation? Should I be using a different strategy for managing allocated objects, such as a linked list or a bitmap for tracking free blocks? Any advice on best practices for this kind of implementation would be greatly appreciated. This is part of a larger application I'm building. Thanks in advance! Has anyone dealt with something similar? For context: I'm using C on macOS. Any feedback is welcome! Any suggestions would be helpful. I'm using C 3.10 in this project. Thanks for your help in advance!