ccmem.h

/* MLPACK 0.2
 *
 * Copyright (c) 2008, 2009 Alexander Gray,
 *                          Garry Boyer,
 *                          Ryan Riegel,
 *                          Nikolaos Vasiloglou,
 *                          Dongryeol Lee,
 *                          Chip Mappus, 
 *                          Nishant Mehta,
 *                          Hua Ouyang,
 *                          Parikshit Ram,
 *                          Long Tran,
 *                          Wee Chin Wong
 *
 * Copyright (c) 2008, 2009 Georgia Institute of Technology
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#ifndef BASE_CCMEM_H
#define BASE_CCMEM_H

#include "fastlib/base/common.h"
#include "fastlib/base/debug.h"
#include "fastlib/base/cc.h"

#include <new>

#define MEM__DEBUG_MEMORY(ptr) \
    DEBUG_ASSERT_MSG((ptr) != NULL, "out of memory")

namespace mem__private {
  const size_t BIG_BAD_BUF_SIZE = 64;

  extern const int32 BIG_BAD_BUF[];

  void PoisonBytes(char *array_cp, size_t bytes);

  const size_t SWAP_BUF_SIZE = 64;

  void SwapBytes(char *a_cp, char *b_cp, size_t bytes);
};

namespace mem {
  template<typename T>
  T *PoisonBytes(T *array, size_t bytes) {
    char *array_cp = reinterpret_cast<char *>(array);
    mem__private::PoisonBytes(array_cp, bytes);
    return array;
  }
  template<typename T>
  inline T *Poison(T *array, size_t elems) {
    return PoisonBytes(array, elems * sizeof(T));
  }
  template<typename T>
  inline T *Poison(T *ptr) {
    if (sizeof(T) <= mem__private::BIG_BAD_BUF_SIZE) {
      return reinterpret_cast<T *>(
          ::memcpy(ptr, mem__private::BIG_BAD_BUF, sizeof(T)));
    } else {
      return PoisonBytes(ptr, sizeof(T));
    }
  }

  template<typename T>
  inline T *DebugPoisonBytes(T *array, size_t bytes) {
    DEBUG_ONLY(PoisonBytes(array, bytes));
    return array;
  }
  template<typename T>
  inline T *DebugPoison(T *array, size_t elems) {
    DEBUG_ONLY(Poison(array, elems));
    return array;
  }
  template<typename T>
  inline T *DebugPoison(T *ptr) {
    DEBUG_ONLY(Poison(ptr));
    return ptr;
  }

  template<typename T>
  inline T *AllocBytes(size_t bytes) {
#ifdef SCALE_NORMAL
    // sanity check for small-scale problems
    DEBUG_BOUNDS(bytes, BIG_BAD_NUMBER);
#endif
    T *array = reinterpret_cast<T *>(::malloc(bytes));
    MEM__DEBUG_MEMORY(array);
    return DebugPoisonBytes(array, bytes);
  }
  template<typename T>
  inline T *Alloc(size_t elems) {
#ifdef SCALE_NORMAL
    // sanity check for small-scale problems
    DEBUG_BOUNDS(elems, BIG_BAD_NUMBER);
#endif
    return AllocBytes<T>(elems * sizeof(T));
  }
  template<typename T>
  inline T *Alloc() {
    T *array = reinterpret_cast<T *>(::malloc(sizeof(T)));
    MEM__DEBUG_MEMORY(array);
    return DebugPoisonBytes(array);
  }

  template<typename T>
  inline T *ZeroBytes(T *array, size_t bytes) {
    return reinterpret_cast<T *>(::memset(array, 0, bytes));
  }
  template<typename T>
  inline T *Zero(T *array, size_t elems = 1) {
    return ZeroBytes(array, elems * sizeof(T));
  }
  template<typename T>
  inline T *AllocZeroBytes(size_t bytes) {
    T *array = reinterpret_cast<T *>(::calloc(bytes, 1));
    MEM__DEBUG_MEMORY(array);
    return array;
  }
  template<typename T>
  inline T *AllocZero(size_t elems = 1) {
    T *array = reinterpret_cast<T *>(::calloc(elems, sizeof(T)));
    MEM__DEBUG_MEMORY(array);
    return array;
  }

  template<typename T, typename U>
  inline T *CopyBytes(T *dest, const U *src, size_t bytes) {
    return reinterpret_cast<T *>(::memcpy(dest, src, bytes));
  }
  template<typename V, typename T, typename U>
  inline T *Copy(T *dest, const U *src, size_t elems = 1) {
    return CopyBytes(dest, src, elems * sizeof(V));
  }
  template<typename T, typename U>
  inline T* /*inline*/ CopyValues(T *dest, const U *src, size_t elems=1) {
    for(index_t i=0; i<elems; i++) {
      dest[i]=T(src[i]);
    }
    return dest; 
  }
  template<typename T>
  inline T *Copy(T *dest, const T *src, size_t elems = 1) {
    return Copy<T, T, T>(dest, src, elems);
  }
  template<typename T, typename U>
  inline T *AllocCopyBytes(const U *src, size_t bytes) {
    T *array = reinterpret_cast<T *>(::malloc(bytes));
    MEM__DEBUG_MEMORY(array);
    return CopyBytes(array, src, bytes);
  }
  template<typename T, typename U>
  inline T *AllocCopy(const U *src, size_t elems = 1) {
    return AllocCopyBytes<T>(src, elems * sizeof(T));
  }

  template<typename T, typename U>
  inline T *AllocCopyValues(const U *src, size_t elems = 1) {
    //FIXME
    T *dest/*array*/ = reinterpret_cast<T *>(::malloc(elems*sizeof(T)));
    MEM__DEBUG_MEMORY(dest/*array*/);
    return CopyValues<T, U>(dest, src, elems);
  }

  template<typename T>
  inline T *AllocCopy(const T *src, size_t elems = 1) {
    return AllocCopy<T, T>(src, elems);
  }

  template<typename T>
  inline T *ReallocBytes(T *array, size_t bytes) {
    array = reinterpret_cast<T *>(::realloc(array, bytes));
    MEM__DEBUG_MEMORY(array);
    return array;
  }
  template<typename T>
  inline T *Realloc(T *array, size_t elems) {
    return ReallocBytes<T>(array, elems * sizeof(T));
  }

  template<typename T>
  inline void Free(T* ptr) {
    ::free(ptr);
  }



  template<typename T, typename U>
  void SwapBytes(T *a, U *b, size_t bytes) {
    char *a_cp = reinterpret_cast<char *>(a);
    char *b_cp = reinterpret_cast<char *>(b);
    mem__private::SwapBytes(a_cp, b_cp, bytes);
  }
  template<typename V, typename T, typename U>
  inline void Swap(T *a, U *b, size_t elems) {
    SwapBytes(a, b, elems * sizeof(V));
  }
  template<typename T>
  inline void Swap(T *a, T *b, size_t elems) {
    Swap<T, T, T>(a, b, elems);
  }
  template<typename V, typename T, typename U>
  inline void Swap(T *a, U *b) {
    if (sizeof(V) <= mem__private::SWAP_BUF_SIZE * 2) {
      char buf[sizeof(V)];

      ::memcpy(buf, a, sizeof(V));
      ::memcpy(a, b, sizeof(V));
      ::memcpy(b, buf, sizeof(V));
    } else {
      SwapBytes(a, b, sizeof(V));
    }
  }
  template<typename T>
  inline void Swap(T *a, T *b) {
    Swap<T, T, T>(a, b);
  }

  template<typename T, typename U>
  inline T *MoveBytes(T *dest, const U *src, size_t bytes) {
    return reinterpret_cast<T *>(::memmove(dest, src, bytes));
  }
  template<typename V, typename T, typename U>
  inline T *Move(T *dest, const U *src, size_t elems = 1) {
    return MoveBytes(dest, src, elems * sizeof(V));
  }
  template<typename T>
  inline T *Move(T *dest, const T *src, size_t elems = 1) {
    return Move<T, T, T>(dest, src, elems);
  }



  template<typename T>
  inline T *Construct(T *ptr) {
    new(ptr) T;
    return ptr;
  }
  template<typename T>
  inline T *Construct(T *array, size_t elems) {
    new(array) T[elems];
    return array;
  }
  template<typename T>
  inline T *Destruct(T *ptr) {
    ptr->~T();
    return DebugPoison(ptr);
  }
  template<typename T>
  inline T *Destruct(T *array, size_t elems) {
    for (size_t i = 0; i < elems; ++i) {
      array[i].~T();
    }
    return DebugPoison(array, elems);
  }
  template<typename T, typename U>
  inline T *CopyConstruct(T *dest, const U *src) {
    new(dest) T(*src);
    return dest;
  }
  template<typename T, typename U>
  inline T *CopyConstruct(T *dest, const U *src, size_t elems) {
    for (size_t i = 0; i < elems; ++i) {
      new(dest + i) T(src[i]);
    }
    return dest;
  }

