Removed MipSolverInfo and last vestiges of MIP race

Author: jajhall

highs/lp_data/HStruct.h

@@ -183,22 +183,4 @@ struct HighsSimplexStats {
   void initialise(const HighsInt iteration_count_ = 0);
 };
 
-struct HighsMipSolverInfo {
-  // Data pulled from the MIP solver that are required after instance
-  // is deleted
-  HighsModelStatus modelstatus;
-  std::vector<double> solution;
-  double solution_objective;
-  double bound_violation;
-  double integrality_violation;
-  double row_violation;
-  double dual_bound;
-  double primal_bound;
-  double gap;
-  HighsInt max_submip_level;
-  int64_t node_count;
-  int64_t total_lp_iterations;
-  double primal_dual_integral;
-  void clear();
-};
 #endif /* LP_DATA_HSTRUCT_H_ */

highs/lp_data/Highs.cpp

@@ -933,8 +933,6 @@ HighsStatus Highs::presolve() {
   return returnFromHighs(return_status);
 }
 
-HighsMipSolverInfo getMipSolverInfo(const HighsMipSolver& solver);
-
 HighsStatus Highs::run() {
   const bool options_had_highs_files = this->optionsHasHighsFiles();
   if (options_had_highs_files) {
@@ -4025,24 +4023,22 @@ HighsStatus Highs::callSolveMip() {
   }
   HighsLp& lp = has_semi_variables ? use_lp : model_.lp_;
   HighsMipSolver solver(callback_, options_, lp, solution_);
-  HighsMipSolverInfo mip_solver_info;
   solver.run();
-  mip_solver_info = getMipSolverInfo(solver);
   options_.log_dev_level = log_dev_level;
   // Set the return_status, model status and, for completeness, scaled
   // model status
   HighsStatus return_status =
-      highsStatusFromHighsModelStatus(mip_solver_info.modelstatus);
-  model_status_ = mip_solver_info.modelstatus;
+      highsStatusFromHighsModelStatus(solver.modelstatus_);
+  model_status_ = solver.modelstatus_;
   // Extract the solution
-  if (mip_solver_info.solution_objective != kHighsInf) {
+  if (solver.solution_objective_ != kHighsInf) {
     // There is a primal solution
     //
     // If the original model has semi-variables, its solution is
     // (still) given by the first model_.lp_.num_col_ entries of the
     // solution from the MIP solver
     solution_.col_value.resize(model_.lp_.num_col_);
-    solution_.col_value = mip_solver_info.solution;
+    solution_.col_value = solver.solution_;
     this->saved_objective_and_solution_ = solver.saved_objective_and_solution_;
     model_.lp_.a_matrix_.productQuad(solution_.row_value, solution_.col_value);
     solution_.value_valid = true;
@@ -4062,7 +4058,7 @@ HighsStatus Highs::callSolveMip() {
   // There is no basis: should be so by default
   assert(!basis_.valid);
   // Get the objective and any KKT failures
-  info_.objective_function_value = mip_solver_info.solution_objective;
+  info_.objective_function_value = solver.solution_objective_;
   // Remember to judge primal feasibility according to
   // mip_feasibility_tolerance, so take a copy of the original
   // value...
@@ -4071,23 +4067,23 @@ HighsStatus Highs::callSolveMip() {
   // NB getKktFailures sets the primal and dual solution status
   getKktFailures(options_, model_, solution_, basis_, info_);
   // Set the MIP-specific values of info_
-  info_.mip_node_count = mip_solver_info.node_count;
-  info_.mip_dual_bound = mip_solver_info.dual_bound;
-  info_.mip_gap = mip_solver_info.gap;
-  info_.primal_dual_integral = mip_solver_info.primal_dual_integral;
+  info_.mip_node_count = solver.node_count_;
+  info_.mip_dual_bound = solver.dual_bound_;
+  info_.mip_gap = solver.gap_;
+  info_.primal_dual_integral = solver.primal_dual_integral_;
   // Get the number of LP iterations, avoiding overflow if the int64_t
   // value is too large
-  int64_t mip_total_lp_iterations = mip_solver_info.total_lp_iterations;
+  int64_t mip_total_lp_iterations = solver.total_lp_iterations_;
   info_.simplex_iteration_count = mip_total_lp_iterations > kHighsIInf
                                       ? -1
                                       : HighsInt(mip_total_lp_iterations);
   info_.valid = true;
   if (model_status_ == HighsModelStatus::kOptimal)
     return_status = checkOptimality("MIP");
   // Overwrite max infeasibility to include integrality if there is a solution
-  if (mip_solver_info.solution_objective != kHighsInf) {
-    const double mip_max_bound_violation = std::max(
-        mip_solver_info.row_violation, mip_solver_info.bound_violation);
+  if (solver.solution_objective_ != kHighsInf) {
+    const double mip_max_bound_violation =
+        std::max(solver.row_violation_, solver.bound_violation_);
     const double delta_max_bound_violation =
         std::abs(mip_max_bound_violation - info_.max_primal_infeasibility);
     // Possibly report a mis-match between the max bound violation
@@ -4099,7 +4095,7 @@ HighsStatus Highs::callSolveMip() {
                   "(%10.4g); Difference of %10.4g\n",
                   mip_max_bound_violation, info_.max_primal_infeasibility,
                   delta_max_bound_violation);
-    info_.max_integrality_violation = mip_solver_info.integrality_violation;
+    info_.max_integrality_violation = solver.integrality_violation_;
     if (info_.max_integrality_violation > options_.mip_feasibility_tolerance) {
       info_.primal_solution_status = kSolutionStatusInfeasible;
       assert(model_status_ == HighsModelStatus::kInfeasible);
@@ -4809,22 +4805,3 @@ void Highs::getHighsFiles() {
   this->options_.write_basis_file = this->files_.write_basis_file;
   this->files_.clear();
 }
-
-HighsMipSolverInfo getMipSolverInfo(const HighsMipSolver& mip_solver) {
-  HighsMipSolverInfo mip_solver_info;
-  mip_solver_info.clear();
-  mip_solver_info.modelstatus = mip_solver.modelstatus_;
-  mip_solver_info.solution = mip_solver.solution_;
-  mip_solver_info.solution_objective = mip_solver.solution_objective_;
-  mip_solver_info.bound_violation = mip_solver.bound_violation_;
-  mip_solver_info.integrality_violation = mip_solver.integrality_violation_;
-  mip_solver_info.row_violation = mip_solver.row_violation_;
-  mip_solver_info.dual_bound = mip_solver.dual_bound_;
-  mip_solver_info.primal_bound = mip_solver.primal_bound_;
-  mip_solver_info.gap = mip_solver.gap_;
-  mip_solver_info.max_submip_level = mip_solver.max_submip_level;
-  mip_solver_info.node_count = mip_solver.node_count_;
-  mip_solver_info.total_lp_iterations = mip_solver.total_lp_iterations_;
-  mip_solver_info.primal_dual_integral = mip_solver.primal_dual_integral_;
-  return mip_solver_info;
-}

highs/lp_data/HighsInterface.cpp

@@ -4300,19 +4300,3 @@ void HighsLinearObjective::clear() {
   this->rel_tolerance = 0.0;
   this->priority = 0;
 }
-
-void HighsMipSolverInfo::clear() {
-  this->modelstatus = HighsModelStatus::kNotset;
-  this->solution.clear();
-  this->solution_objective = -kHighsInf;
-  this->bound_violation = -kHighsInf;
-  this->integrality_violation = -kHighsInf;
-  this->row_violation = -kHighsInf;
-  this->dual_bound = -kHighsInf;
-  this->primal_bound = -kHighsInf;
-  this->gap = -kHighsInf;
-  this->max_submip_level = -1;
-  this->node_count = -kHighsSize_tInf;
-  this->total_lp_iterations = -kHighsSize_tInf;
-  this->primal_dual_integral = -kHighsInf;
-}

highs/mip/HighsMipSolver.cpp

@@ -794,51 +794,44 @@ void HighsMipSolver::cleanupSolve() {
   std::array<char, 128> gapString =
       getGapString(gap_, primal_bound_, options_mip_);
 
-  // Don't log to console if this is in a MIP race
-  HighsOptions temp_options = *options_mip_;
-  if (mipdata_->terminatorActive()) {
-    temp_options.log_to_console = false;
-    temp_options.setLogOptions();
-  }
-
-  bool timeless_log = temp_options.timeless_log;
-  highsLogUser(temp_options.log_options, HighsLogType::kInfo,
+  bool timeless_log = options_mip_->timeless_log;
+  highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
                "\nSolving report\n");
   if (this->orig_model_->model_name_.length())
-    highsLogUser(temp_options.log_options, HighsLogType::kInfo,
+    highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
                  "  Model             %s\n",
                  this->orig_model_->model_name_.c_str());
-  highsLogUser(temp_options.log_options, HighsLogType::kInfo,
+  highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
                "  Status            %s\n"
                "  Primal bound      %.12g\n"
                "  Dual bound        %.12g\n"
                "  Gap               %s\n",
                utilModelStatusToString(modelstatus_).c_str(), primal_bound_,
                dual_bound_, gapString.data());
   if (!timeless_log)
-    highsLogUser(temp_options.log_options, HighsLogType::kInfo,
+    highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
                  "  P-D integral      %.12g\n",
                  mipdata_->primal_dual_integral.value);
-  highsLogUser(temp_options.log_options, HighsLogType::kInfo,
+  highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
                "  Solution status   %s\n", solutionstatus.c_str());
   if (solutionstatus != "-")
-    highsLogUser(temp_options.log_options, HighsLogType::kInfo,
+    highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
                  "                    %.12g (objective)\n"
                  "                    %.12g (bound viol.)\n"
                  "                    %.12g (int. viol.)\n"
                  "                    %.12g (row viol.)\n",
                  solution_objective_, bound_violation_, integrality_violation_,
                  row_violation_);
   if (!timeless_log)
-    highsLogUser(temp_options.log_options, HighsLogType::kInfo,
+    highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
                  "  Timing            %.2f (total)\n"
                  "                    %.2f (presolve)\n"
                  "                    %.2f (solve)\n"
                  "                    %.2f (postsolve)\n",
                  timer_.read(), analysis_.mipTimerRead(kMipClockPresolve),
                  analysis_.mipTimerRead(kMipClockSolve),
                  analysis_.mipTimerRead(kMipClockPostsolve));
-  highsLogUser(temp_options.log_options, HighsLogType::kInfo,
+  highsLogUser(options_mip_->log_options, HighsLogType::kInfo,
                "  Max sub-MIP depth %d\n"
                "  Nodes             %llu\n"
                "  Repair LPs        %llu (%llu feasible; %llu iterations)\n"

highs/mip/HighsMipSolver.h

@@ -8,8 +8,6 @@
 #ifndef MIP_HIGHS_MIP_SOLVER_H_
 #define MIP_HIGHS_MIP_SOLVER_H_
 
-#include <atomic>
-
 #include "Highs.h"
 #include "lp_data/HighsCallback.h"
 #include "lp_data/HighsOptions.h"

highs/mip/HighsMipSolverData.h

@@ -301,12 +301,6 @@ struct HighsMipSolverData {
       const double mipsolver_objective_value,
       const ExternalMipSolutionQueryOrigin external_solution_query_origin);
 
-  HighsInt mipRaceConcurrency() 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;