mem.h

Go to the documentation of this file.

/* -*- mode: C; c-basic-offset: 4 -*- */
/* ex: set shiftwidth=4 tabstop=4 expandtab: */
/*
 * Copyright (c) 2010-2012, Georgia Tech Research Corporation
 * All rights reserved.
 *
 * Author(s): Neil T. Dantam <ntd@gatech.edu>
 * Georgia Tech Humanoid Robotics Lab
 * Under Direction of Prof. Mike Stilman <mstilman@cc.gatech.edu>
 *
 *
 * This file is provided under the following "BSD-style" License:
 *
 *
 *   Redistribution and use in source and binary forms, with or
 *   without modification, are permitted provided that the following
 *   conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *   POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef AA_MEM_H
#define AA_MEM_H

#ifndef AA_ALLOC_STACK_MAX
#define AA_ALLOC_STACK_MAX (4096-64)
#endif //AA_ALLOC_STACK_MAX


enum aa_mem_refop {
    /* Make a private copy */
    AA_MEM_COPY,
    /* Use the existing copy.  Someone else will clean up */
    AA_MEM_BORROW,
    /* Take the reference and cleanup when we're done */
    AA_MEM_STEAL
};

/**************/
/* Allocation */
/**************/

/*----------- General Allocation ------------------*/

/* FIXME: we should do something reasonable when malloc() fails, but
   since Linux lies about whether it can provide memory, there may be
   no point. */

static inline void *aa_malloc0( size_t size ) {
    void *p = malloc(size);
    if(p) memset(p,0,size);
    return p;
}


static inline void aa_free_if_valid( void *ptr ) {
    if( NULL != ptr ) free(ptr);
}

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

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

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

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

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

static inline void aa_checked_free( void * ptr )
{
    if( ptr ) free(ptr);
}

/*----------- Local Allocation ------------------*/

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

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

static inline void aa_frlocal( void *ptr, size_t size ) {
    if( size > AA_ALLOC_STACK_MAX) free(ptr);
}

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

typedef struct {
    size_t n;    
    union {
        uint64_t dalign;   
        uint8_t d[1];      
    };
} aa_flexbuf_t;

AA_API aa_flexbuf_t *aa_flexbuf_alloc(size_t n);
AA_API void aa_flexbuf_free(aa_flexbuf_t *p);

/*----------- Region Allocation ------------------*/

#define AA_MEMREG_ALIGN 16

struct aa_mem_region_node {
    //size_t n;                    ///< size of this chunk
    uint8_t *end;                
    struct aa_mem_region_node *next; 
    uint8_t d[];           
};

typedef struct aa_mem_region {
    uint8_t *head;                
    struct aa_mem_region_node *node;  
    union {
        int reserved;
        struct {
            unsigned free_on_destroy;
        };
    };
} aa_mem_region_t;

AA_API void aa_mem_region_init( aa_mem_region_t *region, size_t size );

AA_API struct aa_mem_region *
aa_mem_region_create( size_t size );

AA_API void aa_mem_region_destroy( aa_mem_region_t *region );


AA_API size_t aa_mem_region_freesize( aa_mem_region_t *region );

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

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

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

AA_API void *aa_mem_region_tmprealloc( aa_mem_region_t *region, size_t size );

AA_API void *aa_mem_region_dup( aa_mem_region_t *region, const void *p, size_t size );

AA_API char *aa_mem_region_strdup( aa_mem_region_t *region, const char *str );

AA_API void aa_mem_region_release( aa_mem_region_t *region );

AA_API char *aa_mem_region_printf( aa_mem_region_t *region, const char *fmt, ... );

AA_API char* aa_mem_region_vprintf(aa_mem_region_t *reg, const char *fmt, va_list ap );

AA_API void aa_mem_region_pop( aa_mem_region_t *region, void *ptr );


AA_API void *aa_mem_region_ptr( aa_mem_region_t *region );

AA_API size_t aa_mem_region_chunk_count( aa_mem_region_t *region );

AA_API size_t aa_mem_region_topsize( aa_mem_region_t *region ) AA_DEPRECATED;


AA_API void aa_mem_region_local_init( size_t size );

AA_API void aa_mem_region_local_destroy( void );

AA_API aa_mem_region_t *aa_mem_region_local_get( void );

AA_API void *aa_mem_region_local_alloc( size_t size );

AA_API void *aa_mem_region_local_tmpalloc( size_t size );

AA_API void aa_mem_region_local_pop( void *ptr );

