Make lprelax also pointer. Add convencience functions

Author: Opt-Mucca

highs/mip/HighsMipSolver.cpp

@@ -137,7 +137,7 @@ void HighsMipSolver::run() {
   // Initialize master worker.
   // Now the worker lives in mipdata.
   // The master worker is used in evaluateRootNode.
-  mipdata_->workers.emplace_back(*this, mipdata_->lp, mipdata_->domain,
+  mipdata_->workers.emplace_back(*this, &mipdata_->lp, mipdata_->domain,
                                  &mipdata_->cutpool, mipdata_->conflictPool);
 
   HighsMipWorker& master_worker = mipdata_->workers.at(0);
@@ -243,7 +243,7 @@ void HighsMipSolver::run() {
       "master_worker lprelaxation_ member  with address %p, %d "
       "columns, and %d rows\n",
       (void*)&master_worker.lprelaxation_,
-      int(master_worker.lprelaxation_.getLpSolver().getNumCol()),
+      int(master_worker.lprelaxation_->getLpSolver().getNumCol()),
       int(mipdata_->lps.at(0).getLpSolver().getNumRow()));
 
   std::shared_ptr<const HighsBasis> basis;
@@ -318,20 +318,57 @@ void HighsMipSolver::run() {
   const HighsInt num_worker = mip_search_concurrency - 1;
   highs::parallel::TaskGroup tg;
 
+  auto recreatePools = [&](HighsInt index, HighsMipWorker& worker) -> void {
+    HighsCutPool* p = &mipdata_->cutpools.at(index);
+    p->~HighsCutPool();
+    ::new (static_cast<void*>(p))
+        HighsCutPool(numCol(), options_mip_->mip_pool_age_limit,
+                     options_mip_->mip_pool_soft_limit, index);
+    mipdata_->conflictpools[index] =
+        HighsConflictPool(5 * options_mip_->mip_pool_age_limit,
+                          options_mip_->mip_pool_soft_limit);
+    worker.conflictpool_ = mipdata_->conflictpools[index];
+  };
+
+  auto recreateLpAndDomains = [&](HighsInt index, HighsMipWorker& worker) {
+    HighsLpRelaxation* p = &mipdata_->lps.at(index);
+    p->~HighsLpRelaxation();
+    ::new (p) HighsLpRelaxation(mipdata_->lp, index);
+    mipdata_->domains[index] = HighsDomain(mipdata_->domain);
+    worker.globaldom_ = mipdata_->domains.at(index);
+  };
+
+  // (Re-)Initialise local cut and conflict pool for master worker
+  if (mip_search_concurrency > 1) {
+    if (mipdata_->numRestarts <= mipdata_->numRestartsRoot) {
+      mipdata_->cutpools.emplace_back(numCol(),
+                                      options_mip_->mip_pool_age_limit,
+                                      options_mip_->mip_pool_soft_limit, 1);
+      master_worker.cutpool_ = &mipdata_->cutpools.back();
+      mipdata_->conflictpools.emplace_back(5 * options_mip_->mip_pool_age_limit,
+                                           options_mip_->mip_pool_soft_limit);
+      master_worker.conflictpool_ = mipdata_->conflictpools.back();
+    } else {
+      recreatePools(1, master_worker);
+    }
+  }
+
+  // Create / re-initialise workers
   for (int i = 1; i < mip_search_concurrency; i++) {
     if (mipdata_->numRestarts <= mipdata_->numRestartsRoot) {
       mipdata_->domains.emplace_back(mipdata_->domain);
       mipdata_->lps.emplace_back(mipdata_->lp, i);
-      mipdata_->cutpools.emplace_back(
-          numCol(), options_mip_->mip_pool_age_limit,
-                       options_mip_->mip_pool_soft_limit, i);
-      mipdata_->conflictpools.emplace_back(
-          5 * options_mip_->mip_pool_age_limit,
-                            options_mip_->mip_pool_soft_limit);
+      mipdata_->cutpools.emplace_back(numCol(),
+                                      options_mip_->mip_pool_age_limit,
+                                      options_mip_->mip_pool_soft_limit, i);
+      mipdata_->conflictpools.emplace_back(5 * options_mip_->mip_pool_age_limit,
+                                           options_mip_->mip_pool_soft_limit);
       mipdata_->workers.emplace_back(
-          *this, mipdata_->lps.back(), mipdata_->domains.back(),
+          *this, &mipdata_->lps.back(), mipdata_->domains.back(),
           &mipdata_->cutpools.back(), mipdata_->conflictpools.back());
     } else {
+      recreatePools(i + 1, mipdata_->workers.at(i));
+      recreateLpAndDomains(i, mipdata_->workers.at(i));
       mipdata_->workers[i].resetSearch();
     }
   }

highs/mip/HighsMipWorker.cpp

@@ -11,7 +11,7 @@
 #include "mip/MipTimer.h"
 
 HighsMipWorker::HighsMipWorker(const HighsMipSolver& mipsolver__,
-                               HighsLpRelaxation& lprelax_, HighsDomain& domain,
+                               HighsLpRelaxation* lprelax_, HighsDomain& domain,
                                HighsCutPool* cutpool,
                                HighsConflictPool& conflictpool)
     : mipsolver_(mipsolver__),
@@ -58,7 +58,7 @@ HighsMipWorker::HighsMipWorker(const HighsMipSolver& mipsolver__,
 
   // HighsSearch has its own relaxation initialized no nullptr.
 
-  search_ptr_->setLpRelaxation(&lprelaxation_);
+  search_ptr_->setLpRelaxation(lprelaxation_);
 
   // printf(
   //     "Search has lp member in constructor of mipworker with address %p, %d "
@@ -88,7 +88,7 @@ void HighsMipWorker::resetSearch() {
   // search_ptr_->getLocalDomain().addConflictPool(mipsolver_.mipdata_->conflictPool);
   // search_ptr_->getLocalDomain().addCutpool(cutpool_);
   // search_ptr_->getLocalDomain().addConflictPool(conflictpool_);
-  search_ptr_->setLpRelaxation(&lprelaxation_);
+  search_ptr_->setLpRelaxation(lprelaxation_);
 }
 
 bool HighsMipWorker::addIncumbent(const std::vector<double>& sol, double solobj,

highs/mip/HighsMipWorker.h

@@ -26,7 +26,7 @@ class HighsMipWorker {
   const HighsMipSolverData& mipdata_;
 
   HighsPseudocost pseudocost_;
-  HighsLpRelaxation& lprelaxation_;
+  HighsLpRelaxation* lprelaxation_;
   HighsDomain& globaldom_;
   HighsCutPool* cutpool_;
   HighsConflictPool& conflictpool_;
@@ -45,7 +45,7 @@ class HighsMipWorker {
 
   // HighsMipWorker(const HighsMipSolver& mipsolver__);
   HighsMipWorker(const HighsMipSolver& mipsolver__,
-                 HighsLpRelaxation& lprelax_,
+                 HighsLpRelaxation* lprelax_,
                  HighsDomain& domain,
                  HighsCutPool* cutpool,
                  HighsConflictPool& conflictpool);

highs/mip/HighsPrimalHeuristics.cpp

@@ -342,7 +342,7 @@ void HighsPrimalHeuristics::RENS(HighsMipWorker& worker,
                      [&](HighsInt i) { return worker.globaldom_.isFixed(i); }),
       intcols.end());
 
-  HighsLpRelaxation heurlp(worker.lprelaxation_);
+  HighsLpRelaxation heurlp(*worker.lprelaxation_);
   // only use the global upper limit as LP limit so that dual proofs are valid
   heurlp.setObjectiveLimit(mipsolver.mipdata_->upper_limit);
   heurlp.setAdjustSymmetricBranchingCol(false);
@@ -603,7 +603,7 @@ void HighsPrimalHeuristics::RINS(HighsMipWorker& worker,
   HighsDomain& localdom = heur.getLocalDomain();
   heur.setHeuristic(true);
 
-  HighsLpRelaxation heurlp(worker.lprelaxation_);
+  HighsLpRelaxation heurlp(*worker.lprelaxation_);
   // only use the global upper limit as LP limit so that dual proofs are valid
   heurlp.setObjectiveLimit(mipsolver.mipdata_->upper_limit);
   heurlp.setAdjustSymmetricBranchingCol(false);
@@ -1103,7 +1103,7 @@ void HighsPrimalHeuristics::shifting(HighsMipWorker& worker,
   std::vector<double> current_relax_solution = relaxationsol;
   HighsInt t = 0;
   const HighsLp& currentLp = *mipsolver.model_;
-  HighsLpRelaxation lprelax(worker.lprelaxation_);
+  HighsLpRelaxation lprelax(*worker.lprelaxation_);
   std::vector<std::pair<HighsInt, double>> current_fractional_integers =
       lprelax.getFractionalIntegers();
   std::vector<std::tuple<HighsInt, HighsInt, double>> current_infeasible_rows =
@@ -1465,7 +1465,7 @@ void HighsPrimalHeuristics::ziRound(HighsMipWorker& worker,
 }
 
 void HighsPrimalHeuristics::feasibilityPump(HighsMipWorker& worker) {
-  HighsLpRelaxation lprelax(worker.lprelaxation_);
+  HighsLpRelaxation lprelax(*worker.lprelaxation_);
   std::unordered_set<std::vector<HighsInt>, HighsVectorHasher, HighsVectorEqual>
       referencepoints;
   std::vector<double> roundedsol;