xmempool.c File Reference

#include "xmempool.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

Go to the source code of this file.

Data Structures
struct	xmem_pool_block
	xmempool - A Simple Memory Pool Implementation More...
struct	xmem_pool

Macros
#define	MIN_ALLOC_BLOCK_NODE_COUNT   (1024)
#define	MAX_ALLOC_BLOCK_NODE_COUNT   (1024 << 2)
#define	MIN_ALLOC_LENGTH   (1024)
#define	MAX_ALLOC_LENGTH   (1024 << 2)

Functions
uint32_t	size_count_with_4 (uint32_t size)
static void	_alloc_block_nodes ()
	Allocate memory for new block nodes.
static xmem_pool_block *	_get_next_block_node ()
	Get the next available block node.
static void	_recover_block_node (xmem_pool_block *node)
static int	_xmem_count_free_blocks (xmem_pool *pool)
xmem_pool_handle	_create_pool (uint32_t block_size, uint32_t block_count)
	Create a new memory pool.
void	xmem_print_info (xmem_pool_handle _pool)
	Print information about the memory pool.
xmem_pool_handle	xmem_create_pool (unsigned int block_size)
void	xmem_destroy_pool (xmem_pool_handle handle)
	Destroy a memory pool and free all associated resources.
char *	xmem_alloc (xmem_pool_handle handle)
	Allocate a block from the memory pool.
int	xmem_free (xmem_pool_handle handle, char *pointer)
	Free a block back to the memory pool.
void	xmem_init ()
void	xmem_clean_up ()
	Clean up global resources used by xmempool.

Variables
static uint32_t	_xmem_pool_next_alloc_block_node_count
static xmem_pool_block *	_free_block_ptr = 0
static xmem_pool_block *	_free_block_ptr_end = 0
static int	_xmem_page_size = 0
static uint32_t	_block_size = sizeof(xmem_pool_block)

Macro Definition Documentation

MAX_ALLOC_BLOCK_NODE_COUNT

#define MAX_ALLOC_BLOCK_NODE_COUNT   (1024 << 2)

Definition at line 48 of file xmempool.c.

MAX_ALLOC_LENGTH

#define MAX_ALLOC_LENGTH   (1024 << 2)

Definition at line 50 of file xmempool.c.

MIN_ALLOC_BLOCK_NODE_COUNT

#define MIN_ALLOC_BLOCK_NODE_COUNT   (1024)

Definition at line 47 of file xmempool.c.

MIN_ALLOC_LENGTH

#define MIN_ALLOC_LENGTH   (1024)

Definition at line 49 of file xmempool.c.

Function Documentation

_alloc_block_nodes()

static void _alloc_block_nodes ( )

inlinestatic

Allocate memory for new block nodes.

This function allocates a chunk of memory for new block nodes when the current pool is exhausted. It doubles the allocation size each time, up to a maximum defined by MAX_ALLOC_BLOCK_NODE_COUNT. The newly allocated nodes are then added to the free block list.

Definition at line 74 of file xmempool.c.

                                        {
  uint32_t size_count = _block_size * _xmem_pool_next_alloc_block_node_count;
  _xmem_pool_next_alloc_block_node_count <<= 1;
  if (_xmem_pool_next_alloc_block_node_count > MAX_ALLOC_BLOCK_NODE_COUNT) {
    _xmem_pool_next_alloc_block_node_count = MAX_ALLOC_BLOCK_NODE_COUNT;
  }
 
#ifdef _WIN32
  char* start = (char*)malloc(size_count);
#else
  char* start;
  posix_memalign((void**)&start, _xmem_page_size, size_count);
#endif
  char* block_ptr = start;
  char* end = start + size_count;
 
  // Check if memory allocation was successful
  if (!block_ptr) return;
 
  for (; block_ptr < end; block_ptr += _block_size) {
    xmem_pool_block* block = (xmem_pool_block*)block_ptr;
    block->is_block_start = (block_ptr == start);
    block->start = 0;
 
    // Link the current block to the previous one, except for the first block
    if (block_ptr != start) {
      ((xmem_pool_block*)(block_ptr - _block_size))->next = block;
    }
 
    block->block_size = 0;
  }
  ((xmem_pool_block*)(end - _block_size))->next = 0;
 
  // Add newly allocated blocks to the free list
  if (_free_block_ptr && _free_block_ptr_end) {
    // Append new blocks to the existing free list
    _free_block_ptr_end->next = (xmem_pool_block*)start;
  } else {
    // Initialize the free list with the new blocks
    _free_block_ptr = (xmem_pool_block*)start;
  }
 
  _free_block_ptr_end = (xmem_pool_block*)(end - _block_size);
}

