mem.h File Reference

Memory Management. More...

Go to the source code of this file.

Classes
struct	aa_flexbuf_t
	A buffer struct. More...
struct	aa_mem_region_node
	A single block of memory to be parceled out by the region allocator. More...
struct	aa_mem_region
	Data Structure for Region-Based memory allocation. More...
struct	aa_mem_pool_t
	Data Structure for Object pools. More...
struct	aa_circbuf_t
	Circular buffers use a fixed-size array that acts as if connected end-to end. More...
struct	aa_mem_cons
	A "cons" cell. More...
struct	aa_mem_rlist
	A linked list allocated out of a memory region. More...

Macros
#define	AA_ALLOC_STACK_MAX   (4096-64)
	maximum size of objects to stack allocate
#define	AA_NEW_AR(type, n)   ( (type*) malloc(sizeof(type)*(n)) )
	Malloc an array[n] of objects of type.
#define	AA_NEW0_AR(type, n)   ( (type*) aa_malloc0(sizeof(type)*(n)) )
	Malloc and zero initialize an array[n] of objects of type.
#define	AA_NEW(type)   AA_NEW_AR(type,1)
	Malloc an object of type.
#define	AA_NEW0(type)   AA_NEW0_AR(type,1)
	Malloc and zero initialize an object of type.
#define	AA_ALIGN2(val, align)   (((val) + (align) - 1) & ~(align-1))
	Returns val aligned to some multiple of align. More...
#define	AA_ALLOCAL(size)
	Allocate a local memory block. More...
#define	AA_NEW_LOCAL(type, n)   ( (type*) AA_ALLOCAL( sizeof(type)*(n) ) )
	Allocate a local array of type with n elements. More...
#define	AA_DEL_LOCAL(ptr, type, n)   aa_frlocal( ptr, sizeof(type)*(n) )
	Frees the result of AA_NEW_LOCAL.
#define	AA_MEMREG_ALIGN   16
	Alignment of each pointer allocated out of a memory region.
#define	AA_MEM_REGION_NEW(reg, type)   ( (type*) aa_mem_region_alloc((reg), sizeof(type)) )
	Allocate a new object of ‘type’ from memory region ‘reg’.
#define	AA_MEM_REGION_ZNEW(reg, type)    ( (type*) aa_mem_region_zalloc((reg), sizeof(type)) )
	Allocate zero-initialized object of ‘type’ from memory region ‘reg’.
#define	AA_MEM_REGION_NEW_CPY(reg, src, type)   ( (type*) aa_mem_region_dup((reg), (src), sizeof(type)) )
	Copy objects of ‘type’ from memory region ‘reg’.
#define	AA_MEM_REGION_DUP(reg, type, src, count)   ( (type*) aa_mem_region_dup((reg), (src), (count)*sizeof(type)) )
	Copy objects of ‘type’ from memory region ‘reg’.
#define	AA_MEM_REGION_NEW_N(reg, type, n)   ( (type*) aa_mem_region_alloc((reg), (n)*sizeof(type)) )
	Allocate an array of ‘n’ objects of ‘type’ from memory region ‘reg’.
#define	AA_MEM_REGION_ZNEW_N(reg, type, n)   ( (type*) aa_mem_region_zalloc((reg), (n)*sizeof(type)) )
	Allocate zero-initialized array of ‘n’ objects of ‘type’ from memory region ‘reg’.
#define	AA_MEM_REGION_LOCAL_NEW(type)   ( (type*) aa_mem_region_local_alloc( sizeof(type)) )
	Allocate a new object of ‘type’ the thread-local memory region.
#define	AA_MEM_REGION_LOCAL_NEW_N(type, n)   ( (type*) aa_mem_region_local_alloc( (n)*sizeof(type)) )
	Allocate a new array of ‘n’ objects of ‘type’ the thread-local memory region.
#define	AA_RLIST_DEF(element_type, list_type)
#define	AA_MEM_CPY(dst, src, n_elem)
	Copy n_elem elements from src to dst. More...
#define	AA_MEM_DUP(type, src, count)    ((type*)aa_mem_dup((src), sizeof(type)*(count)))
	Copy count elements from of type (type) from src into heap memory.
