Fix bugs. Re-enable compiler optimisation

Author: Opt-Mucca

CMakeLists.txt

@@ -622,8 +622,6 @@ elseif (DEBUG_MEMORY STREQUAL "Memory")
   endif()
 endif()
 
-add_compile_options(-O0) 
-
 # HiGHS coverage update in progress
 if(FAST_BUILD AND HIGHS_COVERAGE)
   if(WIN32)

highs/mip/HighsConflictPool.cpp

@@ -53,7 +53,7 @@ void HighsConflictPool::addConflictCut(
     conflictRanges_[conflictIndex].second = end;
   }
 
-  ageResetWhileLocked_[conflictIndex] = false;
+  ageResetWhileLocked_[conflictIndex] = 0;
   modification_[conflictIndex] += 1;
   ages_[conflictIndex] = 0;
   ageDistribution_[ages_[conflictIndex]] += 1;
@@ -127,7 +127,7 @@ void HighsConflictPool::addReconvergenceCut(
     conflictRanges_[conflictIndex].second = end;
   }
 
-  ageResetWhileLocked_[conflictIndex] = false;
+  ageResetWhileLocked_[conflictIndex] = 0;
   modification_[conflictIndex] += 1;
   ages_[conflictIndex] = 0;
   ageDistribution_[ages_[conflictIndex]] += 1;
