Deleted MIP race code

Author: jajhall

check/TestMipSolver.cpp

@@ -1035,33 +1035,3 @@ TEST_CASE("issue-2432", "[highs_test_mip_solver]") {
         "found\n");
   solve(highs, kHighsOffString, require_model_status, optimal_objective);
 }
-
-TEST_CASE("mip-race", "[highs_test_mip_solver]") {
-  const bool ci_test = true;
-  const std::string test_build_model = "fiball";  //"neos-3381206-awhea";  //
-  const std::string model = ci_test ? "flugpl" : test_build_model;
-  // "neos-3381206-awhea";
-  const std::string model_file =
-      ci_test ? std::string(HIGHS_DIR) + "/check/instances/" + model + ".mps"
-              : "/srv/miplib2017/" + model + ".mps.gz";
-  Highs h;
-  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", true);
-  for (HighsInt k = 0; k < 2; 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();
-    h.setOptionValue("mip_race_read_solutions", false);
-    REQUIRE(h.run() == HighsStatus::kOk);
-    REQUIRE(h.getModelStatus() == HighsModelStatus::kOptimal);
-  }
-  h.resetGlobalScheduler(true);
-}

highs/Highs.h

@@ -1503,9 +1503,8 @@ class Highs {
   HighsStatus callSolveLp(HighsLp& lp, const string message);
   HighsStatus callSolveQp();
   HighsStatus callSolveMip();
-  HighsStatus callRunPostsolve(
-      const HighsSolution& solution, const HighsBasis& basis,
-      const bool suppress_mip_model_status_warning = false);
+  HighsStatus callRunPostsolve(const HighsSolution& solution,
+                               const HighsBasis& basis);
 
   PresolveComponent presolve_;
   HighsPresolveStatus runPresolve(const bool force_lp_presolve,
@@ -1715,11 +1714,6 @@ class Highs {
   bool optionsHasHighsFiles() const;
   void saveHighsFiles();
   void getHighsFiles();
-  HighsStatus 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);
 };
 
 // Start of deprecated methods not in the Highs class

highs/lp_data/Highs.cpp

@@ -4030,127 +4030,11 @@ HighsStatus Highs::callSolveMip() {
     use_lp = withoutSemiVariables(model_.lp_, solution_,
                                   options_.primal_feasibility_tolerance);
   }
-  // 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;
-  // Take a copy of the presolve option in case it's switched off for
-  // a single presolve MIP race
-  const std::string presolve = this->options_.presolve;
-  if (use_mip_race_single_presolve) {
-    // Perform presolve before the MIP race
-    //
-    // NB Highs::presolve() 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;
-    HighsStatus call_status = this->presolve();
-    // ... then set it back to false and restart the run clock
-    this->called_return_from_optimize_model = false;
-    this->timer_.start();
-    if (call_status != HighsStatus::kOk) return call_status;
-    presolved_lp = this->getPresolvedLp();
-    this->options_.presolve = kHighsOffString;
-  }
-  // Create the master MIP solver instance that will exist beyond any
-  // MIP race
-  HighsLp& lp =
-      has_semi_variables
-          ? use_lp
-          : (use_mip_race_single_presolve ? presolved_lp : model_.lp_);
+  HighsLp& lp = has_semi_variables ? use_lp : model_.lp_;
   HighsMipSolver solver(callback_, options_, lp, solution_);
   HighsMipSolverInfo mip_solver_info;
-  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_);
-    // Set up the shared memory for the concurrent MIP terminator
-    auto terminator_record =
-        solver.initialiseTerminatorRecord(mip_race_concurrency);
-    // Don't allow callbacks for workers
-    HighsCallback worker_callback = callback_;
-    worker_callback.clear();
-    // Race the MIP solver!
-    highsLogUser(options_.log_options, HighsLogType::kInfo,
-                 "\nStarting MIP race with %d instances: behaviour is "
-                 "non-deterministic!\n\n",
-                 int(mip_race_concurrency));
-    // Define the HighsMipSolverInfo record for each worker
-    std::vector<HighsMipSolverInfo> worker_info(mip_race_concurrency);
-    // Set up the vector of options settings for workers
-    std::vector<HighsOptions> worker_options;
-    //    std::vector<HighsMipSolver*> worker;
-    std::vector<double> mip_time(mip_race_concurrency);
-    for (HighsInt instance = 0; instance < mip_race_concurrency; instance++) {
-      HighsOptions instance_options = options_;
-      // No workers log to console
-      instance_options.log_to_console = false;
-      instance_options.setLogOptions();
-      // Use the instance ID as an offset to the random seed
-      instance_options.random_seed = options_.random_seed + instance;
-      std::string worker_log_file =
-          "mip_worker" + std::to_string(instance) + ".log";
-      if (options_.output_flag)
-        highsOpenLogFile(instance_options, worker_log_file);
-      worker_options.push_back(instance_options);
-    }
-    highs::parallel::for_each(
-        0, mip_race_concurrency, [&](HighsInt start, HighsInt end) {
-          for (HighsInt instance = start; instance < end; instance++) {
-            if (instance == 0) {
-              solver.initialiseTerminator(mip_race_concurrency, instance,
-                                          terminator_record.data());
-              solver.initialiseMipRace(mip_race_concurrency, instance,
-                                       &mip_race_record);
-              mip_time[instance] = -timer_.read();
-              solver.run();
-              mip_time[instance] += timer_.read();
-              mip_solver_info = getMipSolverInfo(solver);
-            } else {
-              HighsMipSolver worker(worker_callback, worker_options[instance],
-                                    lp, solution_);
-              worker.initialiseTerminator(mip_race_concurrency, instance,
-                                          terminator_record.data());
-              worker.initialiseMipRace(mip_race_concurrency, instance,
-                                       &mip_race_record);
-              mip_time[instance] = -timer_.read();
-              worker.run();
-              mip_time[instance] += timer_.read();
-              worker_info[instance] = getMipSolverInfo(worker);
-            }
-          }
-        });
-    // Determine the winner and report on the solution
-    HighsStatus call_status =
-        this->mipRaceResults(use_mip_race_single_presolve, mip_solver_info,
-                             worker_info, mip_time, mip_race_time);
-    // Restore the presolve option - that will have been set to
-    // kHighsOffString for a single presolve MIP race
-    this->options_.presolve = presolve;
-
-    if (call_status == HighsStatus::kError) {
-      const bool undo_mods = true;
-      return returnFromOptimizeModel(HighsStatus::kError, undo_mods);
-    }
-  } else {
-    // Run a single MIP solver
-    solver.run();
-    mip_solver_info = getMipSolverInfo(solver);
-  }
+  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
@@ -4160,14 +4044,7 @@ HighsStatus Highs::callSolveMip() {
   // Extract the solution
   if (mip_solver_info.solution_objective != kHighsInf) {
     // There is a primal solution
-    HighsInt solver_solution_size = mip_solver_info.solution.size();
-    const bool solver_solution_size_ok = solver_solution_size >= lp.num_col_;
-    if (!solver_solution_size)
-      highsLogUser(
-          options_.log_options, HighsLogType::kError,
-          "After MIP race, size of solution is %d < %d = lp.num_col_\n",
-          int(solver_solution_size), int(lp.num_col_));
-    assert(solver_solution_size >= lp.num_col_);
+    //
     // 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
@@ -4240,10 +4117,9 @@ HighsStatus Highs::callSolveMip() {
   return return_status;
 }
 
-// Only called from Highs::postsolve and Highs::mipRaceResults
-HighsStatus Highs::callRunPostsolve(
-    const HighsSolution& solution, const HighsBasis& basis,
-    const bool suppress_mip_model_status_warning) {
+// Only called from Highs::postsolve
+HighsStatus Highs::callRunPostsolve(const HighsSolution& solution,
+                                    const HighsBasis& basis) {
   HighsStatus return_status = HighsStatus::kOk;
   HighsStatus call_status;
   const HighsLp& presolved_lp = presolve_.getReducedProblem();
@@ -4308,12 +4184,9 @@ HighsStatus Highs::callRunPostsolve(
                        max_integrality_violation);
         }
       }
-      // When calling postsolve after MIP race on presolved model,
-      // model status can be trusted so suppress the warning message
-      if (!suppress_mip_model_status_warning)
-        highsLogUser(
-            options_.log_options, HighsLogType::kWarning,
-            "Postsolve performed for MIP, but model status cannot be known\n");
+      highsLogUser(
+          options_.log_options, HighsLogType::kWarning,
+          "Postsolve performed for MIP, but model status cannot be known\n");
     } else {
       highsLogUser(options_.log_options, HighsLogType::kError,
                    "Postsolve return status is %d\n", (int)postsolve_status);

highs/lp_data/HighsInterface.cpp

@@ -4260,143 +4260,3 @@ void HighsMipSolverInfo::clear() {
   this->total_lp_iterations = -kHighsSize_tInf;
   this->primal_dual_integral = -kHighsInf;
 }
-
-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;
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "\nMIP race results\n");
-  for (HighsInt instance = 0; instance < mip_race_concurrency; instance++) {
-    const HighsMipSolverInfo& solver_info =
-        instance == 0 ? mip_solver_info : worker_info[instance];
-    HighsModelStatus instance_model_status = solver_info.modelstatus;
-    highsLogUser(options_.log_options, HighsLogType::kInfo,
-                 "   Solver %2d has best objective %15.8g, gap %6.2f%% (time "
-                 "= %6.2f), and status %s\n",
-                 int(instance), solver_info.solution_objective,
-                 1e2 * solver_info.gap, mip_time[instance],
-                 modelStatusToString(instance_model_status).c_str());
-    if (instance_model_status != HighsModelStatus::kHighsInterrupt) {
-      // Definitive status for this instance, so check compatibility
-      // with any current winning model status
-      if (winning_model_status != HighsModelStatus::kNotset) {
-        if (winning_model_status != instance_model_status) {
-          highsLogUser(options_.log_options, HighsLogType::kError,
-                       "MIP race: conflict between status \"%s\" for "
-                       "instance %d and status \"%s\" for instance %d\n",
-                       modelStatusToString(winning_model_status).c_str(),
-                       int(winning_instance),
-                       modelStatusToString(instance_model_status).c_str(),
-                       int(instance));
-          return HighsStatus::kError;
-        }
-      } else {
-        winning_model_status = instance_model_status;
-        winning_instance = instance;
-      }
-    }
-  }
-  if (winning_instance > 0) mip_solver_info = worker_info[winning_instance];
-
-  const bool havesolution = mip_solver_info.solution_objective != kHighsInf;
-
-  if (use_mip_race_single_presolve && havesolution) {
-    HighsSolution solution;
-    solution.col_value = mip_solver_info.solution;
-    // Perform postsolve after the MIP race
-    //
-    // Set up an empty basis so that callRunPostsolve can be used
-    HighsBasis basis;
-    // Need to suppress the warning about the HighsModelStatus for
-    // MIPs that (in general) can't be set after postsolve
-    const bool suppress_mip_model_status_warning = true;
-    HighsStatus call_status = this->callRunPostsolve(
-        solution, basis, suppress_mip_model_status_warning);
-    // call_status will be HighsStatus::kWarning, since model_status_
-    // is typically HighsModelStatus::kUnknown due to the lack of
-    // optimality test for a MIP. However, since this postsolve was
-    // run for a solution that was optimal for the presolved problem
-    // (and that status is in mip_solver_info) the warning can be
-    // ignored.
-    if (call_status == HighsStatus::kError) return call_status;
-    // Now update the MipSolverInfo with the postsolved solution
-    mip_solver_info.solution = this->solution_.col_value;
-  }
-  const HighsInt mip_solver_info_solution_size =
-      mip_solver_info.solution.size();
-  if (0 < mip_solver_info_solution_size &&
-      mip_solver_info_solution_size < this->model_.lp_.num_col_) {
-    printf(
-        "Highs::mipRaceResults MipSolverInfo solution size = %d < %d = "
-        "num_col\n",
-        int(mip_solver_info_solution_size), int(this->model_.lp_.num_col_));
-    assert(11 == 33);
-  }
-
-  mip_race_time += this->timer_.read();
-
-  std::array<char, 128> gapString = getGapString(
-      mip_solver_info.gap, mip_solver_info.primal_bound, &options_);
-
-  bool feasible;
-  std::string solutionstatus = "-";
-  if (havesolution) {
-    feasible =
-        mip_solver_info.bound_violation <= options_.mip_feasibility_tolerance &&
-        mip_solver_info.integrality_violation <=
-            options_.mip_feasibility_tolerance &&
-        mip_solver_info.row_violation <= options_.mip_feasibility_tolerance;
-  } else {
-    feasible = false;
-  }
-  solutionstatus = feasible ? "feasible" : "infeasible";
-
-  highsLogUser(options_.log_options, HighsLogType::kInfo, "Solving report\n");
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "  Model             %s\n",
-               this->model_.lp_.model_name_.c_str());
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "  Status            %s\n",
-               modelStatusToString(mip_solver_info.modelstatus).c_str());
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "  Primal bound      %.12g\n", mip_solver_info.primal_bound);
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "  Dual bound        %.12g\n", mip_solver_info.dual_bound);
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "  Gap               %s\n", gapString.data());
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "  P-D integral      %.12g\n",
-               mip_solver_info.primal_dual_integral);
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "  Solution status   %s\n", solutionstatus.c_str());
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "                    %.12g\n",
-               mip_solver_info.solution_objective);
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "                    %.12g (bound viol.)\n",
-               mip_solver_info.bound_violation);
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "                    %.12g (int. viol.)\n",
-               mip_solver_info.integrality_violation);
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "                    %.12g (row viol.)\n",
-               mip_solver_info.row_violation);
-  // Report the solution time for the whole concurrent loop, as that's
-  // "real" time
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "  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));
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "  Nodes             %llu\n",
-               (long long unsigned)(mip_solver_info.node_count));
-  highsLogUser(options_.log_options, HighsLogType::kInfo,
-               "  LP iterations     %llu\n",
-               (long long unsigned)(mip_solver_info.total_lp_iterations));
-  return HighsStatus::kOk;
-}