MIP Worker Refactor

check/TestBasisSolves.cpp

@@ -449,7 +449,7 @@ TEST_CASE("Basis-solves", "[highs_basis_solves]") {
   //  filename = std::string(HIGHS_DIR) + "/check/instances/25fv47.mps";
 
   Highs highs;
-  if (!dev_run) highs.setOptionValue("output_flag", false);
+  highs.setOptionValue("output_flag", dev_run);
 
   vector<HighsInt> basic_variables;
   vector<double> rhs, solution_row, solution_col;

check/TestCheckSolution.cpp

@@ -87,6 +87,7 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
   HighsSolution optimal_solution = highs.getSolution();
 
   HighsInt scratch_num_nodes = info.mip_node_count;
+  HighsInt scratch_num_simplex = info.simplex_iteration_count;
   if (dev_run) printf("Num nodes = %d\n", int(scratch_num_nodes));
 
   std::string solution_file = test_name + model + ".sol";
@@ -113,7 +114,10 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
 
     highs.run();
     if (dev_run) printf("Num nodes = %d\n", int(info.mip_node_count));
-    REQUIRE(info.mip_node_count != scratch_num_nodes);
+    const bool different_search =
+        info.mip_node_count != scratch_num_nodes ||
+        info.simplex_iteration_count != scratch_num_simplex;
+    REQUIRE(different_search);
     highs.clear();
   }
 
@@ -132,7 +136,10 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
 
     highs.run();
     if (dev_run) printf("Num nodes = %d\n", int(info.mip_node_count));
-    REQUIRE(info.mip_node_count != scratch_num_nodes);
+    const bool different_search =
+        info.mip_node_count != scratch_num_nodes ||
+        info.simplex_iteration_count != scratch_num_simplex;
+    REQUIRE(different_search);
     highs.clear();
   }
 
@@ -162,7 +169,10 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
 
     highs.run();
     if (dev_run) printf("Num nodes = %d\n", int(info.mip_node_count));
-    REQUIRE(info.mip_node_count != scratch_num_nodes);
+    const bool different_search =
+        info.mip_node_count != scratch_num_nodes ||
+        info.simplex_iteration_count != scratch_num_simplex;
+    REQUIRE(different_search);
     highs.clear();
   }
 
@@ -185,7 +195,10 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
 
     highs.run();
     if (dev_run) printf("Num nodes = %d\n", int(info.mip_node_count));
-    REQUIRE(info.mip_node_count != scratch_num_nodes);
+    const bool different_search =
+        info.mip_node_count != scratch_num_nodes ||
+        info.simplex_iteration_count != scratch_num_simplex;
+    REQUIRE(different_search);
     highs.clear();
   }
 
@@ -232,7 +245,10 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
     return_status = highs.setSolution(starting_solution);
     REQUIRE(return_status == HighsStatus::kOk);
     highs.run();
-    REQUIRE(info.mip_node_count != scratch_num_nodes);
+    const bool different_search =
+        info.mip_node_count != scratch_num_nodes ||
+        info.simplex_iteration_count != scratch_num_simplex;
+    REQUIRE(different_search);
     highs.clear();
   }
 
@@ -283,7 +299,10 @@ TEST_CASE("check-set-mip-solution", "[highs_check_solution]") {
     return_status = highs.setSolution(num_entries, index.data(), value.data());
     REQUIRE(return_status == HighsStatus::kOk);
     highs.run();
-    REQUIRE(info.mip_node_count != scratch_num_nodes);
+    const bool different_search =
+        info.mip_node_count != scratch_num_nodes ||
+        info.simplex_iteration_count != scratch_num_simplex;
+    REQUIRE(different_search);
     highs.clear();
   }
   assert(other_tests);

check/TestMipSolver.cpp

@@ -1162,6 +1162,7 @@ TEST_CASE("mip-lp-solver", "[highs_test_mip_solver]") {
 #endif
 }
 