#define	AA_MEM_DUPOP(refop, type, const_dst, dst_data, src, n_elem)
#define	AA_MEM_SET(dst, val, n_elem)
	Set n_elem elements at dst to val. More...
#define	AA_MEM_ZERO(dst, n_elem)   (memset((dst),0,(n_elem)*sizeof(*(dst))))
	Set n_elem elements at dst to zero. More...
#define	AA_FAR(...)   (aa_far_deprecated(((double[]){__VA_ARGS__})))
	make a floating point array literal More...
#define	AA_ZERO_AR(var)   aa_zero( var, sizeof(var) )
	zeros var, must know sizeof(var)
#define	AA_SET_AR(var, val)
	sets each element of var to val, must know sizeof(var) More...
#define	AA_BITS_BITS   (8*sizeof(aa_bits))
	Number of bits in a aa_bits word.
#define	AA_BITS_JK(i, j, k)
#define	AA_MEM_SWAP(a, b, n_elem)   (aa_memswap( (a), (b), n_elem*sizeof(*(a)) ))
	Swap n_elements at and b.
#define	AA_VECTOR_PUSH(max, size, ptr, value)
	Append an item to the end of the vector. More...
#define	AA_VECTOR_DEF(element_type, vector_type)

Typedefs
typedef struct aa_mem_region	aa_mem_region_t
	Data Structure for Region-Based memory allocation. More...
typedef struct aa_mem_cons	aa_mem_cons_t
	A "cons" cell.
typedef struct aa_mem_rlist	aa_mem_rlist_t
	A linked list allocated out of a memory region. More...
typedef int	aa_bits
	An integer type for bit vectors.
typedef long	aa_memswap_type
	Type to use for memory swapping.

Enumerations
enum	aa_mem_refop { AA_MEM_COPY , AA_MEM_BORROW , AA_MEM_STEAL }

Functions
static void *	aa_malloc0 (size_t size)
	Malloc and zero initialize size bytes.
static void	aa_free_if_valid (void *ptr)
	Frees ptr unless NULL == ptr.
static void	aa_checked_free (void *ptr)
	Free ptr if non-NULL.
static void	aa_frlocal (void *ptr, size_t size)
	Free the results of AA_ALLOCAL. More...
AA_API aa_flexbuf_t *	aa_flexbuf_alloc (size_t n)
	allocate buffer of n bytes
AA_API void	aa_flexbuf_free (aa_flexbuf_t *p)
	free buffer
AA_API void	aa_mem_region_init (aa_mem_region_t *region, size_t size)
	Initialize memory region with an initial chunk of size bytes.
AA_API struct aa_mem_region *	aa_mem_region_create (size_t size)
	Allocate and initialize memory region with an initial chunk of size bytes.
AA_API void	aa_mem_region_destroy (aa_mem_region_t *region)
	Destroy memory region freeing all chunks. More...
AA_API size_t	aa_mem_region_freesize (aa_mem_region_t *region)
	Number of free contiguous bytes in region. More...
AA_API void *	aa_mem_region_tmpalloc (aa_mem_region_t *region, size_t size)
	Temporary allocation. More...
AA_API void *	aa_mem_region_alloc (aa_mem_region_t *region, size_t size)
	Allocate size bytes from the region. More...
AA_API void *	aa_mem_region_zalloc (aa_mem_region_t *region, size_t size)
	Allocate size bytes from the region and zero-initialize. More...
AA_API void *	aa_mem_region_tmprealloc (aa_mem_region_t *region, size_t size)
	Temporary allocation, ensuring that there is enough room for size bytes.
AA_API void *	aa_mem_region_dup (aa_mem_region_t *region, const void *p, size_t size)
	Duplicate size bytes at p, allocated out of region.
AA_API char *	aa_mem_region_strdup (aa_mem_region_t *region, const char *str)
	Duplicate a string, allocating from the region.
AA_API void	aa_mem_region_release (aa_mem_region_t *region)
	Deallocates all allocated objects from the region. More...
AA_API char *	aa_mem_region_printf (aa_mem_region_t *region, const char *fmt,...)
	printf's into a buffer allocated from region
AA_API char *	aa_mem_region_vprintf (aa_mem_region_t *reg, const char *fmt, va_list ap)
	printf's into a buffer allocated from region
