Baillehache Pascal's personal website

LibCapy - memoryPool

Memory pool generic class.

Macros:

#define CAPY_MEMORY_POOL_H

#define CapyDecMemPool(T)                                         \
typedef struct CapyMemPool ## T {                                 \
  T* head;                                                        \
  T* tail;                                                        \
  void (*destruct)(void);                                         \
  T* (*alloc)(void);                                              \
  void (*free)(T** const elem);                                   \
  void (*flush)(void);                                            \
} CapyMemPool ## T;                                               \
CapyMemPool ## T CapyMemPool ## T ## Create(void);                \
CapyMemPool ## T* CapyMemPool ## T ## Alloc(void);                \
void CapyMemPool ## T ## Destruct(void);                          \
void CapyMemPool ## T ## Free(CapyMemPool ## T** const that);     \
T* CapyMemPool ## T ## AllocElem(void);                           \
void CapyMemPool ## T ## FreeElem(T** const elem);                \
void CapyMemPool ## T ## Flush(void);

Generic memory pool class. Declaration macro for a memory pool of a given type. The definition of the type must include CapyMemPoolFields (see below).

#define CapyMemPoolFields(T)    \
struct {                        \
  T* prev;                      \
  T* next;                      \
  bool isFree;                  \
  CapyPad(bool, MemPoolField0); \
} mempool

Macro to add necessary fields to a structure to make it usable with CapyMemPool

#define CapyDefMemPoolCreate(T)                     \
CapyMemPool ## T CapyMemPool ## T ## Create(void) { \
  return (CapyMemPool ## T){                        \
    .head = NULL,                                   \
    .tail = NULL,                                   \
    .destruct = CapyMemPool ## T ## Destruct,       \
    .alloc = CapyMemPool ## T ## AllocElem,         \
    .free = CapyMemPool ## T ## FreeElem,           \
    .flush = CapyMemPool ## T ## Flush,             \
  };                                                \
}

Create a memory pool

Output and side effect(s):

Return an empty memory pool

#define CapyDefMemPoolAlloc(T)                      \
CapyMemPool ## T* CapyMemPool ## T ## Alloc(void) { \
  CapyMemPool ## T* that = NULL;                    \
  safeMalloc(that, 1);                              \
  assert(that != NULL);                             \
  *that = CapyMemPool ## T ## Create();             \
  return that;                                      \
}

Allocate a memory pool

Output and side effect(s):

Return an empty memory pool

#define CapyDefMemPoolDestruct(T)                                 \
void CapyMemPool ## T ## Destruct(void) {                         \
  CapyMemPool ## T* that = (CapyMemPool ## T*)capyThat;           \
  $(that, flush)();                                               \
}

Flush and destruct a memory pool

Input argument(s):

that: the memory pool to destruct

#define CapyDefMemPoolFree(T)                                  \
void CapyMemPool ## T ## Free(CapyMemPool ## T** const that) { \
  if(that == NULL || *that == NULL) return;                    \
  $(*that, destruct)();                                        \
  free(*that);                                                 \
  *that = NULL;                                                \
}

Flush and free a memory pool

Input argument(s):

that: the memory pool to free

#define CapyDefMemPoolAllocElem(T)                                \
T* CapyMemPool ## T ## AllocElem(void) {                          \
  CapyMemPool ## T* that = (CapyMemPool ## T*)capyThat;           \
  T* ptr = that->head;                                            \
  if(ptr && ptr->mempool.isFree) {                                \
    if(ptr->mempool.next) {                                       \
      that->head = ptr->mempool.next;                             \
      ptr->mempool.next = ptr->mempool.next->mempool.prev = NULL; \
      ptr->mempool.prev = that->tail;                             \
      that->tail = that->tail->mempool.next = ptr;                \
    }                                                             \
  } else {                                                        \
    safeMalloc(ptr, 1);                                           \
    if(ptr == NULL) return NULL;                                  \
    *ptr = (T){ .mempool = {.prev=that->tail, .next=NULL} };      \
    if(that->head == NULL) that->head = that->tail = ptr;         \
    else that->tail = that->tail->mempool.next = ptr;             \
  }                                                               \
  ptr->mempool.isFree = false;                                    \
  return ptr;                                                     \
}

Alloc memory using the memory pool

Output and side effect(s):

Return a 'new' element from the pool. If there was a free one, it is reused, else a new element is allocated and added to the pool before returning it.

#define CapyDefMemPoolFreeElem(T)                                  \
void CapyMemPool ## T ## FreeElem(T** const elem) {                \
  if(elem == NULL || *elem == NULL) return;                        \
  CapyMemPool ## T* that = (CapyMemPool ## T*)capyThat;            \
  (*elem)->mempool.isFree = true;                                  \
  if((*elem) != that->head) {                                      \
    if((*elem)->mempool.prev) {                                    \
      (*elem)->mempool.prev->mempool.next = (*elem)->mempool.next; \
    }                                                              \
    if((*elem)->mempool.next) {                                    \
      (*elem)->mempool.next->mempool.prev = (*elem)->mempool.prev; \
    }                                                              \
    if(that->tail == (*elem)) that->tail = (*elem)->mempool.prev;  \
    (*elem)->mempool.prev = NULL;                                  \
    (*elem)->mempool.next = that->head;                            \
    that->head = that->head->mempool.prev = (*elem);               \
  }                                                                \
  *elem = NULL;                                                    \
}

Free an element allocated using the pool

Input argument(s):

elem: pointer to the element to free

Output and side effect(s):

The element is marked as free to reuse in the memory pool

#define CapyDefMemPoolFlush(T)                          \
void CapyMemPool ## T ## Flush(void) {                  \
  CapyMemPool ## T* that = (CapyMemPool ## T*)capyThat; \
  T* ptr = that->head;                                  \
  while(ptr) {                                          \
    T* next = ptr->mempool.next;                        \
    free(ptr);                                          \
    ptr = next;                                         \
  }                                                     \
  that->head = that->tail = NULL;                       \
}

Flush a memory pool

Output and side effect(s):

All the elements in the pool are freed (their memory is released using the standard 'free' function)

#define CapyDefMemPool(T)    \
  CapyDefMemPoolCreate(T)    \
  CapyDefMemPoolAlloc(T)     \
  CapyDefMemPoolDestruct(T)  \
  CapyDefMemPoolFree(T)      \
  CapyDefMemPoolAllocElem(T) \
  CapyDefMemPoolFreeElem(T)  \
  CapyDefMemPoolFlush(T)

Definition macro for a memory pool of a given type.

Enumerations:

None.

Typedefs:

None.

Functions:

None.

2022-10-07
in LibCapy,
23 views