memory_management.h File Reference

Exposes functions for working with the memory management. More...

#include <stdlib.h>

Go to the source code of this file.

Data Structures
struct	memory_block_t
struct	memory_pool_t

Macros
#define	STANDARD_MEMORY_POOL_SIZE   (8 * 1024 * 1024)
#define	MIN_MEMORY_POOL_SIZE   (1024 * 1024)
#define	MIN_MEMORY_BLOCK_SIZE   (sizeof(memory_block_t) + 16)

Typedefs
typedef struct memory_block_t	memory_block_t

Functions
memory_pool_t *	init_memory_pool (size_t size)
	Initialize a memory pool of the given size.
void *	memory_pool_alloc (memory_pool_t *pool, size_t size)
	Allocate a memory pool.
void	memory_pool_free (memory_pool_t *pool, void *ptr)
	Free a memory pool.
void	shutdown_memory_pool (memory_pool_t *pool)
	Shuts down the memory pool.

Detailed Description

Exposes functions for working with the memory management.

Definition in file memory_management.h.

Macro Definition Documentation

MIN_MEMORY_BLOCK_SIZE

#define MIN_MEMORY_BLOCK_SIZE   (sizeof(memory_block_t) + 16)

Definition at line 12 of file memory_management.h.

MIN_MEMORY_POOL_SIZE

#define MIN_MEMORY_POOL_SIZE   (1024 * 1024)

Definition at line 11 of file memory_management.h.

STANDARD_MEMORY_POOL_SIZE

#define STANDARD_MEMORY_POOL_SIZE   (8 * 1024 * 1024)

Definition at line 10 of file memory_management.h.

Function Documentation

init_memory_pool()

memory_pool_t * init_memory_pool

(

size_t

size

)

Initialize a memory pool of the given size.

This function initializes a memory pool for dynamic memory allocation. If the given size is smaller than the minimum required size, it will be automatically set to the minimum size.

Parameters

size	The size of the memory pool to initialize.

Returns

A pointer to the initialized memory pool, or NULL if the initialization failed.

Parameters

size	the size of the memory pool to initialize, when the given size is smaller than 1MB, the size will be automatically set to 1MB

Returns

the pointer to the memory pool. When NULL, the initialization failed

Definition at line 15 of file memory_management.c.

                                             {
    if (size < MIN_MEMORY_POOL_SIZE) {
        //set the size to the minimum
        size = MIN_MEMORY_POOL_SIZE;
    }
 
    memory_pool_t* pool = malloc(sizeof(memory_pool_t));
    if (!pool) {
        log_msg(ERROR, "Memory", "Failed to allocate memory for the pool base structure");
        return NULL;
    }
 
    pool->memory = malloc(size);
    if (!pool->memory) {
        log_msg(ERROR, "Memory", "Failed to allocate memory for the pool");
        free(pool);
        return NULL;
    }
 
    pool->pool_size = size;
    pool->first = (memory_block_t*) pool->memory;
    pool->first->size = size - sizeof(memory_block_t);
    pool->first->active = 0; // mark the block as free
    pool->first->next = NULL;// no next block
 
    return pool;
}

memory_pool_alloc()

void * memory_pool_alloc	(	memory_pool_t *	pool,
		size_t	size )

Allocate a memory pool.

Parameters

pool	The memory pool to allocate.
size	The size of the memory pool.

Allocate a memory pool.

If the remaining memory space is lager enough, creates a new unused block for the remaining memory.

Parameters

pool	the pool to allocate memory from
size	the size of the memory to allocate

Returns

the pointer to the reserved memory space, or NULL if there is no free space on the pool

Definition at line 51 of file memory_management.c.

                                                          {
    memory_block_t* current = pool->first;
 
    while (current) {
        if (!current->active && current->size >= size) {
            // found a free block that is large enough
 
            const size_t remaining = current->size - size;
            if (remaining > MIN_MEMORY_BLOCK_SIZE) {
                // remaining is large enough
                // create a new block for the remaining memory
                memory_block_t* new_block = (memory_block_t*) ((char*) current + sizeof(memory_block_t) + size);
 
                new_block->size = remaining - sizeof(memory_block_t);
                new_block->active = 0;          // mark the new block as free
                new_block->next = current->next;// link to the next block
 
                current->size = size;// set the size of the current block
 
                current->next = new_block;// link to the new block
            } else {
                log_msg(WARNING, "Memory", "No more space left in the block, using the whole block");
            }
 
            //the remaining memory space is too small, so the current block will be used entirely
            current->active = 1;
            return (void*) (current + 1);// return pointer to user data
        }
        current = current->next;// move to the next block
    }
 
    log_msg(ERROR, "Memory", "No free block found for allocation");
    return NULL;
}

memory_pool_free()

void memory_pool_free	(	memory_pool_t *	pool,
		void *	ptr )

Free a memory pool.

Parameters

pool	The pool to free.
ptr	A pointer to who knows what.

Free a memory pool.

But first checks if the pointer is contained in the memory pool. If needed it will defragment the memory pool and merge free blocks.

Parameters

pool	the pool to free memory from
ptr	the pointer to the memory to free

Definition at line 94 of file memory_management.c.

                                                      {
    if (!ptr) {
        log_msg(ERROR, "Memory", "Pointer is NULL");
        return;
    }
 
    memory_block_t* block = (memory_block_t*) ptr - 1;
    if (block < pool->first || block >= (memory_block_t*) ((char*) pool->first + pool->pool_size)) {
        log_msg(ERROR, "Memory", "Pointer is not in the memory pool");
        return;
    }
    block->active = 0;
 
    // when needed, defragmentation of the memory blocks
    memory_block_t* current = pool->first;
    while (current && current->next) {
        if (!current->active && !current->next->active) {
            // merge with the next block
            current->size += sizeof(memory_block_t) + current->next->size;
            current->next = current->next->next;// link to the next block
        } else {
            current = current->next;// move to the next block
        }
    }
}

shutdown_memory_pool()

void shutdown_memory_pool

(

memory_pool_t *

pool

)

Shuts down the memory pool.

Parameters

pool	The memory pool to be shut down.

Definition at line 120 of file memory_management.c.

                                               {
    if (!pool) {
        log_msg(ERROR, "Memory", "Pool is NULL");
        return;
    }
 
    free(pool->memory);
    free(pool);
    pool = NULL;
}