Cleaned up; formatted

Author: jajhall

check/TestMipSolver.cpp

@@ -1047,7 +1047,6 @@ TEST_CASE("mip-race", "[highs_test_mip_solver]") {
   if (ci_test) h.setOptionValue("output_flag", dev_run);
   const HighsInt mip_race_concurrency = ci_test ? 2 : 4;
   h.setOptionValue("mip_race_concurrency", mip_race_concurrency);
-  //  h.setOptionValue("mip_race_read_solutions", false);
   REQUIRE(h.readModel(model_file) == HighsStatus::kOk);
   REQUIRE(h.run() == HighsStatus::kOk);
 

highs/lp_data/Highs.cpp

@@ -4042,7 +4042,8 @@ HighsStatus Highs::callSolveMip() {
     MipRaceRecord mip_race_record;
     mip_race_record.initialise(mip_race_concurrency, lp.num_col_);
     // Set up the shared memory for the concurrent MIP terminator
-    auto terminator_record = solver.initialiseTerminatorRecord(mip_race_concurrency);
+    auto terminator_record =
+        solver.initialiseTerminatorRecord(mip_race_concurrency);
     // Don't allow callbacks for workers
     HighsCallback worker_callback = callback_;
     worker_callback.clear();
@@ -4066,7 +4067,8 @@ HighsStatus Highs::callSolveMip() {
       instance_options.random_seed = options_.random_seed + instance;
       std::string worker_log_file =
           "mip_worker" + std::to_string(instance) + ".log";
-      highsOpenLogFile(instance_options, worker_log_file);
+      if (options_.output_flag)
+        highsOpenLogFile(instance_options, worker_log_file);
       worker_options.push_back(instance_options);
       /*
       HighsMipSolver worker_instance(worker_callback, worker_options[instance],

highs/mip/HighsMipSolver.cpp

@@ -689,26 +689,26 @@ void HighsMipSolver::run() {
 }
 
 void HighsMipSolver::cleanupSolve() {
-  if (!submip) {
-    if (mipdata_->terminatorActive()) {
-      if (!mipdata_->terminatorTerminated()) {
-	// No other instance has terminated the MIP race, so terminate
-	// it
-	highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
-		     "instance%d: terminate   %6.4f (MIP)\n",
-		     int(this->mipdata_->mipRaceMyInstance()),
-		     this->timer_.read());
-	mipdata_->terminatorTerminate();
-      } else {
-	// Indicate that this instance has been interrupted
-	highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
-		     "instance%d: terminated  %6.4f (MIP)\n",
-		     int(this->mipdata_->mipRaceMyInstance()),
-		     this->timer_.read());
-	modelstatus_ = HighsModelStatus::kHighsInterrupt;
-      }
-      if (mipdata_->mipRaceActive()) mipdata_->mipRaceReport();
+  if (!submip && mipdata_->terminatorActive()) {
+    if (!mipdata_->terminatorTerminated()) {
+      // No other instance has terminated the MIP race, so terminate
+      // it
+      highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
+                   "instance%d: terminate   %6.4f (MIP)\n",
+                   int(this->mipdata_->terminatorMyInstance()),
+                   this->timer_.read());
+      mipdata_->terminatorTerminate();
+    } else {
+      // Indicate that this instance has been interrupted
+      highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
+                   "instance%d: terminated  %6.4f (MIP)\n",
+                   int(this->mipdata_->terminatorMyInstance()),
+                   this->timer_.read());
+      modelstatus_ = HighsModelStatus::kHighsInterrupt;
     }
+    mipdata_->terminatorReport();
+    // Report on any active MIP race
+    mipdata_->mipRaceReport();
   }
 
   // Force a final logging line

highs/mip/HighsMipSolver.h

@@ -66,6 +66,7 @@ struct HighsTerminator {
   void clear();
   void initialise(HighsInt num_instance_, HighsInt my_instance_,
                   HighsModelStatus* record_);
+  HighsInt concurrency() const;
   void terminate();
   bool terminated() const;
   HighsModelStatus terminationStatus() const;
@@ -166,7 +167,8 @@ class HighsMipSolver {
                         double& bound_violation, double& row_violation,
                         double& integrality_violation, HighsCDouble& obj) const;
 
-  std::vector<HighsModelStatus> initialiseTerminatorRecord(HighsInt num_instance) const;
+  std::vector<HighsModelStatus> initialiseTerminatorRecord(
+      HighsInt num_instance) const;
   void initialiseTerminator(HighsInt num_instance_ = 0,
                             HighsInt my_instance_ = kNoThreadInstance,
                             HighsModelStatus* record_ = nullptr);

highs/mip/HighsMipSolverData.cpp

@@ -1331,8 +1331,10 @@ void HighsMipSolverData::performRestart() {
   // changed offset_
   runSetup();
   if (mipsolver.terminate()) {
-    printf("HighsMipSolverData::performRestart() mipsolver.termination_status_ = %d\n",
-	   int(mipsolver.termination_status_));
+    printf(
+        "HighsMipSolverData::performRestart() mipsolver.termination_status_ = "
+        "%d\n",
+        int(mipsolver.termination_status_));
     return;
   }
 
@@ -2387,7 +2389,7 @@ void HighsMipSolverData::evaluateRootNode() {
         analysis.mipTimerStart(kMipClockPerformRestart);
         performRestart();
         analysis.mipTimerStop(kMipClockPerformRestart);
-	if (mipsolver.terminate()) return;
+        if (mipsolver.terminate()) return;
         ++numRestartsRoot;
         if (mipsolver.modelstatus_ == HighsModelStatus::kNotset) {
           clockOff(analysis);
@@ -2419,12 +2421,16 @@ bool HighsMipSolverData::checkLimits(int64_t nodeOffset) const {
   const HighsOptions& options = *mipsolver.options_mip_;
 
   // MIP race may have terminated
-  if (!mipsolver.submip) {
+  if (!mipsolver.submip && terminatorActive()) {
     highsLogUser(options.log_options, HighsLogType::kInfo,
-		 "instance%d: terminated? %6.4f (MIP)\n", int(this->mipRaceMyInstance()), this->mipsolver.timer_.read());
+                 "instance%d: terminated? %6.4f (MIP)\n",
+                 int(this->terminatorMyInstance()),
+                 this->mipsolver.timer_.read());
     if (this->terminatorTerminated()) {
       highsLogUser(options.log_options, HighsLogType::kInfo,
-		 "instance%d: terminated  %6.4f (MIP)\n", int(this->mipRaceMyInstance()), this->mipsolver.timer_.read());
+                   "instance%d: terminated  %6.4f (MIP)\n",
+                   int(this->terminatorMyInstance()),
+                   this->mipsolver.timer_.read());
       return true;
     }
   }
@@ -2698,12 +2704,6 @@ void HighsMipSolverData::queryExternalSolution(
   }
 }
 
-HighsInt HighsMipSolverData::mipRaceMyInstance() const {
-  assert(!mipsolver.submip);
-  if (!mipsolver.mip_race_.record) return kNoThreadInstance;
-  return mipsolver.mip_race_.my_instance;
-}
-
 HighsInt HighsMipSolverData::mipRaceConcurrency() const {
   assert(!mipsolver.submip);
   if (!mipsolver.mip_race_.record) return 0;
@@ -2727,21 +2727,33 @@ HighsInt HighsMipSolverData::mipRaceNewSolution(const HighsInt instance,
 
 void HighsMipSolverData::mipRaceReport() const {
   assert(!mipsolver.submip);
-  if (mipsolver.terminator_.record) mipsolver.terminator_.report(mipsolver.options_mip_->log_options);
-  if (mipsolver.mip_race_.record) mipsolver.mip_race_.report();  
+  if (mipsolver.mip_race_.record) mipsolver.mip_race_.report();
+}
+
+HighsInt HighsMipSolverData::terminatorConcurrency() const {
+  return mipsolver.terminator_.num_instance;
+}
+
+HighsInt HighsMipSolverData::terminatorMyInstance() const {
+  return mipsolver.terminator_.my_instance;
 }
 
 void HighsMipSolverData::terminatorTerminate() {
-  assert(mipsolver.terminator_.num_instance > 0);
+  assert(terminatorActive());
   mipsolver.terminator_.terminate();
 }
 
 bool HighsMipSolverData::terminatorTerminated() const {
-  if (this->terminatorActive()) 
+  if (this->terminatorActive())
     mipsolver.termination_status_ = mipsolver.terminator_.terminationStatus();
   return mipsolver.termination_status_ != HighsModelStatus::kNotset;
 }
 
+void HighsMipSolverData::terminatorReport() const {
+  if (this->terminatorActive())
+    mipsolver.terminator_.report(mipsolver.options_mip_->log_options);
+}
+
 static double possInfRelDiff(const double v0, const double v1,
                              const double den) {
   double rel_diff;
@@ -2918,9 +2930,7 @@ HighsInt MipRaceIncumbent::read(const HighsInt last_incumbent_read,
              : kMipRaceNoSolution;
 }
 
-void MipRaceRecord::clear() {
-  this->incumbent.clear();
-}
+void MipRaceRecord::clear() { this->incumbent.clear(); }
 
 void MipRaceRecord::initialise(const HighsInt mip_race_concurrency,
                                const HighsInt num_col) {
@@ -3022,14 +3032,15 @@ void HighsTerminator::clear() {
   this->record = nullptr;
 }
 
-void HighsTerminator::initialise(HighsInt num_instance_,
-				 HighsInt my_instance_,
-				 HighsModelStatus* record_) {
+void HighsTerminator::initialise(HighsInt num_instance_, HighsInt my_instance_,
+                                 HighsModelStatus* record_) {
   this->num_instance = num_instance_;
   this->my_instance = my_instance_;
   this->record = record_;
 }
 
+HighsInt HighsTerminator::concurrency() const { return this->num_instance; }
+
 void HighsTerminator::terminate() {
   assert(this->record);
   assert(this->my_instance < this->num_instance);
@@ -3047,9 +3058,8 @@ HighsModelStatus HighsTerminator::terminationStatus() const {
 
 void HighsTerminator::report(const HighsLogOptions log_options) const {
   highsLogUser(log_options, HighsLogType::kInfo, "\nTerminator:        ");
-  for (HighsInt instance = 0; instance < this->num_instance; instance++) 
+  for (HighsInt instance = 0; instance < this->num_instance; instance++)
     highsLogUser(log_options, HighsLogType::kInfo, " %20d",
-		 int(this->record[instance]));
+                 int(this->record[instance]));
   highsLogUser(log_options, HighsLogType::kInfo, "\n");
 }
-

highs/mip/HighsMipSolverData.h

@@ -302,16 +302,17 @@ struct HighsMipSolverData {
       const ExternalMipSolutionQueryOrigin external_solution_query_origin);
 
   HighsInt mipRaceConcurrency() const;
-  bool mipRaceActive() const { return mipRaceConcurrency() > 0; }
-  HighsInt mipRaceMyInstance() const;
   void mipRaceUpdate();
   HighsInt mipRaceNewSolution(const HighsInt instance, double& objective_value,
                               std::vector<double>& solution);
   void mipRaceReport() const;
 
+  HighsInt terminatorConcurrency() const;
+  bool terminatorActive() const { return terminatorConcurrency() > 0; }
+  HighsInt terminatorMyInstance() const;
   void terminatorTerminate();
   bool terminatorTerminated() const;
-  bool terminatorActive() const { return mipsolver.terminator_.num_instance > 0; }
+  void terminatorReport() const;
 };
 
 #endif