memory.icc

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2004
 *
 *  Last modified:
 *     $Date: 2007-11-13 21:48:32 +0100 (Tue, 13 Nov 2007) $ by $Author: schulte $
 *     $Revision: 5291 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  Permission is hereby granted, free of charge, to any person obtaining
 *  a copy of this software and associated documentation files (the
 *  "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so, subject to
 *  the following conditions:
 *
 *  The above copyright notice and this permission notice shall be
 *  included in all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */

#include <cstring>
#include <cstdlib>

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, size_t m);
    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 || s == 0)
        return p;
      throw MemoryExhausted();
    }

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


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

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

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

  }

}



/*
 * Automatic stack memory management
 *
 */

// The variable-sized arrays gcc extension is broken on
// i386/Apple gcc prior to 4.2
#if defined(__GNUC__) && (! defined(_WIN32) ) && \
    (! (defined(__APPLE__) && defined(__i386) && \
        __GNUC__ == 4 && __GNUC_MINOR__ < 2))

#define GECODE_AUTOARRAY(T,X,N)                    \
char GECODE_FRESH(X) [(N)*sizeof(T)];              \
T* X = ::Gecode::Support::ptr_cast<T*>(GECODE_FRESH(X));

#elif defined(_MSC_VER)

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

namespace Gecode { namespace Memory {

  class ManageMemory {
  private:
    void* _x;
  public:
    ManageMemory(void* p) : _x(p) {}
    ~ManageMemory(void) { _freea(_x); }
  };

}}


#define GECODE_AUTOARRAY(T,X,N)                                 \
T* X;                                                           \
X = static_cast<T*>(_malloca(sizeof(T)*(N)));                   \
::Gecode::Memory::ManageMemory __GECODE__ ## X ## __LINE__(X);


#else

#include <cstdlib>

namespace Gecode { namespace Memory {

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

}}

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

#endif

// STATISTICS: support-any