#define BASE_CCMEM__SIMPLE_CONSTRUCTORS(T, TF) \
  template<> \
  inline T *Construct< T >(T *ptr) { \
    return DebugPoison(ptr); \
  } \
  template<> \
  inline T *Construct< T >(T *array, size_t elems) { \
    return DebugPoison(array, elems); \
  } \
  template<> \
  inline T *Destruct< T >(T *ptr) { \
    return DebugPoison(ptr); \
  } \
  template<> \
  inline T *Destruct< T >(T *array, size_t elems) { \
    return DebugPoison(array, elems); \
  } \
  template<> \
  inline T *CopyConstruct< T >(T *dest, const T *src) { \
    return Copy(dest, src, 1); \
  } \
  template<> \
  inline T *CopyConstruct< T >(T *dest, const T *src, size_t elems) { \
    return Copy(dest, src, elems); \
  }

  FOR_ALL_PRIMITIVES_DO(BASE_CCMEM__SIMPLE_CONSTRUCTORS)
  BASE_CCMEM__SIMPLE_CONSTRUCTORS(bool, "%d")

  
  template<typename T>
  inline T **Construct(T **array, size_t elems = 1) {
    return DebugPoison(array, elems);
  }
  template<typename T>
  inline T **Destruct(T **array, size_t elems = 1) {
    return DebugPoison(array, elems);
  }
  template<typename T>
  inline T **CopyConstruct(T **dest, const T **src, size_t elems = 1) {
    return Copy(dest, src, elems);
  }