AA_API void	aa_mem_region_pop (aa_mem_region_t *region, void *ptr)
	Deallocates ptr and all blocks allocated after ptr was allocated.
AA_API void *	aa_mem_region_ptr (aa_mem_region_t *region)
	Pointer to start of free space in region.
AA_API size_t	aa_mem_region_chunk_count (aa_mem_region_t *region)
	Number of chunks in the region.
AA_API size_t	aa_mem_region_topsize (aa_mem_region_t *region) AA_DEPRECATED
	Size of top chunk in region.
AA_API void	aa_mem_region_local_init (size_t size)
	Initialize the thread-local memory region. More...
AA_API void	aa_mem_region_local_destroy (void)
	Destroy the thread-local memory region. More...
AA_API aa_mem_region_t *	aa_mem_region_local_get (void)
	Return pointer to a thread-local memory region.
AA_API void *	aa_mem_region_local_alloc (size_t size)
	Allocate from thread-local memory region. More...
AA_API void *	aa_mem_region_local_tmpalloc (size_t size)
	Temporary allocate from thread-local memory region. More...
AA_API void	aa_mem_region_local_pop (void *ptr)
	Pop ptr from thread-local memory region. More...
AA_API void	aa_mem_region_local_release (void)
	Release all objects allocated from thread-local memory region. More...
AA_API void	aa_mem_pool_init (aa_mem_pool_t *pool, size_t size, size_t count)
	untested
AA_API void	aa_mem_pool_destroy (aa_mem_pool_t *pool)
	untested
AA_API void *	aa_mem_pool_alloc (aa_mem_pool_t *pool)
	untested
AA_API void	aa_mem_pool_free (aa_mem_pool_t *pool, void *ptr)
	untested
AA_API void	aa_mem_pool_release (aa_mem_pool_t *pool)
	untested
AA_API void	aa_circbuf_create (aa_circbuf_t *cb, size_t n)
	untested
AA_API void	aa_circbuf_destroy (aa_circbuf_t *cb, size_t n)
	untested
AA_API void	aa_circbuf_realloc (aa_circbuf_t *cb, size_t n)
	untested
AA_API size_t	aa_circbuf_space (aa_circbuf_t *cb)
	untested
AA_API size_t	aa_circbuf_used (aa_circbuf_t *cb)
	untested
AA_API void	aa_circbuf_put (aa_circbuf_t *cb, void *buf, size_t n)
	untested
AA_API int	aa_circbuf_read (aa_circbuf_t *cb, int fd, size_t n)
	untested
AA_API int	aa_circbuf_write (aa_circbuf_t *cb, int fd, size_t n)
	untested
AA_API struct aa_mem_rlist *	aa_mem_rlist_alloc (struct aa_mem_region *reg)
	Allocate rlist out of region. More...
AA_API void	aa_mem_rlist_push_cpy (struct aa_mem_rlist *list, void *p, size_t n)
	Push a copy of data at p to the front of the list.
AA_API void	aa_mem_rlist_push_ptr (struct aa_mem_rlist *list, void *p)
	Push the pointer p to the front of the list.
AA_API void	aa_mem_rlist_enqueue_cpy (struct aa_mem_rlist *list, const void *p, size_t n)
	Enqueue a copy of data at p at the back of the list.
AA_API void	aa_mem_rlist_enqueue_ptr (struct aa_mem_rlist *list, void *p)
	Enqueue a the pointer p at the back of the list.
AA_API void	aa_mem_rlist_map (struct aa_mem_rlist *list, void(*function)(void *cx, void *element), void *cx)
	Apply function to each element of list.
AA_API void *	aa_mem_rlist_pop (struct aa_mem_rlist *list)
	Remove front element of the list and return its data pointer. More...
static void *	aa_mem_dup (const void *src, size_t size)
	Copy n octets from src into freshly-allocated heap memory.
static AA_DEPRECATED double *	aa_far_deprecated (double *x)
	Helper for AA_FAR to warn deprecation. More...
static void	aa_fcpy (double *dst, const double *src, size_t n) AA_DEPRECATED
	copy n double floats from src to dst
