arb_mem.h

Go to the documentation of this file.

// ================================================================= //
//                                                                   //
//   File      : arb_mem.h                                           //
//   Purpose   : "Failsafe" memory handlers                          //
//               ("succeed or terminate"!)                           //
//                                                                   //
//   Coded by Elmar Pruesse and Ralf Westram                         //
//   http://www.arb-home.de/                                         //
//                                                                   //
// ================================================================= //

#ifndef ARB_MEM_H
#define ARB_MEM_H

#ifndef _GLIBCXX_CSTDLIB
#include <cstdlib>
#endif
#ifndef _GLIBCXX_CSTRING
#include <cstring>
#endif
#ifndef ATTRIBUTES_H
#include <attributes.h>
#endif

namespace arb_mem {
    void failed_to_allocate(const char *reason) __ATTR__NORETURN;
    void failed_to_allocate(size_t nelem, size_t elsize) __ATTR__NORETURN;
    void failed_to_allocate(size_t size) __ATTR__NORETURN;

    inline void alloc_aligned(void **tgt, size_t alignment, size_t len) {
        int error = posix_memalign(tgt, alignment, len);
        if (error) failed_to_allocate(strerror(error));
    }
};

template<class TYPE>
inline void ARB_alloc_aligned(TYPE*& tgt, size_t nelems) {
    arb_mem::alloc_aligned((void**)&tgt, 16, nelems * sizeof(TYPE));
}

template<class TYPE>
inline void ARB_realloc(TYPE*& tgt, size_t nelem) {
    tgt = (TYPE*)realloc(tgt, nelem*sizeof(TYPE));
    if (!tgt) arb_mem::failed_to_allocate(nelem, sizeof(TYPE));
}
template<class TYPE>
inline void ARB_recalloc(TYPE*& tgt, size_t oelem, size_t nelem) {
    ARB_realloc(tgt, nelem);
    if (nelem>oelem) memset(tgt+oelem, 0, (nelem-oelem)*sizeof(TYPE));
}

template<class TYPE>
inline TYPE *ARB_alloc(size_t nelem) {
    TYPE *mem = (TYPE*)malloc(nelem*sizeof(TYPE));
    if (!mem) arb_mem::failed_to_allocate(nelem, sizeof(TYPE));
    return mem;
}
template<class TYPE>
inline void ARB_alloc(TYPE*& tgt, size_t nelem) {
    tgt = ARB_alloc<TYPE>(nelem);
}

template<class TYPE>
inline TYPE *ARB_calloc(size_t nelem) {
    TYPE *mem = (TYPE*)calloc(nelem, sizeof(TYPE));
    if (!mem) arb_mem::failed_to_allocate(nelem, sizeof(TYPE));
    return mem;
}
template<class TYPE>
inline void ARB_calloc(TYPE*& tgt, size_t nelem) {
    tgt = ARB_calloc<TYPE>(nelem);
}

#else
#error arb_mem.h included twice
#endif // ARB_MEM_H