Mip race

check/TestCallbacks.cpp

@@ -36,7 +36,7 @@ struct MipData {
 struct UserMipSolution {
   double optimal_objective_value;
   std::vector<double> optimal_solution;
-  HighsInt require_user_solution_callback_origin;
+  HighsInt require_external_solution_query_origin;
 };
 
 // Callback that saves message for comparison
@@ -193,8 +193,8 @@ HighsCallbackFunctionType userkMipUserSolution =
        void* user_callback_data) {
       UserMipSolution callback_data =
           *(static_cast<UserMipSolution*>(user_callback_data));
-      if (data_out->user_solution_callback_origin ==
-          callback_data.require_user_solution_callback_origin) {
+      if (data_out->external_solution_query_origin ==
+          callback_data.require_external_solution_query_origin) {
         if (data_out->mip_primal_bound >
             callback_data.optimal_objective_value) {
           // If current objective value is not optimal, pass the
@@ -203,7 +203,7 @@ HighsCallbackFunctionType userkMipUserSolution =
             printf(
                 "userkMipUserSolution: origin = %d; %g = mip_primal_bound > "
                 "optimal_objective_value = %g\n",
-                int(data_out->user_solution_callback_origin),
+                int(data_out->external_solution_query_origin),
                 data_out->mip_primal_bound,
                 callback_data.optimal_objective_value);
           data_in->user_has_solution = true;
@@ -218,13 +218,13 @@ HighsCallbackFunctionType userkMipUserSetSolution =
        void* user_callback_data) {
       const auto& callback_data =
           *(static_cast<UserMipSolution*>(user_callback_data));
-      if (data_out->user_solution_callback_origin ==
-          callback_data.require_user_solution_callback_origin) {
+      if (data_out->external_solution_query_origin ==
+          callback_data.require_external_solution_query_origin) {
         if (dev_run)
           printf(
               "userkMipUserSetSolution: origin = %d; %g = mip_primal_bound > "
               "optimal_objective_value = %g\n",
-              int(data_out->user_solution_callback_origin),
+              int(data_out->external_solution_query_origin),
               data_out->mip_primal_bound,
               callback_data.optimal_objective_value);
 
@@ -239,14 +239,14 @@ HighsCallbackFunctionType userkMipUserSetPartialSolution =
        void* user_callback_data) {
       const auto& callback_data =
           *(static_cast<UserMipSolution*>(user_callback_data));
-      if (data_out->user_solution_callback_origin ==
-          callback_data.require_user_solution_callback_origin) {
+      if (data_out->external_solution_query_origin ==
+          callback_data.require_external_solution_query_origin) {
         if (dev_run)
           printf(
               "userkMipUserSetPartialSolution: origin = %d; %g = "
               "mip_primal_bound > "
               "optimal_objective_value = %g\n",
-              int(data_out->user_solution_callback_origin),
+              int(data_out->external_solution_query_origin),
               data_out->mip_primal_bound,
               callback_data.optimal_objective_value);
 
@@ -511,7 +511,7 @@ static void runMipUserSolutionTest(
     UserMipSolution user_callback_data;
     user_callback_data.optimal_objective_value = objective_function_value0;
     user_callback_data.optimal_solution = optimal_solution;
-    user_callback_data.require_user_solution_callback_origin =
+    user_callback_data.require_external_solution_query_origin =
         require_origin[iModel];
     void* p_user_callback_data = (void*)(&user_callback_data);
 
@@ -597,4 +597,4 @@ TEST_CASE("highs-callback-mip-user-solution-c", "[highs-callback]") {
 
   highs.run();
   highs.resetGlobalScheduler(true);
-}
+}

check/TestMipSolver.cpp

@@ -40,12 +40,16 @@ TEST_CASE("MIP-rowless-1", "[highs_test_mip_solver]") {
   Highs highs;
   if (!dev_run) highs.setOptionValue("output_flag", false);
   rowlessMIP1(highs);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-rowless-2", "[highs_test_mip_solver]") {
   Highs highs;
   if (!dev_run) highs.setOptionValue("output_flag", false);
   rowlessMIP2(highs);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-solution-limit", "[highs_test_mip_solver]") {
@@ -79,6 +83,8 @@ TEST_CASE("MIP-solution-limit", "[highs_test_mip_solver]") {
   REQUIRE(highs.getModelStatus() == HighsModelStatus::kSolutionLimit);
   highs.setOptionValue("mip_max_improving_sols", kHighsIInf);
   highs.clearSolver();
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-integrality", "[highs_test_mip_solver]") {
@@ -173,6 +179,8 @@ TEST_CASE("MIP-integrality", "[highs_test_mip_solver]") {
   REQUIRE(info.mip_node_count == 1);
   REQUIRE(fabs(info.mip_dual_bound + 6) < double_equal_tolerance);
   REQUIRE(std::fabs(info.mip_gap) < 1e-12);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-clear-integrality", "[highs_test_mip_solver]") {
@@ -215,6 +223,8 @@ TEST_CASE("MIP-nmck", "[highs_test_mip_solver]") {
   REQUIRE(info.num_primal_infeasibilities == 0);
   REQUIRE(info.max_primal_infeasibility == 0);
   REQUIRE(info.sum_primal_infeasibilities == 0);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-maximize", "[highs_test_mip_solver]") {
@@ -295,6 +305,8 @@ TEST_CASE("MIP-maximize", "[highs_test_mip_solver]") {
   REQUIRE(std::abs(info.objective_function_value - info.mip_dual_bound) <=
           options.mip_abs_gap);
   REQUIRE(std::abs(info.mip_gap) <= options.mip_rel_gap);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-unbounded", "[highs_test_mip_solver]") {
@@ -403,6 +415,8 @@ TEST_CASE("MIP-unbounded", "[highs_test_mip_solver]") {
 
   model_status = highs.getModelStatus();
   REQUIRE(model_status == HighsModelStatus::kInfeasible);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-od", "[highs_test_mip_solver]") {
@@ -470,6 +484,8 @@ TEST_CASE("MIP-od", "[highs_test_mip_solver]") {
           double_equal_tolerance);
   REQUIRE(fabs(solution.col_value[0] - required_x0_value) <
           double_equal_tolerance);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-infeasible-start", "[highs_test_mip_solver]") {
@@ -513,6 +529,8 @@ TEST_CASE("MIP-infeasible-start", "[highs_test_mip_solver]") {
           HighsStatus::kOk);
   highs.run();
   REQUIRE(model_status == HighsModelStatus::kInfeasible);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("get-integrality", "[highs_test_mip_solver]") {}
@@ -556,6 +574,8 @@ TEST_CASE("MIP-bounds", "[highs_test_mip_solver]") {
            obj1);
   REQUIRE(obj0 == obj1);
   std::remove(test_mps.c_str());
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-get-saved-solutions", "[highs_test_mip_solver]") {
@@ -583,6 +603,8 @@ TEST_CASE("MIP-get-saved-solutions", "[highs_test_mip_solver]") {
     REQUIRE(saved_objective_and_solution[last_saved_solution].col_value[iCol] ==
             highs.getSolution().col_value[iCol]);
   std::remove(solution_file.c_str());
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-objective-target", "[highs_test_mip_solver]") {
@@ -597,6 +619,8 @@ TEST_CASE("MIP-objective-target", "[highs_test_mip_solver]") {
   highs.run();
   REQUIRE(highs.getModelStatus() == HighsModelStatus::kObjectiveTarget);
   REQUIRE(highs.getInfo().objective_function_value > egout_optimal_objective);
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-max-offset-test", "[highs_test_mip_solver]") {
@@ -625,6 +649,8 @@ TEST_CASE("MIP-max-offset-test", "[highs_test_mip_solver]") {
       highs.getInfo().objective_function_value;
   REQUIRE(objectiveOk(max_offset_optimal_objective, -offset_optimal_objective,
                       dev_run));
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("MIP-get-saved-solutions-presolve", "[highs_test_mip_solver]") {
@@ -663,6 +689,8 @@ TEST_CASE("MIP-get-saved-solutions-presolve", "[highs_test_mip_solver]") {
     REQUIRE(saved_objective_and_solution[last_saved_solution].col_value[iCol] ==
             highs.getSolution().col_value[iCol]);
   std::remove(solution_file.c_str());
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("IP-infeasible-unbounded", "[highs_test_mip_solver]") {
@@ -720,6 +748,8 @@ TEST_CASE("IP-infeasible-unbounded", "[highs_test_mip_solver]") {
     }
     highs.setOptionValue("presolve", kHighsOnString);
   }
+
+  highs.resetGlobalScheduler(true);
 }
 
 TEST_CASE("IP-with-fract-bounds-no-presolve", "[highs_test_mip_solver]") {
@@ -755,6 +785,8 @@ TEST_CASE("IP-with-fract-bounds-no-presolve", "[highs_test_mip_solver]") {
 
   // Infeasible
   REQUIRE(highs.getModelStatus() == HighsModelStatus::kInfeasible);
+
+  highs.resetGlobalScheduler(true);
 }
 
 bool objectiveOk(const double optimal_objective,
@@ -787,6 +819,8 @@ void solve(Highs& highs, std::string presolve,
                         require_optimal_objective, dev_run));
   }
   REQUIRE(highs.resetOptions() == HighsStatus::kOk);
+
+  highs.resetGlobalScheduler(true);
 }
 
 void distillationMIP(Highs& highs) {

highs/highs_bindings.cpp

@@ -975,7 +975,8 @@ PYBIND11_MODULE(_core, m, py::mod_gil_not_used()) {
       .value("kUnknown", HighsModelStatus::kUnknown)
       .value("kSolutionLimit", HighsModelStatus::kSolutionLimit)
       .value("kInterrupt", HighsModelStatus::kInterrupt)
-      .value("kMemoryLimit", HighsModelStatus::kMemoryLimit);
+      .value("kMemoryLimit", HighsModelStatus::kMemoryLimit)
+      .value("kHighsInterrupt", HighsModelStatus::kHighsInterrupt);
   py::enum_<HighsPresolveStatus>(m, "HighsPresolveStatus", py::module_local())
       .value("kNotPresolved", HighsPresolveStatus::kNotPresolved)
       .value("kNotReduced", HighsPresolveStatus::kNotReduced)

highs/interfaces/highs_csharp_api.cs

@@ -61,7 +61,8 @@ public enum HighsModelStatus
     kUnknown,
     kSolutionLimit,
     kInterrupt,
-    kMemoryLimit
+    kMemoryLimit,
+    kHighsInterrupt
 }
 
 public enum HighsIntegrality

highs/io/HighsIO.h

@@ -15,7 +15,6 @@
 #include <iostream>
 
 #include "lp_data/HighsCallback.h"
-// #include "util/HighsInt.h"
 
 class HighsOptions;
 

highs/lp_data/HConst.h

@@ -39,6 +39,7 @@ const double kExcessivelyLargeCostValue = 1e10;
 const double kExcessivelySmallBoundValue = 1e-4;
 const double kExcessivelySmallCostValue = 1e-4;
 
+const HighsInt kNoThreadInstance = -1;
 const bool kAllowDeveloperAssert = false;
 const bool kExtendInvertWhenAddingRows = false;
 
@@ -218,8 +219,9 @@ enum class HighsModelStatus {
   kSolutionLimit,
   kInterrupt,
   kMemoryLimit,
+  kHighsInterrupt,
   kMin = kNotset,
-  kMax = kMemoryLimit
+  kMax = kHighsInterrupt
 };
 
 enum HighsCallbackType : int {

highs/lp_data/Highs.cpp

@@ -4033,14 +4033,13 @@ HighsStatus Highs::callSolveMip() {
   // Extract the solution
   if (solver.solution_objective_ != kHighsInf) {
     // There is a primal solution
-    HighsInt solver_solution_size = solver.solution_.size();
-    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
     solution_.col_value.resize(model_.lp_.num_col_);
     solution_.col_value = solver.solution_;
-    saved_objective_and_solution_ = solver.saved_objective_and_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;
   } else {
@@ -4509,6 +4508,7 @@ HighsStatus Highs::returnFromOptimizeModel(const HighsStatus run_return_status,
     case HighsModelStatus::kIterationLimit:
     case HighsModelStatus::kSolutionLimit:
     case HighsModelStatus::kInterrupt:
+    case HighsModelStatus::kHighsInterrupt:
     case HighsModelStatus::kUnknown:
       assert(return_status == HighsStatus::kWarning);
       break;
@@ -4549,6 +4549,7 @@ HighsStatus Highs::returnFromOptimizeModel(const HighsStatus run_return_status,
     case HighsModelStatus::kIterationLimit:
     case HighsModelStatus::kSolutionLimit:
     case HighsModelStatus::kInterrupt:
+    case HighsModelStatus::kHighsInterrupt:
     case HighsModelStatus::kUnknown:
       // Have info and primal solution (unless infeasible). No primal solution
       // in some other case, too!

highs/lp_data/HighsCallback.cpp

@@ -35,8 +35,8 @@ void HighsCallback::clearHighsCallbackOutput() {
   this->data_out.cutpool_value.clear();
   this->data_out.cutpool_lower.clear();
   this->data_out.cutpool_upper.clear();
-  this->data_out.user_solution_callback_origin =
-      userMipSolutionCallbackOrigin::kUserMipSolutionCallbackOriginAfterSetup;
+  this->data_out.external_solution_query_origin =
+      ExternalMipSolutionQueryOrigin::kExternalMipSolutionQueryOriginAfterSetup;
 }
 
 void HighsCallback::clearHighsCallbackInput() {
@@ -134,8 +134,8 @@ HighsCallbackOutput::operator HighsCallbackDataOut() const {
                            ? nullptr
                            : const_cast<double*>(cutpool_upper.data());
 
-  data.user_solution_callback_origin =
-      static_cast<HighsInt>(user_solution_callback_origin);
+  data.external_solution_query_origin =
+      static_cast<HighsInt>(external_solution_query_origin);
   return data;
 }
 
@@ -320,4 +320,4 @@ HighsStatus HighsCallbackInput::repairSolution() {
       return HighsStatus::kError;
     }
   }
-}
+}

highs/lp_data/HighsCallback.h

@@ -20,14 +20,14 @@ class Highs;
 #include "lp_data/HStruct.h"
 #include "lp_data/HighsCallbackStruct.h"
 
-enum userMipSolutionCallbackOrigin {
-  kUserMipSolutionCallbackOriginAfterSetup = 0,
-  kUserMipSolutionCallbackOriginBeforeDive,
-  kUserMipSolutionCallbackOriginEvaluateRootNode0,
-  kUserMipSolutionCallbackOriginEvaluateRootNode1,
-  kUserMipSolutionCallbackOriginEvaluateRootNode2,
-  kUserMipSolutionCallbackOriginEvaluateRootNode3,
-  kUserMipSolutionCallbackOriginEvaluateRootNode4
+enum ExternalMipSolutionQueryOrigin {
+  kExternalMipSolutionQueryOriginAfterSetup = 0,
+  kExternalMipSolutionQueryOriginBeforeDive,
+  kExternalMipSolutionQueryOriginEvaluateRootNode0,
+  kExternalMipSolutionQueryOriginEvaluateRootNode1,
+  kExternalMipSolutionQueryOriginEvaluateRootNode2,
+  kExternalMipSolutionQueryOriginEvaluateRootNode3,
+  kExternalMipSolutionQueryOriginEvaluateRootNode4
 };
 
 /**
@@ -54,7 +54,7 @@ struct HighsCallbackOutput {
   std::vector<double> cutpool_value;
   std::vector<double> cutpool_lower;
   std::vector<double> cutpool_upper;
-  userMipSolutionCallbackOrigin user_solution_callback_origin;
+  ExternalMipSolutionQueryOrigin external_solution_query_origin;
 
   operator HighsCallbackDataOut() const;
 };

highs/lp_data/HighsCallbackStruct.h

@@ -44,7 +44,7 @@ typedef struct {
   double* cutpool_value;
   double* cutpool_lower;
   double* cutpool_upper;
-  HighsInt user_solution_callback_origin;
+  HighsInt external_solution_query_origin;
 } HighsCallbackDataOut;
 
 // Some external packages (e.g., jump) currently assume that the first 2 fields

highs/lp_data/HighsInfoDebug.cpp

@@ -48,6 +48,8 @@ HighsDebugStatus debugInfo(const HighsOptions& options, const HighsLp& lp,
     case HighsModelStatus::kTimeLimit:
     case HighsModelStatus::kIterationLimit:
     case HighsModelStatus::kSolutionLimit:
+    case HighsModelStatus::kInterrupt:
+    case HighsModelStatus::kHighsInterrupt:
     case HighsModelStatus::kUnknown:
       // Should have info
       assert(have_info == true);

highs/lp_data/HighsInterface.cpp

@@ -13,6 +13,7 @@
 #include "Highs.h"
 #include "lp_data/HighsLpUtils.h"
 #include "lp_data/HighsModelUtils.h"
+#include "mip/HighsMipSolver.h"  // For getGapString
 #include "model/HighsHessianUtils.h"
 #include "simplex/HSimplex.h"
 #include "util/HighsMatrixUtils.h"