main page modules namespaces classes files
Gecode home

search for 

memory.icc

Go to the documentation of this file.

/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2004
 *
 *  Last modified:
 *     $Date: 2006-08-04 16:03:05 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
 *     $Revision: 3510 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  See the file "LICENSE" for information on usage and
 *  redistribution of this file, and for a
 *     DISCLAIMER OF ALL WARRANTIES.
 *
 */

namespace Gecode {

  namespace Memory {


    void* malloc(size_t s);
    void* realloc(void* p, size_t s);
    void  free(void* p);

    template <class T>
    T* bmalloc(size_t n);
    template <class T>
    T* brealloc(T* b, size_t n);
    template <class T>
    T* bcopy(T* d, const T* s, size_t n);



    /*
     * Implementations
     *
     */

    forceinline void*
    malloc(size_t s) {
      void* p = ::malloc(s);
      if (p != NULL)
        return p;
      throw MemoryExhausted();
    }

    forceinline void*
    realloc(void *p, size_t s) {
      p = ::realloc(p,s);
      if (p != NULL)
        return p;
      throw MemoryExhausted();
    }

    forceinline void
    free(void* p) {
      ::free(p);
    }


    template <class T>
    forceinline T*
    bmalloc(size_t n) {
      return reinterpret_cast<T*>(Memory::malloc(sizeof(T)*n));
    }

    template <class T>
    forceinline T*
    brealloc(T* b, size_t, size_t m) {
      return reinterpret_cast<T*>(Memory::realloc(b,m*sizeof(T)));
    }

    template <class T>
    forceinline T*
    bcopy(T* d, const T* s, size_t n) {
      return reinterpret_cast<T*>(memcpy(d,s,n*sizeof(T)));
    }

  }

}



/*
 * Automatic stack memory management
 *
 */

#if defined(__GNUC__) && (! defined(_WIN32) )

#define GECODE_AUTOARRAY(T,X,N)                                 \
char __GECODE__ ## X ## __LINE__ [(N)*sizeof(T)];               \
T* X = reinterpret_cast<T*>(__GECODE__ ## X ## __LINE__);

#elif defined(_MSC_VER) || (defined(__GNUC__) && defined(_WIN32))

#include <cstdlib>
#include <malloc.h>

namespace Gecode { namespace Memory {

  class ManageMemory {
  private:
    void* _x;
  public:
    ManageMemory(void) {}
    void init(void* p) { _x = p; }
    ~ManageMemory(void) {
      if (_x != NULL)
	::free(_x);
    }
  };

}}


#define GECODE_AUTOARRAY(T,X,N)                                 \
T* X;                                                           \
::Gecode::Memory::ManageMemory __GECODE__ ## X ## __LINE__;     \
if ((sizeof(T)*(N)) <= 2048) {                                  \
   X = reinterpret_cast<T*>(_alloca(sizeof(T)*(N)));            \
   __GECODE__ ## X ## __LINE__ .init(NULL);                     \
} else {                                                        \
   X = reinterpret_cast<T*>(::malloc(sizeof(T)*(N)));           \
   __GECODE__ ## X ## __LINE__ .init(X);                        \
}

#else

#include <cstdlib>

namespace Gecode { namespace Memory {

  template <class T>
  class AutoArray {
  private:
    T* _x;
  public:
    AutoArray(const int n) {
      _x = reinterpret_cast<T*>(::malloc(sizeof(T)*n));
    }
    ~AutoArray(void) {
      ::free(_x);
    }
    T &operator [](const int i){ return _x[i]; }
    operator T*(void) { return _x; }
  };

}}

#define GECODE_AUTOARRAY(T,X,N) ::Gecode::Memory::AutoArray< T > X(N)

#endif

// STATISTICS: kernel-core