dep_selector 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 233352ee3f369d535368e3765da67ed3821279aa
-  data.tar.gz: e56f298dd78e1fb13281ee40e69f95e9e78f3c05
+  metadata.gz: 2c2b77c7e96ffbe77d1c03fc080b94d221b6daeb
+  data.tar.gz: 96c96d4e9b17c475c538651ab186f2bd6a200a12
 SHA512:
-  metadata.gz: c3f8401ecf5158eb61d7920896346303971df4221c8a9de6690cb06b22a2b47d03447c16bd40992a89d348878ee6f85ff435f27fd1999eb08e4304e1e7e18209
-  data.tar.gz: 4854b4a1c16d8a41bd4e5d53fb093ec0ed6ab5cd55ee009a256c5a87162d5661a5e7a9a8074132b68dd9eff287ab24c3ebd45afc068e2e88fd368df89ade533f
+  metadata.gz: 160d6cebdbe86f5a0e44434a8c87293b1e680940420bcced8caa12059461d21991b3be15b1f59bbcd95d238b511d6484452c181ce6ba88dce7b7c97f83eb4382
+  data.tar.gz: b6f36b5d3aba61b1c9a7ef755ced8d92fc61be0a911a3f4dc8487fb896740624910463c2f21681bd2bb73ae145e28c7293e69fd0de3aa8ce4240c5dde614d8b0

data/ext/dep_gecode/dep_selector_to_gecode.cpp

@@ -100,9 +100,10 @@ void VersionProblemPool::DeleteAll()
 
 int VersionProblem::instance_counter = 0;
 
-VersionProblem::VersionProblem(int packageCount, bool dumpStats, bool debug, const char * logId)
+VersionProblem::VersionProblem(int packageCount, bool dumpStats, bool debug, const char * logId,
+    unsigned long int _timeout)
     : size(packageCount), version_constraint_count(0), dump_stats(dumpStats),
-      debugLogging(debug), 
+      debugLogging(debug), timeout(_timeout), solutionState(SOLUTION_STATE_UNSTARTED),
       finalized(false), cur_package(0), package_versions(*this, packageCount),
       disabled_package_variables(*this, packageCount, 0, 1), total_disabled(*this, 0, packageCount*MAX_TRUST_LEVEL),
       total_required_disabled(*this, 0, packageCount), total_induced_disabled(*this, 0, packageCount),
@@ -128,16 +129,16 @@ VersionProblem::VersionProblem(int packageCount, bool dumpStats, bool debug, con
     if (debugLogging) {
         DEBUG_STREAM << std::endl;
         DEBUG_STREAM << debugPrefix << "Creating VersionProblem inst# " << instance_id << " with " << packageCount << " packages, "
-                     << dumpStats << " stats, " << debug << " debug" << std::endl;
+                     << dumpStats << " stats, " << debug << " debug " << timeout << " timeout" << std::endl;
         DEBUG_STREAM.flush();
     }
 }
 
 VersionProblem::VersionProblem(bool share, VersionProblem & s)
     : Space(share, s),
-      size(s.size), version_constraint_count(s.version_constraint_count), 
-      dump_stats(s.dump_stats), 
-      debugLogging(s.debugLogging), 
+      size(s.size), version_constraint_count(s.version_constraint_count),
+      dump_stats(s.dump_stats),
+      debugLogging(s.debugLogging), timeout(s.timeout), solutionState(s.solutionState),
       finalized(s.finalized), cur_package(s.cur_package),
       disabled_package_variables(s.disabled_package_variables), total_disabled(s.total_disabled),
       total_required_disabled(s.total_required_disabled), total_induced_disabled(s.total_induced_disabled),
