dep_selector 0.0.4 → 0.0.5

data/ext/dep_gecode/dep_selector_to_gecode.cpp

@@ -29,6 +29,8 @@
 #include <iostream>
 #include <vector>
 
+
+//#define MEMORY_DEBUG
 //#define DEBUG
 //#define USE_DUMB_BRANCHING
 #define VECTOR_CONSTRAIN
@@ -39,6 +41,64 @@ const int VersionProblem::MIN_TRUST_LEVEL = 0;
 const int VersionProblem::MAX_TRUST_LEVEL = 10;
 const int VersionProblem::MAX_PREFERRED_WEIGHT = 10;
 
+VersionProblemPool::VersionProblemPool() : elems() 
+{ }
+
+VersionProblemPool::~VersionProblemPool() 
+{
+    DeleteAll();
+}
+void VersionProblemPool::Add(VersionProblem * vp) 
+{
+    vp->pool = this;
+#ifdef MEMORY_DEBUG
+    std::cout << "Pool add\t" << vp << std::endl << std::flush;
+#endif // MEMORY_DEBUG
+    elems.insert(vp); 
+}
+void VersionProblemPool::Delete(VersionProblem *vp) 
+{ 
+    if (vp->pool != 0) 
+    {
+#ifdef MEMORY_DEBUG
+        std::cout << "Pool del\t" << vp << std::endl << std::flush;
+#endif // MEMORY_DEBUG
+        elems.erase(vp); 
+        vp->pool = 0;
+    }
+}
+void VersionProblemPool::ShowAll() 
+{
+    std::cout << "ShowAll =====================================================" << std::endl << std::flush;
+    std::set<VersionProblem *>::iterator i;
+    for(i = elems.begin(); i != elems.end(); i++) {
+#ifdef MEMORY_DEBUG
+        std::cout << "ShowAll has\t\t\t" << *i << std::endl << std::flush;
+#endif // MEMORY_DEBUG
+    }
+    std::cout << "ShowAll =====================================================" << std::endl << std::flush;
+}
+
+void VersionProblemPool::DeleteAll()
+{
+#ifdef MEMORY_DEBUG
+    ShowAll();
+#endif 
+    std::set<VersionProblem *>::iterator i;
+    for(i = elems.begin(); i != elems.end(); i++) {
+        VersionProblem *vp = *i;
+        vp->pool = 0;
+        delete *i;
+    }
+    elems.clear();
+#ifdef MEMORY_DEBUG
+    std::cout << "DeleteAll ===================================================" << std::endl << std::flush;
+#endif
+}
+
+
+
+
 VersionProblem::VersionProblem(int packageCount, bool dumpStats)
   : size(packageCount), version_constraint_count(0), dump_stats(dumpStats),
     finalized(false), cur_package(0), package_versions(*this, packageCount), 
@@ -51,7 +111,8 @@ VersionProblem::VersionProblem(int packageCount, bool dumpStats)
     // These domains could be narrowed a bit; check later
     total_preferred_at_latest(*this, -packageCount*MAX_PREFERRED_WEIGHT, packageCount*MAX_PREFERRED_WEIGHT), 
     total_not_preferred_at_latest(*this, -packageCount, packageCount), 
-    preferred_at_latest_weights(new int[packageCount])
+    preferred_at_latest_weights(new int[packageCount]),
+    pool(0)
 {
   for (int i = 0; i < packageCount; i++)
   {
@@ -59,6 +120,7 @@ VersionProblem::VersionProblem(int packageCount, bool dumpStats)
     is_required[i] = 0;
     is_suspicious[i] = 0;
   }
+//  std::cout << "C VersionProblem(int,bool)\t" << this << std::endl << std::flush;
 }
 
 VersionProblem::VersionProblem(bool share, VersionProblem & s) 
@@ -72,7 +134,8 @@ VersionProblem::VersionProblem(bool share, VersionProblem & s)
     at_latest(s.at_latest),
     total_preferred_at_latest(s.total_preferred_at_latest), 
     total_not_preferred_at_latest(s.total_preferred_at_latest), 
