Still passes bin/unit_tests mip-race

Author: jajhall

check/TestMipSolver.cpp

@@ -1049,9 +1049,13 @@ TEST_CASE("mip-race", "[highs_test_mip_solver]") {
   const HighsInt mip_race_concurrency = ci_test ? 2 : 4;
   h.setOptionValue("mip_race_concurrency", mip_race_concurrency);
   h.setOptionValue("mip_race_read_solutions", true);
-  REQUIRE(h.readModel(model_file) == HighsStatus::kOk);
-  REQUIRE(h.run() == HighsStatus::kOk);
-  REQUIRE(h.getModelStatus() == HighsModelStatus::kOptimal);
+  for (HighsInt k = 0; k < 1; k++) {
+    bool mip_race_single_presolve = k == 0 ? false : true;
+    h.setOptionValue("mip_race_single_presolve", mip_race_single_presolve);
+    REQUIRE(h.readModel(model_file) == HighsStatus::kOk);
+    REQUIRE(h.run() == HighsStatus::kOk);
+    REQUIRE(h.getModelStatus() == HighsModelStatus::kOptimal);
+  }
 
   if (ci_test) {
     h.clearSolver();

highs/Highs.h

@@ -1714,10 +1714,11 @@ class Highs {
   bool optionsHasHighsFiles() const;
   void saveHighsFiles();
   void getHighsFiles();
-  HighsStatus mipRaceResults(HighsMipSolverInfo& mip_solver_info,
+  HighsStatus mipRaceResults(bool use_mip_race_single_presolve,
+			     HighsMipSolverInfo& mip_solver_info,
                              const std::vector<HighsMipSolverInfo>& worker_info,
                              const std::vector<double>& mip_time,
-                             const double& report_mip_time);
+                             double mip_race_time);
 };
 
 // Start of deprecated methods not in the Highs class

highs/lp_data/Highs.cpp

@@ -4031,13 +4031,45 @@ HighsStatus Highs::callSolveMip() {
                                   options_.primal_feasibility_tolerance);
   }
   HighsLp& lp = has_semi_variables ? use_lp : model_.lp_;
-
+  // Start timing any MIP race before its presolve and parallel MIP
+  // solver calls. This timer is stopped in Highs::mipRaceResults
+  // after any postsolve is performed
+  double mip_race_time = -this->timer_.read();
+  HighsLp presolved_lp;
+  const HighsInt mip_race_concurrency = this->options_.mip_race_concurrency;
+  const bool run_mip_race = mip_race_concurrency > 1;
+  // Determine whether to do a single presolve before any MIP race
+  //
+  // Doesn't work when there are semi-variables since they have to be
+  // converted into the use_lp instance, and this->presolve(); works
+  // on the incumbent model
+  const bool use_mip_race_single_presolve =
+    run_mip_race &&
+    options_.mip_race_single_presolve &&
+    options_.presolve != kHighsOffString &&
+    !has_semi_variables;
+  if (use_mip_race_single_presolve) {
+    // Perform presolve before the MIP race
+    //
+    // NB This is normally called externally, so calls
+    // returnFromHighs(). This will stop the run clock, and check that
+    // called_return_from_optimize_model is true - when it isn't. So,
+    // add a hack to set called_return_from_optimize_model true before
+    // the call to presolve...
+    assert(!this->called_return_from_optimize_model);
+    this->called_return_from_optimize_model = true;
+    this->presolve();
+    // ... then set it back to false and restart the run clock
+    this->called_return_from_optimize_model = false;
+    this->timer_.start();
+    presolved_lp = this->getPresolvedLp();
+    lp = presolved_lp;
+  }
   // Create the master MIP solver instance that will exist beyond any
-  // race
+  // MIP race
   HighsMipSolver solver(callback_, options_, lp, solution_);
   HighsMipSolverInfo mip_solver_info;
-  const HighsInt mip_race_concurrency = this->options_.mip_race_concurrency;
-  if (mip_race_concurrency > 1) {
+  if (run_mip_race) {
     // Set up the shared memory for the MIP solver race
     MipRaceRecord mip_race_record;
     mip_race_record.initialise(mip_race_concurrency, lp.num_col_);
@@ -4070,14 +4102,7 @@ HighsStatus Highs::callSolveMip() {
       if (options_.output_flag)
         highsOpenLogFile(instance_options, worker_log_file);
       worker_options.push_back(instance_options);
-      /*
-      HighsMipSolver worker_instance(worker_callback, worker_options[instance],
-      lp, solution_); worker.push_back(&worker_instance);
-      */
     }
-    // Time the master outside the parallel loop so that this "real"
-    // time is reported
-    double loop_mip_time = -timer_.read();
     highs::parallel::for_each(
         0, mip_race_concurrency, [&](HighsInt start, HighsInt end) {
           for (HighsInt instance = start; instance < end; instance++) {
@@ -4104,10 +4129,10 @@ HighsStatus Highs::callSolveMip() {
             }
           }
         });
-    loop_mip_time += timer_.read();
     // Determine the winner and report on the solution
-    HighsStatus call_status = this->mipRaceResults(mip_solver_info, worker_info,
-                                                   mip_time, loop_mip_time);
+    HighsStatus call_status = this->mipRaceResults(use_mip_race_single_presolve,
+						   mip_solver_info, worker_info,
+                                                   mip_time, mip_race_time);
     if (call_status == HighsStatus::kError) {
       const bool undo_mods = true;
       return returnFromOptimizeModel(HighsStatus::kError, undo_mods);

highs/lp_data/HighsInterface.cpp

@@ -4261,10 +4261,11 @@ void HighsMipSolverInfo::clear() {
   this->primal_dual_integral = -kHighsInf;
 }
 
-HighsStatus Highs::mipRaceResults(
-    HighsMipSolverInfo& mip_solver_info,
-    const std::vector<HighsMipSolverInfo>& worker_info,
-    const std::vector<double>& mip_time, const double& report_mip_time) {
+HighsStatus Highs::mipRaceResults(bool use_mip_race_single_presolve,
+				  HighsMipSolverInfo& mip_solver_info,
+				  const std::vector<HighsMipSolverInfo>& worker_info,
+				  const std::vector<double>& mip_time,
+				  double mip_race_time) {
   const HighsInt mip_race_concurrency = this->options_.mip_race_concurrency;
   HighsInt winning_instance = -1;
   HighsModelStatus winning_model_status = HighsModelStatus::kNotset;
@@ -4301,6 +4302,10 @@ HighsStatus Highs::mipRaceResults(
     }
   }
   if (winning_instance > 0) mip_solver_info = worker_info[winning_instance];
+
+  if (use_mip_race_single_presolve) assert(111==444);
+  mip_race_time += this->timer_.read();
+
   std::array<char, 128> gapString = getGapString(
       mip_solver_info.gap, mip_solver_info.primal_bound, &options_);
 
@@ -4351,7 +4356,7 @@ HighsStatus Highs::mipRaceResults(
   // Report the solution time for the whole concurrent loop, as that's
   // "real" time
   highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "  Timing            %.2f\n", report_mip_time);
+               "  Timing            %.2f\n", mip_race_time);
   highsLogUser(options_.log_options, HighsLogType::kInfo,
                "  Max sub-MIP depth %d\n",
                int(mip_solver_info.max_submip_level));

highs/lp_data/HighsOptions.h

@@ -426,6 +426,7 @@ struct HighsOptionsStruct {
   bool mip_allow_restart;
   HighsInt mip_race_concurrency;
   bool mip_race_read_solutions;
+  bool mip_race_single_presolve;
   HighsInt mip_max_nodes;
   HighsInt mip_max_stall_nodes;
   HighsInt mip_max_start_nodes;
@@ -579,6 +580,7 @@ struct HighsOptionsStruct {
         mip_allow_restart(false),
         mip_race_concurrency(0),
         mip_race_read_solutions(false),
+	mip_race_single_presolve(false),
         mip_max_nodes(0),
         mip_max_stall_nodes(0),
         mip_max_start_nodes(0),
@@ -1032,6 +1034,12 @@ class HighsOptions : public HighsOptionsStruct {
         &mip_race_read_solutions, true);
     records.push_back(record_bool);
 
+    record_bool = new OptionRecordBool(
+        "mip_race_single_presolve",
+        "Whether the MIP races should follow a single presolve", advanced,
+        &mip_race_single_presolve, true);
+    records.push_back(record_bool);
+
     record_int = new OptionRecordInt("mip_max_nodes",
                                      "MIP solver max number of nodes", advanced,
                                      &mip_max_nodes, 0, kHighsIInf, kHighsIInf);