memory.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include "memory.h"
#include "endrun.h"

Include dependency graph for memory.c:

Go to the source code of this file.

Classes
struct	BlockHeader

Macros
#define	MAGIC   "DEADBEEF"
#define	ALIGNMENT   4096

Functions
int	allocator_init (Allocator *alloc, const char *name, const size_t request_size, const int zero, Allocator *parent)
int	allocator_malloc_init (Allocator *alloc, const char *name, const size_t request_size, const int zero, Allocator *parent)
int	allocator_reset (Allocator *alloc, int zero)
static void *	allocator_alloc_va (Allocator *alloc, const char *name, const size_t request_size, const int dir, const char *fmt, va_list va)
void *	allocator_alloc (Allocator *alloc, const char *name, const size_t request_size, const int dir, const char *fmt,...)
int	allocator_destroy (Allocator *alloc)
int	allocator_iter_start (AllocatorIter *iter, Allocator *alloc)
static int	is_header (struct BlockHeader *header)
int	allocator_iter_next (AllocatorIter *iter)
int	allocator_iter_ended (AllocatorIter *iter)
size_t	allocator_get_free_size (Allocator *alloc)
size_t	allocator_get_used_size (Allocator *alloc, int dir)
void	allocator_print (Allocator *alloc)
void *	allocator_realloc_int (Allocator *alloc, void *ptr, const size_t new_size, const char *fmt,...)
void	allocator_free (void *ptr)
int	allocator_dealloc (Allocator *alloc, void *ptr)

Macro Definition Documentation

ALIGNMENT

#define ALIGNMENT   4096

Definition at line 9 of file memory.c.

MAGIC

#define MAGIC   "DEADBEEF"

Definition at line 8 of file memory.c.

Function Documentation

allocator_alloc()

void* allocator_alloc	(	Allocator *	alloc,
		const char *	name,
		const size_t	request_size,
		const int	dir,
		const char *	fmt,
			...
	)

Definition at line 166 of file memory.c.

{
    va_list va;
    va_start(va, fmt);
    void * rt = allocator_alloc_va(alloc, name, request_size, dir, fmt, va);
    va_end(va);
    return rt;
}

References BlockHeader::alloc, allocator_alloc_va(), BlockHeader::dir, name, and BlockHeader::request_size.

Referenced by allocator_init(), and allocator_malloc_init().

Here is the call graph for this function:

Here is the caller graph for this function:

allocator_alloc_va()

static void* allocator_alloc_va ( Allocator *  alloc, const char *  name, const size_t  request_size, const int  dir, const char *  fmt, va_list  va  )

static

Definition at line 106 of file memory.c.

{
    size_t size = request_size;
 
    if(alloc->use_malloc) {
        size = 0; /* because we'll get it from malloc */
    } else {
        size = ((size + ALIGNMENT - 1) / ALIGNMENT) * ALIGNMENT;
    }
    size += ALIGNMENT; /* for the header */
 
    char * ptr;
    if(dir == ALLOC_DIR_BOT) {
        if(alloc->bottom + size > alloc->top) {
            allocator_print(alloc);
            endrun(1, "Not enough memory for %s %td bytes\n", name, size);
        }
        ptr = alloc->base + alloc->bottom;
        alloc->bottom += size;
        alloc->refcount += 1;
    } else if (dir == ALLOC_DIR_TOP) {
        if(alloc->top < alloc->bottom + size) {
            allocator_print(alloc);
            endrun(1, "Not enough memory for %s %td bytes\n", name, size);
        }
        ptr = alloc->base + alloc->top - size;
        alloc->refcount += 1;
        alloc->top -= size;
    } else {
        /* wrong dir cannot allocate */
        return NULL;
    }
 
    struct BlockHeader * header = (struct BlockHeader *) ptr;
    memcpy(header->magic, MAGIC, 8);
    header->self = ptr;
    header->size = size;
    header->request_size = request_size;
    header->dir = dir;
    header->alloc = alloc;
    strncpy(header->name, name, 126);
    header->name[126] = '\0';
 
    vsprintf(header->annotation, fmt, va);
 
    char * cptr;
    if(alloc->use_malloc) {
        /* prepend a copy of the header to the malloc block; allocator_free will use it*/
        if(posix_memalign((void **) &cptr, ALIGNMENT, request_size + ALIGNMENT))
            endrun(1, "Failed malloc: %lu bytes for %s\n", request_size, header->name);
        header->ptr = cptr + ALIGNMENT;
        memcpy(cptr, header, ALIGNMENT);
        cptr = header->ptr;
    } else {
        cptr = ptr + ALIGNMENT;
        header->ptr = cptr;
    }
    return cptr;
}