static void	aa_fset (double *dst, double val, size_t n) AA_DEPRECATED
	set n double floats to val
static void	aa_zero (void *p, size_t n) AA_DEPRECATED
	set n bytes of p to zero
static void	aa_fzero (double *p, size_t n) AA_DEPRECATED
	zero array p of length n
static size_t	aa_bits_words (size_t n)
	Number of aa_bits words to store n bits.
static size_t	aa_bits_size (size_t n_bits)
	Size of bit vector in octets.
static int	aa_bits_get (aa_bits *b, size_t i)
	Return the value of the i'th bit in bitset b.
static int	aa_bits_getn (aa_bits *b, size_t n, size_t i)
	Return the value of the i'th bit in bitset b of size n. More...
static void	aa_bits_set (aa_bits *b, size_t i, int val)
	Set the value of the i'th bit in bitset b to val.
static void	aa_bits_and (aa_bits *a, const aa_bits *b, size_t n_bits)
	Compute the bitwise AND of a and b, storing the result in a.
static void	aa_bits_or (aa_bits *a, const aa_bits *b, size_t n_bits)
	Compute the bitwise OR of a and b, storing the result in a.
static void	aa_bits_xor (aa_bits *a, const aa_bits *b, size_t n_bits)
	Compute the bitwise XOR of a and b, storing the result in a.
static void	aa_memswap (void *AA_RESTRICT a, void *AA_RESTRICT b, size_t size)
	Swap size bytes of memory at a and b.

Detailed Description

Memory Management.

Definition in file mem.h.

Macro Definition Documentation

AA_ALIGN2

#define AA_ALIGN2	(		val,
			align
	)		(((val) + (align) - 1) & ~(align-1))

Returns val aligned to some multiple of align.

align must be a power of 2. Evaluates arguments multiple times.

Definition at line 103 of file mem.h.

AA_ALLOCAL

#define AA_ALLOCAL

(

size

)

Value:

            ({ size_t aa_$_allocal_size = (size);          \
            aa_$_allocal_size > AA_ALLOC_STACK_MAX ?                    \
                malloc(aa_$_allocal_size) : alloca(aa_$_allocal_size);   })

Allocate a local memory block.

This macro will stack-allocate small memory blocks and heap-allocate large ones.

This is necessary because GCC does not verify that calls to alloca() or VLAs can actually fit on the stack. Exceeding the stack bounds will usually cause a segfault.

You can change limit for stack allocations by redefining AA_ALLOC_STACK_MAX before including this header or amino.h

Definition at line 125 of file mem.h.

AA_BITS_JK

#define AA_BITS_JK	(		i,
			j,
			k
	)

Value:

    j = (i) / AA_BITS_BITS;                   \
    k = (i) - (j)*AA_BITS_BITS;

Definition at line 650 of file mem.h.

AA_FAR

#define AA_FAR

(

...

)

(aa_far_deprecated(((double[]){__VA_ARGS__})))

make a floating point array literal

Deprecated due to C++ incompatibility.

Definition at line 588 of file mem.h.

AA_MEM_CPY

#define AA_MEM_CPY	(		dst,
			src,
			n_elem
	)

Value:

    {                                                           \
        /* _Static_assert(sizeof(*dst) == sizeof(*src));*/      \
        memcpy( (dst), (src), sizeof((dst)[0])*(n_elem) );      \
    }

Copy n_elem elements from src to dst.

May evaluate arguments multiple times.

Definition at line 523 of file mem.h.

AA_MEM_DUPOP

#define AA_MEM_DUPOP	(		refop,
			type,
			const_dst,
			dst_data,
			src,
			n_elem
	)

Value:

    switch(refop) {                                                     \
    case AA_MEM_COPY:                                                   \
        dst_data = AA_MEM_DUP(type, src, n_elem);                       \
        const_dst = dst_data;                                           \
        break;                                                          \
    case AA_MEM_STEAL:                                                  \
        dst_data = src;                                                 \
        const_dst = dst_data;                                           \
        break;                                                          \
    case AA_MEM_BORROW:                                                 \
        dst_data = NULL;                                                \
        const_dst = src;                                                \
        break;                                                          \
    };

Definition at line 544 of file mem.h.

AA_MEM_SET

