amino  1.0-beta2
Lightweight Robot Utility Library
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
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. More...
 
#define AA_NEW0_AR(type, n)   ( (type*) aa_malloc0(sizeof(type)*(n)) )
 Malloc and zero initialize an array[n] of objects of type. More...
 
#define AA_NEW(type)   AA_NEW_AR(type,1)
 Malloc an object of type. More...
 
#define AA_NEW0(type)   AA_NEW0_AR(type,1)
 Malloc and zero initialize an object of type. More...
 
#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. More...
 
#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_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_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_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(...)   ((double[]){__VA_ARGS__})
 make a floating point array literal
 
#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. More...
 
static void aa_free_if_valid (void *ptr)
 Frees ptr unless NULL == ptr.
 
static void aa_checked_free (void *ptr)
 
static void aa_frlocal (void *ptr, size_t size)
 Free the results of AA_ALLOCAL. More...
 
AA_API aa_flexbuf_taa_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. More...
 
AA_API void aa_mem_region_destroy (aa_mem_region_t *region)
 Destroy memory region freeing all chunks.
 
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_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_taa_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_rlistaa_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 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

#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.

#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); })
#define AA_ALLOC_STACK_MAX
maximum size of objects to stack allocate
Definition: mem.h:53

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 124 of file mem.h.

#define AA_BITS_JK (   i,
  j,
 
)
Value:
j = (i) / AA_BITS_BITS; \
k = (i) - (j)*AA_BITS_BITS;
#define AA_BITS_BITS
Number of bits in a aa_bits word.
Definition: mem.h:573

Definition at line 591 of file mem.h.

#define AA_DEL_LOCAL (   ptr,
  type,
 
)    aa_frlocal( ptr, sizeof(type)*(n) )

Frees the result of AA_NEW_LOCAL.

Definition at line 144 of file mem.h.

#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 471 of file mem.h.

#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; \
};
#define AA_MEM_DUP(type, src, count)
Copy count elements from of type (type) from src into heap memory.
Definition: mem.h:489

Definition at line 492 of file mem.h.

#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 514 of file mem.h.

#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 526 of file mem.h.

#define AA_NEW (   type)    AA_NEW_AR(type,1)

Malloc an object of type.

Definition at line 96 of file mem.h.

#define AA_NEW0 (   type)    AA_NEW0_AR(type,1)

Malloc and zero initialize an object of type.

Definition at line 99 of file mem.h.

#define AA_NEW0_AR (   type,
 
)    ( (type*) aa_malloc0(sizeof(type)*(n)) )

Malloc and zero initialize an array[n] of objects of type.

Definition at line 93 of file mem.h.

#define AA_NEW_AR (   type,
 
)    ( (type*) malloc(sizeof(type)*(n)) )

Malloc an array[n] of objects of type.

Definition at line 90 of file mem.h.

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

Allocate a local array of type with n elements.

Uses AA_ALLOCAL.

Definition at line 132 of file mem.h.

#define AA_RLIST_DEF (   element_type,
  list_type 
)
Value:
typedef struct { \
} list_type; \
static inline list_type* \
list_type ## _alloc( aa_mem_region *reg ) \
{ \
return (list_type*)aa_mem_rlist_alloc(reg); \
}
AA_API struct aa_mem_rlist * aa_mem_rlist_alloc(struct aa_mem_region *reg)
Allocate rlist out of region.
Data Structure for Region-Based memory allocation.
Definition: mem.h:198
struct aa_mem_rlist aa_mem_rlist_t
A linked list allocated out of a memory region.

Definition at line 453 of file mem.h.

#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 559 of file mem.h.

#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); \
};
#define AA_VECTOR_PUSH(max, size, ptr, value)
Append an item to the end of the vector.
Definition: mem.h:721

Definition at line 728 of file mem.h.

#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
maxMaximum number of elements ptr can hold. May be evaluated multiple times.
fillNumber of elements to store in vector. May be evaluated multiple times.
ptrBase pointer of the vector. May be evaluated multiple times.
valueValue to append

Definition at line 721 of file mem.h.

Typedef Documentation

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.

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

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 614 of file mem.h.

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 139 of file mem.h.

static void* aa_malloc0 ( size_t  size)
inlinestatic

Malloc and zero initialize size bytes.

Definition at line 77 of file mem.h.

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_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_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 void* aa_mem_region_local_alloc ( size_t  size)

Allocate from thread-local memory region.

See also
aa_mem_region_alloc
AA_API void aa_mem_region_local_destroy ( void  )

Destroy the thread-local memory region.

See also
aa_mem_region_destroy
AA_API void aa_mem_region_local_init ( size_t  size)

Initialize the thread-local memory region.

See also
aa_mem_region_init
AA_API void aa_mem_region_local_pop ( void *  ptr)

Pop ptr from thread-local memory region.

See also
aa_mem_region_pop
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_API void* aa_mem_region_local_tmpalloc ( size_t  size)

Temporary allocate from thread-local memory region.

See also
aa_mem_region_tmpalloc
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_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_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_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.