117 lines
2.9 KiB
C
117 lines
2.9 KiB
C
#include "freelist.h"
|
|
#include "stddef.h"
|
|
#include <assert.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
/* Fiddle these around according to your need. */
|
|
#ifdef FREELIST_NOALIGN
|
|
#define ALIGN(x) (x)
|
|
#else // FREELIST_NOALIGN
|
|
|
|
/* Align to nearest multiple of sizeof(void*) */
|
|
static inline size_t align_up(size_t n) {
|
|
return (n + sizeof(void *) - 1) & ~(sizeof(void *) - 1);
|
|
}
|
|
|
|
#define ALIGN(x) (align_up(x))
|
|
#endif // FREELIST_NOALIGN
|
|
|
|
/* Initialize the FreeList */
|
|
int fl_init(FreeList *fl, uintptr_t start, uintptr_t end, size_t itemsize) {
|
|
size_t size = ALIGN(itemsize + sizeof(FreeListBlock));
|
|
|
|
if (!fl || end <= start)
|
|
return EXIT_FAILURE;
|
|
|
|
fl->start = start;
|
|
fl->end = end;
|
|
fl->size = size;
|
|
fl->allocated = 0;
|
|
|
|
FreeListBlock *block = (FreeListBlock *)start;
|
|
for (size_t i = 0; i < fl_capacity(fl); i++) {
|
|
block->next = (FreeListBlock *)((void *)block + size);
|
|
block->block_state = FL_FREE;
|
|
block = block->next;
|
|
}
|
|
|
|
block->next = NULL;
|
|
|
|
fl->free = (FreeListBlock *)start;
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
/* Allocate some memory from the FreeList */
|
|
void *fl_alloc(FreeList *fl) {
|
|
if (!fl->free || fl->free->block_state != FL_FREE)
|
|
return NULL;
|
|
|
|
FreeListBlock *m = fl->free;
|
|
m->block_state = FL_USED;
|
|
|
|
fl->free = fl->free->next;
|
|
fl->allocated++;
|
|
|
|
return ((void *)m) + sizeof(FreeListBlock);
|
|
}
|
|
|
|
/* Return some memory to the FreeList */
|
|
int fl_free(FreeList *fl, void *ptr) {
|
|
if (!fl_is_managed(fl, ptr)) {
|
|
return EXIT_FAILURE; /* We cant free memory we do not own */
|
|
}
|
|
|
|
FreeListBlock *block = (FreeListBlock *)((uintptr_t)ptr - sizeof(FreeListBlock));
|
|
|
|
if (block->block_state != FL_USED) {
|
|
return EXIT_FAILURE; /* Block must be used */
|
|
}
|
|
|
|
block->block_state = FL_FREE;
|
|
block->next = fl->free;
|
|
fl->free = block;
|
|
fl->allocated--;
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
/* Returns how many slots are occupied */
|
|
size_t fl_allocated(FreeList *fl) {
|
|
return fl->allocated;
|
|
}
|
|
|
|
/* Returns how many free slots are available (O(1)) */
|
|
size_t fl_available(FreeList *fl) {
|
|
return fl_capacity(fl) - fl->allocated;
|
|
}
|
|
|
|
/* Returns the total amount of items the freelist will hold */
|
|
size_t fl_capacity(FreeList *fl) {
|
|
return (fl->end - fl->start) / fl->size;
|
|
}
|
|
|
|
/* Check if a piece of memory is managed by the FreeList */
|
|
int fl_is_managed(FreeList *fl, void *ptr) {
|
|
return ((uintptr_t)ptr >= fl->start && (uintptr_t)ptr < fl->end);
|
|
}
|
|
|
|
/* Returns the ratio of metadata versus data as a scalar in range 0..1 */
|
|
float fl_utilization(FreeList *fl, size_t itemsize) {
|
|
return (float)itemsize / fl->size;
|
|
}
|
|
|
|
/* Walks the free pages/slots, returns total count (O(n), given no cycles) */
|
|
size_t fl_check(FreeList *fl) {
|
|
int avail = 0;
|
|
FreeListBlock *cursor = fl->free;
|
|
|
|
while (cursor->next != NULL) {
|
|
avail++;
|
|
assert(cursor->block_state == FL_FREE);
|
|
cursor = cursor->next;
|
|
}
|
|
|
|
return avail;
|
|
}
|