dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/kernel/range-list.hpp

@@ -0,0 +1,184 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2011-05-11 20:44:17 +1000 (Wed, 11 May 2011) $ by $Author: tack $
+ *     $Revision: 12001 $
+ *
+ *  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.
+ *
+ */
+
+namespace Gecode {
+
+  /**
+   * \brief Lists of ranges (intervals)
+   *
+   * This class implements a simple datastructure for storing sets of
+   * integers as lists of ranges (intervals). Memory is managed as 
+   * space-allocated free lists.
+   *
+   * \ingroup FuncMemSpace
+   */
+  class RangeList : public FreeList {
+  protected:
+    /// Minimum of range
+    int        _min;
+    /// Maximum of range
+    int        _max;
+  public:
+    /// \name Constructors
+    //@{
+    /// Default constructor (noop)
+    RangeList(void);
+    /// Initialize with minimum \a min and maximum \a max and successor \a n
+    RangeList(int min, int max, RangeList* n);
+    //@}
+
+    /// \name Access
+    //@{
+    /// Return minimum
+    int min(void) const;
+    /// Return maximum
+    int max(void) const;
+    /// Return width (distance between maximum and minimum)
+    unsigned int width(void) const;
+
+    /// Return next element
+    RangeList* next(void) const;
+    //@}
+
+    /// \name Update
+    //@{
+    /// Set minimum to \a n
+    void min(int n);
+    /// Set maximum to \a n
+    void max(int n);
+    /// Set next rane to \a n
+    void next(RangeList* n);
+    //@}
+
+    /// \name Memory management
+    //@{
+    /**
+     * \brief Free memory for all elements between this and \a l (inclusive)
+     */
+    void dispose(Space& home, RangeList* l);
+
+    /// Allocate memory from space
+    static void* operator new(size_t s, Space& home);
+    /// Placement-new operator (noop)
+    static void* operator new(size_t s, void* p);
+    /// No-op (for exceptions)
+    static void  operator delete(void*);
+    /// No-op (use dispose instead)
+    static void  operator delete(void*, Space& home);
+    /// No-op (use dispose instead)
+    static void  operator delete(void*, void*);
+    //@}
+  };
+
+  /*
+   * Range lists
+   *
+   */
+
+  forceinline
+  RangeList::RangeList(void) {}
+
+  forceinline
+  RangeList::RangeList(int min, int max, RangeList* n)
+    : FreeList(n), _min(min), _max(max) {}
+
+  forceinline RangeList*
+  RangeList::next() const {
+    return static_cast<RangeList*>(FreeList::next());
+  }
+
+  forceinline void
+  RangeList::min(int n) {
+    _min = n;
+  }
+  forceinline void
+  RangeList::max(int n) {
+    _max = n;
+  }
+  forceinline void
+  RangeList::next(RangeList* n) {
+    FreeList::next(n);
+  }
+
+  forceinline int
+  RangeList::min(void) const {
+    return _min;
+  }
+  forceinline int
+  RangeList::max(void) const {
+    return _max;
+  }
+  forceinline unsigned int
+  RangeList::width(void) const {
+    return static_cast<unsigned int>(_max - _min + 1);
+  }
+
+
+  forceinline void
+  RangeList::operator delete(void*) {}
+
+  forceinline void
+  RangeList::operator delete(void*, Space&) {
+    GECODE_NEVER;
+  }
+
+  forceinline void
+  RangeList::operator delete(void*, void*) {
+    GECODE_NEVER;
+  }
+
+  forceinline void*
+  RangeList::operator new(size_t, Space& home) {
+    return home.fl_alloc<sizeof(RangeList)>();
+  }
+
+  forceinline void*
+  RangeList::operator new(size_t, void* p) {
+    return p;
+  }
+
+  forceinline void
+  RangeList::dispose(Space& home, RangeList* l) {
+    home.fl_dispose<sizeof(RangeList)>(this,l);
+  }
+
+}
+// STATISTICS: kernel-other

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/kernel/region.cpp

@@ -0,0 +1,85 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2008
+ *
+ *  Last modified:
+ *     $Date: 2011-04-08 22:12:09 +1000 (Fri, 08 Apr 2011) $ by $Author: schulte $
+ *     $Revision: 11917 $
+ *
+ *  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 <gecode/kernel.hh>
+
+namespace Gecode {
+
+  void*
+  Region::heap_alloc(size_t s) {
+    void* p = heap.ralloc(s);
+    if (hi == NULL) {
+      hi = p;
+      assert(!Support::marked(hi));
+    } else if (!Support::marked(hi)) {
+      HeapInfo* h = static_cast<HeapInfo*>
+        (heap.ralloc(sizeof(HeapInfo)+4*sizeof(void*)));
+      h->n=2; h->size=4;
+      h->blocks[0]=hi; h->blocks[1]=p;
+      hi = Support::mark(h);
+    } else {
+      HeapInfo* h = static_cast<HeapInfo*>(Support::unmark(hi));
+      if (h->n == h->size) {
+        HeapInfo* n = static_cast<HeapInfo*>
+          (heap.ralloc(sizeof(HeapInfo)+2*h->n*sizeof(void*)));
+        n->size = 2*h->n;
+        n->n = h->n;
+        memcpy(&n->blocks[0], &h->blocks[0], h->n*sizeof(void*));
+        hi = Support::mark(n);
+        h = n;
+      }
+      h->blocks[h->n++] = p;
+    }
+    return p;
+  }
+
+  void
+  Region::heap_free(void) {
+    assert(hi != NULL);
+    if (Support::marked(hi)) {
+      HeapInfo* h = static_cast<HeapInfo*>(Support::unmark(hi));
+      for (unsigned int i=h->n; i--; )
+        heap.rfree(h->blocks[i]);
+      heap.rfree(h);
+    } else {
+      heap.rfree(hi);
+    }
+  }
+
+}
+
+// STATISTICS: kernel-other

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/kernel/region.hpp

@@ -0,0 +1,459 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Filip Konvicka <filip.konvicka@logis.cz>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2008
+ *     LOGIS, s.r.o., 2009
+ *
+ *  Last modified:
+ *     $Date: 2011-04-08 22:12:09 +1000 (Fri, 08 Apr 2011) $ by $Author: schulte $
+ *     $Revision: 11917 $
+ *
+ *  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.
+ *
+ */
+
+namespace Gecode {
+
+  /**
+   * \defgroup FuncMemRegion Region memory management
+   *
+   * A region provides a handle to temporary memory owned by
+   * a space. The memory will be managed in a stack fashion, that is,
+   * the memory allocated through a region will be released
+   * only after the region is deleted and all other regions
+   * created later also have been deleted.
+   *
+   * In case a memory request cannot be fulfilled from a space's region,
+   * heap memory is allocated and returned to the operating system
+   * as soon as the region is deleted.
+   *
+   * \ingroup FuncMem
+   */
+  //@{
+  /// Handle to region
+  class Region {
+  private:
+    /// Location to space
+    Space& home;
+    /// Free memory to reset
+    size_t free_reset;
+    /// Heap information data structure
+    class HeapInfo {
+    public:
+      /// Number of allocated heap blocks
+      unsigned int n;
+      /// Limit of allocated heap blocks
+      unsigned int size;
+      /// Pointers to allocated heap blocks (more entries)
+      void* blocks[0];
+    };
+    /**
+     * \brief Heap allocation information
+     *
+     * If NULL, no heap memory has been allocated. If the pointer
+     * is marked, it points to a single heap allocated block. Otherwise,
+     * it points to a HeapInfo data structure.
+     */
+    void* hi;
+    /// Allocate memory from heap
+    GECODE_KERNEL_EXPORT void* heap_alloc(size_t s);
+    /// Free memory previously allocated from heap
+    GECODE_KERNEL_EXPORT void heap_free(void);
+  public:
+    /// Initialize region from space
+    Region(const Space& home);
+    /// \name Typed allocation routines
+    //@{
+    /**
+     * \brief Allocate block of \a n objects of type \a T from region
+     *
+     * Note that this function implements C++ semantics: the default
+     * constructor of \a T is run for all \a n objects.
+     */
+    template<class T>
+    T* alloc(long unsigned int n);
+    /**
+     * \brief Allocate block of \a n objects of type \a T from region
+     *
+     * Note that this function implements C++ semantics: the default
+     * constructor of \a T is run for all \a n objects.
+     */
+    template<class T>
+    T* alloc(long int n);
+    /**
+     * \brief Allocate block of \a n objects of type \a T from region
+     *
+     * Note that this function implements C++ semantics: the default
+     * constructor of \a T is run for all \a n objects.
+     */
+    template<class T>
+    T* alloc(unsigned int n);
+    /**
+     * \brief Allocate block of \a n objects of type \a T from region
+     *
+     * Note that this function implements C++ semantics: the default
+     * constructor of \a T is run for all \a n objects.
+     */
+    template<class T>
+    T* alloc(int n);
+    /**
+     * \brief Delete \a n objects allocated from the region starting at \a b
+     *
+     * Note that this function implements C++ semantics: the destructor
+     * of \a T is run for all \a n objects.
+     *
+     * Note that the memory is not freed, the only effect is running the
+     * destructors.
+     */
+    template<class T>
+    void free(T* b, long unsigned int n);
+    /**
+     * \brief Delete \a n objects allocated from the region starting at \a b
+     *
+     * Note that this function implements C++ semantics: the destructor
+     * of \a T is run for all \a n objects.
+     *
+     * Note that the memory is not freed, the only effect is running the
+     * destructors.
+     */
+    template<class T>
+    void free(T* b, long int n);
+    /**
+     * \brief Delete \a n objects allocated from the region starting at \a b
+     *
+     * Note that this function implements C++ semantics: the destructor
+     * of \a T is run for all \a n objects.
+     *
+     * Note that the memory is not freed, the only effect is running the
+     * destructors.
+     */
+    template<class T>
+    void free(T* b, unsigned int n);
+    /**
+     * \brief Delete \a n objects allocated from the region starting at \a b
+     *
+     * Note that this function implements C++ semantics: the destructor
+     * of \a T is run for all \a n objects.
+     *
+     * Note that the memory is not freed, the only effect is running the
+     * destructors.
+     */
+    template<class T>
+    void free(T* b, int n);
+    /**
+     * \brief Reallocate block of \a n objects starting at \a b to \a m objects of type \a T from the region
+     *
+     * Note that this function implements C++ semantics: the copy constructor
+     * of \a T is run for all \f$\min(n,m)\f$ objects, the default
+     * constructor of \a T is run for all remaining
+     * \f$\max(n,m)-\min(n,m)\f$ objects, and the destrucor of \a T is
+     * run for all \a n objects in \a b.
+     *
+     * Returns the address of the new block.
+     */
+    template<class T>
+    T* realloc(T* b, long unsigned int n, long unsigned int m);
+    /**
+     * \brief Reallocate block of \a n objects starting at \a b to \a m objects of type \a T from the region
+     *
+     * Note that this function implements C++ semantics: the copy constructor
+     * of \a T is run for all \f$\min(n,m)\f$ objects, the default
+     * constructor of \a T is run for all remaining
+     * \f$\max(n,m)-\min(n,m)\f$ objects, and the destrucor of \a T is
+     * run for all \a n objects in \a b.
+     *
+     * Returns the address of the new block.
+     */
+    template<class T>
+    T* realloc(T* b, long int n, long int m);
+    /**
+     * \brief Reallocate block of \a n objects starting at \a b to \a m objects of type \a T from the region
+     *
+     * Note that this function implements C++ semantics: the copy constructor
+     * of \a T is run for all \f$\min(n,m)\f$ objects, the default
+     * constructor of \a T is run for all remaining
+     * \f$\max(n,m)-\min(n,m)\f$ objects, and the destrucor of \a T is
+     * run for all \a n objects in \a b.
+     *
+     * Returns the address of the new block.
+     */
+    template<class T>
+    T* realloc(T* b, unsigned int n, unsigned int m);
+    /**
+     * \brief Reallocate block of \a n objects starting at \a b to \a m objects of type \a T from the region
+     *
+     * Note that this function implements C++ semantics: the copy constructor
+     * of \a T is run for all \f$\min(n,m)\f$ objects, the default
+     * constructor of \a T is run for all remaining
+     * \f$\max(n,m)-\min(n,m)\f$ objects, and the destrucor of \a T is
+     * run for all \a n objects in \a b.
+     *
+     * Returns the address of the new block.
+     */
+    template<class T>
+    T* realloc(T* b, int n, int m);
+    //@}
+    /// \name Raw allocation routines
+    //@{
+    /// Allocate memory from region
+    void* ralloc(size_t s);
+    /**
+     * \brief Free memory previously allocated
+     *
+     * Note that the memory is only guaranteed to be freed after the
+     * region object itself gets deleted.
+     */
+    void rfree(void* p, size_t s);
+    //@}
+    /// \name Construction routines
+    //@{
+    /**
+     * \brief Constructs a single object of type \a T from region using the default constructor.
+     */
+    template<class T> 
+    T& construct(void);
+    /**
+     * \brief Constructs a single object of type \a T from region using a unary constructor.
+     *
+     * The parameter is passed as a const reference.
+     */
+    template<class T, typename A1> 
+    T& construct(A1 const& a1);
+    /**
+     * \brief Constructs a single object of type \a T from region using a binary constructor.
+     *
+     * The parameters are passed as const references.
+     */
+    template<class T, typename A1, typename A2> 
+    T& construct(A1 const& a1, A2 const& a2);
+    /**
+     * \brief Constructs a single object of type \a T from region using a ternary constructor.
+     *
+     * The parameters are passed as const references.
+     */
+    template<class T, typename A1, typename A2, typename A3>
+    T& construct(A1 const& a1, A2 const& a2, A3 const& a3);
+    /**
+     * \brief Constructs a single object of type \a T from region using a quaternary constructor.
+     *
+     * The parameters are passed as const references.
+     */
+    template<class T, typename A1, typename A2, typename A3, typename A4>
+    T& construct(A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4);
+    /**
+     * \brief Constructs a single object of type \a T from region using a quinary constructor.
+     *
+     * The parameters are passed as const references.
+     */
+    template<class T, typename A1, typename A2, typename A3, typename A4, typename A5>
+    T& construct(A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5);
+    //@}
+    /// Return memory
+    ~Region(void);
+  private:
+    /// Allocate memory from heap (disabled)
+    static void* operator new(size_t s) throw() { (void) s; return NULL; }
+    /// Free memory allocated from heap (disabled)
+    static void  operator delete(void* p) { (void) p; };
+    /// Copy constructor (disabled)
+    Region(const Region& r) : home(r.home) {}
+    /// Assignment operator (disabled)
+    const Region& operator =(const Region&) { return *this; }
+  };
+  //@}
+
+
+  /*
+   * Implementation
+   *
+   */
+  forceinline
+  Region::Region(const Space& h)
+    : home(const_cast<Space&>(h)), free_reset(home.sm->region.free), hi(0) {}
+
+  forceinline void*
+  Region::ralloc(size_t s) {
+    void* p;
+    if (home.sm->region_alloc(s,p))
+      return p;
+    return heap_alloc(s);
+  }
+
+  forceinline void
+  Region::rfree(void*, size_t) {}
+
+  forceinline
+  Region::~Region(void) {
+    home.sm->region.free = free_reset;
+    if (hi != NULL)
+      heap_free();
+  }
+
+
+  /*
+   * Typed allocation routines
+   *
+   */
+  template<class T>
+  forceinline T*
+  Region::alloc(long unsigned int n) {
+    T* p = static_cast<T*>(ralloc(sizeof(T)*n));
+    for (long unsigned int i=n; i--; )
+      (void) new (p+i) T();
+    return p;
+  }
+  template<class T>
+  forceinline T*
+  Region::alloc(long int n) {
+    assert(n >= 0);
+    return alloc<T>(static_cast<long unsigned int>(n));
+  }
+  template<class T>
+  forceinline T*
+  Region::alloc(unsigned int n) {
+    return alloc<T>(static_cast<long unsigned int>(n));
+  }
+  template<class T>
+  forceinline T*
+  Region::alloc(int n) {
+    assert(n >= 0);
+    return alloc<T>(static_cast<long unsigned int>(n));
+  }
+
+  template<class T>
+  forceinline void
+  Region::free(T* b, long unsigned int n) {
+    for (long unsigned int i=n; i--; )
+      b[i].~T();
+    rfree(b,n*sizeof(T));
+  }
+  template<class T>
+  forceinline void
+  Region::free(T* b, long int n) {
+    assert(n >= 0);
+    free<T>(b,static_cast<long unsigned int>(n));
+  }
+  template<class T>
+  forceinline void
+  Region::free(T* b, unsigned int n) {
+    free<T>(b,static_cast<long unsigned int>(n));
+  }
+  template<class T>
+  forceinline void
+  Region::free(T* b, int n) {
+    assert(n >= 0);
+    free<T>(b,static_cast<long unsigned int>(n));
+  }
+
+  template<class T>
+  forceinline T*
+  Region::realloc(T* b, long unsigned int n, long unsigned int m) {
+    if (n < m) {
+      T* p = static_cast<T*>(ralloc(sizeof(T)*m));
+      for (long unsigned int i=n; i--; )
+        (void) new (p+i) T(b[i]);
+      for (long unsigned int i=n; i<m; i++)
+        (void) new (p+i) T();
+      free<T>(b,n);
+      return p;
+    } else {
+      free<T>(b+m,m-n);
+      return b;
+    }
+  }
+  template<class T>
+  forceinline T*
+  Region::realloc(T* b, long int n, long int m) {
+    assert((n >= 0) && (m >= 0));
+    return realloc<T>(b,static_cast<long unsigned int>(n),
+                      static_cast<long unsigned int>(m));
+  }
+  template<class T>
+  forceinline T*
+  Region::realloc(T* b, unsigned int n, unsigned int m) {
+    return realloc<T>(b,static_cast<long unsigned int>(n),
+                      static_cast<long unsigned int>(m));
+  }
+  template<class T>
+  forceinline T*
+  Region::realloc(T* b, int n, int m) {
+    assert((n >= 0) && (m >= 0));
+    return realloc<T>(b,static_cast<long unsigned int>(n),
+                      static_cast<long unsigned int>(m));
+  }
+
+  /*
+   * Region construction support
+   *
+   */
+  template<class T> 
+  forceinline T& 
+  Region::construct(void) {
+    return alloc<T>(1);
+  }
+  template<class T, typename A1> 
+  forceinline T& 
+  Region::construct(A1 const& a1) {
+    T& t = *static_cast<T*>(ralloc(sizeof(T)));
+    new (&t) T(a1);
+    return t;
+  }
+  template<class T, typename A1, typename A2> 
+  forceinline T& 
+  Region::construct(A1 const& a1, A2 const& a2) {
+    T& t = *static_cast<T*>(ralloc(sizeof(T)));
+    new (&t) T(a1,a2);
+    return t;
+  }
+  template<class T, typename A1, typename A2, typename A3>
+  forceinline T& 
+  Region::construct(A1 const& a1, A2 const& a2, A3 const& a3) {
+    T& t = *static_cast<T*>(ralloc(sizeof(T)));
+    new (&t) T(a1,a2,a3);
+    return t;
+  }
+  template<class T, typename A1, typename A2, typename A3, typename A4>
+  forceinline T& 
+  Region::construct(A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4) {
+    T& t = *static_cast<T*>(ralloc(sizeof(T)));
+    new (&t) T(a1,a2,a3,a4);
+    return t;
+  }
+  template<class T, typename A1, typename A2, typename A3, typename A4, typename A5>
+  forceinline T& 
+  Region::construct(A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5) {
+    T& t = *static_cast<T*>(ralloc(sizeof(T)));
+    new (&t) T(a1,a2,a3,a4,a5);
+    return t;
+  }
+
+}
+
+// STATISTICS: kernel-other