mem.c File Reference

#include "amathc.h"
#include <stdlib.h>

Include dependency graph for mem.c:

Go to the source code of this file.

Classes
struct	MemoryBlock
	Block of allocated memory. More...
struct	MemoryList
	List of allocated memory. Uses the LIFO principle. More...

Macros
#define	ALLOC_MEM(x)   calloc(1L,x)
#define	FREE_MEM(x)   free(x)
#define	Debug(x, y, z)

Functions
void	alloc_error (char *descr, size_t size)
	Log a memory allocation error. More...
void	dealloc_error (char *descr, void *p)
	Log a memory deallocation error. More...
void *	AllocMemSafe (size_t size)
	Allocate memory and add it to the global memory list. More...
void	RemoveMemSafe (void *block, bool deallocate)
void	FreeMemSafe (void *block)
	Deallocate memory from the global memory list. More...
void	DetachMemSafe (void *block)
	Detach an allocated memory from the global memory list. More...
void	FreeAllSafe ()
	Deallocate all memory in the global memory list. More...
void	MemUsage (long *blocks, long *size, long *peak)
	Get memory usage in the global memory list. More...

Variables
struct MemoryList *	list = nullptr
	Global list of allocated memory. More...

Macro Definition Documentation

ALLOC_MEM

#define ALLOC_MEM

(

x

)

calloc(1L,x)

Definition at line 43 of file mem.c.

Debug

#define Debug	(		x,
			y,
			z
	)

Definition at line 45 of file mem.c.

FREE_MEM

#define FREE_MEM

(

x

)

free(x)

Definition at line 44 of file mem.c.

Function Documentation

alloc_error()

void alloc_error	(	char *	descr,
		size_t	size
	)

Log a memory allocation error.

Definition at line 252 of file mem.c.

Referenced by AllocMemSafe().

{
    Debug("Memory allocation error (%s) with size (%d)\n", descr, size);
    //if (size == 0)
    //    exit(10);
}

Here is the caller graph for this function:

AllocMemSafe()

void* AllocMemSafe

(

size_t

size

)

Allocate memory and add it to the global memory list.

Definition at line 86 of file mem.c.

References MemoryBlock::address, alloc_error(), MemoryList::count, MemoryList::first, list, MemoryBlock::next, MemoryList::peak, MemoryBlock::size, and MemoryList::size.

{
    struct MemoryBlock* newblock;
    size_t allocsize;

    if (list == nullptr)
    {
        list = (struct MemoryList*)ALLOC_MEM(sizeof(struct MemoryList));
        if (!list)
        {
            alloc_error("list", sizeof(struct MemoryList));
            return 0;
        }

        list->first = nullptr;
        list->peak = 0;
        list->size = 0;
        list->count = 0;
    }

#ifdef P64BIT
    // Align to bytes of 8
    allocsize = (size + 7) & ~0x07;
#else
    // Align to bytes of 4
    allocsize = (size + 3) & ~0x03;
#endif

    newblock = (struct MemoryBlock*)ALLOC_MEM(sizeof(struct MemoryBlock));
    if (!newblock)
    {
        alloc_error("block", sizeof(struct MemoryBlock));
        return 0;
    }

    newblock->address = (struct MemoryBlock*)ALLOC_MEM(allocsize);
    if (!newblock->address)
    {
        FREE_MEM(newblock);
        alloc_error("memory", allocsize);
        return 0;
    }

    newblock->size = allocsize;
    newblock->next = list->first;
    list->first = newblock;
    list->size += allocsize;
    list->count++;

    if (list->size > list->peak)
    {
        list->peak = list->size;
    }

    // Memory allocated
    return newblock->address;
}

Here is the call graph for this function:

dealloc_error()

void dealloc_error	(	char *	descr,
		void *	p
	)

Log a memory deallocation error.

Definition at line 262 of file mem.c.

Referenced by RemoveMemSafe().

{
    Debug("Memory deallocation error (%s) address (%x)\n", descr, p);
}

Here is the caller graph for this function:

DetachMemSafe()

void DetachMemSafe

(

void *

block

)

Detach an allocated memory from the global memory list.

The memory block is only detached, not deallocated.

Definition at line 209 of file mem.c.

References RemoveMemSafe().

{
    RemoveMemSafe(block, false);
}

Here is the call graph for this function:

FreeAllSafe()

void FreeAllSafe

(

)

Deallocate all memory in the global memory list.

Definition at line 217 of file mem.c.

References MemoryBlock::address, MemoryList::first, list, and MemoryBlock::next.

Referenced by main().

{
    struct MemoryBlock *current, *next;

    if (list == nullptr)
    {
        return;
    }

    current = list->first;
    while (current != nullptr)
    {
        next = current->next;
        FREE_MEM(current->address);
        FREE_MEM(current);
        current = next;
    }

    FREE_MEM(list);
    list = nullptr;
}

Here is the caller graph for this function:

FreeMemSafe()

void FreeMemSafe

(

void *

block

)

Deallocate memory from the global memory list.

Definition at line 200 of file mem.c.

References RemoveMemSafe().

{
    RemoveMemSafe(block, true);
}

Here is the call graph for this function:

MemUsage()

void MemUsage	(	long *	blocks,
		long *	size,
		long *	peak
	)

Get memory usage in the global memory list.

Definition at line 242 of file mem.c.

References MemoryList::count, list, MemoryList::peak, and MemoryList::size.

Referenced by MemoryStatement::Execute().

{
    *blocks = list->count;
    *size = (long)list->size;
    *peak = (long)list->peak;;
}

Here is the caller graph for this function:

RemoveMemSafe()

void RemoveMemSafe	(	void *	block,
		bool	deallocate
	)

Definition at line 144 of file mem.c.

References MemoryBlock::address, MemoryList::count, dealloc_error(), MemoryList::first, list, MemoryBlock::next, MemoryBlock::size, and MemoryList::size.

Referenced by DetachMemSafe(), and FreeMemSafe().

{
    struct MemoryBlock *current, *previous;

    if (list == nullptr || block == nullptr)
    {
        dealloc_error("list", 0);
        return;
    }

    if (block == nullptr)
    {
        dealloc_error("memory", 0);
        return;
    }

    previous = nullptr;
    current = list->first;
    while (current != nullptr && current->address != block)
    {
        previous = current;
        current = current->next;
    }

    if (current == nullptr)
    {
        dealloc_error("address not found", block);
        return;
    }

    if (previous == nullptr)
    {
        list->first = current->next;
    }
    else
    {
        previous->next = current->next;
    }

    list->size -= current->size;
    list->count--;

    if (deallocate)
    {
        FREE_MEM(current->address);
    }

    current->address = nullptr;
    current->next = nullptr;
    current->size = 0;
    FREE_MEM(current);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

list

struct MemoryList* list = nullptr

Global list of allocated memory.

Definition at line 78 of file mem.c.

Referenced by AllocMemSafe(), FreeAllSafe(), MemUsage(), and RemoveMemSafe().