dep-selector-libgecode 1.0.0.alpha.0

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

@@ -0,0 +1,203 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2009
+ *
+ *  Last modified:
+ *     $Date: 2011-04-11 19:28:27 +1000 (Mon, 11 Apr 2011) $ by $Author: tack $
+ *     $Revision: 11929 $
+ *
+ *  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_BAB_HH__
+#define __GECODE_SEARCH_PARALLEL_BAB_HH__
+
+#include <gecode/search/parallel/engine.hh>
+
+namespace Gecode { namespace Search { namespace Parallel {
+
+  /// %Parallel branch-and-bound engine
+  class BAB : public Engine {
+  protected:
+    /// %Parallel branch-and-bound search worker
+    class Worker : public Engine::Worker {
+    protected:
+      /// Number of entries not yet constrained to be better
+      int mark;
+      /// Best solution found so far
+      Space* best;
+    public:
+      /// Initialize for space \a s (of size \a sz) with engine \a e
+      Worker(Space* s, size_t sz, BAB& e);
+      /// Provide access to engine
+      BAB& engine(void) const;
+      /// Start execution of worker
+      virtual void run(void);
+      /// Accept better solution \a b
+      void better(Space* b);
+      /// Try to find some work
+      void find(void);
+      /// Destructor
+      virtual ~Worker(void);
+    };
+    /// Array of worker references
+    Worker** _worker;
+    /// Best solution so far
+    Space* best;
+  public:
+    /// Provide access to worker \a i
+    Worker* worker(unsigned int i) const;
+
+    /// \name Search control
+    //@{
+    /// Report solution \a s
+    void solution(Space* s);
+    //@}
+
+    /// \name Engine interface
+    //@{
+    /// Initialize for space \a s (of size \a sz) with options \a o
+    BAB(Space* s, size_t sz, const Options& o);
+    /// Return statistics
+    virtual Statistics statistics(void) const;
+    /// Destructor
+    virtual ~BAB(void);
+    //@}
+  };
+
+
+
+  /*
+   * Engine: basic access routines
+   */
+  forceinline BAB&
+  BAB::Worker::engine(void) const {
+    return static_cast<BAB&>(_engine);
+  }
+  forceinline BAB::Worker*
+  BAB::worker(unsigned int i) const {
+    return _worker[i];
+  }
+
+
+  /*
+   * Engine: initialization
+   */
+  forceinline
+  BAB::Worker::Worker(Space* s, size_t sz, BAB& e)
+    : Engine::Worker(s,sz,e), mark(0), best(NULL) {}
+
+  forceinline
+  BAB::BAB(Space* s, size_t sz, const Options& o)
+    : Engine(o), best(NULL) {
+    // Create workers
+    _worker = static_cast<Worker**>
+      (heap.ralloc(workers() * sizeof(Worker*)));
+    // The first worker gets the entire search tree
+    _worker[0] = new Worker(s,sz,*this);
+    // All other workers start with no work
+    for (unsigned int i=1; i<workers(); i++)
+      _worker[i] = new Worker(NULL,sz,*this);
+    // Block all workers
+    block();
+    // Create and start threads
+    for (unsigned int i=0; i<workers(); i++)
+      Support::Thread::run(_worker[i]);
+  }
+
+
+  /*
+   * Engine: search control
+   */
+  forceinline void
+  BAB::Worker::better(Space* b) {
+    m.acquire();
+    delete best;
+    best = b->clone(false);
+    mark = path.entries();
+    if (cur != NULL)
+      cur->constrain(*best);
+    m.release();
+  }
+  forceinline void 
+  BAB::solution(Space* s) {
+    m_search.acquire();
+    if (best != NULL) {
+      s->constrain(*best);
+      if (s->status() == SS_FAILED) {
+        delete s;
+        m_search.release();
+        return;
+      } else {
+        delete best;
+        best = s->clone();
+      }
+    } else {
+      best = s->clone();
+    }
+    // Announce better solutions
+    for (unsigned int i=0; i<workers(); i++)
+      worker(i)->better(best);
+    bool bs = signal();
+    solutions.push(s);
+    if (bs)
+      e_search.signal();
+    m_search.release();
+  }
+  
+
+  /*
+   * Worker: finding and stealing working
+   */
+  forceinline void
+  BAB::Worker::find(void) {
+    // Try to find new work (even if there is none)
+    for (unsigned int i=0; i<engine().workers(); i++) {
+      unsigned long int r_d = 0ul;
+      if (Space* s = engine().worker(i)->steal(r_d)) {
+        // Reset this guy
+        m.acquire();
+        idle = false;
+        d = 0;
+        cur = s;
+        mark = 0;
+        if (best != NULL)
+          cur->constrain(*best);
+        Search::Worker::reset(cur,r_d);
+        m.release();
+        return;
+      }
+    }
+  }
+
+}}}
+
+#endif
+
+// STATISTICS: search-parallel

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