#undef BASE_CCMEM__SIMPLE_CONSTRUCTORS

  template<typename T, typename U>
  inline T *RepeatConstruct(T *array, const U &init, size_t elems) {
    for (size_t i = 0; i < elems; ++i) {
      new(array + i) T(init);
    }
    return array;
  }

  template<typename T>
  inline T *AllocConstruct(size_t elems = 1) {
    return Construct(Alloc<T>(elems), elems);
  }
  template<typename T, typename U>
  inline T *AllocCopyConstruct(const U *src, size_t elems = 1) {
    return CopyConstruct(Alloc<T>(elems), src, elems);
  }
  template<typename T>
  inline T *AllocCopyConstruct(const T *src, size_t elems = 1) {
    return AllocCopyConstruct<T, T>(src, elems);
  }
  template<typename T, typename U>
  inline T *AllocRepeatConstruct(const U &init, size_t elems) {
    return RepeatConstruct(Alloc<T>(elems), init, elems);
  }
  template<typename T>
  inline T *AllocRepeatConstruct(const T &init, size_t elems) {
    return AllocRepeatConstruct<T, T>(init, elems);
  }

  template<typename T>
  inline void FreeDestruct(T *array, size_t elems = 1) {
    Free(Destruct(array, elems));
  }



  template<typename T>
  inline T *PtrAddBytes(T *ptr, ptrdiff_t bytes) {
    return reinterpret_cast<T *>(
        reinterpret_cast<char *>(ptr) + bytes);
  }
  template<typename T>
  inline const T *PtrAddBytes(const T *ptr, ptrdiff_t bytes) {
    return reinterpret_cast<const T *>(
        reinterpret_cast<const char *>(ptr) + bytes);
  }
  template<typename T, typename U>
  inline ptrdiff_t PtrDiffBytes(const T *lhs, const U *rhs) {
    return reinterpret_cast<const char *>(lhs)
        - reinterpret_cast<const char *>(rhs);
  }
  template<typename T>
  inline ptrdiff_t PtrAbsAddr(const T *ptr) {
    return reinterpret_cast<ptrdiff_t>(ptr);
  }
  template<typename T, typename U>
  inline bool PtrsEqual(const T *lhs, const U *rhs) {
    return reinterpret_cast<size_t>(lhs)
        == reinterpret_cast<size_t>(rhs);
  }


  template<typename T>
  T *BitZeroBytes(T *array, size_t bytes) {
    return ZeroBytes(array, bytes);
  }
  template<typename T>
  T *BitZero(T *array, size_t elems = 1) {
    return Zero(array, elems);
  }
  template<typename T, typename U>
  T *BitCopyBytes(T *dest, const U *src, size_t bytes) {
    return CopyBytes(dest, src, bytes);
  }
  template<typename T>
  T *BitCopy(T *dest, const T *src, size_t elems = 1) {
    return Copy(dest, src, elems);
  }
  template<typename T>
  void BitSwap(T *a, T *b, size_t elems = 1) {
    Swap(a, b, elems);
  }
};

#undef MEM__DEGUG_MEMORY

#endif /* BASE_CCMEM_H */