AA_API void aa_mem_region_local_release( void );


#define AA_MEM_REGION_NEW( reg, type ) ( (type*) aa_mem_region_alloc((reg), sizeof(type)) )

#define AA_MEM_REGION_ZNEW( reg, type )                         \
    ( (type*) aa_mem_region_zalloc((reg), sizeof(type)) )

#define AA_MEM_REGION_NEW_CPY( reg, src, type ) ( (type*) aa_mem_region_dup((reg), (src), sizeof(type)) )

#define AA_MEM_REGION_DUP( reg, type, src, count ) ( (type*) aa_mem_region_dup((reg), (src), (count)*sizeof(type)) )

#define AA_MEM_REGION_NEW_N( reg, type, n ) ( (type*) aa_mem_region_alloc((reg), (n)*sizeof(type)) )

#define AA_MEM_REGION_ZNEW_N( reg, type, n ) ( (type*) aa_mem_region_zalloc((reg), (n)*sizeof(type)) )

#define AA_MEM_REGION_LOCAL_NEW( type ) ( (type*) aa_mem_region_local_alloc( sizeof(type)) )

#define AA_MEM_REGION_LOCAL_NEW_N( type, n ) ( (type*) aa_mem_region_local_alloc( (n)*sizeof(type)) )

/*----------- Pooled Allocation ------------------*/

typedef struct {
    size_t size; 
    void *top;   
    aa_mem_region_t region; 
} aa_mem_pool_t;

AA_API void aa_mem_pool_init( aa_mem_pool_t *pool, size_t size, size_t count );
AA_API void aa_mem_pool_destroy( aa_mem_pool_t *pool );
AA_API void *aa_mem_pool_alloc( aa_mem_pool_t *pool );
AA_API void aa_mem_pool_free( aa_mem_pool_t *pool, void *ptr );
AA_API void aa_mem_pool_release( aa_mem_pool_t *pool );

/*----------- Circular Buffers ------------------*/
typedef struct {
    void *buf;      
    size_t n;       
    size_t start;   
    size_t end;     
} aa_circbuf_t;

AA_API void aa_circbuf_create( aa_circbuf_t *cb, size_t n );
AA_API void aa_circbuf_destroy( aa_circbuf_t *cb, size_t n );
AA_API void aa_circbuf_realloc( aa_circbuf_t *cb, size_t n );
AA_API size_t aa_circbuf_space( aa_circbuf_t *cb );
AA_API size_t aa_circbuf_used( aa_circbuf_t *cb );
AA_API void aa_circbuf_put( aa_circbuf_t *cb, void *buf, size_t n );
AA_API int aa_circbuf_read( aa_circbuf_t *cb, int fd, size_t n );
AA_API int aa_circbuf_write( aa_circbuf_t *cb, int fd, size_t n );


/***************/
/* Linked List */
/***************/

typedef struct aa_mem_cons {
    void *data;               
    struct aa_mem_cons *next; 
} aa_mem_cons_t;

typedef struct aa_mem_rlist {
    struct aa_mem_region *reg;
    struct aa_mem_cons *head;
    struct aa_mem_cons **tailp;
} aa_mem_rlist_t;

AA_API struct aa_mem_rlist *
aa_mem_rlist_alloc( struct aa_mem_region *reg );

AA_API void
aa_mem_rlist_push_cpy( struct aa_mem_rlist *list, void *p, size_t n );

AA_API void
aa_mem_rlist_push_ptr( struct aa_mem_rlist *list, void *p );

AA_API void
aa_mem_rlist_enqueue_cpy( struct aa_mem_rlist *list, const void *p, size_t n );

AA_API void
aa_mem_rlist_enqueue_ptr( struct aa_mem_rlist *list, void *p );

AA_API void
aa_mem_rlist_map( struct aa_mem_rlist *list,
                  void (*function)(void *cx, void *element ),
                  void *cx );

AA_API void *aa_mem_rlist_pop( struct aa_mem_rlist *list );

#define AA_RLIST_DEF( element_type, list_type )                  \
    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);              \
    }

/**********/
/* Arrays */
/**********/

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

static inline void *aa_mem_dup( const void *src, size_t size )
{
    void *dst = malloc(size);
    memcpy(dst,src,size);
    return dst;
}

#define AA_MEM_DUP( type, src, count )                  \
    ((type*)aa_mem_dup((src), sizeof(type)*(count)))

