dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/search/parallel/restart.cpp

@@ -0,0 +1,167 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2009
+ *
+ *  Last modified:
+ *     $Date: 2009-08-11 23:05:41 +1000 (Tue, 11 Aug 2009) $ by $Author: schulte $
+ *     $Revision: 9585 $
+ *
+ *  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/support.hh>
+
+#ifdef GECODE_HAS_THREADS
+
+#include <gecode/search/parallel/restart.hh>
+
+namespace Gecode { namespace Search { namespace Parallel {
+
+  Space*
+  Restart::next(void) {
+    // Invariant: the worker holds the wait mutex
+    m_search.acquire();
+    // Check whether root space is already failed
+    if (root == NULL) {
+      m_search.release();
+      return NULL;
+    }
+    while (!solutions.empty()) {
+      // No search needs to be done, try to take leftover solution
+      Space* s = solutions.pop();
+      if (best == NULL) {
+        best = s->clone();
+        reset_needed = true;
+        m_search.release();
+        return s;
+      } else {
+        s->constrain(*best);
+        if (s->status() == SS_FAILED) {
+          delete s;
+        } else {
+          delete best;
+          best = s->clone();
+          reset_needed = true;
+          m_search.release();
+          return s;
+        }
+      }
+    }
+    // We ignore stopped (it will be reported again if needed)
+    has_stopped = false;
+    // No more solutions?
+    if (n_busy == 0) {
+      m_search.release();
+      return NULL;
+    }
+    if (reset_needed) {
+      reset_needed = false;
+      root->constrain(*best);
+      // Leave lock
+      m_search.release();
+      // Grab wait lock for reset
+      m_wait_reset.acquire();
+      // Release workers for reset
+      release(C_RESET);
+      // Wait for reset cycle started
+      e_reset_ack_start.wait();
+      // Perform reset
+      root = reset(root);
+      // Block workers again to ensure invariant
+      block();
+      // Release reset lock
+      m_wait_reset.release();
+      // Wait for reset cycle stopped
+      e_reset_ack_stop.wait();
+      if (root == NULL)
+        return NULL;
+    } else {
+      m_search.release();
+    }
+
+    // Okay, now search has to continue, make the guys work
+    release(C_WORK);
+
+    /*
+     * Wait until a search related event has happened. It might be that
+     * the event has already been signalled in the last run, but the
+     * solution has been removed. So we have to try until there has
+     * something new happened.
+     */
+    while (true) {
+      e_search.wait();
+      m_search.acquire();
+      while (!solutions.empty()) {
+        // Check solution
+        Space* s = solutions.pop();
+        if (best == NULL) {
+          best = s->clone();
+          reset_needed = true;
+          m_search.release();
+          // Make workers wait again
+          block();
+          return s;
+        } else {
+          s->constrain(*best);
+          if (s->status() == SS_FAILED) {
+            delete s;
+          } else {
+            delete best;
+            best = s->clone();
+            reset_needed = true;
+            m_search.release();
+            // Make workers wait again
+            block();
+            return s;
+          }
+        }
+      }
+      // No more solutions or stopped?
+      if ((n_busy == 0) || has_stopped) {
+        m_search.release();
+        // Make workers wait again
+        block();
+        return NULL;
+      }
+      m_search.release();
+    }
+    GECODE_NEVER;
+    return NULL;
+  }
+
+  Restart::~Restart(void) {
+    delete best;
+    delete root;
+  }
+
+}}}
+
+#endif
+
+// STATISTICS: search-parallel

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/search/parallel/restart.hh

@@ -0,0 +1,73 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2009
+ *
+ *  Last modified:
+ *     $Date: 2009-05-13 22:48:34 +1000 (Wed, 13 May 2009) $ by $Author: schulte $
+ *     $Revision: 9085 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_SEARCH_PARALLEL_RESTART_HH__
+#define __GECODE_SEARCH_PARALLEL_RESTART_HH__
+
+#include <gecode/search/parallel/dfs.hh>
+
+namespace Gecode { namespace Search { namespace Parallel {
+
+  /// Depth-first restart best solution search engine implementation
+  class Restart : public DFS {
+  protected:
+    /// Root node
+    Space* root;
+    /// So-far best solution
+    Space* best;
+    /// Whether a reset is needed
+    bool reset_needed;
+  public:
+    /// Initialize engine for space \a s (with size \a sz) and options \a o
+    Restart(Space* s, size_t sz, const Search::Options& o);
+    /// Return next better solution (NULL, if none exists or search has been stopped)
+    virtual Space* next(void);
+    /// Destructor
+    virtual ~Restart(void);
+  };
+
+  forceinline 
+  Restart::Restart(Space* s, size_t sz, const Search::Options& o) :
+    DFS(s,sz,o),
+    root(s->status() == SS_FAILED ? NULL : s->clone()), 
+    best(NULL), reset_needed(false) {}
+
+}}}
+
+#endif
+
+// STATISTICS: search-parallel

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/search/restart.cpp

@@ -0,0 +1,62 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2009
+ *
+ *  Last modified:
+ *     $Date: 2009-05-12 18:35:58 +1000 (Tue, 12 May 2009) $ by $Author: schulte $
+ *     $Revision: 9057 $
+ *
+ *  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/search.hh>
+#include <gecode/search/sequential/restart.hh>
+#ifdef GECODE_HAS_THREADS
+#include <gecode/search/parallel/restart.hh>
+#endif
+#include <gecode/search/support.hh>
+
+namespace Gecode { namespace Search {
+    
+  Engine* 
+  restart(Space* s, size_t sz, const Options& o) {
+#ifdef GECODE_HAS_THREADS
+    Options to = o.expand();
+    if (to.threads == 1.0)
+      return new WorkerToEngine<Sequential::Restart>(s,sz,to);
+    else
+      return new Parallel::Restart(s,sz,to);
+#else
+    return new WorkerToEngine<Sequential::Restart>(s,sz,o);
+#endif
+  }
+
+}}
+
+// STATISTICS: search-other

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/search/restart.hpp