@@ -0,0 +1,176 @@
+/* -*- 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-27 05:10:00 +1000 (Thu, 27 Aug 2009) $ by $Author: schulte $
+ *     $Revision: 9632 $
+ *
+ *  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/dfs.hh>
+
+namespace Gecode { namespace Search { namespace Parallel {
+
+  /*
+   * Statistics
+   */
+  Statistics 
+  DFS::statistics(void) const {
+    Statistics s;
+    for (unsigned int i=0; i<workers(); i++)
+      s += worker(i)->statistics();
+    return s;
+  }
+
+
+  /*
+   * Engine: search control
+   */
+  void
+  DFS::Worker::run(void) {
+    // Peform initial delay, if not first worker
+    if (this != engine().worker(0))
+      Support::Thread::sleep(Config::initial_delay);
+    // Okay, we are in business, start working
+    while (true) {
+      switch (engine().cmd()) {
+      case C_WAIT:
+        // Wait
+        engine().wait();
+        break;
+      case C_TERMINATE:
+        // Acknowledge termination request
+        engine().ack_terminate();
+        // Wait until termination can proceed
+        engine().wait_terminate();
+        // Terminate thread
+        engine().terminated();
+        return;
+      case C_RESET:
+        // Acknowledge reset request
+        engine().ack_reset_start();
+        // Wait until reset has been performed
+        engine().wait_reset();
+        // Acknowledge that reset cycle is over
+        engine().ack_reset_stop();
+        break;
+      case C_WORK:
+        // Perform exploration work
+        {
+          m.acquire();
+          if (idle) {
+            m.release();
+            // Try to find new work
+            find();
+          } else if (cur != NULL) {
+            start();
+            if (stop(engine().opt(),path.size())) {
+              // Report stop
+              m.release();
+              engine().stop();
+            } else {
+              node++;
+              switch (cur->status(*this)) {
+              case SS_FAILED:
+                fail++;
+                delete cur;
+                cur = NULL;
+                Worker::current(NULL);
+                m.release();
+                break;
+              case SS_SOLVED:
+                {
+                  // Deletes all pending branchers
+                  (void) cur->choice();
+                  Space* s = cur->clone(false);
+                  delete cur;
+                  cur = NULL;
+                  Worker::current(NULL);
+                  m.release();
+                  engine().solution(s);
+                }
+                break;
+              case SS_BRANCH:
+                {
+                  Space* c;
+                  if ((d == 0) || (d >= engine().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);
+                  m.release();
+                }
+                break;
+              default:
+                GECODE_NEVER;
+              }
+            }
+          } else if (path.next(*this)) {
+            cur = path.recompute(d,engine().opt().a_d,*this);
+            Worker::current(cur);
+            m.release();
+          } else {
+            idle = true;
+            m.release();
+            // Report that worker is idle
+            engine().idle();
+          }
+        }
+        break;
+      default:
+        GECODE_NEVER;
+      }
+    }
+  }
+
+
+  /*
+   * Termination and deletion
+   */
+  DFS::~DFS(void) {
+    terminate();
+    heap.rfree(_worker);
+  }
+
+}}}
+
+#endif
+
+// STATISTICS: search-parallel

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