@@ -204,10 +205,10 @@ VersionProblem::AddPackage(int minVersion, int maxVersion, int currentVersion)
     }
 
     if (debugLogging) {
-        sprintf(outputBuffer, "%s DepSelector inst# %d - Adding package id %d/%d: min = %d, max = %d, current version %d",
+        sprintf(outputBuffer, "%sDepSelector inst# %d - Adding package id %d/%d: min = %d, max = %d, current version %d\n",
                 debugPrefix, instance_id, cur_package, size, minVersion, maxVersion, currentVersion);
         DEBUG_STREAM << outputBuffer;
-//        DEBUG_STREAM << debugPrefix << "DepSelector inst# " << instance_id 
+//        DEBUG_STREAM << debugPrefix << "DepSelector inst# " << instance_id
 //                     << " - Adding package id " << cur_package << '/' << size << ": min = " << minVersion << ", max = " << maxVersion << ", current version " << currentVersion << std::endl;
         DEBUG_STREAM.flush();
     }
@@ -232,10 +233,10 @@ VersionProblem::AddVersionConstraint(int packageId, int version,
 
     version_constraint_count++;
     if (debugLogging) {
-        sprintf(outputBuffer, "%sDepSelector inst# %d - Adding VC for %d @ %d depPkg %d [%d, %d]",
+        sprintf(outputBuffer, "%sDepSelector inst# %d - Adding VC for %d @ %d depPkg %d [%d, %d]\n",
                 debugPrefix, instance_id, packageId, version, dependentPackageId, minDependentVersion, maxDependentVersion);
         DEBUG_STREAM << outputBuffer;
-//        DEBUG_STREAM << debugPrefix << "DepSelector inst# " << instance_id 
+//        DEBUG_STREAM << debugPrefix << "DepSelector inst# " << instance_id
 //                     << " - Adding VC for " << packageId << " @ " << version << " depPkg " << dependentPackageId
 //                     << " [ " << minDependentVersion << ", " << maxDependentVersion << " ]" << std::endl;
         DEBUG_STREAM.flush();
@@ -270,7 +271,7 @@ VersionProblem::MarkPackageSuspicious(int packageId)
         sprintf(outputBuffer, "%sDepSelector inst# %d - Marking Package Suspicious %d",
                 debugPrefix, instance_id, packageId);
         DEBUG_STREAM << outputBuffer;
-//        DEBUG_STREAM << debugPrefix << "DepSelector inst# " << instance_id 
+//        DEBUG_STREAM << debugPrefix << "DepSelector inst# " << instance_id
 //                     << " - Marking Package Suspicious " << packageId << std::endl;
         DEBUG_STREAM.flush();
     }
@@ -283,7 +284,7 @@ VersionProblem::MarkPackageRequired(int packageId)
 
     if (debugLogging) {
         sprintf(outputBuffer, "%sDepSelector inst# %d - Marking Package Required %d", debugPrefix, instance_id, packageId);
-        DEBUG_STREAM << debugPrefix << "DepSelector inst# " << instance_id 
+        DEBUG_STREAM << debugPrefix << "DepSelector inst# " << instance_id
                      << " - Marking Package Required " << packageId << std::endl;
         DEBUG_STREAM.flush();
     }
@@ -297,7 +298,7 @@ VersionProblem::MarkPackagePreferredToBeAtLatest(int packageId, int weight)
     if (debugLogging) {
         sprintf(outputBuffer, "%sDepSelector inst# %d - Marking Package Preferred Latest %d weight %d",
                 debugPrefix, instance_id, packageId, weight);
-        DEBUG_STREAM << debugPrefix << "DepSelector inst# " << instance_id 
+        DEBUG_STREAM << debugPrefix << "DepSelector inst# " << instance_id
                      << " - Marking Package Preferred Latest " << packageId << " weight " << weight << std::endl;
         DEBUG_STREAM.flush();
     }
@@ -310,6 +311,7 @@ void VersionProblem::Finalize()
         DEBUG_STREAM.flush();
     }
     finalized = true;
+    solutionState = SOLUTION_STATE_FINALIZED;
 
     // Setup constraint for cost
     // We wish to minimize the total number of disabled packages, by priority ranks
@@ -381,11 +383,51 @@ void VersionProblem::Finalize()
     }
 
 #ifdef USE_DUMB_BRANCHING
+    AddBrancherPoor(DEBUG_STREAM);
+#else // USE_DUMB_BRANCHING
+    AddBrancherV2(DEBUG_STREAM);
+#endif // USE_DUMB_BRANCHING
+
+    if (debugLogging) {
+        DEBUG_STREAM << debugPrefix << "Finalization Done" << std::endl;
+        DEBUG_STREAM.flush();
+    }
+}
+
+// GECODE VERSION NUMBER is 100000 * x + 100 * y + z for version x.y.z
+#ifndef GECODE_VERSION_3
+#undef INT_VAL_MAX
+#undef INT_VAL_MIN
+#undef INT_VAR_DEGREE_MAX
+#undef INT_VAR_DEGREE_MIN
+#undef INT_VAR_SIZE_MAX
+#undef INT_VAR_SIZE_MIN
+
+#define INT_VAL_MAX INT_VAL_MAX()
+#define INT_VAL_MIN INT_VAL_MIN()
+#define INT_VAR_DEGREE_MAX INT_VAR_DEGREE_MAX()
+#define INT_VAR_DEGREE_MIN INT_VAR_DEGREE_MINX()
+#define INT_VAR_SIZE_MAX INT_VAR_SIZE_MAX()
+#define INT_VAR_SIZE_MIN INT_VAR_SIZE_MIN()
+
+#endif
+
+// Define various branchers:
+//
+// The ordering here is important; we make variable choices in
+// order that the branchings are listed, and a bad variable choice
+// can be orders of magnitude slower to solve. In general we want to
+// choose variables that generate lots of propagations; each variable
+// choice can involve a backtrack, so the bias is towards maximizing the
+// bindings induced by a choice.
+
+// This branching starts as far as possible from the solution, in order to exercise the optimization functions.
+void VersionProblem::AddBrancherPoor(std::ostream & o) {
     if (debugLogging) {
         DEBUG_STREAM << debugPrefix << "    Adding branching (POOR)" << std::endl;
         DEBUG_STREAM.flush();
     }
-    // This branching starts as far as possible from the solution, in order to exercise the optimization functions.
+
     branch(*this, disabled_package_variables, INT_VAR_SIZE_MIN, INT_VAL_MAX);
     branch(*this, package_versions, INT_VAR_SIZE_MIN, INT_VAL_MIN);
     branch(*this, total_required_disabled, INT_VAL_MAX);
@@ -395,12 +437,19 @@ void VersionProblem::Finalize()
     branch(*this, at_latest, INT_VAR_SIZE_MIN, INT_VAL_MIN);
     branch(*this, total_preferred_at_latest, INT_VAL_MIN);
     branch(*this, total_not_preferred_at_latest, INT_VAL_MIN);
-#else // USE_DUMB_BRANCHING
+}
+
+// This is the 'classic' brancher that's been used since 2012. Has
+// some pathological solves
+void VersionProblem::AddBrancherOriginal(std::ostream & o) {
     if (debugLogging) {
-        DEBUG_STREAM << debugPrefix << "    Adding branching (BEST)" << std::endl;
+        DEBUG_STREAM << debugPrefix << "    Adding branching (ORIGINAL)" << std::endl;
         DEBUG_STREAM.flush();
     }
     // This branching is meant to start with most probable solution
+    // The ordering here is important; we make variable choices in
+    // order that the branchings are listed, and a bad variable choice
+    // can be orders of magnitude slower to solve.
     branch(*this, disabled_package_variables, INT_VAR_SIZE_MIN, INT_VAL_MIN);
     branch(*this, package_versions, INT_VAR_SIZE_MIN, INT_VAL_MAX);
     branch(*this, total_required_disabled, INT_VAL_MIN);
@@ -410,12 +459,50 @@ void VersionProblem::Finalize()
     branch(*this, at_latest, INT_VAR_SIZE_MIN, INT_VAL_MAX);
     branch(*this, total_preferred_at_latest, INT_VAL_MAX);
     branch(*this, total_not_preferred_at_latest, INT_VAL_MAX);
-#endif // USE_DUMB_BRANCHING
+}
 
