memory_management.c File Reference

Implements memory management functionality. More...

#include "memory_management.h"
#include "../logging/logger.h"

Go to the source code of this file.

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)
	Allocates memory on the given memory pool.
void	memory_pool_free (memory_pool_t *pool, void *ptr)
	Sets the given data pointer to not active in the given memory pool.
void	shutdown_memory_pool (memory_pool_t *pool)
	Shuts down the memory pool.

Detailed Description

Implements memory management functionality.

Definition in file memory_management.c.

Function Documentation

init_memory_pool()

memory_pool_t * init_memory_pool

(

size_t

size

)

Initialize a memory pool of the given size.

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 )

Allocates memory on the given 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 )

Sets the given data pointer to not active in the given memory pool.

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;
}