+/*
 TEST_CASE("mip-sub-solver-time", "[highs_test_mip_solver]") {
   const std::string model = "flugpl";  //"rgn"; //
   std::string model_file =
@@ -1174,6 +1175,7 @@ TEST_CASE("mip-sub-solver-time", "[highs_test_mip_solver]") {
   REQUIRE(h.run() == HighsStatus::kOk);
   REQUIRE(h.getModelStatus() == HighsModelStatus::kOptimal);
 }
+*/
 
 TEST_CASE("get-fixed-lp", "[highs_test_mip_solver]") {
   std::string model = "avgas";
@@ -1405,6 +1407,28 @@ TEST_CASE("issue-2173", "[highs_test_mip_solver]") {
   solve(highs, kHighsOnString, require_model_status, optimal_objective);
 }
 
+TEST_CASE("parallel-mip-determinism", "[highs_test_mip_solver]") {
+  std::string filename = std::string(HIGHS_DIR) + "/check/instances/bell5.mps";
+  HighsInt num_runs = 6;
+  std::vector<HighsInt> lp_iters(num_runs);
+  for (HighsInt i = 0; i < num_runs; i++) {
+    Highs highs;
+    highs.setOptionValue("output_flag", dev_run);
+    highs.setOptionValue("mip_rel_gap", 0);
+    highs.setOptionValue("threads", 2);
+    highs.setOptionValue("mip_search_concurrency", 2);
+    if (i % 2 == 0) highs.setOptionValue("mip_search_simulate_concurrency", 1);
+    highs.readModel(filename);
+    const HighsModelStatus require_model_status = HighsModelStatus::kOptimal;
+    const double optimal_objective = 8966406.491519;
+    solve(highs, kHighsOffString, require_model_status, optimal_objective);
+    lp_iters[i] = highs.getInfo().simplex_iteration_count;
+    if (i > 0) {
+      REQUIRE(lp_iters[i] == lp_iters[0]);
+    }
+  }
+}
+
 TEST_CASE("issue-2957", "[highs_test_mip_solver]") {
   HighsLp lp;
   lp.num_col_ = 2;

check/TestSemiVariables.cpp

@@ -26,6 +26,7 @@ TEST_CASE("semi-variable-model", "[highs_test_semi_variables]") {
   const double semi_col_lower = lp.col_lower_[semi_col];
   const double semi_col_upper = lp.col_upper_[semi_col];
   lp.col_cost_[semi_col] = semi_col_cost;
+  lp.model_name_ = "semi-variable-model";
   optimal_objective_function_value = 6.83333;
   // Legal to have infinte upper bounds on semi-variables
   lp.col_upper_[semi_col] = inf;

cmake/sources.cmake

@@ -380,9 +380,9 @@ set(highs_sources
     mip/HighsImplications.cpp
     mip/HighsLpAggregator.cpp
     mip/HighsLpRelaxation.cpp
-    mip/HighsMipAnalysis.cpp
     mip/HighsMipSolver.cpp
     mip/HighsMipSolverData.cpp
+    mip/HighsMipWorker.cpp
     mip/HighsModkSeparator.cpp
     mip/HighsNodeQueue.cpp
     mip/HighsObjectiveFunction.cpp
@@ -510,9 +510,9 @@ set(highs_headers
     mip/HighsImplications.h
     mip/HighsLpAggregator.h
     mip/HighsLpRelaxation.h
-    mip/HighsMipAnalysis.h
     mip/HighsMipSolver.h
     mip/HighsMipSolverData.h
+    mip/HighsMipWorker.h
     mip/HighsModkSeparator.h
     mip/HighsNodeQueue.h
     mip/HighsObjectiveFunction.h

highs/Highs.h

@@ -1235,24 +1235,9 @@ class Highs {
   HighsStatus setBasis();
 
   /**
-   * @brief Return a const reference to the internal sub-solver call and time
-   * instance
-   */
-  const HighsSubSolverCallTime& getSubSolverCallTime() const {
-    return sub_solver_call_time_;
-  }
-
-  /**
-   * @brief Report internal sub-solver call and time instance
-   */
-  void reportSubSolverCallTime() const;
-
-  /**
-   * @brief Initialise the internal sub-solver call and time instance
+   * @brief Report profiling
    */
-  void initialiseSubSolverCallTime() {
-    this->sub_solver_call_time_.initialise();
-  }
+  void reportProfiling() const;
 
   /**
    * @brief Run IPX crossover from a given HighsSolution instance and,
@@ -1282,6 +1267,14 @@ class Highs {
   std::string basisValidityToString(const HighsInt basis_validity) const;
   std::string presolveRuleTypeToString(const HighsInt presolve_rule) const;
 
+  /**
+   * @brief Ensures that the global scheduler is initialized,
+   * returning HighsStatus::kError if it has already been initialized,
+   * but the threads option is nonzero and not equal to
+   * this->max_threads_.
+   */
+  HighsStatus initializeMultiThreading();
+
   /**
    * @brief Releases all resources held by the global scheduler instance. It is
    * not thread-safe to call this function while calling run() or presolve() on
@@ -1297,6 +1290,29 @@ class Highs {
    */
   static void resetGlobalScheduler(bool blocking = false);
 
+  /**
+   * @brief If profiling is not nullptr, sets up profiling and copies
+   * its pointer to Highs
+   */
+  void initializeProfiling(HighsProfiling* profiling);
+  void initializeSingleThreadedProfiling(HighsProfiling* profiling);
+
+  /**
+   * @brief Clears and then initializes profiling
+   */
+  void resetProfiling();
+
+  /**
+   * @brief If Highs::profiling_ is not nullptr, clears profiling and
+   * sets Highs::profiling_ to nullptr
+   */
+  void clearProfiling();
+
+  /**
+   * @brief Checks that pointer is not nullptr, and copies it to Highs
+   */
+  void setProfiling(HighsProfiling* profiling);
+
   // Start of advanced methods: only for internal use!
 
   // Nested methods below Highs::run()
@@ -1563,9 +1579,9 @@ class Highs {
 
   HighsPresolveLog presolve_log_;
 
-  HighsSubSolverCallTime sub_solver_call_time_;
+  HighsProfiling* profiling_ = nullptr;
 
-  HighsInt max_threads = 0;
+  HighsInt max_threads_ = 0;
   // This is strictly for debugging. It's used to check whether
   // returnFromOptimizeModel() was called after the previous call to
   // Highs::optimizeModel() and, assuming that this is always done, it checks

highs/lp_data/HConst.h

@@ -33,6 +33,7 @@ const std::string kHighsChooseString = "choose";
 const std::string kHighsOnString = "on";
 const HighsInt kHighsMaxStringLength = 512;
 const HighsInt kSimplexConcurrencyLimit = 8;
+const HighsInt kMipSearchConcurrencyLimit = 8;
 const double kRunningAverageMultiplier = 0.05;
 
 const double kExcessivelySmallObjectiveCoefficient = 1e-4;
@@ -302,8 +303,22 @@ enum IisStatus : int {
   kIisStatusMax = kIisStatusInConflict
 };
 
+enum MipChooseSubMipRecord : int {
+  kMipRecord = -1,
+  kChooseRecord,
+  kSubMipRecord
+};
+
+enum PresolveSolvePostsolveIndex : int {
+  kPresolveTime = 0,
+  kSolveTime,
+  kPostsolveTime,
+  kToPresolveSolvePostsolve
+};
+
 enum SubSolverIndex : int {
-  kSubSolverMip = 0,
+  kFromSubSolver = kToPresolveSolvePostsolve,
+  kSubSolverMip = kFromSubSolver,
   kSubSolverDuSimplexBasis,
   kSubSolverDuSimplexNoBasis,
   kSubSolverPrSimplexBasis,
@@ -315,7 +330,8 @@ enum SubSolverIndex : int {
   kSubSolverPdlp,
   kSubSolverQpAsm,
   kSubSolverSubMip,
-  kSubSolverCount
+  kLastSubSolver = kSubSolverSubMip,
+  kToSubSolver = kLastSubSolver + 1
 };
 
 // Minimum and default KKT tolerance

highs/lp_data/HStruct.h

@@ -15,6 +15,7 @@
 #include <vector>
 
 #include "lp_data/HConst.h"
+#include "util/HighsTimer.h"
 
 struct HighsSolution {
   bool value_valid = false;
@@ -165,13 +166,45 @@ struct HighsLinearObjective {
   void clear();
 };
 
-struct HighsSubSolverCallTime {
-  std::vector<std::string> name;
+struct HighsProfilingRecord {
   std::vector<HighsInt> num_call;
   std::vector<double> run_time;
-  void initialise();
-  void add(const HighsSubSolverCallTime& sub_solver_call_time,
-           const bool analytic_centre = false);
+  std::vector<double> start_time;
+};
+
+struct HighsProfiling {
+  HighsTimer* timer = nullptr;
+  bool multi_threaded = true;
+  std::string model_name_ = "";
+  bool sub_solver_ = false;
+  bool mip_ = false;
+  HighsInt num_profiling_clock_ = -1;
+  std::vector<std::string> name;
+  // These vectors are over threads
+  std::vector<bool> submip;
+  std::vector<HighsProfilingRecord> record;
+  std::vector<HighsProfilingRecord> submip_record;
+  bool initialized = false;
+
+  void initialize(HighsTimer& timer_, const bool subsolver_profiling,
+                  const bool mip_profiling = false);
+  void clear();
+  HighsInt numThread();
+  HighsInt myThread();
+  void setSubMip(const bool submip);
+  bool isSubMip();
+  HighsProfilingRecord* getHighsProfilingRecord(
+      const HighsInt record_type = kChooseRecord);
+  void start(const HighsInt profiling_clock, const bool restart = false);
+  void stop(const HighsInt profiling_clock);
+  double read(const HighsInt profiling_clock,
+              const HighsInt record_type = kChooseRecord);
+  bool running(const HighsInt profiling_clock,
+               const HighsInt record_type = kChooseRecord);
+  HighsInt numCall(const HighsInt profiling_clock,
+                   const HighsInt record_type = kChooseRecord);
+  void solveCall(const std::string& model, const bool submip);
+  //  HighsInt getSepaClockIndex(const std::string& name);
 };
 
 struct HighsSimplexStats {