References ALIGNMENT, BlockHeader::alloc, ALLOC_DIR_BOT, ALLOC_DIR_TOP, allocator_print(), BlockHeader::annotation, Allocator::base, Allocator::bottom, BlockHeader::dir, endrun(), MAGIC, BlockHeader::magic, name, BlockHeader::name, BlockHeader::ptr, Allocator::refcount, BlockHeader::request_size, BlockHeader::self, BlockHeader::size, Allocator::top, and Allocator::use_malloc.

Referenced by allocator_alloc(), and allocator_realloc_int().

Here is the call graph for this function:

Here is the caller graph for this function:

allocator_dealloc()

int allocator_dealloc	(	Allocator *	alloc,
		void *	ptr
	)

Definition at line 376 of file memory.c.

{
    char * cptr = (char *) ptr;
    struct BlockHeader * header = (struct BlockHeader*) (cptr - ALIGNMENT);
 
    if (!is_header(header)) {
        return ALLOC_ENOTALLOC;
    }
 
    /* ->self is always the header in the allocator; header maybe a duplicate in use_malloc */
    ptr = header->self;
    if(header->dir == ALLOC_DIR_BOT) {
        if(ptr != alloc->bottom - header->size + alloc->base) {
            return ALLOC_EMISMATCH;
        }
        alloc->bottom -= header->size;
    } else if(header->dir == ALLOC_DIR_TOP) {
        if(ptr != alloc->top + alloc->base) {
            return ALLOC_EMISMATCH;
        }
        alloc->top += header->size;
    } else {
        return ALLOC_ENOTALLOC;
    }
 
    if(alloc->use_malloc) {
        free(header);
    }
 
    /* remove the link to the memory. */
    header = (struct BlockHeader *) ptr; /* modify the true header in the allocator */
    header->ptr = NULL;
    header->self = NULL;
    header->alloc = NULL;
    alloc->refcount --;
 
    return 0;
}

References ALIGNMENT, BlockHeader::alloc, ALLOC_DIR_BOT, ALLOC_DIR_TOP, ALLOC_EMISMATCH, ALLOC_ENOTALLOC, Allocator::base, Allocator::bottom, BlockHeader::dir, is_header(), BlockHeader::ptr, Allocator::refcount, BlockHeader::self, BlockHeader::size, Allocator::top, and Allocator::use_malloc.

Referenced by allocator_destroy(), allocator_free(), allocator_realloc_int(), test_allocator(), and test_allocator_malloc().

Here is the call graph for this function:

Here is the caller graph for this function:

allocator_destroy()

int allocator_destroy

(

Allocator *

alloc

)

Definition at line 176 of file memory.c.

{
    if(alloc->refcount != 1) {
        allocator_print(alloc);
        endrun(1, "leaked\n");
    }
    if(alloc->parent)
        allocator_dealloc(alloc->parent, alloc->rawbase);
    else
        free(alloc->rawbase);
    return 0;
}

References BlockHeader::alloc, allocator_dealloc(), allocator_print(), endrun(), Allocator::parent, Allocator::rawbase, and Allocator::refcount.

Referenced by test_allocator(), test_allocator_malloc(), and test_sub_allocator().

Here is the call graph for this function:

Here is the caller graph for this function:

allocator_free()

void allocator_free

(

void *

ptr

)

Definition at line 358 of file memory.c.

{
    char * cptr = (char *) ptr;
    struct BlockHeader * header = (struct BlockHeader*) (cptr - ALIGNMENT);
 
    if (!is_header(header)) {
        allocator_print(header->alloc);
        endrun(1, "Not an allocated address: Header = %08p ptr = %08p\n", header, cptr);
    }
 
    int rt = allocator_dealloc(header->alloc, ptr);
    if (rt != 0) {
        allocator_print(header->alloc);
        endrun(1, "Mismatched Free: %s : %s\n", header->name, header->annotation);
    }
}

References ALIGNMENT, BlockHeader::alloc, allocator_dealloc(), allocator_print(), BlockHeader::annotation, endrun(), is_header(), BlockHeader::name, and BlockHeader::ptr.

Referenced by test_allocator(), test_allocator_malloc(), and test_sub_allocator().

Here is the call graph for this function:

Here is the caller graph for this function:

allocator_get_free_size()

size_t allocator_get_free_size

(

Allocator *

alloc

)

Definition at line 246 of file memory.c.