-    preferred_at_latest_weights(NULL)
+    preferred_at_latest_weights(NULL),
+    pool(s.pool)
 {
   package_versions.update(*this, share, s.package_versions);
   disabled_package_variables.update(*this, share, s.disabled_package_variables);
@@ -83,6 +146,11 @@ VersionProblem::VersionProblem(bool share, VersionProblem & s)
   at_latest.update(*this, share, s.at_latest);
   total_preferred_at_latest.update(*this, share, s.total_preferred_at_latest);
   total_not_preferred_at_latest.update(*this, share, s.total_not_preferred_at_latest);
+
+  pool->Add(this);
+#ifdef MEMORY_DEBUG
+  std::cout << "C VersionProblem(bool, VP)\t" << this << std::endl << std::flush;
+#endif 
 }
 
 // Support for gecode
@@ -96,6 +164,12 @@ VersionProblem::~VersionProblem()
   delete[] preferred_at_latest_weights;
   delete[] is_required;
   delete[] is_suspicious;
+  if (pool!= 0) {
+      pool->Delete(this);
+  }
+#ifdef MEMORY_DEBUG
+  std::cout << "D VersionProblem\t\t" << this << std::endl << std::flush;
+#endif
 }
 
 int VersionProblem::Size() 
@@ -478,59 +552,84 @@ void VersionProblem::ConstrainVectorLessThanBest(IntVarArgs & current, IntVarArg
   rel(*this, borrow[current.size()], IRT_EQ, 1);
 }
 
-VersionProblem * VersionProblem::Solve(VersionProblem * problem) 
+VersionProblem * VersionProblem::InnerSolve(VersionProblem * problem, int &itercount) 
 {
-  problem->Finalize();
-  problem->status();
-#ifdef DEBUG
-  std::cout << "Before solve" << std::endl;
-  problem->Print(std::cout);
-#endif //DEBUG
-  int i = 0;
-
-  Gecode::Support::Timer timer;
-  VersionProblem *best_solution = NULL;
-  timer.start();
+    Gecode::Support::Timer timer;
+    timer.start();
 
-  Restart<VersionProblem> solver(problem);
-  best_solution = NULL;
-
-  while (VersionProblem *solution = solver.next())
+#ifdef MEMORY_DEBUG
+    std::cout << "Creating solver" << std::endl << std::flush;
+#endif
+    VersionProblem *best_solution = NULL;
+    Restart<VersionProblem> solver(problem);
+    
+#ifdef MEMORY_DEBUG
+    std::cout << "Starting Solve" << std::endl << std::flush;
+#endif    
+
+    while (VersionProblem *solution = solver.next())
     {
-      if (best_solution != NULL) 
+#ifdef MEMORY_DEBUG
+        std::cout << "Solver Next " << solution << std::endl << std::flush;
+#endif
+        if (best_solution != NULL) 
         {
-          delete best_solution;
+            delete best_solution;
         }
-      best_solution = solution;
-      ++i;
+        best_solution = solution;
+        ++itercount;
 #ifdef DEBUG
-      std::cout << "Trial Solution #" << i << "===============================" << std::endl;
-      const Search::Statistics & stats = solver.statistics();
-      std::cout << "Solver stats: Prop:" << stats.propagate << " Fail:" << stats.fail << " Node:" << stats.node;
-      std::cout << " Depth:" << stats.depth << " memory:" << stats.memory << std::endl;
-      solution->Print(std::cout);
-#endif //DEBUG
-  }
+        std::cout << "Trial Solution #" << itercount << "===============================" << std::endl;
+        const Search::Statistics & stats = solver.statistics();
+        std::cout << "Solver stats: Prop:" << stats.propagate << " Fail:" << stats.fail << " Node:" << stats.node;
+        std::cout << " Depth:" << stats.depth << " memory:" << stats.memory << std::endl;
+        solution->Print(std::cout);
+#endif //DEBUG  
+    }
 
-  double elapsed_time = timer.stop();
-
-  if (problem->dump_stats) {
-      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: " << i << " steps, " << final_stats.memory << " bytes, ";
-      std::cerr << final_stats.propagate << " props, " << final_stats.node << " nodes, " << final_stats.depth << " depth ";
-      std::cerr << std::endl << std::flush;
-  }
+    double elapsed_time = timer.stop();
+    
+    if (problem->dump_stats) {
+        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;
+    }
+    
+    return best_solution;
+}
 