-    if (debugLogging) {
-        DEBUG_STREAM << debugPrefix << "Finalization Done" << std::endl;
+// This is the minimal tweak to the 'classic' brancher that avoids the solves.
+void VersionProblem::AddBrancherV2(std::ostream & o) {
+     if (debugLogging) {
+        DEBUG_STREAM << debugPrefix << "    Adding branching (V2)" << std::endl;
         DEBUG_STREAM.flush();
     }
+    // This branching is meant to start with most probable solution
+    // The ordering here is important; we make variable choices in
+    // order that the branchings are listed, and a bad variable choice
+    // can be orders of magnitude slower to solve.
+    branch(*this, disabled_package_variables, INT_VAR_SIZE_MIN, INT_VAL_MIN);
+    // Using INT_VAR_SIZE_MIN (what old versions do; can cause 12E3 x slowdown)
+    branch(*this, package_versions, INT_VAR_DEGREE_MAX, INT_VAL_MAX);
+    branch(*this, total_required_disabled, INT_VAL_MIN);
+    branch(*this, total_induced_disabled, INT_VAL_MIN);
+    branch(*this, total_suspicious_disabled, INT_VAL_MIN);
+    branch(*this, total_disabled, INT_VAL_MIN);
+    branch(*this, at_latest, INT_VAR_SIZE_MIN, INT_VAL_MAX);
+    branch(*this, total_preferred_at_latest, INT_VAL_MAX);
+    branch(*this, total_not_preferred_at_latest, INT_VAL_MAX);
+}
+
+// This behaves better on some problems, and worse on others; still
+// figuring out why. Behaves very well on gecode 4.x
+void VersionProblem::AddBrancherAtLatest(std::ostream & o) {
+     if (debugLogging) {
+        DEBUG_STREAM << debugPrefix << "    Adding branching (AtLatest)" << std::endl;
+        DEBUG_STREAM.flush();
+    }
+    // We total preferred at latest at maximum first, to trigger as much
+    // propagation as possible, followed by all other packages at
+    // latest in order of degree (# of constraints related to this variable)
+    //
+    branch(*this, package_versions, INT_VAR_DEGREE_MAX, INT_VAL_MAX);
+    branch(*this, at_latest, INT_VAR_DEGREE_MAX, INT_VAL_MAX);
+    branch(*this, disabled_package_variables, INT_VAR_SIZE_MIN, INT_VAL_MIN);
+    branch(*this, total_preferred_at_latest, INT_VAL_MAX);
+    branch(*this, total_disabled, INT_VAL_MIN);
+    branch(*this, total_required_disabled, INT_VAL_MIN);
+    branch(*this, total_induced_disabled, INT_VAL_MIN);
+    branch(*this, total_suspicious_disabled, INT_VAL_MIN);
+    branch(*this, total_not_preferred_at_latest, INT_VAL_MAX);
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -490,6 +577,7 @@ void VersionProblem::constrain(const Space & _best_known_solution)
     IntVarArgs best(5);
     BuildCostVector(current);
     best_known_solution.BuildCostVector(best);
+//    rel(*this, best, IRT_LE, current);
     ConstrainVectorLessThanBest(current, best);
 }
 #endif // VECTOR_CONSTRAIN
@@ -502,7 +590,34 @@ void VersionProblem::BuildCostVector(IntVarArgs & costVector) const {
     costVector[4] = total_required_disabled;
 }
 
+// We want to sort vectors
+// This constrains current to be less than best by a process analogous to subtraction
+// we compute current - best, pairwise with borrows from less significant elements. We require it to be less than zero by requiring the most
+// significant element to generate a borrow.
+//
+// DEPRECATED; remove once replacement is validated
+void VersionProblem::ConstrainVectorLessThanBest(IntVarArgs & current, IntVarArgs & best) {
+    BoolVarArray borrow(*this, current.size()+1, 0, 1);
 
+    // No borrows can happen at the least significant element.
+    rel(*this, borrow[0], IRT_EQ, 0);
+
+    for (int i = 0; i < current.size(); i++) {
+        // If best+borrow is greater than current (equivalently current-(best+borrow) is < 0) then a more significant element
+        // must have decreased, so we propagate a borrow to the next most significant element.
+        int best_val = best[i].val();
+        IntVar delta = expr(*this, current[i] - best_val - borrow[i]);
+        // (delta < 0) <=> borrow[i+1]
+        rel(*this, delta, IRT_LE, 0, borrow[i+1]);
+        if (debugLogging) {
+            DEBUG_STREAM << debugPrefix << "      ConstrainVector: borrow[" << i+1 << "] " << borrow[i+1] << ",\tdelta " << delta << std::endl;
+            DEBUG_STREAM << debugPrefix << "      ConstrainVector: current[" << i << "] " << current[i] << ",\tbest_val " << best_val << std::endl;
+        }
+    }
+
+    // must borrow off past the most significant element.
+    rel(*this, borrow[current.size()], IRT_EQ, 1);
+}
 
 IntVar * VersionProblem::GetPackageVersionVar(int packageId)
 {
@@ -546,6 +661,16 @@ int VersionProblem::GetDisabledVariableCount()
     }
 }
 
+void VersionProblem::SetTimeout(unsigned long int _timeout)
+{
+    timeout = _timeout;
+}
+
+int VersionProblem::GetSolutionState()
+{
+    return solutionState;
+}
+
 
 // Utility
 void VersionProblem::Print(std::ostream & out)
@@ -580,88 +705,124 @@ bool VersionProblem::CheckPackageId(int id)
     return (id < size);
 }
 