{
    /*For malloc, return a fixed 2GB */
    if(alloc->use_malloc) {
        return 2L*1024L*1024L*1024L;
    }
    return (alloc->top - alloc->bottom);
}

References BlockHeader::alloc, Allocator::bottom, Allocator::top, and Allocator::use_malloc.

Referenced by allocator_print().

Here is the caller graph for this function:

allocator_get_used_size()

size_t allocator_get_used_size	(	Allocator *	alloc,
		int	dir
	)

Definition at line 256 of file memory.c.

{
    /* For malloc sum up the requested memory.
     * I considered mallinfo, but there may be multiple memory arenas. */
    if(alloc->use_malloc) {
        size_t total = 0;
        AllocatorIter iter[1];
        for(allocator_iter_start(iter, alloc); !allocator_iter_ended(iter);
            allocator_iter_next(iter))
        {
            total += iter->request_size;
        }
        return total;
    }
    if (dir == ALLOC_DIR_TOP) {
        return (alloc->size - alloc->top);
    }
    if (dir == ALLOC_DIR_BOT) {
        return (alloc->bottom - 0);
    }
    if (dir == ALLOC_DIR_BOTH) {
        return (alloc->size - alloc->top + alloc->bottom - 0);
    }
    /* unknown */
    return 0;
}

References BlockHeader::alloc, ALLOC_DIR_BOT, ALLOC_DIR_BOTH, ALLOC_DIR_TOP, allocator_iter_ended(), allocator_iter_next(), allocator_iter_start(), Allocator::bottom, BlockHeader::dir, AllocatorIter::request_size, Allocator::size, Allocator::top, and Allocator::use_malloc.

Referenced by allocator_print(), and report_detailed_memory_usage().

Here is the call graph for this function:

Here is the caller graph for this function:

allocator_init()

int allocator_init	(	Allocator *	alloc,
		const char *	name,
		const size_t	request_size,
		const int	zero,
		Allocator *	parent
	)

Definition at line 24 of file memory.c.

{
    size_t size = (request_size / ALIGNMENT + 1) * ALIGNMENT;
 
    char * rawbase;
    if (parent) {
        rawbase = (char *) allocator_alloc(parent, name, size + ALIGNMENT, ALLOC_DIR_BOT, "Child");
        if(rawbase == NULL)
            return ALLOC_ENOMEMORY;
    }
    else
        if(posix_memalign((void **) &rawbase, ALIGNMENT, size + ALIGNMENT))
            return ALLOC_ENOMEMORY;
 
    alloc->parent = parent;
    alloc->rawbase = rawbase;
    alloc->base = rawbase + ALIGNMENT - ((size_t) rawbase % ALIGNMENT);
    alloc->size = size;
    alloc->use_malloc = 0;
    strncpy(alloc->name, name, 11);
    alloc->refcount = 1;
    alloc->top = alloc->size;
    alloc->bottom = 0;
 
    allocator_reset(alloc, zero);
 
    return 0;
}

References ALIGNMENT, ALLOC_DIR_BOT, ALLOC_ENOMEMORY, allocator_alloc(), allocator_reset(), Allocator::base, Allocator::bottom, name, Allocator::name, Allocator::parent, Allocator::rawbase, Allocator::refcount, Allocator::size, Allocator::top, and Allocator::use_malloc.

Referenced by mymalloc_init(), tamalloc_init(), test_allocator(), and test_sub_allocator().

Here is the call graph for this function:

Here is the caller graph for this function:

allocator_iter_ended()

int allocator_iter_ended

(

AllocatorIter *

iter

)

Definition at line 240 of file memory.c.

{
    return iter->_ended;
}

References AllocatorIter::_ended.

Referenced by allocator_get_used_size(), allocator_print(), and allocator_reset().

Here is the caller graph for this function:

allocator_iter_next()

int allocator_iter_next

(

AllocatorIter *

iter

)

Definition at line 209 of file memory.c.

{
    struct BlockHeader * header;
    Allocator * alloc = iter->alloc;
    if(alloc->bottom != iter->_bottom) {
        header = (struct BlockHeader *) (iter->_bottom + alloc->base);
        iter->_bottom += header->size;
    } else
    if(iter->_top != alloc->size) {
        header = (struct BlockHeader *) (iter->_top + alloc->base);
        iter->_top += header->size;
    } else {
        iter->_ended = 1;
        return 0;
    }
    if (! is_header(header)) {
        /* several corruption that shall not happen */
        endrun(5, "Ptr %p is not a magic header\n", header);
    }
    iter->ptr =  header->ptr;
    iter->name = header->name;
    iter->annotation = header->annotation;
    iter->size = header->size;
    iter->request_size = header->request_size;
    iter->dir = header->dir;
    return 1;
}

