linear_solver: implement logcallback for HiGHS

Author: kiijeonghoo

ortools/linear_solver/java/ModelBuilderTest.java

@@ -152,4 +152,25 @@ public void importFromLpString() {
     assertThat(model.varFromIndex(0).getUpperBound()).isEqualTo(42.0);
     assertThat(model.varFromIndex(0).getName()).isEqualTo("x");
   }
+
+  @Test
+  public void highsLogCallback_receivesLogsWhenEnabled() {
+    ModelBuilder model = new ModelBuilder();
+    double infinity = Double.POSITIVE_INFINITY;
+    Variable x = model.newNumVar(0.0, infinity, "x");
+    Variable y = model.newNumVar(0.0, infinity, "y");
+    model.addLessOrEqual(LinearExpr.sum(new Variable[] {x, y}), 10.0);
+    model.maximize(LinearExpr.newBuilder().addTerm(x, 1.0).addTerm(y, 2.0));
+
+    ModelSolver solver = new ModelSolver("highs");
+    if (!solver.solverIsSupported()) {
+      return;
+    }
+    StringBuilder log = new StringBuilder();
+    solver.setLogCallback(msg -> log.append(msg));
+    solver.enableOutput(true);
+    assertThat(solver.solve(model)).isEqualTo(SolveStatus.OPTIMAL);
+    assertThat(log.length()).isGreaterThan(0);
+    assertThat(log.toString()).contains("Model");
+  }
 }

ortools/linear_solver/proto_solver/highs_proto_solver.cc