_create_pool()

xmem_pool_handle _create_pool	(	uint32_t	block_size,
		uint32_t	block_count )

Create a new memory pool.

This function creates a new memory pool with the specified block size and count. It allocates memory for the pool structure and the actual memory blocks, then initializes the free block list.

Parameters

block_size	Size of each memory block in the pool
block_count	Number of blocks to allocate initially

Returns

Handle to the created pool, or NULL if creation failed

Definition at line 189 of file xmempool.c.

                                                                         {
  static uint32_t _pool_size = sizeof(xmem_pool);
  xmem_pool* pool = (xmem_pool*)malloc(_pool_size);
  uint32_t size_count = block_count * block_size;
  uint32_t alloc_size = size_count_with_4(size_count);
  char* space;
 
#ifndef _WIN32
  if (_xmem_page_size < alloc_size) {
    posix_memalign((void**)&space, _xmem_page_size, alloc_size);
  } else {
#endif
    space = (char*)malloc(size_count);
#ifndef _WIN32
  }
#endif
  xmem_pool_block* start_block = 0;
  xmem_pool_block* end_block = 0;
 
  // Allocate memory for the pool structure
  if (!pool) return (char*)0;
  if (!space) {
    free(pool);
    return (char*)0;
  }
 
  // Initialize pool properties
  pool->start = space;
  pool->end = space + (block_count * block_size);
 
  pool->block_size = block_size;
  pool->block_count = block_count;
  pool->next = 0;
 
  pool->next_alloc_length = block_count << 1;
  if (pool->next_alloc_length > MAX_ALLOC_LENGTH) {
    pool->next_alloc_length = MAX_ALLOC_LENGTH;
  }
 
  // Initialize free blocks
  for (; space < pool->end; space += block_size) {
    xmem_pool_block* wrapper = _get_next_block_node();
    if (!start_block) {
      start_block = wrapper;
    }
 
    // Handle allocation failure
    if (!wrapper) {
      free(pool);
      free(space);
      while (start_block) {
        xmem_pool_block* next = start_block->next;
        _recover_block_node(start_block);
        start_block = next;
      }
      return 0;
    }
 
    wrapper->block_size = block_size;
    wrapper->start = space;
    wrapper->next = 0;
 
    // Link blocks in the free list
    if (end_block) {
      end_block->next = wrapper;
    }
    end_block = wrapper;
  }
 
  pool->free_blocks = start_block;
  pool->free_blocks_tail = end_block;
 
  return (char*)pool;
}

_get_next_block_node()

static xmem_pool_block * _get_next_block_node ( )

inlinestatic

Get the next available block node.

This function returns the next available block node from the free list. If the free list is empty, it calls _alloc_block_nodes() to allocate more.

Returns

Pointer to the next available block node, or NULL if allocation fails

Definition at line 127 of file xmempool.c.

                                                      {
  xmem_pool_block* should_return;
 
  // If no more block node, generate a new block node list
  if (!_free_block_ptr) {
    _alloc_block_nodes();
  }
 
  // If still no more block node, return NULL to indicate error
  if (!_free_block_ptr) return (xmem_pool_block*)0;
 
  should_return = _free_block_ptr;
  _free_block_ptr = _free_block_ptr->next;
 
  // If should_return is the last one, set the tail to NULL
  if (should_return == _free_block_ptr_end) {
    _free_block_ptr_end = 0;
  }
 
  return should_return;
}

_recover_block_node()

static void _recover_block_node ( xmem_pool_block * node )

inlinestatic