@@ -0,0 +1,88 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2009-09-09 05:10:29 +1000 (Wed, 09 Sep 2009) $ by $Author: schulte $
+ *     $Revision: 9692 $
+ *
+ *  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 {
+
+  namespace Search {
+    /// Create restart engine
+    GECODE_SEARCH_EXPORT Engine* restart(Space* s, size_t sz, const Options& o);
+  }
+
+  template<class T>
+  forceinline
+  Restart<T>::Restart(T* s, const Search::Options& o)
+    : e(Search::restart(s,sizeof(T),o)) {}
+
+  template<class T>
+  forceinline T*
+  Restart<T>::next(void) {
+    return dynamic_cast<T*>(e->next());
+  }
+
+  template<class T>
+  forceinline Search::Statistics
+  Restart<T>::statistics(void) const {
+    return e->statistics();
+  }
+
+  template<class T>
+  forceinline bool
+  Restart<T>::stopped(void) const {
+    return e->stopped();
+  }
+
+  template<class T>
+  forceinline
+  Restart<T>::~Restart(void) {
+    delete e;
+  }
+
+
+  template<class T>
+  T*
+  restart(T* s, const Search::Options& o) {
+    Restart<T> b(s,o);
+    T* l = NULL;
+    while (T* n = b.next()) {
+      delete l; l = n;
+    }
+    return l;
+  }
+
+}
+
+// STATISTICS: search-other

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/search/sequential/bab.hh

@@ -0,0 +1,177 @@
+/* -*- 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-09-02 19:00:55 +1000 (Fri, 02 Sep 2011) $ by $Author: tack $
+ *     $Revision: 12387 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_SEARCH_SEQUENTIAL_BAB_HH__
+#define __GECODE_SEARCH_SEQUENTIAL_BAB_HH__
+
+#include <gecode/search.hh>
+#include <gecode/search/support.hh>
+#include <gecode/search/worker.hh>
+#include <gecode/search/sequential/path.hh>
+
+namespace Gecode { namespace Search { namespace Sequential {
+
+  /// Implementation of depth-first branch-and-bound search engine
+  class BAB : public Worker {
+  private:
+    /// Search options
+    Options opt;
+    /// Current path in search tree
+    Path path;
+    /// Current space being explored
+    Space* cur;
+    /// Distance until next clone
+    unsigned int d;
+    /// Number of entries not yet constrained to be better
+    int mark;
+    /// Best solution found so far
+    Space* best;
+  public:
+    /// Initialize with space \a s (of size \a sz) and search options \a o
+    BAB(Space* s, size_t sz, const Options& o);
+    /// %Search for next better solution
+    Space* next(void);
+    /// Return statistics
+    Statistics statistics(void) const;
+    /// Destructor
+    ~BAB(void);
+  };
+
+  forceinline 
+  BAB::BAB(Space* s, size_t sz, const Options& o)
+    : Worker(sz), opt(o), d(0), mark(0), best(NULL) {
+    current(s);
+    if (s->status(*this) == SS_FAILED) {
+      fail++;
+      cur = NULL;
+      if (!o.clone)
+        delete s;
+    } else {
+      cur = snapshot(s,opt);
+    }
+    current(NULL);
+    current(cur);
+  }
+
+  forceinline Space*
+  BAB::next(void) {
+    /*
+     * The invariant maintained by the engine is:
+     *   For all nodes stored at a depth less than mark, there
+     *   is no guarantee of betterness. For those above the mark,
+     *   betterness is guaranteed.
+     *
+     * The engine maintains the path on the stack for the current
+     * node to be explored.
+     *
+     */
+    start();
+    while (true) {
+      while (cur) {
+        if (stop(opt,path.size()))
+          return NULL;
+        node++;
+        switch (cur->status(*this)) {
+        case SS_FAILED:
+          fail++;
+          delete cur;
+          cur = NULL;
+          Worker::current(NULL);
+          break;
+        case SS_SOLVED:
+          // Deletes all pending branchers
+          (void) cur->choice();
+          delete best;
+          best = cur;
+          cur = NULL;
+          mark = path.entries();
+          Worker::current(NULL);
+          return best->clone();
+        case SS_BRANCH:
+          {
+            Space* c;
+            if ((d == 0) || (d >= opt.c_d)) {
+              c = cur->clone();
+              d = 1;
+            } else {
+              c = NULL;
+              d++;
+            }
+            const Choice* ch = path.push(*this,cur,c);
+            Worker::push(c,ch);
+            cur->commit(*ch,0);
+            break;
+          }
+        default:
+          GECODE_NEVER;
+        }
+      }
+      // Recompute and add constraint if necessary
+      do {
+        if (!path.next(*this))
+          return NULL;
+        cur = path.recompute(d,opt.a_d,*this,best,mark);
+      } while (cur == NULL);
+      Worker::current(cur);
+    }
+    GECODE_NEVER;
+    return NULL;
+  }
+
+  forceinline Statistics
+  BAB::statistics(void) const {
+    Statistics s = *this;
+    s.memory += path.size();
+    return s;
+  }
+
+  forceinline 
+  BAB::~BAB(void) {
+    path.reset();
+    delete best;
+    delete cur;
+  }
+
+}}}
+
+#endif
+
+// STATISTICS: search-sequential