-// We want to sort vectors
-// This constrains current to be less than best by a process analogous to subtraction
-// we compute current - best, pairwise with borrows from less significant elements. We require it to be less than zero by requiring the most
-// significant element to generate a borrow.
-//
-void VersionProblem::ConstrainVectorLessThanBest(IntVarArgs & current, IntVarArgs & best) {
-    BoolVarArray borrow(*this, current.size()+1, 0, 1);
-
-    // No borrows can happen at the least significant element.
-    rel(*this, borrow[0], IRT_EQ, 0);
-
-    for (int i = 0; i < current.size(); i++) {
-        // If best+borrow is greater than current (equivalently current-(best+borrow) is < 0) then a more significant element
-        // must have decreased, so we propagate a borrow to the next most significant element.
-        int best_val = best[i].val();
-        IntVar delta = expr(*this, current[i] - best_val - borrow[i]);
-        // (delta < 0) <=> borrow[i+1]
-        rel(*this, delta, IRT_LE, 0, borrow[i+1]);
-        if (debugLogging) {
-            DEBUG_STREAM << debugPrefix << "      ConstrainVector: borrow[" << i+1 << "] " << borrow[i+1] << ",\tdelta " << delta << std::endl;
-            DEBUG_STREAM << debugPrefix << "      ConstrainVector: current[" << i << "] " << current[i] << ",\tbest_val " << best_val << std::endl;
-        }
-    }
-
-    // must borrow off past the most significant element.
-    rel(*this, borrow[current.size()], IRT_EQ, 1);
-}
-
-VersionProblem * VersionProblem::InnerSolve(VersionProblem * problem, int &itercount)
+int VersionProblem::InnerSolve(VersionProblem * problem, int &itercount, VersionProblem** best_solution)
 {
-    Gecode::Support::Timer timer;
-    timer.start();
-
 #ifdef MEMORY_DEBUG
     DEBUG_STREAM << "Creating solver" << std::endl << std::flush;
 #endif
-    VersionProblem *best_solution = NULL;
-    Restart<VersionProblem> solver(problem);
+    Gecode::Support::Timer timer;
+    timer.start();
+    *best_solution = NULL;
+    int result_code = SOLUTION_STATE_FAILED;
+
+    // This needs to accumulate over multiple steps.
+    Search::TimeStop timeStop(problem->timeout);
+    Search::Options options;
+    options.stop = &timeStop;
+
+#ifdef GECODE_VERSION_3
+    // Restart strategy starts branching from scratch. BNB adds the
+    // constraint but keeps on going from where it was currently.
+    Restart<VersionProblem> solver(problem, options);
+#else
+    options.cutoff = Search::Cutoff::geometric();
+    RBS<DFS, VersionProblem> solver(problem, options);
+#endif
+
 
 #ifdef MEMORY_DEBUG
     DEBUG_STREAM << "Starting Solve" << std::endl << std::flush;
 #endif
 
-    while (VersionProblem *solution = solver.next())
-        {
+    // Iterate over solutions; each call to solver.next creates a new
+    // copy of the problem, and constrains it to be better than the
+    // last solution. Null is returned if no solution is found.
+    while (VersionProblem *solution = solver.next()) {
+
 #ifdef MEMORY_DEBUG
-            DEBUG_STREAM << "Solver Next " << solution << std::endl << std::flush;
+        DEBUG_STREAM << "Solver Next " << solution << std::endl << std::flush;
 #endif
-            if (best_solution != NULL)
-                {
-                    delete best_solution;
-                }
-            best_solution = solution;
-            ++itercount;
-            if (problem->debugLogging) {
-                DEBUG_STREAM << problem->debugPrefix << "Trial Solution #" << itercount << "===============================" << std::endl;
-                const Search::Statistics & stats = solver.statistics();
-                DEBUG_STREAM << problem->debugPrefix << "Solver stats: Prop:" << stats.propagate << " Fail:" << stats.fail << " Node:" << stats.node;
-                DEBUG_STREAM << " Depth:" << stats.depth << " memory:" << stats.memory << std::endl;
-                solution->Print(DEBUG_STREAM);
-            }
+        delete *best_solution;
+        *best_solution = solution;
+
+        ++itercount;
+        const Search::Statistics & stats = solver.statistics();
+        DebugLogStep(solution, itercount, stats);
+    }
+
+    // Solve with GIST:
+    VersionProblem * last = *best_solution ? *best_solution : problem;
+    last->GistSolveStep();
+
+    // If we fail to find a solution in time we treat it as no
+    // solution. We could return a special token to differentiate a
+    // timeout, but that could cause problems for the FFI interface.
+    if (solver.stopped()) {
+        result_code = SOLUTION_STATE_TIMED_OUT;
+        if (problem->debugLogging) {
+            DEBUG_STREAM << problem->debugPrefix << "Solver FAILED: timed out with timeout set to "
+                         << problem->timeout << " ms" << std::endl;
+            const Search::Statistics & stats = solver.statistics();
+            LogStats(DEBUG_STREAM, problem->debugPrefix, stats);
         }
 
+    } else if (*best_solution) {
+        result_code = SOLUTION_STATE_OPTIMAL;
+    } else {
+        result_code = SOLUTION_STATE_FAILED;
+    }
+
     double elapsed_time = timer.stop();
 
     if (problem->dump_stats) {
-        if (problem->debugLogging) std::cerr << problem->debugPrefix;
-        std::cerr << "dep_selector solve: ";
-        std::cerr << (best_solution ? "SOLVED" : "FAILED") << " ";
-        std::cerr << problem->size << " packages, " << problem->version_constraint_count << " constraints, ";
-        std::cerr << "Time: " << elapsed_time << "ms ";
         const Search::Statistics & final_stats = solver.statistics();
-        std::cerr << "Stats: " << itercount << " steps, ";
-        std::cerr << final_stats.memory << " bytes, ";
-        std::cerr << final_stats.propagate << " props, " << final_stats.node << " nodes, " << final_stats.depth << " depth ";
-        std::cerr << std::endl << std::flush;
+        DebugLogFinal(problem, itercount, elapsed_time, final_stats, result_code);
     }
 
-    return best_solution;
+    return result_code;
 }
 
-VersionProblem * VersionProblem::Solve(VersionProblem * problem)
+void VersionProblem::GistSolveStep() {
+#ifdef GIST_ENABLED
+    VersionProblem * trial = dynamic_cast<VersionProblem*>(this->copy(false));
+    trial->constrain(*this);
+    Gist::Options options;
+    Gist::dfs(trial, options);
+    delete trial;
+#endif
+}
+
+void VersionProblem::LogStats(std::ostream & o, const char * debugPrefix, const Search::Statistics & stats) {
+    o << debugPrefix << "Solver stats: Prop:" << stats.propagate << " Fail:" << stats.fail << " Node:" << stats.node;
+    o << " Depth:" << stats.depth;
+#ifdef GECODE_VERSION_3
+    o << " memory:" << stats.memory;
+#endif // GECODE_VERSION_3
+    o << std::endl;
+}
+
+void VersionProblem::DebugLogStep(VersionProblem *problem, int itercount, const Search::Statistics & stats) {
+     if (problem->debugLogging) {
+         DEBUG_STREAM << problem->debugPrefix << "Trial Solution #" << itercount << "===============================" << std::endl;
+         LogStats(DEBUG_STREAM, problem->debugPrefix, stats);
+         problem->Print(DEBUG_STREAM);
+     }
+}
+
+void VersionProblem::DebugLogFinal(VersionProblem *problem, int itercount, double elapsed_time, const Search::Statistics & stats, int solutionState) {
+     if (problem->debugLogging) std::cerr << problem->debugPrefix;
+     std::cerr << "dep_selector solve: ";
+     std::cerr << ((solutionState == SOLUTION_STATE_OPTIMAL) ? "SOLVED" : "FAILED") << " ";
+     std::cerr << problem->size << " packages, " << problem->version_constraint_count << " constraints, ";
+     std::cerr << "Time: " << elapsed_time << "ms ";
+
+     std::cerr << "Stats: " << itercount << " steps, ";
+     LogStats(std::cerr, (problem->debugLogging ? problem->debugPrefix : ""), stats);
+     std::cerr << std::flush;
+}
+
+
+int VersionProblem::Solve(VersionProblem * problem, VersionProblem ** solution)
 {
 
     problem->Finalize();
@@ -676,19 +837,19 @@ VersionProblem * VersionProblem::Solve(VersionProblem * problem)
     }
     int itercount = 0;
 
-    VersionProblem *best_solution = InnerSolve(problem, itercount);
+    int result_code = InnerSolve(problem, itercount, solution);
 
     if (problem->debugLogging) {
-        DEBUG_STREAM << problem->DebugPrefix() << "Solver Best Solution " << best_solution << std::endl << std::flush;
+        DEBUG_STREAM << problem->DebugPrefix() << "Solver Best Solution " << *solution << std::endl << std::flush;
     }
 
-    pool->Delete(best_solution);
+    pool->Delete(*solution);
     problem->pool = 0;
 
     pool->DeleteAll();
     delete pool;
 
-    return best_solution;
+    return result_code;
 }
 
 //