Definition at line 149 of file xmempool.c.

                                                              {
  node->block_size = 0;
  node->next = NULL;
  node->start = NULL;
 
  if (_free_block_ptr && _free_block_ptr_end) {
    _free_block_ptr_end->next = node;
    _free_block_ptr_end = node;
  } else {
    _free_block_ptr = _free_block_ptr_end = node;
  }
}

_xmem_count_free_blocks()

static int _xmem_count_free_blocks ( xmem_pool * pool )

inlinestatic

Definition at line 162 of file xmempool.c.

                                                           {
  xmem_pool_block* block;
  int count;
 
  if (!pool->free_blocks) return 0;
  block = pool->free_blocks;
  count = 1;
 
  while (block != pool->free_blocks_tail) {
    count++;
    block = block->next;
  }
 
  return count;
}

size_count_with_4()

uint32_t size_count_with_4

(

uint32_t

size

)

Definition at line 58 of file xmempool.c.

                                          {
  if (size % 4 == 0) {
    return size;
  } else {
    return size + (4 - size % 4);
  }
}

xmem_alloc()

char * xmem_alloc

(

xmem_pool_handle

handle

)

Allocate a block from the memory pool.

This function returns a pointer to a free block from the pool. If the current pool is full, it automatically creates and chains a new pool. The allocated block is always zero-initialized.

Parameters

handle

Handle to the pool to allocate from

Returns

Pointer to the allocated block, or NULL if allocation failed

Definition at line 341 of file xmempool.c.

                                          {
  static uint32_t pool_element_size = sizeof(xmem_pool);
  xmem_pool* pool = (xmem_pool*)handle;
  xmem_pool temp_pool;
  xmem_pool_block* block;
  char* space;
 
  // If no more free blocks, create a new pool
  if (!pool->free_blocks) {
    xmem_pool* new_pool =
        (xmem_pool*)_create_pool(pool->block_size, pool->next_alloc_length);
 
    if (!new_pool) {
      return 0;
    }
 
    // Swap the new pool with the current one
    memcpy(&temp_pool, pool, pool_element_size);
    memcpy(pool, new_pool, pool_element_size);
    memcpy(new_pool, &temp_pool, pool_element_size);
 
    pool->next = new_pool;
  }
 
  // Allocate the first free block
  block = pool->free_blocks;
  pool->free_blocks = block->next;
  space = block->start;
 
  if (!pool->free_blocks) pool->free_blocks_tail = 0;
 
  // Initialize allocated space and recover the block node
  memset(space, 0, block->block_size);
  _recover_block_node(block);
 
  return space;
}

xmem_clean_up()

void xmem_clean_up

(

)

Clean up global resources used by xmempool.

This function frees all global resources used by the xmempool system, particularly the memory used for managing block nodes. It should be called when the xmempool system is no longer needed.

Definition at line 408 of file xmempool.c.

                     {
  xmem_pool_block* blk = _free_block_ptr;
  xmem_pool_block* start = 0;
  xmem_pool_block* end = 0;
 
  // Reorganize the free block list
  while (blk != 0) {
    if (blk->is_block_start) {
      if (end) {
        end->next = blk;
      } else {
        start = blk;
      }
      end = blk;
    }
    blk = blk->next;
  }
  if (end) end->next = 0;
 
  // Free all allocated block nodes
  blk = start;
  while (blk != 0) {
    end = blk->next;  // Temporary variable for the next block
    free(blk);
    blk = end;
  }
 
  // Reset global pointers
  _free_block_ptr = _free_block_ptr_end = 0;
}

xmem_create_pool()

xmem_pool_handle xmem_create_pool

(

unsigned int

block_size

)

Definition at line 292 of file xmempool.c.

                                                           {
#ifndef _WIN32
  // Initialize page size for non-Windows systems
  if (_xmem_page_size == 0) {
    _xmem_page_size = getpagesize();
  }
#endif
 
#ifdef XMEM_DBG
  // Debug mode: create pool and print creation message
  char* pool = _create_pool(block_size, MIN_ALLOC_LENGTH);
  printf("A new pool of [%d] is created!", block_size);
  return pool;
#endif
 
  // Normal mode: create pool with minimum allocation length
  return _create_pool(block_size, MIN_ALLOC_LENGTH);
}