References AllocatorIter::_bottom, AllocatorIter::_ended, AllocatorIter::_top, BlockHeader::alloc, AllocatorIter::alloc, BlockHeader::annotation, AllocatorIter::annotation, Allocator::base, Allocator::bottom, BlockHeader::dir, AllocatorIter::dir, endrun(), is_header(), BlockHeader::name, AllocatorIter::name, BlockHeader::ptr, AllocatorIter::ptr, BlockHeader::request_size, AllocatorIter::request_size, BlockHeader::size, Allocator::size, and AllocatorIter::size.

Referenced by allocator_get_used_size(), allocator_iter_start(), allocator_print(), and allocator_reset().

Here is the call graph for this function:

Here is the caller graph for this function:

allocator_iter_start()

int allocator_iter_start	(	AllocatorIter *	iter,
		Allocator *	alloc
	)

Definition at line 190 of file memory.c.

{
    iter->alloc = alloc;
    iter->_bottom = 0;
    iter->_top = alloc->top;
    iter->_ended = 0;
    return allocator_iter_next(iter);
}

References AllocatorIter::_bottom, AllocatorIter::_ended, AllocatorIter::_top, BlockHeader::alloc, AllocatorIter::alloc, allocator_iter_next(), and Allocator::top.

Referenced by allocator_get_used_size(), allocator_print(), and allocator_reset().

Here is the call graph for this function:

Here is the caller graph for this function:

allocator_malloc_init()

int allocator_malloc_init	(	Allocator *	alloc,
		const char *	name,
		const size_t	request_size,
		const int	zero,
		Allocator *	parent
	)

Definition at line 54 of file memory.c.

{
    /* max support 4096 blocks; ignore request_size */
    size_t size = ALIGNMENT * 4096;
 
    char * rawbase;
    if (parent) {
        rawbase = (char *) allocator_alloc(parent, name, size + ALIGNMENT, ALLOC_DIR_BOT, "Child");
        if (rawbase == NULL) return ALLOC_ENOMEMORY;
    }
    else
        if(posix_memalign((void **) &rawbase, ALIGNMENT, size + ALIGNMENT))
            return ALLOC_ENOMEMORY;
 
 
    alloc->parent = parent;
    alloc->use_malloc = 1;
    alloc->rawbase = rawbase;
    alloc->base = rawbase;
    alloc->size = size;
    strncpy(alloc->name, name, 11);
    alloc->refcount = 1;
    alloc->top = alloc->size;
    alloc->bottom = 0;
 
    allocator_reset(alloc, zero);
 
    return 0;
}

References ALIGNMENT, ALLOC_DIR_BOT, ALLOC_ENOMEMORY, allocator_alloc(), allocator_reset(), Allocator::base, Allocator::bottom, name, Allocator::name, Allocator::parent, Allocator::rawbase, Allocator::refcount, Allocator::size, Allocator::top, and Allocator::use_malloc.

Referenced by test_allocator_malloc().

Here is the call graph for this function:

Here is the caller graph for this function:

allocator_print()

void allocator_print

(

Allocator *

alloc

)

Definition at line 284 of file memory.c.

{
    message(1, "--------------- Allocator: %-17s %12s-----------------\n",
                alloc->name,
                alloc->use_malloc?"(libc managed)":"(self managed)"
                );
    message(1, " Total: %010td kbytes\n", alloc->size/1024);
    message(1, " Free: %010td Used: %010td Top: %010td Bottom: %010td \n",
            allocator_get_free_size(alloc)/1024,
            allocator_get_used_size(alloc, ALLOC_DIR_BOTH)/1024,
            allocator_get_used_size(alloc, ALLOC_DIR_TOP)/1024,
            allocator_get_used_size(alloc, ALLOC_DIR_BOT)/1024
            );
    AllocatorIter iter[1];
    message(1, " %-20s | %c | %-12s %-12s | %s\n", "Name", 'd', "Requested", "Allocated", "Annotation");
    message(1, "-------------------------------------------------------\n");
    for(allocator_iter_start(iter, alloc);
        !allocator_iter_ended(iter);
        allocator_iter_next(iter))
    {
        message(1, " %-20s | %c | %012td %012td | %s\n",
                 iter->name,
                 "T?B"[iter->dir + 1],
                 iter->request_size/1024, iter->size/1024, iter->annotation);
    }
}