@@ -193,11 +193,11 @@ void HighsConflictPool::performAging(const bool thread_safe) {
 
   for (HighsInt i = 0; i != conflictMaxIndex; ++i) {
     if (ages_[i] < 0) continue;
-    if (thread_safe && ageResetWhileLocked_[i]) resetAge(i);
+    if (thread_safe && ageResetWhileLocked_[i] == 1) resetAge(i);
 
     ageDistribution_[ages_[i]] -= 1;
     ages_[i] += 1;
-    ageResetWhileLocked_[i] = false;
+    ageResetWhileLocked_[i] = 0;
 
     if (ages_[i] > agelim) {
       ages_[i] = -1;
@@ -248,7 +248,7 @@ void HighsConflictPool::addConflictFromOtherPool(
     conflictRanges_[conflictIndex].second = end;
   }
 
-  ageResetWhileLocked_[conflictIndex] = false;
+  ageResetWhileLocked_[conflictIndex] = 0;
   modification_[conflictIndex] += 1;
   ages_[conflictIndex] = 0;
   ageDistribution_[ages_[conflictIndex]] += 1;

highs/mip/HighsConflictPool.h

@@ -22,7 +22,7 @@ class HighsConflictPool {
   std::vector<HighsInt> ageDistribution_;
   std::vector<int16_t> ages_;
   std::vector<unsigned> modification_;
-  std::vector<bool> ageResetWhileLocked_;
+  std::vector<uint8_t> ageResetWhileLocked_;
 
   std::vector<HighsDomainChange> conflictEntries_;
   std::vector<std::pair<HighsInt, HighsInt>> conflictRanges_;
@@ -75,7 +75,7 @@ class HighsConflictPool {
   void resetAge(HighsInt conflict) {
     if (ages_[conflict] > 0) {
       if (age_lock_) {
-        ageResetWhileLocked_[conflict] = true;
+        ageResetWhileLocked_[conflict] = 1;
         return;
       }
       ageDistribution_[ages_[conflict]] -= 1;

highs/mip/HighsCutPool.cpp

@@ -191,10 +191,10 @@ void HighsCutPool::performAging() {
       ages_[i] = 1;
       --numLpCuts;
       ++ageDistribution[1];
-    } else if (ageResetWhileLocked_[i]) {
+    } else if (ageResetWhileLocked_[i] == 1) {
       resetAge(i);
     }
-    ageResetWhileLocked_[i] = false;
+    ageResetWhileLocked_[i] = 0;
     if (ages_[i] < 0) continue;
 
     bool isPropagated = matrix_.columnsLinked(i);
@@ -290,7 +290,7 @@ void HighsCutPool::separate(const std::vector<double>& sol, HighsDomain& domain,
         matrix_.removeRow(i);
         ages_[i] = -1;
         rhs_[i] = kHighsInf;
-        ageResetWhileLocked_[i] = false;
+        ageResetWhileLocked_[i] = 0;
         hasSynced_[i] = false;
         auto range = hashToCutMap.equal_range(h);
 
@@ -613,7 +613,7 @@ HighsInt HighsCutPool::addCut(const HighsMipSolver& mipsolver, HighsInt* Rindex,
   ++ageDistribution[ages_[rowindex]];
   rowintegral[rowindex] = integral;
   numLps_[rowindex] = 0;
-  ageResetWhileLocked_[rowindex] = false;
+  ageResetWhileLocked_[rowindex] = 0;
   hasSynced_[rowindex] = false;
   if (propagate) propRows.emplace(ages_[rowindex], rowindex);
   assert((HighsInt)propRows.size() == numPropRows);

highs/mip/HighsCutPool.h

@@ -57,7 +57,7 @@ class HighsCutPool {
   std::vector<double> rhs_;
   std::vector<int16_t> ages_;
   std::deque<std::atomic<int16_t>> numLps_;
-  std::vector<bool> ageResetWhileLocked_;  // Was the cut propagated?
+  std::vector<uint8_t> ageResetWhileLocked_;  // Was the cut propagated?
   std::vector<bool> hasSynced_;            // Has the cut been globally synced?
   std::vector<double> rownormalization_;
   std::vector<double> maxabscoef_;
@@ -105,7 +105,7 @@ class HighsCutPool {
   void resetAge(HighsInt cut, bool thread_safe = false) {
     if (ages_[cut] > 0) {
       if (thread_safe) {
-        ageResetWhileLocked_[cut] = true;
+        ageResetWhileLocked_[cut] = 1;
         return;
       }
       if (matrix_.columnsLinked(cut)) {

highs/mip/HighsMipSolver.cpp

@@ -572,23 +572,23 @@ void HighsMipSolver::run() {
       HighsInt worker_id = indices[i];
       if (search_results[worker_id] == HighsSearch::NodeResult::kSubOptimal) {
         analysis_.mipTimerStart(kMipClockCurrentNodeToQueue);
-        mipdata_->workers[indices[worker_id]].search_ptr_->currentNodeToQueue(
+        mipdata_->workers[worker_id].search_ptr_->currentNodeToQueue(
             mipdata_->nodequeue);
         analysis_.mipTimerStop(kMipClockCurrentNodeToQueue);
       }
     }
   };
 
   auto handlePrunedNodes = [&](std::vector<HighsInt>& indices) -> bool {
-    std::deque<bool> infeasible(num_workers, false);
-    std::deque<bool> flush(num_workers, false);
-    std::vector<bool> prune(num_workers, false);
+    std::vector<uint8_t> infeasible(num_workers, 0);
+    std::vector<uint8_t> flush(num_workers, 0);
+    std::vector<uint8_t> prune(num_workers, 0);
     bool multiple_workers = num_workers > 1;
     auto doHandlePrunedNodes = [&](HighsInt i) {
       if (!mipdata_->workers[i].search_ptr_->currentNodePruned()) return;
       HighsDomain& globaldom = mipdata_->workers[i].getGlobalDomain();
       mipdata_->workers[i].search_ptr_->backtrack();
-      flush[i] = true;
+      flush[i] = 1;
 
       globaldom.propagate();
       if (!multiple_workers) {
@@ -597,7 +597,7 @@ void HighsMipSolver::run() {
       }
 
       if (globaldom.infeasible()) {
-        infeasible[i] = true;
+        infeasible[i] = 1;
         if (!multiple_workers) {
           mipdata_->nodequeue.clear();
           mipdata_->pruned_treeweight = 1.0;
@@ -615,7 +615,7 @@ void HighsMipSolver::run() {
         return;
       }
 
-      prune[i] = true;
+      prune[i] = 1;
 
       if (multiple_workers || mipdata_->checkLimits()) {
         return;
@@ -635,25 +635,25 @@ void HighsMipSolver::run() {
     analysis_.mipTimerStart(kMipClockNodePrunedLoop);
     runTask(doHandlePrunedNodes, tg, true, indices);
     // Flush pruned nodes statistics that haven't yet been flushed
-    for (HighsInt i = 0; i != num_workers; ++i) {
-      if (flush[i]) {
+    for (HighsInt i : indices) {
+      if (flush[i] == 1) {
         ++mipdata_->num_leaves;
         ++mipdata_->num_nodes;
-        mipdata_->workers[indices[i]].search_ptr_->flushStatistics();
+        mipdata_->workers[i].search_ptr_->flushStatistics();
       }
     }
     // Remove search indices that need a new node
     HighsInt num_search_indices = static_cast<HighsInt>(indices.size());
     for (HighsInt i = num_search_indices - 1; i >= 0; i--) {
-      if (prune[i]) {
+      if (prune[indices[i]] == 1) {
         num_search_indices--;
         std::swap(indices[i], indices[num_search_indices]);
       }
     }
     indices.resize(num_search_indices);
 
-    for (bool status : infeasible) {
-      if (status) {
+    for (uint8_t status : infeasible) {
+      if (status == 1) {
         mipdata_->nodequeue.clear();
         mipdata_->pruned_treeweight = 1.0;
 
@@ -805,7 +805,7 @@ void HighsMipSolver::run() {
   };
 
   auto runHeuristics = [&](std::vector<HighsInt>& indices) -> void {
-    std::vector<bool> suboptimal(num_workers, false);
+    std::vector<uint8_t> suboptimal(num_workers, 0);
     auto doRunHeuristics = [&](HighsInt i) -> void {
       HighsMipWorker& worker = mipdata_->workers[i];
       // analysis_.mipTimerStart(kMipClockDiveEvaluateNode);
@@ -814,7 +814,7 @@ void HighsMipSolver::run() {
       // analysis_.mipTimerStop(kMipClockDiveEvaluateNode);
 
       if (evaluate_node_result == HighsSearch::NodeResult::kSubOptimal) {
-        suboptimal[i] = true;
+        suboptimal[i] = 1;
         return;
       }
 
@@ -845,7 +845,7 @@ void HighsMipSolver::run() {
     };
     runTask(doRunHeuristics, tg, true, indices);
     for (const HighsInt i : indices) {
-      if (!suboptimal[i]) {
+      if (suboptimal[i] == 0) {
         if (mipdata_->workers[i].search_ptr_->currentNodePruned()) {
           ++mipdata_->num_leaves;
           mipdata_->workers[i].search_ptr_->flushStatistics();
@@ -856,7 +856,7 @@ void HighsMipSolver::run() {
     // Remove search indices that have suboptimal status
     HighsInt num_search_indices = static_cast<HighsInt>(indices.size());
     for (HighsInt i = num_search_indices - 1; i >= 0; i--) {
-      if (suboptimal[indices[i]]) {
+      if (suboptimal[indices[i]] == 1) {
         num_search_indices--;
         std::swap(indices[i], indices[num_search_indices]);
       }

highs/mip/HighsPrimalHeuristics.cpp

@@ -224,7 +224,7 @@ double HighsPrimalHeuristics::determineTargetFixingRate(
   double highFixingRate = 0.6;
 
   HighsRandom& randgen =
-      mipsolver.mipdata_->parallelLockActive() ? this->randgen : worker.randgen;
+      mipsolver.mipdata_->parallelLockActive() ? worker.randgen : this->randgen;
 
   if (getNumInfeasObservations(worker) != 0) {
     double infeasRate =
@@ -1081,7 +1081,7 @@ void HighsPrimalHeuristics::randomizedRounding(
 
   HighsDomain localdom = worker.getGlobalDomain();
   HighsRandom& randgen =
-      mipsolver.mipdata_->parallelLockActive() ? this->randgen : worker.randgen;
+      mipsolver.mipdata_->parallelLockActive() ? worker.randgen : this->randgen;
 
   for (HighsInt i : intcols) {
     double intval;
@@ -1170,7 +1170,7 @@ void HighsPrimalHeuristics::shifting(HighsMipWorker& worker,
   HighsLpRelaxation lprelax(worker.getLpRelaxation());
   lprelax.setMipWorker(worker);
   HighsRandom& randgen =
-      mipsolver.mipdata_->parallelLockActive() ? this->randgen : worker.randgen;
+      mipsolver.mipdata_->parallelLockActive() ? worker.randgen : this->randgen;
   std::vector<std::pair<HighsInt, double>> current_fractional_integers =
       lprelax.getFractionalIntegers();
   std::vector<std::tuple<HighsInt, HighsInt, double>> current_infeasible_rows =
@@ -1542,7 +1542,7 @@ void HighsPrimalHeuristics::feasibilityPump(HighsMipWorker& worker) {
   worker.heur_stats.lp_iterations += lprelax.getNumLpIterations();
 
   HighsRandom& randgen =
-      mipsolver.mipdata_->parallelLockActive() ? this->randgen : worker.randgen;
+      mipsolver.mipdata_->parallelLockActive() ? worker.randgen : this->randgen;
 
   std::vector<double> fracintcost;
   std::vector<HighsInt> fracintset;

highs/mip/HighsSearch.cpp

@@ -1941,7 +1941,6 @@ HighsSymmetries& HighsSearch::getSymmetries() const {
 bool HighsSearch::addIncumbent(const std::vector<double>& sol, double solobj,
                                const int solution_source,
                                const bool print_display_line) {
-  // if (mipsolver.mipdata_->workers.size() <= 1)
   if (mipsolver.mipdata_->parallelLockActive()) {
     return mipworker.addIncumbent(sol, solobj, solution_source);
   } else {