-#ifdef DEBUG_LITE
-  std::cout << "Solution completed: " << (best_solution ? "Found solution" : "No solution found") << std::endl;
-  std::cout << "Solution consumed: " << elapsed_time << " ms " << i << " steps" << std::endl;
-  std::cout << "======================================================================" << std::endl;
-  std::cout.flush();
-#endif // DEBUG_LITE
+VersionProblem * VersionProblem::Solve(VersionProblem * problem) 
+{
+
+    problem->Finalize();
+    problem->status();
+
+    VersionProblemPool *pool = new VersionProblemPool();
+    problem->pool = pool;
+
+#ifdef DEBUG
+    std::cout << "Before solve" << std::endl;
+    problem->Print(std::cout);
+#endif //DEB    UG
+    int itercount = 0;
+    
+    VersionProblem *best_solution = InnerSolve(problem, itercount);
+    
+#ifdef MEMORY_DEBUG
+    std::cout << "Solver Best Solution " << best_solution << std::endl << std::flush;
+#endif    
+
+    pool->Delete(best_solution);
+    problem->pool = 0;    
+
+    pool->DeleteAll();
+    delete pool;
 
   return best_solution;
 }

data/ext/dep_gecode/dep_selector_to_gecode.h

@@ -23,6 +23,7 @@
 #include "dep_selector_to_gecode_interface.h"
 #include <iostream>	       
 #include <vector>
+#include <set>
 
 #include <gecode/driver.hh>
 #include <gecode/int.hh>
@@ -40,6 +41,19 @@ using namespace Gecode;
 // Add optimization functions
 // Allow non-contiguous ranges in package dependencies. 
 
+// TODO: Add locking 
+struct VersionProblemPool 
+{
+    std::set<VersionProblem *> elems;
+    VersionProblemPool();
+    ~VersionProblemPool();
+    void Add(VersionProblem * vp);
+    void Delete(VersionProblem *vp);
+    void ShowAll();
+    void DeleteAll();
+};
+
+
 class VersionProblem : public Space
 {
 public:
@@ -90,6 +104,7 @@ public:
   void Print(std::ostream &out);
   void PrintPackageVar(std::ostream & out, int packageId) ;
 
+    static VersionProblem *InnerSolve(VersionProblem * problem, int & itercount);
   static VersionProblem *Solve(VersionProblem *problem);
  
 
@@ -117,10 +132,14 @@ public:
   int * is_required;
   int * is_suspicious;
 
+  VersionProblemPool *pool;
+
   bool CheckPackageId(int id);
   void AddPackagesPreferredToBeAtLatestObjectiveFunction(const VersionProblem & best_known_solution);
   void ConstrainVectorLessThanBest(IntVarArgs & current, IntVarArgs & best);
   void BuildCostVector(IntVarArgs & costVector) const;
+  
+  friend class VersionProblemPool;
 };
 
 template<class T> void PrintVarAligned(const char * message, T & var);

data/ext/dep_gecode/extconf.rb

@@ -25,7 +25,7 @@ require 'mkmf'
 
 $LIBS << " -lstdc++"
 
-#$CFLAGS << "-g"
+$CFLAGS << "-g"
 
 gecode_installed =
   have_library('gecodesearch') &&

data/lib/dep_selector/dep_selector_version.rb

@@ -1,3 +1,3 @@
 module DepSelector
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

metadata

@@ -1,8 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: dep_selector
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.0.4
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Christopher Walters
@@ -11,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-30 00:00:00 -07:00
+date: 2011-04-01 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -49,7 +53,7 @@ files:
 - ext/dep_gecode/dep_selector_to_gecode_interface.cpp
 - ext/dep_gecode/extconf.rb
 - ext/dep_gecode/lib/dep_selector_to_gecode.rb
-has_rdoc: true
+has_rdoc: false
 homepage: http://github.com/algorist/dep_selector
 licenses: 
 - Apache v2
@@ -59,22 +63,24 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
 requirements: 
 - gecode, version 3.5 or greater
 - g++
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Given packages, versions, and a dependency graph, find a valid assignment of package versions