References BlockHeader::alloc, ALLOC_DIR_BOT, ALLOC_DIR_BOTH, ALLOC_DIR_TOP, allocator_get_free_size(), allocator_get_used_size(), allocator_iter_ended(), allocator_iter_next(), allocator_iter_start(), AllocatorIter::annotation, AllocatorIter::dir, message(), Allocator::name, AllocatorIter::name, AllocatorIter::request_size, Allocator::size, AllocatorIter::size, and Allocator::use_malloc.

Referenced by allocator_alloc_va(), allocator_destroy(), allocator_free(), allocator_realloc_int(), report_detailed_memory_usage(), test_allocator(), test_allocator_malloc(), and test_sub_allocator().

Here is the call graph for this function:

Here is the caller graph for this function:

allocator_realloc_int()

void* allocator_realloc_int	(	Allocator *	alloc,
		void *	ptr,
		const size_t	new_size,
		const char *	fmt,
			...
	)

Definition at line 312 of file memory.c.

{
    va_list va;
    va_start(va, fmt);
 
    char * cptr = (char *) ptr;
    struct BlockHeader * header = (struct BlockHeader*) (cptr - ALIGNMENT);
    struct BlockHeader tmp = * header;
 
    if (!is_header(header)) {
        allocator_print(header->alloc);
        endrun(1, "Not an allocated address: Header = %08p ptr = %08p\n", header, cptr);
    }
 
    if(alloc->use_malloc) {
        struct BlockHeader * header2 = (struct BlockHeader *) realloc(header, new_size + ALIGNMENT);
        header2->ptr = (char*) header2 + ALIGNMENT;
        header2->request_size = new_size;
        /* update record */
        vsprintf(header2->annotation, fmt, va);
        va_end(va);
        memcpy(header2->self, header2, sizeof(header2[0]));
        return header2->ptr;
    }
 
    if(0 != allocator_dealloc(alloc, ptr)) {
        allocator_print(header->alloc);
        endrun(1, "Mismatched Free: %s : %s\n", header->name, header->annotation);
    }
 
    /*If we are shrinking memory, move the existing data block up and then write a new header.*/
    if(tmp.dir == ALLOC_DIR_TOP && new_size < tmp.request_size) {
        /*Offset for new memory, after header*/
        size_t size = ((new_size + ALIGNMENT - 1) / ALIGNMENT) * ALIGNMENT;
        memmove(alloc->base + alloc->top - size, tmp.ptr, new_size);
    }
    void * newptr = allocator_alloc_va(alloc, tmp.name, new_size, tmp.dir, fmt, va);
    /*If we are extending memory, move the existing data block down after writing a new header below it*/
    if(tmp.dir == ALLOC_DIR_TOP && new_size > tmp.request_size) {
        memmove(newptr, tmp.ptr, tmp.size);
    }
    va_end(va);
    return newptr;
}

References ALIGNMENT, BlockHeader::alloc, ALLOC_DIR_TOP, allocator_alloc_va(), allocator_dealloc(), allocator_print(), BlockHeader::annotation, Allocator::base, BlockHeader::dir, endrun(), is_header(), BlockHeader::name, BlockHeader::ptr, BlockHeader::request_size, BlockHeader::self, BlockHeader::size, Allocator::top, and Allocator::use_malloc.

Here is the call graph for this function:

allocator_reset()

int allocator_reset	(	Allocator *	alloc,
		int	zero
	)

Definition at line 85 of file memory.c.

{
    /* Free the memory when using malloc*/
    if(alloc->use_malloc) {
        AllocatorIter iter[1];
        for(allocator_iter_start(iter, alloc); !allocator_iter_ended(iter); allocator_iter_next(iter))
        {
            free(iter->ptr - ALIGNMENT);
        }
    }
    alloc->refcount = 1;
    alloc->top = alloc->size;
    alloc->bottom = 0;
 
    if(zero) {
        memset(alloc->base, 0, alloc->size);
    }
    return 0;
}

References ALIGNMENT, allocator_iter_ended(), allocator_iter_next(), allocator_iter_start(), Allocator::base, Allocator::bottom, AllocatorIter::ptr, Allocator::refcount, Allocator::size, Allocator::top, and Allocator::use_malloc.

Referenced by allocator_init(), and allocator_malloc_init().

Here is the call graph for this function:

Here is the caller graph for this function:

is_header()

static int is_header ( struct BlockHeader *  header )

static

Definition at line 203 of file memory.c.

{
    return 0 == memcmp(header->magic, MAGIC, 8);
}

References MAGIC, and BlockHeader::magic.

Referenced by allocator_dealloc(), allocator_free(), allocator_iter_next(), and allocator_realloc_int().

Here is the caller graph for this function: