gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/kernel/exception.cc

@@ -0,0 +1,49 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2006-07-12 21:37:21 +0200 (Wed, 12 Jul 2006) $ by $Author: schulte $
+ *     $Revision: 3352 $
+ *
+ *  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.
+ *
+ */
+
+#include "gecode/kernel.hh"
+
+namespace Gecode {
+
+  /*
+   * Base class for exceptions
+   *
+   */
+  Exception::Exception(const char* l, const char* i) throw() {
+    int j = 0;
+    while ((*l != 0) && (j < li_max))
+      li[j++] = *(l++);
+    if (j < li_max)
+      li[j++] = ':';
+    if (j < li_max)
+      li[j++] = ' ';
+    while ((*i != 0) && (j < li_max))
+      li[j++] = *(i++);
+    li[j] = 0;
+  }
+  const char*
+  Exception::what(void) const throw() {
+    return &li[0];
+  }
+
+}
+
+// STATISTICS: kernel-other

data/ext/gecode-1.3.1/gecode/kernel/exception.icc

@@ -0,0 +1,104 @@
+/*
+ *  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.
+ *
+ */
+
+#include <exception>
+
+namespace Gecode {
+
+  /**
+   * \brief %Exception: Base-class for exceptions
+   * \ingroup FuncThrow
+   */
+  class GECODE_KERNEL_EXPORT Exception : public std::exception {
+  private:
+    static const int li_max = 128;
+    char li[li_max+1];
+  public:
+    /// Initialize with location \a l and information \a i
+    Exception(const char* l, const char* i) throw ();
+    /// Return information
+    virtual const char* what(void) const throw();
+  };
+
+
+  /**
+   * \defgroup FuncThrowKernel Kernel exceptions
+   * \ingroup FuncThrow
+   */
+
+  //@{
+
+  /// %Exception: %Memory exhausted
+  class MemoryExhausted : public Exception {
+  public:
+    /// Initialize
+    MemoryExhausted(void);
+  };
+
+  /// %Exception: Operation on failed space invoked
+  class SpaceFailed : public Exception {
+  public:
+    /// Initialize with location \a l
+    SpaceFailed(const char* l);
+  };
+
+  /// %Exception: Commit when no branching present
+  class SpaceNoBranching : public Exception {
+  public:
+    /// Initialize
+    SpaceNoBranching(void);
+  };
+
+  /// %Exception: Commit with illegal alternative
+  class SpaceIllegalAlternative : public Exception {
+  public:
+    /// Initialize
+    SpaceIllegalAlternative(void);
+  };
+
+  //@}
+
+  /*
+   * Classes for exceptions raised by kernel
+   *
+   */
+
+  inline
+  MemoryExhausted::MemoryExhausted(void)
+    : Exception("Memory","Heap memory exhausted") {}
+
+  inline
+  SpaceFailed::SpaceFailed(const char* l)
+    : Exception(l,"Attempt to invoke operation on failed space") {}
+
+  inline
+  SpaceNoBranching::SpaceNoBranching(void)
+    : Exception("Space::commit",
+		"Attempt to commit with no branching") {}
+
+  inline
+  SpaceIllegalAlternative::SpaceIllegalAlternative(void)
+    : Exception("Space::commit",
+		"Attempt to commit with illegal alternative") {}
+
+}
+
+// STATISTICS: kernel-other

data/ext/gecode-1.3.1/gecode/kernel/macros.icc

@@ -0,0 +1,98 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-09-12 10:05:22 +0200 (Tue, 12 Sep 2006) $ by $Author: tack $
+ *     $Revision: 3658 $
+ *
+ *  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.
+ *
+ */
+
+/**
+ * \brief Check whether modification event \a me is failed, and forward failure.
+ *
+ * To be used inside the propagate member function of a propagator
+ * or the commit member function of a branching.
+ * \ingroup TaskActor
+ */
+#define GECODE_ME_CHECK(me)			\
+  if (::Gecode::me_failed(me))			\
+    return ::Gecode::ES_FAILED;
+
+/**
+ * \brief Check whether \a me is failed or modified, and forward failure.
+ *
+ * To be used inside the propagate member function of a propagator
+ * or the commit member function of a branching.
+ * \ingroup TaskActor
+ */
+#define GECODE_ME_CHECK_MODIFIED(modified, me) {           \
+    ModEvent __me__ ## __LINE__ = (me);                    \
+    if (::Gecode::me_failed(__me__ ## __LINE__))	   \
+      return ::Gecode::ES_FAILED;                          \
+    modified |= ::Gecode::me_modified(__me__ ## __LINE__); \
+  }
+
+/**
+ * \brief Check whether modification event \a me is failed, and fail space \a home.
+ *
+ * To be used inside post functions.
+ * \ingroup TaskActor
+ */
+#define GECODE_ME_FAIL(home,me)			\
+  if (::Gecode::me_failed(me)) {		\
+    (home)->fail();				\
+    return;					\
+  }
+
+
+
+/**
+ * \brief Check whether execution status \a es is failed, and forward failure.
+ * \ingroup TaskActor
+ */
+#define GECODE_ES_CHECK(es)		\
+  if ((es) < ::Gecode::ES_OK)		\
+    return ::Gecode::ES_FAILED;
+
+/**
+ * \brief Check whether execution status \a es is failed, and fail space \a home.
+ * \ingroup TaskActor
+ */
+#define GECODE_ES_FAIL(home,es)		\
+  if ((es) < ::Gecode::ES_OK) {		\
+    (home)->fail();			\
+    return;				\
+  }
+
+/**
+ * \def GECODE_NEVER
+ * \brief Assert that this command is never executed
+ *
+ * This is preferred over assert(false) as it is used for optimization,
+ * if supported by a compiler (for example, Microsoft Visual C++).
+ *
+ */
+
+#if defined(_MSC_VER) && defined(NDEBUG)
+
+#define GECODE_NEVER __assume(false);
+
+#else
+
+#define GECODE_NEVER assert(false);
+
+#endif
+
+// STATISTICS: kernel-other

data/ext/gecode-1.3.1/gecode/kernel/memory-manager.cc

@@ -0,0 +1,41 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *      <duchier@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Denys Duchier, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  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.
+ *
+ */
+
+#include "gecode/kernel.hh"
+
+namespace Gecode {
+
+  void
+  MemoryManager::alloc_refill(size_t sz) {
+    // Try to reuse the not used memory
+    reuse(start,lsz);
+    alloc_fill(sz);
+  }
+
+}
+
+// STATISTICS: kernel-core
+
+

data/ext/gecode-1.3.1/gecode/kernel/memory-manager.icc

@@ -0,0 +1,438 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-07 20:47:02 +0200 (Mon, 07 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3525 $
+ *
+ *  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 {
+    /**
+     * \brief Parameters defining memory management policy for spaces
+     * \ingroup FuncMemSpace
+     */
+    namespace Config {
+      /**
+       * \brief Minimal size of a heap chunk requested from the OS
+       */
+      const size_t hcsz_min =  2 * 1024;
+      /**
+       * \brief Maximal size of a heap chunk requested from the OS
+       *
+       * Maximal is not strictly true, if a contiguous memory chunk is
+       * requested that exceeds \a hcsz_max, a chunk will be allocated
+       * that fits that request.
+       */
+      const size_t hcsz_max = 64 * 1024;
+      /**
+       * \brief Increment ratio for chunk size
+       *
+       * If a space has requested \a hcsz_inc_ratio chunks of heap memory,
+       * the chunk size is doubled.
+       */
+      const int hcsz_inc_ratio = 8;
+      /**
+       * \brief Decrement ratio for chunk size
+       *
+       * When a space is cloned, the new clone normally inherits the
+       * current chunk size from the original space. However, if the
+       * original space has requested less than \a hcsz_dec_ratio
+       * heap chunks of the current chunk size, the current chunk size
+       * for the clone is halfed.
+       */
+      const int hcsz_dec_ratio = 4;
+
+      /**
+       * \brief Unit size for free lists
+       *
+       * The unit size (given as binary logarithm) defines how big
+       * a unit of memory for free lists is. Also, it defines the
+       * alignment. Sizes of free list objects must be multiples of
+       * the unit size.
+       *
+       * Currently, for 32 bit machines, the unit size is 4 bytes.
+       * For 64 bit machines, it is 8 bytes.
+       */
+      const int fl_unit_size = ((sizeof(void*) == 4) ? 2 : 3);
+      /**
+       * \brief Minimal size for free list element
+       *
+       * The minimal size is given in the number of free list units.
+       *
+       * Currently, for 32 bit machines, the minimal size is 12 bytes.
+       * For 64 bit machines, it is 16 bytes.
+       */
+      const int fl_size_min  = ((sizeof(void*) == 4) ? 3 : 2);
+      /**
+       * \brief Maximal size for free list element
+       *
+       * The maximal size is given in the number of free list units.
+       *
+       * Currently, for 32 bit machines, the maximal size is 12 bytes.
+       * For 64 bit machines, it is 16 bytes.
+       */
+      const int fl_size_max  = ((sizeof(void*) == 4) ? 3 : 2);
+      /**
+       * \brief Number of free lists elements to allocate
+       *
+       * When a request for a free list element can not be fulfilled, as
+       * the free list is empty and there is also no reusable memory
+       * available, allocate \a fl_refill free list elements.
+       */
+      const int fl_refill = 8;
+      /**
+       * \brief Memory alignment
+       *
+       * Memory alignment is controlled by the macro GECODE_MEMORY_ALIGNMENT.
+       * If it is not defined, it assumed to be 8. Otherwise, the defined
+       * value is used.
+       */
+#ifndef GECODE_MEMORY_ALIGNMENT
+#define GECODE_MEMORY_ALIGNMENT 8
+#endif
+    }
+  }
+
+  /**
+   * \brief Base-class for freelist-managed objects
+   *
+   * Freelist-managed object must inherit from this class. The size
+   * of objects of subclasses is defined by the parameters in
+   * Gecode::Memory::Config.
+   * \ingroup FuncMemSpace
+   */
+  class FreeList {
+  protected:
+    FreeList* _next;
+  public:
+    FreeList(void);
+    FreeList(FreeList*);
+    FreeList* next(void) const;
+    void next(FreeList*);
+  };
+
+  /// Manage memory for space
+  class MemoryManager {
+  private:
+    /// Memory-chunks allocated from heap
+    class HeapChunk {
+    public:
+      /// Next heap chunk already allocated
+      HeapChunk* next;
+      /// Start of memory area inside chunk
+      double area[1];
+    };
+  private:
+    /// Initialize and allocate first heap chunk
+    void init(void);
+  public:
+    /// Constructor initialization
+    MemoryManager(void);
+    /// Constructor during cloning \a mm
+    MemoryManager(MemoryManager& mm);
+    /// Release all allocated heap chunks
+    ~MemoryManager(void);
+
+  private:
+    size_t     cur_hcsz;  ///< Current heap chunk size
+    HeapChunk* cur_hc;    ///< Current heap chunk
+    size_t     requested; ///< Total amount of heap memory requested
+
+    char*  start; ///< Start of current heap area used for allocation
+    size_t lsz;   ///< Size left for allocation
+
+    /// Refill current heap area (outlined) issued by request of size \a s
+    GECODE_KERNEL_EXPORT
+    void alloc_refill(size_t s);
+    /// Do the real work for refilling
+    void alloc_fill(size_t s);
+
+  public:
+    /// Allocate memory of size \a s
+    void* alloc(size_t s);
+    /// Return how much memory has been allocated
+    size_t allocated(void) const;
+
+  private:
+    /// Start of free lists
+    FreeList* fl[Memory::Config::fl_size_max-Memory::Config::fl_size_min+1];
+    /// Refill free list
+    template <size_t> void fl_refill(void);
+    /// Translate size to index in free list
+    static size_t sz2i(size_t);
+    /// Translate index in free list to size
+    static size_t i2sz(size_t);
+
+  public:
+    /// Allocate free list element of size \a s
+    template <size_t s>
+    void* fl_alloc(void);
+    /// Release all free list elements of size \a s between f and l (inclusive)
+    template <size_t> void  fl_dispose(FreeList* f, FreeList* l);
+
+  public:
+    /// Memory-chunks for reusing slack memory
+    class ReuseChunk {
+    public:
+      /// Size of chunk
+      size_t      size;
+      /// Next chunk for reusal
+      ReuseChunk* next;
+    };
+  private:
+    /// Slack memory chunks
+    ReuseChunk* slack;
+  public:
+    /// Store for reusal, if of sufficient size for free list
+    void reuse(void* p, size_t s);
+    /// Try to allocate from slack
+    void* reusealloc(size_t s);
+  };
+
+
+  /*
+   * Freelists
+   *
+   */
+
+  forceinline
+  FreeList::FreeList(void) {}
+
+  forceinline
+  FreeList::FreeList(FreeList* n)
+    : _next(n) {}
+
+  forceinline FreeList*
+  FreeList::next(void) const {
+    return _next;
+  }
+
+  forceinline void
+  FreeList::next(FreeList* n) {
+    _next = n;
+  }
+
+  forceinline size_t
+  MemoryManager::sz2i(size_t s) {
+    assert((s % (1 << Memory::Config::fl_unit_size)) == 0);
+    assert(s >= (Memory::Config::fl_size_min << Memory::Config::fl_unit_size));
+    assert(s <= (Memory::Config::fl_size_max << Memory::Config::fl_unit_size));
+    return (s >> Memory::Config::fl_unit_size) - Memory::Config::fl_size_min;
+  }
+
+  forceinline size_t
+  MemoryManager::i2sz(size_t i) {
+    return (i + Memory::Config::fl_size_min) << Memory::Config::fl_unit_size;
+  }
+
+
+  /*
+   * The active memory manager
+   *
+   */
+
+  forceinline size_t
+  MemoryManager::allocated(void) const {
+    return requested;
+  }
+
+  forceinline void*
+  MemoryManager::alloc(size_t sz) {
+    // Size must be a multiple of four
+    assert((sz > 0) && ((sz % 4) == 0));
+#if GECODE_MEMORY_ALIGNMENT == 8
+    // Performs alignment to 8 bytes
+    sz += sz & 4;
+#endif
+    // Check whether sufficient memory left
+    if (sz > lsz)
+      alloc_refill(sz);
+    lsz -= sz;
+    return start + lsz;
+  }
+
+  forceinline void
+  MemoryManager::alloc_fill(size_t sz) {
+    // Adjust current heap chunk size
+    if (((requested > Memory::Config::hcsz_inc_ratio*cur_hcsz) ||
+	 (sz > cur_hcsz)) &&
+	(cur_hcsz < Memory::Config::hcsz_max)) {
+      cur_hcsz <<= 1;
+    }
+
+    // Round size to next multiple of current heap chunk size
+    lsz = ((sz > cur_hcsz) ?
+	   (((size_t) (sz / cur_hcsz)) + 1) * cur_hcsz : cur_hcsz);
+
+    // Request as close as possible a chunk with lsz sizes free
+#if GECODE_MEMORY_ALIGNMENT == 4
+    requested += lsz;
+    HeapChunk* hc = reinterpret_cast<HeapChunk*>
+      (Memory::malloc(sizeof(HeapChunk)+lsz-sizeof(double)));
+    start = reinterpret_cast<char*>(&(hc->area[0]));
+#endif
+#if GECODE_MEMORY_ALIGNMENT == 8
+    // Leave room for adjusting alignment by 4
+    requested += lsz+sizeof(double);
+    HeapChunk* hc = reinterpret_cast<HeapChunk*>
+      (Memory::malloc(sizeof(HeapChunk)+lsz));
+    start = reinterpret_cast<char*>(&(hc->area[0]));
+    // This is four if it is only four aligned
+    size_t size_adj = reinterpret_cast<size_t>(start) & 4;
+    start += size_adj;
+    lsz += sizeof(double) - size_adj;
+#endif
+    // Link heap chunk
+    hc->next = cur_hc; cur_hc = hc;
+#ifdef GECODE_MEMORY_CHECK
+    for (char* c = start; c < (start+lsz); c++)
+      *c = 0;
+#endif
+  }
+
+  forceinline void
+  MemoryManager::init(void) {
+    cur_hc    = NULL;
+    requested = 0;
+    alloc_fill(cur_hcsz);
+    for (size_t i = Memory::Config::fl_size_max-Memory::Config::fl_size_min+1;
+	 i--; )
+      fl[i] = NULL;
+  }
+
+  forceinline
+  MemoryManager::MemoryManager(void)
+    : cur_hcsz(Memory::Config::hcsz_min), slack(NULL) {
+    init();
+  }
+
+  forceinline
+  MemoryManager::MemoryManager(MemoryManager& mm)
+    : cur_hcsz(mm.cur_hcsz), slack(NULL) {
+    if ((mm.requested < Memory::Config::hcsz_dec_ratio*mm.cur_hcsz) &&
+	(mm.cur_hcsz > Memory::Config::hcsz_min))
+      cur_hcsz >>= 1;
+    init();
+  }
+
+  forceinline
+  MemoryManager::~MemoryManager(void) {
+    // Release all allocated heap chunks
+    HeapChunk* hc = cur_hc;
+    do {
+      HeapChunk* t = hc; hc = hc->next;
+      Memory::free(t);
+    } while (hc != NULL);
+  }
+
+
+  /*
+   * Slack memory management
+   *
+   */
+  forceinline void
+  MemoryManager::reuse(void* p, size_t s) {
+#ifdef GECODE_MEMORY_CHECK
+    {
+      char* c = reinterpret_cast<char*>(p);
+      char* e = c + s;
+      while (c < e) {
+	*c = 0; c++;
+      }
+    }
+#endif
+    if (s >= (Memory::Config::fl_size_max<<Memory::Config::fl_unit_size)) {
+      ReuseChunk* rc = reinterpret_cast<ReuseChunk*>(p);
+      rc->next = slack;
+      rc->size = s;
+      slack = rc;
+    }
+  }
+
+
+  /*
+   * Freelist management
+   *
+   */
+
+  template <size_t s>
+  forceinline void*
+  MemoryManager::fl_alloc(void) {
+    size_t i = sz2i(s);
+    FreeList* f = fl[i];
+    if (f == NULL) {
+      fl_refill<s>(); f = fl[i];
+    }
+    FreeList* n = f->next();
+    fl[i] = n;
+    return f;
+  }
+
+  template <size_t s>
+  forceinline void
+  MemoryManager::fl_dispose(FreeList* f, FreeList* l) {
+    size_t i = sz2i(s);
+    l->next(fl[i]); fl[i] = f;
+  }
+
+#define GECODE_KERNEL_PTR2FL(p) (reinterpret_cast<FreeList*>(p))
+#define GECODE_KERNEL_PTR2CH(p) (reinterpret_cast<char*>(p))
+
+  template <size_t sz>
+  void
+  MemoryManager::fl_refill(void) {
+    // Try to acquire memory from slack
+    if (slack != NULL) {
+      ReuseChunk* m = slack;
+      slack = NULL;
+      do {
+	char*  block = GECODE_KERNEL_PTR2CH(m);
+	size_t s     = m->size;
+	assert(s >= sz);
+	m = m->next;
+	fl[sz2i(sz)] = GECODE_KERNEL_PTR2FL(block);
+	while (s >= 2*sz) {
+	  GECODE_KERNEL_PTR2FL(block)->next(GECODE_KERNEL_PTR2FL(block+sz));
+	  block += sz;
+	  s     -= sz;
+	}
+	GECODE_KERNEL_PTR2FL(block)->next(NULL);
+      } while (m != NULL);
+    } else {
+      char* block = GECODE_KERNEL_PTR2CH(alloc(Memory::Config::fl_refill*sz));
+      fl[sz2i(sz)] = GECODE_KERNEL_PTR2FL(block);
+      int i = Memory::Config::fl_refill-2;
+      do {
+	GECODE_KERNEL_PTR2FL(block+i*sz)->next
+	  (GECODE_KERNEL_PTR2FL(block+(i+1)*sz));
+      } while (--i >= 0);
+      GECODE_KERNEL_PTR2FL(block+(Memory::Config::fl_refill-1)*sz)->next
+	(GECODE_KERNEL_PTR2FL(NULL));
+    }
+  }
+
+#undef GECODE_KERNEL_PTR2FL
+#undef GECODE_KERNEL_PTR2CH
+
+}
+
+// STATISTICS: kernel-core