#define AA_MEM_SET	(		dst,
			val,
			n_elem
	)

Value:

    {                                                                   \
        for( size_t aa_$_set_i = 0;                                     \
             aa_$_set_i < (n_elem);                                     \
             aa_$_set_i++ )                                             \
            (dst)[aa_$_set_i] = (val);                                  \
    }

Set n_elem elements at dst to val.

May evaluate arguments multiple times.

Definition at line 566 of file mem.h.

AA_MEM_ZERO

#define AA_MEM_ZERO	(		dst,
			n_elem
	)		(memset((dst),0,(n_elem)*sizeof(*(dst))))

Set n_elem elements at dst to zero.

May evaluate arguments multiple times.

Definition at line 578 of file mem.h.

AA_NEW_LOCAL

#define AA_NEW_LOCAL	(		type,
			n
	)		( (type*) AA_ALLOCAL( sizeof(type)*(n) ) )

Allocate a local array of type with n elements.

Uses AA_ALLOCAL.

Definition at line 133 of file mem.h.

AA_RLIST_DEF

#define AA_RLIST_DEF	(		element_type,
			list_type
	)

Value:

    typedef struct {                                             \
        aa_mem_rlist_t rlist;                                    \
    } list_type;                                                 \
    static inline list_type*                                     \
    list_type ## _alloc( aa_mem_region *reg )                    \
    {                                                            \
        return (list_type*)aa_mem_rlist_alloc(reg);              \
    }

Definition at line 505 of file mem.h.

AA_SET_AR

#define AA_SET_AR	(		var,
			val
	)

Value:

    for( size_t aa_$_set_ar_i = 0;                              \
         aa_$_set_ar_i < sizeof(var)/sizeof(var[0]);            \
         aa_$_set_ar_i ++ ) var[aa_$_set_ar_i] = val;

sets each element of var to val, must know sizeof(var)

Definition at line 618 of file mem.h.

AA_VECTOR_DEF

#define AA_VECTOR_DEF	(		element_type,
			vector_type
	)

Value:

    typedef struct {                                                    \
        size_t max;                                                     \
        size_t size;                                                    \
        element_type *data;                                             \
    } vector_type;                                                      \
    static inline void vector_type ## _init                             \
    ( vector_type *vec, size_t max ) {                                  \
        vec->data = (element_type*)malloc(max*sizeof(*vec->data));      \
        vec->max = max;                                                 \
        vec->size = (size_t)0;                                          \
    }                                                                  \
    static inline void vector_type ## _push                             \
    ( vector_type *vec, element_type value ) {                          \
        AA_VECTOR_PUSH(vec->max, vec->size, vec->data, value);          \
    }

Definition at line 787 of file mem.h.

AA_VECTOR_PUSH

#define AA_VECTOR_PUSH	(		max,
			size,
			ptr,
			value
	)

Value:

    if( (size) >= (max) ) {                                     \
        (max) = 2*(size+1);                                     \
        (ptr) = (__typeof__(ptr))realloc(ptr,sizeof(*ptr)*max); \
    }                                                           \
    ptr[(size)++] = (value);

Append an item to the end of the vector.

Parameters

max	Maximum number of elements ptr can hold. May be evaluated multiple times.
size	Number of elements in the vector. May be evaluated multiple times.
ptr	Base pointer of the vector. May be evaluated multiple times.
value	The value to append

Definition at line 780 of file mem.h.

Typedef Documentation

aa_mem_region_t

typedef struct aa_mem_region aa_mem_region_t

Data Structure for Region-Based memory allocation.

Memory regions provide fast allocation of individual objects and fast deallocation of all objects in the region and of all objects allocated after some given object. It is not possible to deallocate only a single arbitrary object from the region.

This provides two benefits over malloc/free. First, as long as the requested allocation can be fulfilled from the memory available in the region, allocation and deallocation require only a pointer increment or decrement. Second, there is no need to store any metadata for each individual allocation resulting in some space savings, expecially for small objects.

This implementation pre-allocates chunks of memory and fulfills individual requests from those chunks. If the request cannot be satisfied from the currently available chunk, this implemention will malloc() another chunk and add it to the region in a linked list. When objects are deallocated via a release or a pop, chunks are merged into one, possibly requiring several calls to free() followed by a single malloc of a new, larger chunk.