#define AA_MEM_DUPOP( refop, type, const_dst, dst_data, src, n_elem )   \
    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_SET(dst, val, n_elem)                                    \
    {                                                                   \
        for( size_t aa_$_set_i = 0;                                     \
             aa_$_set_i < (n_elem);                                     \
             aa_$_set_i++ )                                             \
            (dst)[aa_$_set_i] = (val);                                  \
    }

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

#define AA_FAR(...) ((double[]){__VA_ARGS__})

static inline void aa_fcpy( double *dst, const double *src, size_t n ) AA_DEPRECATED;
static inline void aa_fcpy( double *dst, const double *src, size_t n ) {
    AA_MEM_CPY( dst, src, n );
}

static inline void aa_fset( double *dst, double val, size_t n ) AA_DEPRECATED;
static inline void aa_fset( double *dst, double val, size_t n ) {
    AA_MEM_SET( dst, val, n );
}

static inline void aa_zero( void *p, size_t n ) AA_DEPRECATED;
static inline void aa_zero( void *p, size_t n ) {
    memset(p,0,n);
}

static inline void aa_fzero( double *p, size_t n ) AA_DEPRECATED;
static inline void aa_fzero( double *p, size_t n ) {
    AA_MEM_SET( p, 0, n );
}

#define AA_ZERO_AR( var ) aa_zero( var, sizeof(var) )

#define AA_SET_AR( var, val )                                   \
    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;


/**************/
/* Bit Array */
/**************/

typedef int aa_bits;

#define AA_BITS_BITS (8*sizeof(aa_bits))

static inline size_t
aa_bits_words( size_t n )
{
    size_t words = n / AA_BITS_BITS;
    if( words*sizeof(aa_bits)*8 < n ) words++;
    return words;
}

static inline size_t
aa_bits_size( size_t n_bits )
{
    return aa_bits_words(n_bits) * sizeof(aa_bits);
}

#define AA_BITS_JK( i, j, k )                 \
    j = (i) / AA_BITS_BITS;                   \
    k = (i) - (j)*AA_BITS_BITS;

static inline int
aa_bits_get( aa_bits *b, size_t i )
{
    size_t j,k;
    AA_BITS_JK(i,j,k);

    return (b[j] >> k) & 0x1;
}


static inline int
aa_bits_getn( aa_bits *b, size_t n, size_t i )
{
    if( aa_bits_size(i+1) > n ) return 0;
    else return aa_bits_get( b, i );
}

static inline void
aa_bits_set( aa_bits *b, size_t i, int val )
{
    size_t j,k;
    AA_BITS_JK(i,j,k);
    if( val ) {
        b[j] |=  0x1<<k;
    } else {
        b[j] &= ~ ( 0x1<<k );
    }
}

static inline void
aa_bits_and( aa_bits *a, const aa_bits *b, size_t n_bits )
{
    size_t n_words = aa_bits_words(n_bits);
    while( n_words ) {
        a[n_words] &= b[n_words];
    }
}

static inline void
aa_bits_or( aa_bits *a, const aa_bits *b, size_t n_bits )
{
    size_t n_words = aa_bits_words(n_bits);
    while( n_words ) {
        a[n_words] |= b[n_words];
    }
}

static inline void
aa_bits_xor( aa_bits *a, const aa_bits *b, size_t n_bits )
{
    size_t n_words = aa_bits_words(n_bits);
    while( n_words ) {
        a[n_words] ^= b[n_words];
    }
}


/************/
/* Swapping */
/************/

typedef long aa_memswap_type;

static inline void aa_memswap( void *AA_RESTRICT a, void *AA_RESTRICT b, size_t size )
{

    // TODO: consider alignment
    aa_memswap_type *la = (aa_memswap_type*)a, *lb = (aa_memswap_type*)b;
    for( size_t i = 0; i < size/sizeof(*la); i++ ) {
        aa_memswap_type tmp = la[i];
        la[i] = lb[i];
        lb[i] = tmp;
    }

    uint8_t *ca = (uint8_t*)a, *cb = (uint8_t*)b;
    for( size_t i = size - size%sizeof(*la); i < size; i ++ ) {
        uint8_t tmp = ca[i];
        ca[i] = cb[i];
        cb[i] = tmp;
    }

}

#define AA_MEM_SWAP( a, b, n_elem ) (aa_memswap( (a), (b), n_elem*sizeof(*(a)) ))

/***********/
/* VECTORS */
/***********/

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

#define AA_VECTOR_DEF( element_type, vector_type )                      \
    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);          \
    };



#endif //AA_MEM_H