@@ -46,8 +46,25 @@ namespace operations_research {
 absl::Status SetSolverSpecificParameters(const std::string& parameters,
                                          Highs& highs);
 
+namespace {
+
+// Adapter from HiGHS unified callback (setCallback) to OR-Tools
+// TODO: Only forwards kCallbackLogging now
+void HighsCallbackAdapter(int callback_type, const std::string& message,
+                          const HighsCallbackOutput*, HighsCallbackInput*,
+                          void* user_data) {
+  if (callback_type == kCallbackLogging && user_data != nullptr) {
+    const auto* cb =
+        static_cast<const std::function<void(const std::string&)>*>(user_data);
+    if (*cb) (*cb)(message);
+  }
+}
+
+}
+
 absl::StatusOr<MPSolutionResponse> HighsSolveProto(
-    LazyMutableCopy<MPModelRequest> request, HighsSolveInfo* solve_info) {
+    LazyMutableCopy<MPModelRequest> request, HighsSolveInfo* solve_info,
+    const std::function<void(const std::string&)>* logging_callback) {
   MPSolutionResponse response;
   const std::optional<LazyMutableCopy<MPModelProto>> optional_model =
       GetMPModelOrPopulateResponse(request, &response);
@@ -81,6 +98,29 @@ absl::StatusOr<MPSolutionResponse> HighsSolveProto(
     }
   }
 
+  // Logging.
+  if (request->enable_internal_solver_output()) {
+    highs.setOptionValue("log_to_console", true);
+    highs.setOptionValue("output_flag", true);
+    if (logging_callback != nullptr && *logging_callback) {
+      if (highs.setCallback(HighsCallbackAdapter,
+                            const_cast<std::function<void(const std::string&)>*>(
+                                logging_callback)) != HighsStatus::kOk) {
+        response.set_status(MPSOLVER_ABNORMAL);
+        response.set_status_str("HiGHS setCallback failed");
+        return response;
+      }
+      if (highs.startCallback(kCallbackLogging) != HighsStatus::kOk) {
+        response.set_status(MPSOLVER_ABNORMAL);
+        response.set_status_str("HiGHS startCallback(kCallbackLogging) failed");
+        return response;
+      }
+    }
+  } else {
+    highs.setOptionValue("log_to_console", false);
+    highs.setOptionValue("output_flag", false);
+  }
+
   const int variable_size = model.variable_size();
   bool has_integer_variables = false;
   {
@@ -211,19 +251,16 @@ absl::StatusOr<MPSolutionResponse> HighsSolveProto(
     highs.changeObjectiveOffset(offset);
   }
 
-  // Logging.
-  if (request->enable_internal_solver_output()) {
-    highs.setOptionValue("log_to_console", true);
-    highs.setOptionValue("output_flag", true);
-  } else {
-    highs.setOptionValue("log_to_console", false);
-    highs.setOptionValue("output_flag", false);
-  }
-
   const absl::Time time_before = absl::Now();
   UserTimer user_timer;
   user_timer.Start();
   const HighsStatus run_status = highs.run();
+
+  // Unregister log callback.
+  if (logging_callback != nullptr && *logging_callback) {
+    highs.stopCallback(kCallbackLogging);
+    highs.setCallback(nullptr, nullptr);
+  }
   VLOG(2) << "run_status: " << highsStatusToString(run_status);
   if (run_status == HighsStatus::kError) {
     response.set_status(MPSOLVER_NOT_SOLVED);

ortools/linear_solver/proto_solver/highs_proto_solver.h

@@ -15,6 +15,8 @@
 #define ORTOOLS_LINEAR_SOLVER_PROTO_SOLVER_HIGHS_PROTO_SOLVER_H_
 
 #include <cstdint>
+#include <functional>
+#include <string>
 
 #include "absl/status/statusor.h"
 #include "ortools/linear_solver/linear_solver.pb.h"
@@ -28,10 +30,12 @@ struct HighsSolveInfo {
 };
 
 // Solve the input MIP model with the HIGHS solver and fills `solve_info` if
-// provided.
+// provided. When `logging_callback` is non-null and points to a callable
+// function, solver log messages are sent to it instead of the console.
 absl::StatusOr<MPSolutionResponse> HighsSolveProto(
     LazyMutableCopy<MPModelRequest> request,
-    HighsSolveInfo* solve_info = nullptr);
+    HighsSolveInfo* solve_info = nullptr,
+    const std::function<void(const std::string&)>* logging_callback = nullptr);
 
 }  // namespace operations_research
 

ortools/linear_solver/python/model_builder_helper.cc

@@ -47,6 +47,7 @@
 #include "ortools/linear_solver/model_exporter.h"
 #include "pybind11/cast.h"
 #include "pybind11/eigen.h"
+#include "pybind11/functional.h"
 #include "pybind11/numpy.h"
 #include "pybind11/pybind11.h"
 #include "pybind11/pytypes.h"

ortools/linear_solver/python/model_builder_test.py

@@ -205,6 +205,23 @@ def test_import_from_lp_file(self):
         self.assertEqual(42, model.var_from_index(0).upper_bound)
         self.assertEqual("x", model.var_from_index(0).name)
 
+    def test_highs_log_callback_receives_logs_when_enabled(self):
+        model = mb.Model()
+        x = model.new_num_var(0.0, math.inf, "x")
+        y = model.new_num_var(0.0, math.inf, "y")
+        model.add(x + y <= 10.0)
+        model.maximize(1.0 * x + 2.0 * y)
+
+        solver = mb.Solver("highs")
+        if not solver.solver_is_supported():
+            return
+        log_lines = []
+        solver.log_callback = log_lines.append
+        solver.enable_output(True)
+        self.assertEqual(solver.solve(model), mb.SolveStatus.OPTIMAL)
+        self.assertGreater(len(log_lines), 0, "Log callback should receive output")
+        self.assertIn("Model", "".join(log_lines))
+
     def test_class_api(self):
         model = mb.Model()
         x = model.new_int_var(0, 10, "x")

ortools/linear_solver/wrappers/model_builder_helper.cc

@@ -619,9 +619,8 @@ void ModelSolverHelper::Solve(const ModelBuilderHelper& model) {
 #if defined(USE_HIGHS)
     case MPModelRequest::HIGHS_LINEAR_PROGRAMMING:  // ABSL_FALLTHROUGH_INTENDED
     case MPModelRequest::HIGHS_MIXED_INTEGER_PROGRAMMING: {
-      // TODO(user): Enable log_callback support.
       // TODO(user): Enable interrupt_solve.
-      const auto temp = HighsSolveProto(std::move(request));
+      const auto temp = HighsSolveProto(std::move(request), nullptr, &log_callback_);
       if (temp.ok()) {
         response_ = std::move(temp.value());
       }