aa_mem_rlist_t

typedef struct aa_mem_rlist aa_mem_rlist_t

A linked list allocated out of a memory region.

"Region List" / "Real-Time List"

See also

amino::RegionList

Function Documentation

aa_bits_getn()

static int aa_bits_getn ( aa_bits *  b, size_t  n, size_t  i  )

inlinestatic

Return the value of the i'th bit in bitset b of size n.

Bits beyond the size of the bitset are assumed to be zero.

Definition at line 673 of file mem.h.

aa_far_deprecated()

static AA_DEPRECATED double* aa_far_deprecated ( double *  x )

inlinestatic

Helper for AA_FAR to warn deprecation.

Definition at line 582 of file mem.h.

aa_frlocal()

static void aa_frlocal ( void *  ptr, size_t  size  )

inlinestatic

Free the results of AA_ALLOCAL.

This function should be called once for every call to AA_ALLOCAL in case the previously requested memory was put in the heap.

Definition at line 140 of file mem.h.

aa_mem_region_alloc()

AA_API void* aa_mem_region_alloc	(	aa_mem_region_t *	region,
		size_t	size
	)

Allocate size bytes from the region.

The head pointer of the top chunk will be returned if it has sufficient space for the allocation.

aa_mem_region_destroy()

AA_API void aa_mem_region_destroy

(

aa_mem_region_t *

region

)

Destroy memory region freeing all chunks.

For regions created with aa_mem_region_create(), free the created struct aa_mem_region.

aa_mem_region_freesize()

AA_API size_t aa_mem_region_freesize

(

aa_mem_region_t *

region

)

Number of free contiguous bytes in region.

This is the number of bytes which may be allocated without creating another chunk.

aa_mem_region_local_alloc()

AA_API void* aa_mem_region_local_alloc

(

size_t

size

)

Allocate from thread-local memory region.

See also

aa_mem_region_alloc

aa_mem_region_local_destroy()

AA_API void aa_mem_region_local_destroy

(

void

)

Destroy the thread-local memory region.

See also

aa_mem_region_destroy

aa_mem_region_local_init()

AA_API void aa_mem_region_local_init

(

size_t

size

)

Initialize the thread-local memory region.

See also

aa_mem_region_init

aa_mem_region_local_pop()

AA_API void aa_mem_region_local_pop

(

void *

ptr

)

Pop ptr from thread-local memory region.

See also

aa_mem_region_pop

aa_mem_region_local_release()

AA_API void aa_mem_region_local_release

(

void

)

Release all objects allocated from thread-local memory region.

See also

aa_mem_region_release

aa_mem_region_local_tmpalloc()

AA_API void* aa_mem_region_local_tmpalloc

(

size_t

size

)

Temporary allocate from thread-local memory region.

See also

aa_mem_region_tmpalloc

aa_mem_region_release()

AA_API void aa_mem_region_release

(

aa_mem_region_t *

region

)

Deallocates all allocated objects from the region.

If the region contains multiple chunks, they are merged into one.

aa_mem_region_tmpalloc()

AA_API void* aa_mem_region_tmpalloc	(	aa_mem_region_t *	region,
		size_t	size
	)

Temporary allocation.

The next call to aa_mem_region_alloc or aa_mem_region_tmpalloc will return the same pointer if sufficient space is available in the top chunk for that subsequent call.

aa_mem_region_zalloc()

AA_API void* aa_mem_region_zalloc	(	aa_mem_region_t *	region,
		size_t	size
	)

Allocate size bytes from the region and zero-initialize.

The head pointer of the top chunk will be returned if it has sufficient space for the allocation.

aa_mem_rlist_alloc()

AA_API struct aa_mem_rlist* aa_mem_rlist_alloc

(

struct aa_mem_region *

reg

)

Allocate rlist out of region.

All nodes in the rlist will also come from the same region You can free all nodes by popping the list itself from the region

aa_mem_rlist_pop()

AA_API void* aa_mem_rlist_pop

(

struct aa_mem_rlist *

list

)

Remove front element of the list and return its data pointer.

Note, this does not release any memory from the list's underlying region.