data/ext/dep_gecode/dep_selector_to_gecode.h

@@ -21,13 +21,18 @@
 #define dep_selector_to_gecode_h
 
 #include "dep_selector_to_gecode_interface.h"
-#include <iostream>	       
+#include <iostream>
 #include <vector>
 #include <set>
 
 #include <gecode/driver.hh>
 #include <gecode/int.hh>
 #include <gecode/minimodel.hh>
+#include <gecode/support.hh>
+
+#if GECODE_VERSION_NUMBER < 400000
+#define GECODE_VERSION_3
+#endif
 
 using namespace Gecode;
 
@@ -39,10 +44,10 @@ using namespace Gecode;
 
 // Extend:
 // Add optimization functions
-// Allow non-contiguous ranges in package dependencies. 
+// Allow non-contiguous ranges in package dependencies.
 
-// TODO: Add locking 
-struct VersionProblemPool 
+// TODO: Add locking
+struct VersionProblemPool
 {
     std::set<VersionProblem *> elems;
     VersionProblemPool();
@@ -59,15 +64,16 @@ class VersionProblem : public Space
 {
 public:
   static const int UNRESOLVED_VARIABLE;
-  static const int MIN_TRUST_LEVEL;  
+  static const int MIN_TRUST_LEVEL;
   static const int MAX_TRUST_LEVEL;
   static const int MAX_PREFERRED_WEIGHT;
 
   static int instance_counter;
 
-    VersionProblem(int packageCount, bool dumpStats = true, 
-                   bool debug = false, 
-                   const char * logId = 0);
+  VersionProblem(int packageCount, bool dumpStats = true,
+                 bool debug = false,
+                 const char * logId = 0,
+                 unsigned long int _timeout = 10000);
   // Clone constructor; check gecode rules for this...
   VersionProblem(bool share, VersionProblem & s);
   virtual ~VersionProblem();
@@ -80,20 +86,20 @@ public:
   virtual int AddPackage(int minVersion, int maxVersion, int currentVersion);
 
   virtual void AddVersionConstraint(int packageId, int version,
-			    int dependentPackageId, int minDependentVersion, int maxDependentVersion);
+                            int dependentPackageId, int minDependentVersion, int maxDependentVersion);
 
-  // We may wish to indicate that some packages have suspicious constraints, and when chosing packages to disable we 
-  // would disable them first. 
+  // We may wish to indicate that some packages have suspicious constraints, and when chosing packages to disable we
+  // would disable them first.
   void MarkPackageSuspicious(int packageId);
 
-  void MarkPackageRequired(int packageId); 
+  void MarkPackageRequired(int packageId);
 
   // Packages marked by this method are preferentially chosen at
   // latest according to weights
   void MarkPackagePreferredToBeAtLatest(int packageId, int weight);
 
   void Finalize();
-  
+
   virtual void constrain(const Space & _best_known_solution);
 
   int GetPackageVersion(int packageId);
@@ -101,17 +107,27 @@ public:
   int GetMax(int packageId);
   int GetMin(int packageId);
   int GetDisabledVariableCount();
-  
+
+  void SetTimeout(unsigned long int _timeout);
+  int GetSolutionState();
+
   // Support for gecode
   virtual Space* copy(bool share);
 
   // Debug and utility functions
   void Print(std::ostream &out);
   void PrintPackageVar(std::ostream & out, int packageId) ;
+  void GistSolveStep();
+
   const char * DebugPrefix() const { return debugPrefix; }
 
-  static VersionProblem *InnerSolve(VersionProblem * problem, int & itercount);
-  static VersionProblem *Solve(VersionProblem *problem);
+  static int InnerSolve(VersionProblem * problem, int & itercount, VersionProblem** solution);
+
+  static void DebugLogStep(VersionProblem *problem, int itercount, const Search::Statistics & stats);
+  static void LogStats(std::ostream & o, const char * debugPrefix, const Search::Statistics & stats);
+  static void DebugLogFinal(VersionProblem *problem, int itercount, double elapsed_time, const Search::Statistics & stats, int solutionState);
+
+  static int Solve(VersionProblem *problem, VersionProblem**solution);
 
  protected:
   int instance_id;
@@ -122,6 +138,9 @@ public:
   bool debugLogging;
   char debugPrefix[DEBUG_PREFIX_LENGTH];
   char outputBuffer[1024];
+  unsigned long int timeout;
+  int solutionState;
+
   bool finalized;
 
   BoolVarArgs version_flags;
@@ -147,19 +166,16 @@ public:
   void AddPackagesPreferredToBeAtLatestObjectiveFunction(const VersionProblem & best_known_solution);
   void ConstrainVectorLessThanBest(IntVarArgs & current, IntVarArgs & best);
   void BuildCostVector(IntVarArgs & costVector) const;
- 
+
+  void AddBrancherPoor(std::ostream & o);
+  void AddBrancherOriginal(std::ostream & o);
+  void AddBrancherV2(std::ostream & o);
+  void AddBrancherAtLatest(std::ostream & o);
+
   friend class VersionProblemPool;
 };
 
 template<class T> void PrintVarAligned(const char * message, T & var);
 template<class S, class T> void PrintVarAligned(const char * message, S & var1, T & var2);
 