xmem_destroy_pool()

void xmem_destroy_pool

(

xmem_pool_handle

pool

)

Destroy a memory pool and free all associated resources.

This function frees all memory associated with the pool, including all chained pools and their blocks. It also recovers all block nodes used for managing free blocks.

Parameters

pool	Handle to the pool to be destroyed

Definition at line 311 of file xmempool.c.

                                                {
  xmem_pool* pool = (xmem_pool*)handle;
  xmem_pool* next_pool;
 
  if (!handle) return;
 
  // Iterate through all pools in the chain
  while (pool) {
    // Free the memory space allocated for blocks
    free(pool->start);
 
    // For the first pool, recover all free block nodes
    if (pool == (xmem_pool*)handle) {
      xmem_pool_block* block = pool->free_blocks;
      xmem_pool_block* next_block;
 
      while (block) {
        next_block = block->next;
        _recover_block_node(block);
        block = next_block;
      }
    }
 
    // Move to the next pool
    next_pool = pool->next;
    free(pool);
    pool = next_pool;
  }
}

xmem_free()

int xmem_free	(	xmem_pool_handle	handle,
		char *	pointer )

Free a block back to the memory pool.

This function returns a block to the free list of the first pool in the chain. It does not actually free memory, but makes the block available for future allocations.

Parameters

handle	Handle to the pool
pointer	Pointer to the block to be freed

Returns

1 if successful, 0 if failed (e.g., if no free block nodes are available)

Definition at line 379 of file xmempool.c.

                                                      {
  xmem_pool* pool = (xmem_pool*)handle;
 
  // Get a new block node
  xmem_pool_block* block = _get_next_block_node();
  if (!block) {
    return 0;
  }
 
  // Initialize the new block and add it to the free list
  block->block_size = pool->block_size;
  block->start = pointer;
  block->next = 0;
 
  if (!pool->free_blocks && !pool->free_blocks_tail) {
    pool->free_blocks = pool->free_blocks_tail = block;
    return 1;
  }
 
  pool->free_blocks_tail->next = block;
  pool->free_blocks_tail = block;
 
  return 1;
}

xmem_init()

void xmem_init

(

)

Definition at line 404 of file xmempool.c.

                 {
  // Placeholder for potential initialization code
}

xmem_print_info()

void xmem_print_info

(

xmem_pool_handle

pool

)

Print information about the memory pool.

This function prints detailed information about each pool in the chain, including its size, block count, memory range, and number of free blocks.

Parameters

pool	Handle to the pool

Definition at line 264 of file xmempool.c.

                                             {
  xmem_pool* pool = (xmem_pool*)_pool;
  int pool_id = 0;
 
  if (!_pool) return;
 
  while (pool) {
    printf("----- POOL OF SIZE [%.4d] -----\n", pool->block_size);
    printf("  + id: %d\n", pool_id++);
    printf("  + count: %d\n", pool->block_count);
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpointer-to-int-cast"
    printf("  + spaces: [0x%.8X, 0x%.8X)\n",
           (unsigned int)pool->start,
           (unsigned int)pool->end);
#pragma GCC diagnostic pop
 
    if (pool_id == 1) {
      printf("  + free blocks: %d\n", _xmem_count_free_blocks(pool));
    } else {
      printf("  + free blocks: -\n");
    }
 
    pool = pool->next;
  }
}

Variable Documentation

_block_size

uint32_t _block_size = sizeof(xmem_pool_block)

static

Definition at line 56 of file xmempool.c.

_free_block_ptr

xmem_pool_block* _free_block_ptr = 0

static

Definition at line 53 of file xmempool.c.

_free_block_ptr_end

xmem_pool_block* _free_block_ptr_end = 0

static

Definition at line 54 of file xmempool.c.

_xmem_page_size

int _xmem_page_size = 0

static

Definition at line 55 of file xmempool.c.

_xmem_pool_next_alloc_block_node_count

uint32_t _xmem_pool_next_alloc_block_node_count

static

Initial value:

=
    (1024)

Definition at line 51 of file xmempool.c.