Enable trivial heur. Change sync sol logic.

Author: Opt-Mucca

highs/mip/HighsMipSolver.cpp

@@ -335,21 +335,14 @@ void HighsMipSolver::run() {
   };
 
   auto syncSolutions = [&]() -> void {
+    // Note: Upper bound / limit of workers updated via addIncumbent
     for (HighsMipWorker& worker : mipdata_->workers) {
       for (auto& sol : worker.solutions_) {
         mipdata_->addIncumbent(std::get<0>(sol), std::get<1>(sol),
                                std::get<2>(sol));
       }
       worker.solutions_.clear();
     }
-    // TODO: Should addIncumbent just update all worker bounds?
-    // Pass the new upper bound information back to the workers
-    for (HighsMipWorker& worker : mipdata_->workers) {
-      assert(mipdata_->upper_bound <= worker.upper_bound);
-      worker.upper_bound = mipdata_->upper_bound;
-      worker.upper_limit = mipdata_->upper_limit;
-      worker.optimality_limit = mipdata_->optimality_limit;
-    }
   };
 
   auto syncPools = [&](std::vector<HighsInt>& indices) -> void {
@@ -358,8 +351,6 @@ void HighsMipSolver::run() {
     for (const HighsInt i : indices) {
       mipdata_->workers[i].conflictpool_->syncConflictPool(
           mipdata_->conflictPool);
-      // TODO: Is this aging call needed? (Already aged at end of separate)
-      mipdata_->workers[i].cutpool_->performAging();
       mipdata_->workers[i].cutpool_->syncCutPool(*this, mipdata_->cutpool);
     }
     mipdata_->cutpool.performAging();
@@ -767,9 +758,7 @@ void HighsMipSolver::run() {
       if (evaluate_node_result == HighsSearch::NodeResult::kSubOptimal) return;
 
       // analysis_.mipTimerStart(kMipClockDivePrimalHeuristics);
-      // TODO MT: Make trivial heuristics work locally
-      // TODO MT: Why can't these run locally now???
-      if (mipdata_->incumbent.empty() && !mipdata_->parallelLockActive()) {
+      if (mipdata_->incumbent.empty()) {
         // analysis_.mipTimerStart(kMipClockDiveRandomizedRounding);
         mipdata_->heuristics.randomizedRounding(
             worker, worker.lp_->getLpSolver().getSolution().col_value);

highs/mip/HighsMipSolverData.cpp

@@ -1585,8 +1585,8 @@ bool HighsMipSolverData::addIncumbent(const std::vector<double>& sol,
     double prev_upper_bound = upper_bound;
 
     upper_bound = solobj;
-    if (hasSingleWorker()) {
-      workers[0].upper_bound = upper_bound;
+    for (HighsMipWorker& worker : workers) {
+      worker.upper_bound = upper_bound;
     }
 
     bool bound_change = upper_bound != prev_upper_bound;
@@ -1607,9 +1607,9 @@ bool HighsMipSolverData::addIncumbent(const std::vector<double>& sol,
           computeNewUpperLimit(solobj, mipsolver.options_mip_->mip_abs_gap,
                                mipsolver.options_mip_->mip_rel_gap);
       nodequeue.setOptimalityLimit(optimality_limit);
-      if (hasSingleWorker()) {
-        workers[0].upper_limit = upper_limit;
-        workers[0].optimality_limit = optimality_limit;
+      for (HighsMipWorker& worker : workers) {
+        worker.upper_limit = upper_limit;
+        worker.optimality_limit = optimality_limit;
       }
       debugSolution.newIncumbentFound();
       domain.propagate();

highs/mip/HighsMipSolverData.h

@@ -274,10 +274,6 @@ struct HighsMipSolverData {
   bool hasMultipleWorkers() const {
     return workers.size() > 1;
   }
-
-  bool hasSingleWorker() const {
-    return workers.size() == 1;
-  }
 };
 
 #endif

highs/mip/HighsPrimalHeuristics.cpp

@@ -954,6 +954,7 @@ bool HighsPrimalHeuristics::tryRoundedPoint(HighsMipWorker& worker,
 
   if (numintcols != mipsolver.numCol()) {
     HighsLpRelaxation lprelax(mipsolver);
+    lprelax.setMipWorker(worker);
     lprelax.loadModel();
     lprelax.setIterationLimit(
         std::max(int64_t{10000}, 2 * mipsolver.mipdata_->firstrootlpiters));
@@ -1094,6 +1095,7 @@ void HighsPrimalHeuristics::randomizedRounding(
   if (mipsolver.mipdata_->integer_cols.size() !=
       static_cast<size_t>(mipsolver.numCol())) {
     HighsLpRelaxation lprelax(mipsolver);
+    lprelax.setMipWorker(worker);
     lprelax.loadModel();
     lprelax.setIterationLimit(
         std::max(int64_t{10000}, 2 * mipsolver.mipdata_->firstrootlpiters));
@@ -1147,6 +1149,7 @@ void HighsPrimalHeuristics::shifting(HighsMipWorker& worker,
   HighsInt t = 0;
   const HighsLp& currentLp = *mipsolver.model_;
   HighsLpRelaxation lprelax(worker.getLpRelaxation());
+  lprelax.setMipWorker(worker);
   std::vector<std::pair<HighsInt, double>> current_fractional_integers =
       lprelax.getFractionalIntegers();
   std::vector<std::tuple<HighsInt, HighsInt, double>> current_infeasible_rows =
@@ -1510,6 +1513,7 @@ void HighsPrimalHeuristics::ziRound(HighsMipWorker& worker,
 
 void HighsPrimalHeuristics::feasibilityPump(HighsMipWorker& worker) {
   HighsLpRelaxation lprelax(worker.getLpRelaxation());
+  lprelax.setMipWorker(worker);
   std::unordered_set<std::vector<HighsInt>, HighsVectorHasher, HighsVectorEqual>
       referencepoints;
   std::vector<double> roundedsol;