-class Solver {
- public:
-  Solver(VersionProblem *s);
-  VersionProblem GetNextSolution();
- private:
-  Restart<VersionProblem> solver;
-};
-
 #endif // dep_selector_to_gecode_h

data/ext/dep_gecode/dep_selector_to_gecode_interface.cpp

@@ -30,9 +30,10 @@
 
 // FFI friendly
 VersionProblem * VersionProblemCreate(int packageCount, bool dump_stats,
-                                      bool debug, const char * logId) 
+                                      bool debug, const char * logId,
+                                      unsigned long int _timeout)
 {
-  return new VersionProblem(packageCount, dump_stats, debug, logId);
+  return new VersionProblem(packageCount, dump_stats, debug, logId, _timeout);
 }
 
 void VersionProblemDestroy(VersionProblem * p)
@@ -40,12 +41,12 @@ void VersionProblemDestroy(VersionProblem * p)
   delete p;
 }
 
-int VersionProblemSize(VersionProblem *p) 
+int VersionProblemSize(VersionProblem *p)
 {
   return p->Size();
 }
 
-int VersionProblemPackageCount(VersionProblem *p) 
+int VersionProblemPackageCount(VersionProblem *p)
 {
   return p->PackageCount();
 }
@@ -58,7 +59,7 @@ void VersionProblemDump(VersionProblem *p)
   std::cout.flush();
 }
 
-void VersionProblemPrintPackageVar(VersionProblem *p, int packageId) 
+void VersionProblemPrintPackageVar(VersionProblem *p, int packageId)
 {
   p->PrintPackageVar(std::cout, packageId);
   std::cout.flush();
@@ -68,16 +69,16 @@ void VersionProblemPrintPackageVar(VersionProblem *p, int packageId)
 int AddPackage(VersionProblem *problem, int min, int max, int currentVersion) {
   return problem->AddPackage(min,max,currentVersion);
 }
-// Add constraint for package pkg @ version, 
+// Add constraint for package pkg @ version,
 // that dependentPackage is at version [minDependentVersion,maxDependentVersion]
 // Returns false if system becomes insoluble.
 void AddVersionConstraint(VersionProblem *problem, int packageId, int version,
-			  int dependentPackageId, int minDependentVersion, int maxDependentVersion) 
+                          int dependentPackageId, int minDependentVersion, int maxDependentVersion)
 {
   return problem->AddVersionConstraint(packageId, version, dependentPackageId, minDependentVersion, maxDependentVersion);
 }
 
-void MarkPackageSuspicious(VersionProblem *problem, int packageId) 
+void MarkPackageSuspicious(VersionProblem *problem, int packageId)
 {
   return problem->MarkPackageSuspicious(packageId);
 }
@@ -117,7 +118,16 @@ int GetDisabledVariableCount(VersionProblem *problem)
   return problem->GetDisabledVariableCount();
 }
 
+void SetTimeout(VersionProblem *problem, unsigned long int timeout)
+{
+    problem->SetTimeout(timeout);
+}
+
+int GetSolutionState(VersionProblem * problem)
+{
+    return problem->GetSolutionState();
+}
 
-VersionProblem * Solve(VersionProblem * problem)  {
-  return VersionProblem::Solve(problem);
+int Solve(VersionProblem * problem, VersionProblem ** solution)  {
+    return VersionProblem::Solve(problem, solution);
 }

data/ext/dep_gecode/dep_selector_to_gecode_interface.h

@@ -25,6 +25,15 @@
 extern "C" {
 #endif // __cplusplus
 
+#define SOLUTION_STATE_FAILED    0
+#define SOLUTION_STATE_UNSTARTED 1
+#define SOLUTION_STATE_FINALIZED 2
+#define SOLUTION_STATE_SOLVED    3
+#define SOLUTION_STATE_TIMED_OUT 4
+#define SOLUTION_STATE_OPTIMAL   5
+
+
+
 #ifdef __cplusplus
   class VersionProblem;
 #else
@@ -32,7 +41,8 @@ extern "C" {
 #endif // __cplusplus
 
   VersionProblem * VersionProblemCreate(int packageCount, bool dumpStats,
-                                        bool debug, const char * logId);
+                                        bool debug, const char * logId,
+                                        unsigned long int timeout);
   void VersionProblemDestroy(VersionProblem * vp);
 
 
@@ -41,11 +51,11 @@ extern "C" {
 
   // Return ID #
   int AddPackage(VersionProblem *problem, int min, int max, int currentVersion);
-  // Add constraint for package pkg @ version, 
+  // Add constraint for package pkg @ version,
   // that dependentPackage is at version [minDependentVersion,maxDependentVersion]
   // Returns false if system becomes insoluble.
   void AddVersionConstraint(VersionProblem *problem, int packageId, int version,
-			    int dependentPackageId, int minDependentVersion, int maxDependentVersion);
+                            int dependentPackageId, int minDependentVersion, int maxDependentVersion);
 
   void MarkPackageSuspicious(VersionProblem *problem, int packageId);
   void MarkPackageRequired(VersionProblem *problem, int packageId);
@@ -59,10 +69,13 @@ extern "C" {
 
   int GetDisabledVariableCount(VersionProblem *problem);
 
+  void SetTimeout(VersionProblem *problem, unsigned long int timeout);
+  int GetSolutionState(VersionProblem *problem);
+
   void VersionProblemDump(VersionProblem * problem);
   void VersionProblemPrintPackageVar(VersionProblem * problem, int packageId);
 
-  VersionProblem * Solve(VersionProblem * problem);
+  int Solve(VersionProblem * problem, VersionProblem** solution);
 
 #ifdef __cplusplus
 }

data/lib/dep_selector.rb

@@ -17,6 +17,7 @@
 # limitations under the License.
 #
 
+require 'dep_selector/debug.rb'
 require 'dep_selector/dep_selector_version'
 
 require 'dep_selector/selector'

data/lib/dep_selector/debug.rb

@@ -0,0 +1,29 @@
+#
+# Author:: Salim Alam (<salam@chef.io>)
+# Copyright:: Copyright (c) 2016 Chef, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'logger'
+
+module DepSelector
+  class Debug
+    class << self
+      def log
+        @logger ||= Logger.new(STDOUT)
+      end
+    end
+  end
+end

data/lib/dep_selector/dep_gecode.rb

@@ -38,9 +38,9 @@ module Dep_gecode
 
   ffi_lib path
 
-  # VersionProblem * VersionProblemCreate(int packageCount, bool dumpStats, 
-  #                                       bool debug, const char * log_id);
-  attach_function :VersionProblemCreate, [:int, :bool, :bool, :string], :pointer
+  # VersionProblem * VersionProblemCreate(int packageCount, bool dumpStats,
+  #                                       bool debug, const char * log_id, unsigned long int _timeout);
+  attach_function :VersionProblemCreate, [:int, :bool, :bool, :string, :ulong], :pointer
 
   # void VersionProblemDestroy(VersionProblem * vp);
   attach_function :VersionProblemDestroy, [:pointer], :void
@@ -48,7 +48,7 @@ module Dep_gecode
   # int AddPackage(VersionProblem *problem, int min, int max, int currentVersion);
   attach_function :AddPackage, [:pointer, :int, :int, :int], :int
 
-  # int VersionProblemSize(VersionProblem *p); 
+  # int VersionProblemSize(VersionProblem *p);
   attach_function :VersionProblemSize, [:pointer], :int
 
   # void MarkPackagePreferredToBeAtLatest(VersionProblem *problem, int packageId, int weight);
@@ -62,7 +62,7 @@ module Dep_gecode
   attach_function :AddVersionConstraint, [:pointer, :int, :int, :int, :int, :int], :void
 
   # VersionProblem * Solve(VersionProblem * problem);
-  attach_function :Solve, [:pointer], :pointer
+  attach_function :Solve, [:pointer, :pointer], :int
 
   # int GetDisabledVariableCount(VersionProblem *problem);
   attach_function :GetDisabledVariableCount, [:pointer], :int
@@ -84,6 +84,9 @@ module Dep_gecode
 
   # int GetPackageMin(VersionProblem *problem, int packageId);
   attach_function :GetPackageMin, [:pointer, :int], :int
-end
+
+  # void SetTimeout(VersionProblem * problem, unsigned long int);
+  attach_function :SetTimeout, [:pointer, :ulong], :void
 
 
+end

data/lib/dep_selector/dep_selector_version.rb

@@ -1,3 +1,3 @@
 module DepSelector
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

data/lib/dep_selector/dependency_graph.rb

@@ -60,11 +60,17 @@ module DepSelector
             packages.map{ |name, pkg| pkg }
           end
 
+        logId = SecureRandom.uuid
         debugFlag = DebugOptionFile && File::exists?(DebugOptionFile)
+        Debug.log.level = Logger::INFO unless debugFlag
+        Debug.log.formatter = proc do |severity, datetime, progname, msg|
+          "#{logId}: #{msg}\n"
+        end
+
         # In addition to all the packages that the user specified,
         # there is a "ghost" package that contains the solution
         # constraints. See Selector#solve for more information.
-        @gecode_wrapper = GecodeWrapper.new(packages_in_solve.size + 1, debugFlag)
+        @gecode_wrapper = GecodeWrapper.new(packages_in_solve.size + 1, logId, debugFlag)
         packages_in_solve.each{ |pkg| pkg.generate_gecode_wrapper_constraints }
       end
     end

data/lib/dep_selector/gecode_wrapper.rb

@@ -37,17 +37,27 @@ module DepSelector
 
     attr_reader :gecode_problem
     attr_reader :debug_logs_on
+    attr_reader :log_id
+
     DontCareConstraint = -1
     NoMatchConstraint = -2
 
+    # from dep_selector_to_gecode_interface.h
+    SolutionStateUnstarted = 1
+    SolutionStateFinalized =  2
+    SolutionStateSolved = 3
+    SolutionStateTimedOut = 4
+    SolutionStateOptimal = 5
+
     # This insures that we properly deallocate the c++ class at the heart of dep_gecode.
     # modeled after http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/
-    def initialize(problem_or_package_count, debug=false)
+    def initialize(problem_or_package_count, logId, debug=false, timeout = 10000)
       if (problem_or_package_count.is_a?(Numeric))
-        logId = SecureRandom.uuid
         dump_statistics = DepSelector.dump_statistics || debug
+        @log_id = logId
         @debug_logs_on = debug
-        @gecode_problem = Dep_gecode.VersionProblemCreate(problem_or_package_count, dump_statistics, debug, logId)
+        @timeout = timeout
+        @gecode_problem = Dep_gecode.VersionProblemCreate(problem_or_package_count, dump_statistics, debug, logId, @timeout)
       else
         @gecode_problem = problem_or_package_count
       end
@@ -155,11 +165,28 @@ module DepSelector
       Dep_gecode.MarkPackagePreferredToBeAtLatest(gecode_problem, package_id, weight);
     end
 
+    def set_timeout(timeout)
+      raise "Gecode internal failure (set_timeout)" if gecode_problem.nil?
+      Dep_gecode.SetTimeout(gecode_problem, timeout)
+    end
+
+    def get_solution_state()
+      raise "Gecode internal failure (get_solution_state)" if gecode_problem.nil?
+      Dep_gecode.GetSolutionState(gecode_problem);
+    end
+
     def solve()
       raise "Gecode internal failure (solve)" if gecode_problem.nil?
-      solution = GecodeWrapper.new(Dep_gecode.Solve(gecode_problem), debug_logs_on)
+
+      solutionPtr = FFI::MemoryPointer.new :pointer
+      resultCode = Dep_gecode.Solve(gecode_problem, solutionPtr)
+      solutionRaw = solutionPtr.get_pointer(0)
+
+      solution = GecodeWrapper.new(solutionRaw, log_id, debug_logs_on, @timeout)
+
       raise "Gecode internal failure (no solution found)" if (solution.nil?)
 
+      raise Exceptions::TimeBoundExceeded.new() if resultCode == SolutionStateTimedOut
       raise Exceptions::NoSolutionFound.new(solution) if solution.package_disabled_count > 0
       solution
     end

data/lib/dep_selector/package.rb

@@ -37,7 +37,14 @@ module DepSelector
 
     # Note: only invoke this method after all PackageVersions have been added
     def densely_packed_versions
-      @densely_packed_versions ||= DenselyPackedSet.new(versions.map{|pkg_version| pkg_version.version})
+      if @densely_packed_versions.nil?
+        @densely_packed_versions = DenselyPackedSet.new(versions.map{|pkg_version| pkg_version.version})
+        Debug.log.debug { "Package Versions for '#{@name}' :" }
+        versions.each do |v|
+          Debug.log.debug { "    #{v.to_s(true)}" }
+        end
+      end
+      @densely_packed_versions
     end
 
     # Given a version, this method returns the corresonding
@@ -91,7 +98,11 @@ module DepSelector
       # invalid portion of the state space instead of naively limiting
       # it for the purposes of having failure count heuristics?
       max = densely_packed_versions.range.max || -1
-      @gecode_package_id ||= dependency_graph.gecode_wrapper.add_package(-1, max, 0)
+      if @gecode_package_id.nil?
+         @gecode_package_id = dependency_graph.gecode_wrapper.add_package(-1, max, 0)
+         Debug.log.debug { "Adding Package '#{@name}' PackageId: #{@gecode_package_id}" }
+      end
+      @gecode_package_id
     end
 
     def generate_gecode_wrapper_constraints

data/lib/dep_selector/selector.rb

@@ -67,11 +67,9 @@ module DepSelector
       packages_to_include_in_solve = trim_unreachable_packages(dep_graph, solution_constraints)
 
       begin
-        Timeout::timeout(@time_bound, Exceptions::TimeBoundExceeded) do
-          # first, try to solve the whole set of constraints
-          solve(dep_graph.clone, solution_constraints, valid_packages, packages_to_include_in_solve)
-        end
-      rescue Exceptions::NoSolutionFound
+        # first, try to solve the whole set of constraints
+        solve(dep_graph.clone, solution_constraints, valid_packages, packages_to_include_in_solve)
+      rescue Exceptions::NoSolutionFound, Exceptions::TimeBoundExceededNoSolution
         # since we're here, solving the whole system failed, so add
         # the solution_constraints one-by-one and try to solve in
         # order to find the constraint that breaks the system in order
@@ -148,6 +146,7 @@ module DepSelector
       process_soln_constraints(workspace, solution_constraints, valid_packages)
 
       # solve and trim the solution down to only the
+      workspace.gecode_wrapper.set_timeout(@time_bound * 1000)      
       soln = workspace.gecode_wrapper.solve
       trim_solution(solution_constraints, soln, workspace)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dep_selector
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Christopher Walters
@@ -9,76 +9,76 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-22 00:00:00.000000000 Z
+date: 2016-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.9'
 - !ruby/object:Gem::Dependency
   name: dep-selector-libgecode
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.14'
 - !ruby/object:Gem::Dependency
   name: solve
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
 description: Given packages, versions, and a dependency graph, find a valid assignment
@@ -90,13 +90,23 @@ extensions:
 - ext/dep_gecode/extconf.rb
 extra_rdoc_files: []
 files:
+- ext/dep_gecode/define_dummy_init.cxx
+- ext/dep_gecode/dep_gecode-all.def
+- ext/dep_gecode/dep_selector_swig.i
+- ext/dep_gecode/dep_selector_to_gecode.cpp
+- ext/dep_gecode/dep_selector_to_gecode.h
+- ext/dep_gecode/dep_selector_to_gecode_interface.cpp
+- ext/dep_gecode/dep_selector_to_gecode_interface.h
+- ext/dep_gecode/extconf.rb
+- lib/dep_selector.rb
+- lib/dep_selector/debug.rb
 - lib/dep_selector/densely_packed_set.rb
 - lib/dep_selector/dep_gecode.rb
 - lib/dep_selector/dep_selector_version.rb
 - lib/dep_selector/dependency.rb
 - lib/dep_selector/dependency_graph.rb
-- lib/dep_selector/error_reporter/simple_tree_traverser.rb
 - lib/dep_selector/error_reporter.rb
+- lib/dep_selector/error_reporter/simple_tree_traverser.rb
 - lib/dep_selector/exceptions.rb
 - lib/dep_selector/gecode_wrapper.rb
 - lib/dep_selector/package.rb
@@ -105,15 +115,6 @@ files:
 - lib/dep_selector/solution_constraint.rb
 - lib/dep_selector/version.rb
 - lib/dep_selector/version_constraint.rb
-- lib/dep_selector.rb
-- ext/dep_gecode/dep_selector_swig.i
-- ext/dep_gecode/define_dummy_init.cxx
-- ext/dep_gecode/dep_selector_to_gecode.h
-- ext/dep_gecode/dep_selector_to_gecode_interface.h
-- ext/dep_gecode/dep_selector_to_gecode.cpp
-- ext/dep_gecode/dep_selector_to_gecode_interface.cpp
-- ext/dep_gecode/extconf.rb
-- ext/dep_gecode/dep_gecode-all.def
 homepage: http://github.com/opscode/dep-selector
 licenses:
 - Apache v2
@@ -124,19 +125,19 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
 - gecode, version 3.5 or greater
 - g++
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: Given packages, versions, and a dependency graph, find a valid assignment