@@ -0,0 +1,195 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2009
+ *
+ *  Last modified:
+ *     $Date: 2011-04-11 19:28:27 +1000 (Mon, 11 Apr 2011) $ by $Author: tack $
+ *     $Revision: 11929 $
+ *
+ *  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_DFS_HH__
+#define __GECODE_SEARCH_PARALLEL_DFS_HH__
+
+#include <gecode/search/parallel/engine.hh>
+
+namespace Gecode { namespace Search { namespace Parallel {
+
+  /// %Parallel depth-first search engine
+  class DFS : public Engine {
+  protected:
+    /// %Parallel depth-first search worker
+    class Worker : public Engine::Worker {
+    public:
+      /// Initialize for space \a s (of size \a sz) with engine \a e
+      Worker(Space* s, size_t sz, DFS& e);
+      /// Provide access to engine
+      DFS& engine(void) const;
+      /// Start execution of worker
+      virtual void run(void);
+      /// Try to find some work
+      void find(void);
+      /// Reset engine to restart at space \a s and return new root space
+      Space* reset(Space* s);
+    };
+    /// Array of worker references
+    Worker** _worker;
+  public:
+    /// Provide access to worker \a i
+    Worker* worker(unsigned int i) const;
+
+    /// \name Search control
+    //@{
+    /// Report solution \a s
+    void solution(Space* s);
+    /// Reset engine to restart at space \a s and return new root space
+    Space* reset(Space* s);
+    //@}
+
+    /// \name Engine interface
+    //@{
+    /// Initialize for space \a s (of size \a sz) with options \a o
+    DFS(Space* s, size_t sz, const Options& o);
+    /// Return statistics
+    virtual Statistics statistics(void) const;
+    /// Destructor
+    virtual ~DFS(void);
+    //@}
+  };
+
+
+  /*
+   * Basic access routines
+   */
+  forceinline DFS&
+  DFS::Worker::engine(void) const {
+    return static_cast<DFS&>(_engine);
+  }
+  forceinline DFS::Worker*
+  DFS::worker(unsigned int i) const {
+    return _worker[i];
+  }
+
+
+  /*
+   * Engine: initialization
+   */
+  forceinline
+  DFS::Worker::Worker(Space* s, size_t sz, DFS& e)
+    : Engine::Worker(s,sz,e) {}
+  forceinline
+  DFS::DFS(Space* s, size_t sz, const Options& o)
+    : Engine(o) {
+    // Create workers
+    _worker = static_cast<Worker**>
+      (heap.ralloc(workers() * sizeof(Worker*)));
+    // The first worker gets the entire search tree
+    _worker[0] = new Worker(s,sz,*this);
+    // All other workers start with no work
+    for (unsigned int i=1; i<workers(); i++)
+      _worker[i] = new Worker(NULL,sz,*this);
+    // Block all workers
+    block();
+    // Create and start threads
+    for (unsigned int i=0; i<workers(); i++)
+      Support::Thread::run(_worker[i]);
+  }
+
+  /*
+   * Statistics
+   */
+  forceinline Space*
+  DFS::Worker::reset(Space* s) {
+    delete cur;
+    path.reset();
+    d = 0;
+    idle = false;
+    if ((s == NULL) || (s->status(*this) == SS_FAILED)) {
+      delete s;
+      cur = NULL;
+      Search::Worker::reset();
+      return NULL;
+    } else {
+      cur = s;
+      Search::Worker::reset(cur);
+      return s->clone(false);
+    }
+  }
+  forceinline Space*
+  DFS::reset(Space* s) {
+    // All workers are marked as busy again
+    n_busy = workers();
+    for (unsigned int i=1; i<workers(); i++)
+      (void) worker(i)->reset(NULL);
+    return worker(0)->reset(s);
+  }
+
+  /*
+   * Engine: search control
+   */
+  forceinline void 
+  DFS::solution(Space* s) {
+    m_search.acquire();
+    bool bs = signal();
+    solutions.push(s);
+    if (bs)
+      e_search.signal();
+    m_search.release();
+  }
+  
+
+
+
+  /*
+   * Worker: finding and stealing working
+   */
+  forceinline void
+  DFS::Worker::find(void) {
+    // Try to find new work (even if there is none)
+    for (unsigned int i=0; i<engine().workers(); i++) {
+      unsigned long int r_d = 0ul;
+      if (Space* s = engine().worker(i)->steal(r_d)) {
+        // Reset this guy
+        m.acquire();
+        idle = false;
+        d = 0;
+        cur = s;
+        Search::Worker::reset(cur,r_d);
+        m.release();
+        return;
+      }
+    }
+  }
+
+}}}
+
+#endif
+
+// STATISTICS: search-parallel