51 #ifndef AA_ALLOC_STACK_MAX 52 #define AA_ALLOC_STACK_MAX (4096-64) 54 #endif //AA_ALLOC_STACK_MAX 78 void *p = malloc(size);
79 if(p) memset(p,0,size);
86 if( NULL != ptr ) free(ptr);
90 #define AA_NEW_AR(type,n) ( (type*) malloc(sizeof(type)*(n)) ) 93 #define AA_NEW0_AR(type,n) ( (type*) aa_malloc0(sizeof(type)*(n)) ) 96 #define AA_NEW(type) AA_NEW_AR(type,1) 99 #define AA_NEW0(type) AA_NEW0_AR(type,1) 103 #define AA_ALIGN2( val, align ) (((val) + (align) - 1) & ~(align-1)) 105 static inline void aa_checked_free(
void * ptr )
124 #define AA_ALLOCAL(size) ({ size_t aa_$_allocal_size = (size); \ 125 aa_$_allocal_size > AA_ALLOC_STACK_MAX ? \ 126 malloc(aa_$_allocal_size) : alloca(aa_$_allocal_size); }) 132 #define AA_NEW_LOCAL(type, n) ( (type*) AA_ALLOCAL( sizeof(type)*(n) ) ) 144 #define AA_DEL_LOCAL(ptr, type, n) aa_frlocal( ptr, sizeof(type)*(n) ) 163 #define AA_MEMREG_ALIGN 16 350 #define AA_MEM_REGION_NEW( reg, type ) ( (type*) aa_mem_region_alloc((reg), sizeof(type)) ) 355 #define AA_MEM_REGION_ZNEW( reg, type ) \ 356 ( (type*) aa_mem_region_zalloc((reg), sizeof(type)) ) 361 #define AA_MEM_REGION_NEW_CPY( reg, src, type ) ( (type*) aa_mem_region_dup((reg), (src), sizeof(type)) ) 366 #define AA_MEM_REGION_DUP( reg, type, src, count ) ( (type*) aa_mem_region_dup((reg), (src), (count)*sizeof(type)) ) 371 #define AA_MEM_REGION_NEW_N( reg, type, n ) ( (type*) aa_mem_region_alloc((reg), (n)*sizeof(type)) ) 376 #define AA_MEM_REGION_ZNEW_N( reg, type, n ) ( (type*) aa_mem_region_zalloc((reg), (n)*sizeof(type)) ) 381 #define AA_MEM_REGION_LOCAL_NEW( type ) ( (type*) aa_mem_region_local_alloc( sizeof(type)) ) 386 #define AA_MEM_REGION_LOCAL_NEW_N( type, n ) ( (type*) aa_mem_region_local_alloc( (n)*sizeof(type)) ) 494 void (*
function)(
void *cx,
void *element ),
504 #define AA_RLIST_DEF( element_type, list_type ) \ 506 aa_mem_rlist_t rlist; \ 508 static inline list_type* \ 509 list_type ## _alloc( aa_mem_region *reg ) \ 511 return (list_type*)aa_mem_rlist_alloc(reg); \ 522 #define AA_MEM_CPY(dst, src, n_elem) \ 525 memcpy( (dst), (src), sizeof((dst)[0])*(n_elem) ); \ 530 static inline void *
aa_mem_dup(
const void *src,
size_t size )
532 void *dst = malloc(size);
533 memcpy(dst,src,size);
540 #define AA_MEM_DUP( type, src, count ) \ 541 ((type*)aa_mem_dup((src), sizeof(type)*(count))) 543 #define AA_MEM_DUPOP( refop, type, const_dst, dst_data, src, n_elem ) \ 546 dst_data = AA_MEM_DUP(type, src, n_elem); \ 547 const_dst = dst_data; \ 551 const_dst = dst_data; \ 553 case AA_MEM_BORROW: \ 565 #define AA_MEM_SET(dst, val, n_elem) \ 567 for( size_t aa_$_set_i = 0; \ 568 aa_$_set_i < (n_elem); \ 570 (dst)[aa_$_set_i] = (val); \ 577 #define AA_MEM_ZERO(dst, n_elem) (memset((dst),0,(n_elem)*sizeof(*(dst)))) 580 #define AA_FAR(...) ((double[]){__VA_ARGS__}) 584 static inline void aa_fcpy(
double *dst,
const double *src,
size_t n ) {
590 static inline void aa_fset(
double *dst,
double val,
size_t n ) {
596 static inline void aa_zero(
void *p,
size_t n ) {
602 static inline void aa_fzero(
double *p,
size_t n ) {
607 #define AA_ZERO_AR( var ) aa_zero( var, sizeof(var) ) 610 #define AA_SET_AR( var, val ) \ 611 for( size_t aa_$_set_ar_i = 0; \ 612 aa_$_set_ar_i < sizeof(var)/sizeof(var[0]); \ 613 aa_$_set_ar_i ++ ) var[aa_$_set_ar_i] = val; 624 #define AA_BITS_BITS (8*sizeof(aa_bits)) 631 if( words*
sizeof(
aa_bits)*8 < n ) words++;
642 #define AA_BITS_JK( i, j, k ) \ 643 j = (i) / AA_BITS_BITS; \ 644 k = (i) - (j)*AA_BITS_BITS; 655 return (b[j] >> k) & 0x1;
682 b[j] &= ~ ( 0x1<<k );
694 a[n_words] &= b[n_words];
706 a[n_words] |= b[n_words];
718 a[n_words] ^= b[n_words];
738 for(
size_t i = 0; i < size/
sizeof(*la); i++ ) {
744 uint8_t *ca = (uint8_t*)a, *cb = (uint8_t*)b;
745 for(
size_t i = size - size%
sizeof(*la); i < size; i ++ ) {
754 #define AA_MEM_SWAP( a, b, n_elem ) (aa_memswap( (a), (b), n_elem*sizeof(*(a)) )) 772 #define AA_VECTOR_PUSH( max, size, ptr, value ) \ 773 if( (size) >= (max) ) { \ 774 (max) = 2*(size+1); \ 775 (ptr) = (__typeof__(ptr))realloc(ptr,sizeof(*ptr)*max); \ 777 ptr[(size)++] = (value); 779 #define AA_VECTOR_DEF( element_type, vector_type ) \ 783 element_type *data; \ 785 static inline void vector_type ## _init \ 786 ( vector_type *vec, size_t max ) { \ 787 vec->data = (element_type*)malloc(max*sizeof(*vec->data)); \ 789 vec->size = (size_t)0; \ 791 static inline void vector_type ## _push \ 792 ( vector_type *vec, element_type value ) { \ 793 AA_VECTOR_PUSH(vec->max, vec->size, vec->data, value); \ uint8_t * head
pointer to first free element of top chunk
AA_API void * aa_mem_rlist_pop(struct aa_mem_rlist *list)
Remove front element of the list and return its data pointer.
int reserved
Reserve space for other bits.
uint64_t dalign
dummy element for alignment
A linked list allocated out of a memory region.
static int aa_bits_get(aa_bits *b, size_t i)
Return the value of the i'th bit in bitset b.
AA_API void * aa_mem_region_alloc(aa_mem_region_t *region, size_t size)
Allocate size bytes from the region.
static void aa_fcpy(double *dst, const double *src, size_t n) AA_DEPRECATED
copy n double floats from src to dst
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.
static void aa_fset(double *dst, double val, size_t n) AA_DEPRECATED
set n double floats to val
AA_API void aa_mem_region_local_destroy(void)
Destroy the thread-local memory region.
aa_mem_region_t region
memory region to allocate from
static void * aa_malloc0(size_t size)
Malloc and zero initialize size bytes.
AA_API int aa_circbuf_write(aa_circbuf_t *cb, int fd, size_t n)
untested
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.
size_t size
size of each element
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.
struct aa_mem_region_node * node
linked list of chunks
AA_API void aa_mem_pool_init(aa_mem_pool_t *pool, size_t size, size_t count)
untested
static void * aa_mem_dup(const void *src, size_t size)
Copy n octets from src into freshly-allocated heap memory.
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 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_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_pool_alloc(aa_mem_pool_t *pool)
untested
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_printf(aa_mem_region_t *region, const char *fmt,...)
printf's into a buffer allocated from region
uint8_t * end
pointer to end of this chunk
struct aa_mem_cons aa_mem_cons_t
A "cons" cell.
static size_t aa_bits_words(size_t n)
Number of aa_bits words to store n bits.
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 size_t aa_bits_size(size_t n_bits)
Size of bit vector in octets.
AA_API struct aa_mem_rlist * aa_mem_rlist_alloc(struct aa_mem_region *reg)
Allocate rlist out of region.
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_local_pop(void *ptr)
Pop ptr from thread-local memory region.
AA_API void aa_circbuf_create(aa_circbuf_t *cb, size_t n)
untested
static void aa_zero(void *p, size_t n) AA_DEPRECATED
set n bytes of p to zero
static void aa_memswap(void *AA_RESTRICT a, void *AA_RESTRICT b, size_t size)
Swap size bytes of memory at a and b.
Data Structure for Region-Based memory allocation.
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_rlist_map(struct aa_mem_rlist *list, void(*function)(void *cx, void *element), void *cx)
Apply function to each element of list.
static void aa_fzero(double *p, size_t n) AA_DEPRECATED
zero array p of length n
AA_API void aa_mem_region_release(aa_mem_region_t *region)
Deallocates all allocated objects from the region.
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.
AA_API size_t aa_mem_region_chunk_count(aa_mem_region_t *region)
Number of chunks in the region.
AA_API void aa_mem_region_local_init(size_t size)
Initialize the thread-local memory region.
AA_API void aa_mem_pool_free(aa_mem_pool_t *pool, void *ptr)
untested
AA_API void aa_circbuf_destroy(aa_circbuf_t *cb, size_t n)
untested
AA_EXTERN const char *aa_verbf_prefix AA_DEPRECATED
don't use
AA_API void * aa_mem_region_zalloc(aa_mem_region_t *region, size_t size)
Allocate size bytes from the region and zero-initialize.
Circular buffers use a fixed-size array that acts as if connected end-to end.
void * top
top of list of free elements
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.
AA_API void aa_mem_pool_release(aa_mem_pool_t *pool)
untested
AA_API int aa_circbuf_read(aa_circbuf_t *cb, int fd, size_t n)
untested
struct aa_mem_region aa_mem_region_t
Data Structure for Region-Based memory allocation.
long aa_memswap_type
Type to use for memory swapping.
int aa_bits
An integer type for bit vectors.
#define AA_RESTRICT
Defined restrict keyword based on language flavor.
AA_API void * aa_mem_region_ptr(aa_mem_region_t *region)
Pointer to start of free space in region.
AA_API void aa_mem_pool_destroy(aa_mem_pool_t *pool)
untested
AA_API size_t aa_mem_region_freesize(aa_mem_region_t *region)
Number of free contiguous bytes in region.
#define AA_API
calling and name mangling convention for functions
AA_API void * aa_mem_region_local_alloc(size_t size)
Allocate from thread-local memory region.
AA_API void aa_circbuf_realloc(aa_circbuf_t *cb, size_t n)
untested
size_t end
end of filled data
struct aa_mem_rlist aa_mem_rlist_t
A linked list allocated out of a memory region.
AA_API void * aa_mem_region_local_tmpalloc(size_t size)
Temporary allocate from thread-local memory region.
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.
#define AA_ALLOC_STACK_MAX
maximum size of objects to stack allocate
void * data
pointer to data
AA_API void * aa_mem_region_tmpalloc(aa_mem_region_t *region, size_t size)
Temporary allocation.
AA_API void aa_mem_region_destroy(aa_mem_region_t *region)
Destroy memory region freeing all chunks.
static void aa_frlocal(void *ptr, size_t size)
Free the results of AA_ALLOCAL.
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_flexbuf_free(aa_flexbuf_t *p)
free buffer
AA_API size_t aa_circbuf_used(aa_circbuf_t *cb)
untested
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.
AA_API size_t aa_circbuf_space(aa_circbuf_t *cb)
untested
Data Structure for Object pools.
size_t start
start of filled data
AA_API void aa_circbuf_put(aa_circbuf_t *cb, void *buf, size_t n)
untested
unsigned free_on_destroy
Free struct when calling aa_mem_region_destroy().
A single block of memory to be parceled out by the region allocator.
AA_API void aa_mem_region_local_release(void)
Release all objects allocated from thread-local memory region.
size_t n
size of the circbuf
#define AA_MEM_CPY(dst, src, n_elem)
Copy n_elem elements from src to dst.
AA_API aa_flexbuf_t * aa_flexbuf_alloc(size_t n)
allocate buffer of n bytes
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.
#define AA_MEM_SET(dst, val, n_elem)
Set n_elem elements at dst to val.
static void aa_free_if_valid(void *ptr)
Frees ptr unless NULL == ptr.
struct aa_mem_region_node * next
pointer to next chunk node
#define AA_BITS_BITS
Number of bits in a aa_bits word.
AA_API size_t aa_mem_region_topsize(aa_mem_region_t *region) AA_DEPRECATED
Size of top chunk in region.
struct aa_mem_cons * next
pointer to next list cell
AA_API void aa_mem_region_pop(aa_mem_region_t *region, void *ptr)
Deallocates ptr and all blocks allocated after ptr was allocated.