toybchan/minimal-heap
1
0
Fork 0
mirror of https://github.com/ToyB-Chan/minimal-heap.git synced 2026-07-13 21:51:16 +02:00
Code Issues Packages Projects Releases Wiki Activity

outsourced lifetime of MIHP_Heap, gave heap ptr as identifier to platform functions

Browse Source
This commit is contained in:
toybchan
2026-06-08 21:52:22 +02:00
parent ad14fa7c74
commit dd92501753
3 changed files with 48 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
minimal_heap.h
View File

@@ -32,9 +32,9 @@
/* */ /* */
/* Hooks to be implemented by the library user */ /* Hooks to be implemented by the library user */
void* MIHP_PlatformRequestMemory(size_t minRequestedSize, size_t* outActualSize); // Alignment must at least be alignment of size_t, outActualSize must at least be minRequestedSize void* MIHP_PlatformRequestMemory(const struct _MIHP_Heap* heap, size_t minRequestedSize, size_t* outActualSize); // Alignment must at least be alignment of size_t, outActualSize must at least be minRequestedSize
bool MIHP_PlatformFreeMemory(void* ptr, size_t actualSize); bool MIHP_PlatformFreeMemory(const struct _MIHP_Heap* heap, void* ptr, size_t actualSize);
void MIHP_PlatformOnHeapCorruptionDetected(struct _MIHP_HeapCorruptionInfo info); void MIHP_PlatformOnHeapCorruptionDetected(const struct _MIHP_Heap* heap, struct _MIHP_HeapCorruptionInfo info);
/* */ /* */
#define MIHP_HEAP_CORRUPTION_TYPE_MEMORY_AREA_CHECKSUM_MISMATCH 0 #define MIHP_HEAP_CORRUPTION_TYPE_MEMORY_AREA_CHECKSUM_MISMATCH 0
@@ -94,7 +94,6 @@ typedef struct _MIHP_HeapSegmentHeader
typedef struct _MIHP_HeapCorruptionInfo typedef struct _MIHP_HeapCorruptionInfo
{ {
const struct _MIHP_Heap* Heap;
uint8_t Type; uint8_t Type;
const void* Ptr; const void* Ptr;
uint32_t ExpectedValue; uint32_t ExpectedValue;
@@ -108,14 +107,14 @@ typedef struct _MIHP_Heap
MIHP_HeapMemoryAreaHeader* FirstArea; MIHP_HeapMemoryAreaHeader* FirstArea;
MIHP_HeapMemoryAreaHeader* LastSuccessfulAllocationArea; MIHP_HeapMemoryAreaHeader* LastSuccessfulAllocationArea;
size_t HeapStructureAllocationSize;
MIHP_HEAP_LOCK_TYPE HeapLock; MIHP_HEAP_LOCK_TYPE HeapLock;
} MIHP_Heap; } MIHP_Heap;
/* API Interface */ /* API Interface */
MIHP_Heap* MIHP_CreateHeap(MIHP_HeapConfig config); bool MIHP_InitializeHeap(MIHP_Heap* heap, MIHP_HeapConfig config);
bool MIHP_DestroyHeap(MIHP_Heap* heap, bool force); bool MIHP_IsHeapInitialized(const MIHP_Heap* heap);
bool MIHP_UninitializeHeap(MIHP_Heap* heap, bool force);
void* MIHP_Allocate(MIHP_Heap* heap, size_t size); void* MIHP_Allocate(MIHP_Heap* heap, size_t size);
void* MIHP_Realloc(MIHP_Heap* heap, void* ptr, size_t newSize); void* MIHP_Realloc(MIHP_Heap* heap, void* ptr, size_t newSize);
bool MIHP_Free(MIHP_Heap* heap, void* ptr); bool MIHP_Free(MIHP_Heap* heap, void* ptr);

57
minimal_heap_implementation.inl
View File

@@ -5,49 +5,49 @@
#define MIHP_IS_PO2(Val) (Val != 0 && (Val & (Val - 1)) == 0) #define MIHP_IS_PO2(Val) (Val != 0 && (Val & (Val - 1)) == 0)
MIHP_Heap* MIHP_CreateHeap(MIHP_HeapConfig config) bool MIHP_InitializeHeap(MIHP_Heap* heap, MIHP_HeapConfig config)
{ {
if (MIHP_IsHeapInitialized(heap))
return false;
if (config.AllocationAlignment < sizeof(size_t)) if (config.AllocationAlignment < sizeof(size_t))
return NULL; return false;
if (!MIHP_IS_PO2(config.AllocationAlignment)) if (!MIHP_IS_PO2(config.AllocationAlignment))
return NULL; return false;
if (config.MinimalMemoryAreaSize % config.AllocationAlignment != 0) if (config.MinimalMemoryAreaSize % config.AllocationAlignment != 0)
return NULL; return false;
if (config.MaximalMemoryAreaSize % config.AllocationAlignment != 0) if (config.MaximalMemoryAreaSize % config.AllocationAlignment != 0)
return NULL; return false;
size_t actualHeapStructAllocSize = 0;
MIHP_Heap* heap = (MIHP_Heap*)MIHP_PlatformRequestMemory(sizeof(MIHP_Heap), &actualHeapStructAllocSize);
if (heap == NULL)
return NULL;
MIHP_ASSERT(actualHeapStructAllocSize >= sizeof(MIHP_Heap));
MIHP_MEMSET(heap, sizeof(MIHP_Heap), 0); MIHP_MEMSET(heap, sizeof(MIHP_Heap), 0);
heap->Config = config; heap->Config = config;
heap->HeapStructureAllocationSize = actualHeapStructAllocSize; heap->FirstArea = MIHP_CreateHeapMemoryArea(heap, config.MinimalMemoryAreaSize);
heap->FirstArea = MIHP_CreateHeapMemoryArea(heap, actualHeapStructAllocSize);
heap->LastSuccessfulAllocationArea = heap->FirstArea; heap->LastSuccessfulAllocationArea = heap->FirstArea;
if (heap->FirstArea == NULL)
{
MIHP_PlatformFreeMemory(heap, heap->HeapStructureAllocationSize);
return NULL;
}
heap->FirstArea->Checksum = MIHP_GenerateHeapMemoryAreaChecksum(heap->FirstArea); heap->FirstArea->Checksum = MIHP_GenerateHeapMemoryAreaChecksum(heap->FirstArea);
return heap; return heap;
} }
bool MIHP_DestroyHeap(MIHP_Heap* heap, bool force) bool MIHP_IsHeapInitialized(const MIHP_Heap* heap)
{ {
if (heap == NULL) if (heap == NULL)
return false; return false;
return heap->FirstArea != NULL;
}
bool MIHP_UninitializeHeap(MIHP_Heap* heap, bool force)
{
if (!MIHP_IsHeapInitialized(heap))
return false;
if (heap == NULL)
return false;
if (!force && heap->Stats.NumTotalOccupiedSegments > 0) if (!force && heap->Stats.NumTotalOccupiedSegments > 0)
return false; return false;
@@ -61,7 +61,7 @@ bool MIHP_DestroyHeap(MIHP_Heap* heap, bool force)
MIHP_DestroyHeapMemoryArea(heap, currentArea); MIHP_DestroyHeapMemoryArea(heap, currentArea);
} }
MIHP_PlatformFreeMemory(heap, heap->HeapStructureAllocationSize); MIHP_MEMSET(heap, sizeof(MIHP_Heap), 0);
return true; return true;
} }
@@ -260,11 +260,10 @@ bool MIHP_Free(MIHP_Heap* heap, void* ptr)
if (segment->OccupiedSize == 0) if (segment->OccupiedSize == 0)
{ {
MIHP_HeapCorruptionInfo corruptionInfo = {0}; MIHP_HeapCorruptionInfo corruptionInfo = {0};
corruptionInfo.Heap = heap;
corruptionInfo.Type = MIHP_HEAP_CORRUPTION_TYPE_DOUBLE_FREE; corruptionInfo.Type = MIHP_HEAP_CORRUPTION_TYPE_DOUBLE_FREE;
corruptionInfo.Ptr = ptr; corruptionInfo.Ptr = ptr;
MIHP_PlatformOnHeapCorruptionDetected(corruptionInfo); MIHP_PlatformOnHeapCorruptionDetected(heap, corruptionInfo);
return false; return false;
} }
@@ -393,7 +392,7 @@ MIHP_HeapMemoryAreaHeader* MIHP_CreateHeapMemoryArea(MIHP_Heap* heap, size_t req
effectiveSize = MIHP_MIN(effectiveSize, heap->Config.MaximalMemoryAreaSize); effectiveSize = MIHP_MIN(effectiveSize, heap->Config.MaximalMemoryAreaSize);
size_t actualSize = 0; size_t actualSize = 0;
MIHP_HeapMemoryAreaHeader* area = (MIHP_HeapMemoryAreaHeader*)MIHP_PlatformRequestMemory(effectiveSize, &actualSize); MIHP_HeapMemoryAreaHeader* area = (MIHP_HeapMemoryAreaHeader*)MIHP_PlatformRequestMemory(heap, effectiveSize, &actualSize);
if (area == NULL) if (area == NULL)
return NULL; return NULL;
@@ -423,7 +422,7 @@ bool MIHP_DestroyHeapMemoryArea(MIHP_Heap* heap, MIHP_HeapMemoryAreaHeader* memo
size_t areaNumOccupiedSegments = memoryArea->NumOccupiedSegments; size_t areaNumOccupiedSegments = memoryArea->NumOccupiedSegments;
size_t areaSize = memoryArea->AreaSize; size_t areaSize = memoryArea->AreaSize;
if (!MIHP_PlatformFreeMemory(memoryArea, memoryArea->AreaSize)) if (!MIHP_PlatformFreeMemory(heap, memoryArea, memoryArea->AreaSize))
return false; return false;
heap->Stats.NumTotalSegments -= areaNumSegments; heap->Stats.NumTotalSegments -= areaNumSegments;
@@ -608,13 +607,12 @@ void MIHP_ValidateHeapMemoryAreaHeader(const MIHP_Heap* heap, const MIHP_HeapMem
if (area->Checksum != newChecksum) if (area->Checksum != newChecksum)
{ {
MIHP_HeapCorruptionInfo corruptionInfo; MIHP_HeapCorruptionInfo corruptionInfo;
corruptionInfo.Heap = heap;
corruptionInfo.Type = MIHP_HEAP_CORRUPTION_TYPE_MEMORY_AREA_CHECKSUM_MISMATCH; corruptionInfo.Type = MIHP_HEAP_CORRUPTION_TYPE_MEMORY_AREA_CHECKSUM_MISMATCH;
corruptionInfo.Ptr = area; corruptionInfo.Ptr = area;
corruptionInfo.ExpectedValue = area->Checksum; corruptionInfo.ExpectedValue = area->Checksum;
corruptionInfo.ActualValue = newChecksum; corruptionInfo.ActualValue = newChecksum;
MIHP_PlatformOnHeapCorruptionDetected(corruptionInfo); MIHP_PlatformOnHeapCorruptionDetected(heap, corruptionInfo);
} }
} }
@@ -635,13 +633,12 @@ void MIHP_ValidateHeapSegmentHeader(const MIHP_Heap* heap, const MIHP_HeapSegmen
if (segment->Checksum != newChecksum) if (segment->Checksum != newChecksum)
{ {
MIHP_HeapCorruptionInfo corruptionInfo; MIHP_HeapCorruptionInfo corruptionInfo;
corruptionInfo.Heap = heap;
corruptionInfo.Type = MIHP_HEAP_CORRUPTION_TYPE_SEGMENT_CHECKSUM_MISMATCH; corruptionInfo.Type = MIHP_HEAP_CORRUPTION_TYPE_SEGMENT_CHECKSUM_MISMATCH;
corruptionInfo.Ptr = segment; corruptionInfo.Ptr = segment;
corruptionInfo.ExpectedValue = segment->Checksum; corruptionInfo.ExpectedValue = segment->Checksum;
corruptionInfo.ActualValue = newChecksum; corruptionInfo.ActualValue = newChecksum;
MIHP_PlatformOnHeapCorruptionDetected(corruptionInfo); MIHP_PlatformOnHeapCorruptionDetected(heap, corruptionInfo);
} }
} }

26
minimal_heap_test.c
View File

@@ -9,19 +9,19 @@
#define MIHP_ValidateHeap(x) #define MIHP_ValidateHeap(x)
void* MIHP_PlatformRequestMemory(size_t minRequestedSize, size_t* outActualSize) void* MIHP_PlatformRequestMemory(const MIHP_Heap* heap, size_t minRequestedSize, size_t* outActualSize)
{ {
*outActualSize = minRequestedSize; *outActualSize = minRequestedSize;
return malloc(minRequestedSize); return malloc(minRequestedSize);
} }
bool MIHP_PlatformFreeMemory(void* ptr, size_t actualSize) bool MIHP_PlatformFreeMemory(const MIHP_Heap* heap, void* ptr, size_t actualSize)
{ {
free(ptr); free(ptr);
return true; return true;
} }
void MIHP_PlatformOnHeapCorruptionDetected(MIHP_HeapCorruptionInfo info) void MIHP_PlatformOnHeapCorruptionDetected(const MIHP_Heap* heap, MIHP_HeapCorruptionInfo info)
{ {
__debugbreak(); __debugbreak();
} }
@@ -37,7 +37,9 @@ int main()
config.AllocationAlignment = 16; config.AllocationAlignment = 16;
config.MinimalMemoryAreaSize = 4096 * 32; config.MinimalMemoryAreaSize = 4096 * 32;
config.MaximalMemoryAreaSize = 4096ull * 4096ull * 4096ull; config.MaximalMemoryAreaSize = 4096ull * 4096ull * 4096ull;
MIHP_Heap* myHeap = MIHP_CreateHeap(config);
MIHP_Heap myHeap = { 0 };
MIHP_InitializeHeap(&myHeap, config);
for (int i = 0; i < NUM_ALLOCATIONS; i++) for (int i = 0; i < NUM_ALLOCATIONS; i++)
{ {
@@ -45,8 +47,8 @@ int main()
#if USE_MALLOC #if USE_MALLOC
myptrs[i] = malloc(size); myptrs[i] = malloc(size);
#else #else
myptrs[i] = MIHP_Allocate(myHeap, size); myptrs[i] = MIHP_Allocate(&myHeap, size);
MIHP_ValidateHeap(myHeap); MIHP_ValidateHeap(&myHeap);
#endif #endif
} }
@@ -59,8 +61,8 @@ int main()
#if USE_MALLOC #if USE_MALLOC
free(myptrs[i]); free(myptrs[i]);
#else #else
MIHP_Free(myHeap, myptrs[i]); MIHP_Free(&myHeap, myptrs[i]);
MIHP_ValidateHeap(myHeap); MIHP_ValidateHeap(&myHeap);
#endif #endif
myptrs[i] = NULL; myptrs[i] = NULL;
@@ -79,8 +81,8 @@ int main()
#if USE_MALLOC #if USE_MALLOC
myptrs[i] = realloc(myptrs[i], size); myptrs[i] = realloc(myptrs[i], size);
#else #else
myptrs[i] = MIHP_Realloc(myHeap, myptrs[i], size); myptrs[i] = MIHP_Realloc(&myHeap, myptrs[i], size);
MIHP_ValidateHeap(myHeap); MIHP_ValidateHeap(&myHeap);
#endif #endif
@@ -96,8 +98,8 @@ int main()
#if USE_MALLOC #if USE_MALLOC
free(myptrs[i]); free(myptrs[i]);
#else #else
MIHP_Free(myHeap, myptrs[i]); MIHP_Free(&myHeap, myptrs[i]);
MIHP_ValidateHeap(myHeap); MIHP_ValidateHeap(&myHeap);
#endif #endif
myptrs[i] = NULL; myptrs[i] = NULL;