Writing incumbent solutions to shared memory

Author: jajhall

highs/lp_data/HStruct.h

@@ -73,9 +73,11 @@ struct MipRaceIncumbent {
 };
 
 struct MipRaceRecord {
+  std::vector<bool> terminate;
   std::vector<MipRaceIncumbent> record;
   void clear();
   void initialise(const HighsInt num_race_instance, const HighsInt num_col);
+  void report() const;
 };
 
 struct HighsBasis {

highs/lp_data/Highs.cpp

@@ -4027,7 +4027,17 @@ HighsStatus Highs::callSolveMip() {
                                   options_.primal_feasibility_tolerance);
   }
   HighsLp& lp = has_semi_variables ? use_lp : model_.lp_;
+  //
+  // Set up the shared memory for the MIP solver race
+  const HighsInt num_num_race_instance = 2;
+  MipRaceRecord mip_race_record;
+  mip_race_record.initialise(num_num_race_instance, lp.num_col_);
+  mip_race_record.report();
   HighsMipSolver solver(callback_, options_, lp, solution_);
+  // Initialise the pointer to the shared memory space
+  solver.mip_race_record_ = &mip_race_record;
+  solver.my_mip_race_instance_ = 0;
+  // Run the MIP solver!
   solver.run();
   options_.log_dev_level = log_dev_level;
   // Set the return_status, model status and, for completeness, scaled

highs/mip/HighsMipSolver.cpp

@@ -972,3 +972,9 @@ bool HighsMipSolver::solutionFeasible(const HighsLp* lp,
                         row_violation <= mip_feasibility_tolerance;
   return feasible;
 }
+
+void HighsMipSolver::makeMipRaceRecord(const double objective,
+				       const std::vector<double>& solution) {
+  this->mip_race_record_->record[this->my_mip_race_instance_].write(objective, solution);
+  this->mip_race_record_->report();
+}

highs/mip/HighsMipSolver.h

@@ -55,6 +55,9 @@ class HighsMipSolver {
 
   HighsMipAnalysis analysis_;
 
+  HighsInt my_mip_race_instance_;
+  MipRaceRecord* mip_race_record_;  
+
   void run();
 
   HighsInt numCol() const { return model_->num_col_; }
@@ -107,6 +110,7 @@ class HighsMipSolver {
                         const std::vector<double>* pass_row_value,
                         double& bound_violation, double& row_violation,
                         double& integrality_violation, HighsCDouble& obj) const;
+  void makeMipRaceRecord(const double objective, const std::vector<double>& solution);
 };
 
 #endif

highs/mip/HighsMipSolverData.cpp

@@ -736,6 +736,7 @@ void HighsMipSolverData::runSetup() {
   upper_bound -= mipsolver.model_->offset_;
 
   if (mipsolver.solution_objective_ != kHighsInf) {
+    // Assigning new incumbent
     incumbent = postSolveStack.getReducedPrimalSolution(mipsolver.solution_);
     // return the objective value in the transformed space
     double solobj =
@@ -764,6 +765,10 @@ void HighsMipSolverData::runSetup() {
                                  upper_bound);
 
       double new_upper_limit = computeNewUpperLimit(solobj, 0.0, 0.0);
+      // Possibly write the improving solution to the shared memory space
+      if (!mipsolver.submip && mipsolver.mip_race_record_)
+	mipsolver.makeMipRaceRecord(solobj, incumbent);
+
       saveReportMipSolution(new_upper_limit);
       if (new_upper_limit < upper_limit) {
         upper_limit = new_upper_limit;
@@ -1399,13 +1404,17 @@ bool HighsMipSolverData::addIncumbent(const std::vector<double>& sol,
       updatePrimalDualIntegral(lower_bound, lower_bound, prev_upper_bound,
                                upper_bound);
 
+    // Assigning new incumbent
     incumbent = sol;
     double new_upper_limit = computeNewUpperLimit(solobj, 0.0, 0.0);
 
     if (!is_user_solution && !mipsolver.submip)
       saveReportMipSolution(new_upper_limit);
     if (new_upper_limit < upper_limit) {
       ++numImprovingSols;
+      // Possibly write the improving solution to the shared memory space
+      if (!mipsolver.submip && mipsolver.mip_race_record_)
+	mipsolver.makeMipRaceRecord(solobj, incumbent);
       upper_limit = new_upper_limit;
       optimality_limit =
           computeNewUpperLimit(solobj, mipsolver.options_mip_->mip_abs_gap,
@@ -1438,6 +1447,7 @@ bool HighsMipSolverData::addIncumbent(const std::vector<double>& sol,
       printDisplayLine(solution_source);
     }
   } else if (incumbent.empty())
+    // Assigning new incumbent
     incumbent = sol;
 
   return true;
@@ -2821,13 +2831,38 @@ bool MipRaceIncumbent::readOk(double& objective,
   return this->start_write_incumbent == start_write_incumbent;
 }
 
-void MipRaceRecord::clear() { this->record.clear(); }
+void MipRaceRecord::clear() {
+  this->terminate.clear();
+  this->record.clear();
+}
 
 void MipRaceRecord::initialise(const HighsInt num_race_instance,
                                const HighsInt num_col) {
   this->clear();
+  this->terminate.assign(num_race_instance, false);
   MipRaceIncumbent mip_race_incumbent;
   mip_race_incumbent.initialise(num_col);
   for (HighsInt instance = 0; instance < num_race_instance; instance++)
     this->record.push_back(mip_race_incumbent);
 }
+
+void MipRaceRecord::report() const {
+  HighsInt num_race_instance = this->terminate.size();
+  printf("\nMipRaceRecord:");
+  for (HighsInt instance = 0; instance < num_race_instance; instance++)
+    printf(" %11d", int(instance));
+  printf("\nTerminate:    ");
+  for (HighsInt instance = 0; instance < num_race_instance; instance++)
+    printf(" %11s", this->terminate[instance] ? "T" : "F");
+  printf("\nStartWrite:   ");
+  for (HighsInt instance = 0; instance < num_race_instance; instance++)
+    printf(" %11d", this->record[instance].start_write_incumbent);
+  printf("\nObjective:    ");
+  for (HighsInt instance = 0; instance < num_race_instance; instance++)
+    printf(" %11.4g", this->record[instance].best_incumbent_objective);
+  printf("\nFinishWrite:  ");
+  for (HighsInt instance = 0; instance < num_race_instance; instance++)
+    printf(" %11d", this->record[instance].finish_write_incumbent);
+  printf("\n\n");
+}
+