run concurrent LP instead

Author: aliceb-nv

cpp/src/linear_programming/solve.cu

@@ -467,7 +467,7 @@ void run_dual_simplex_thread(
 
 template <typename i_t, typename f_t>
 optimization_problem_solution_t<i_t, f_t> run_concurrent(
-  optimization_problem_t<i_t, f_t>& op_problem,
+  const optimization_problem_t<i_t, f_t>& op_problem,
   detail::problem_t<i_t, f_t>& problem,
   pdlp_solver_settings_t<i_t, f_t> const& settings,
   bool is_batch_mode)
@@ -540,7 +540,7 @@ optimization_problem_solution_t<i_t, f_t> run_concurrent(
 
 template <typename i_t, typename f_t>
 optimization_problem_solution_t<i_t, f_t> solve_lp_with_method(
-  optimization_problem_t<i_t, f_t>& op_problem,
+  const optimization_problem_t<i_t, f_t>& op_problem,
   detail::problem_t<i_t, f_t>& problem,
   pdlp_solver_settings_t<i_t, f_t> const& settings,
   bool is_batch_mode)
@@ -714,6 +714,12 @@ optimization_problem_solution_t<i_t, f_t> solve_lp(
     bool problem_checking,                                                             \
     bool use_pdlp_solver_mode);                                                        \
                                                                                        \
+  template optimization_problem_solution_t<int, F_TYPE> solve_lp_with_method(          \
+    const optimization_problem_t<int, F_TYPE>& op_problem,                             \
+    detail::problem_t<int, F_TYPE>& problem,                                           \
+    pdlp_solver_settings_t<int, F_TYPE> const& settings,                               \
+    bool is_batch_mode = false);                                                       \
+                                                                                       \
   template optimization_problem_t<int, F_TYPE> mps_data_model_to_optimization_problem( \
     raft::handle_t const* handle_ptr,                                                  \
     const cuopt::mps_parser::mps_data_model_t<int, F_TYPE>& data_model);

cpp/src/linear_programming/solve.cuh

@@ -30,4 +30,11 @@ cuopt::linear_programming::optimization_problem_t<i_t, f_t> mps_data_model_to_op
   raft::handle_t const* handle_ptr,
   const cuopt::mps_parser::mps_data_model_t<i_t, f_t>& data_model);
 
+template <typename i_t, typename f_t>
+cuopt::linear_programming::optimization_problem_solution_t<i_t, f_t> solve_lp_with_method(
+  const optimization_problem_t<i_t, f_t>& op_problem,
+  detail::problem_t<i_t, f_t>& problem,
+  pdlp_solver_settings_t<i_t, f_t> const& settings,
+  bool is_batch_mode = false);
+
 }  // namespace cuopt::linear_programming

cpp/src/mip/solver.cu

@@ -24,6 +24,7 @@
 #include "solver.cuh"
 
 #include <linear_programming/pdlp.cuh>
+#include <linear_programming/solve.cuh>
 
 #include <dual_simplex/branch_and_bound.hpp>
 #include <dual_simplex/simplex_solver_settings.hpp>
@@ -126,16 +127,19 @@ solution_t<i_t, f_t> mip_solver_t<i_t, f_t>::run_solver()
     return sol;
   }
 
-  // if the problem was reduced to a LP: run PDLP
+  // if the problem was reduced to a LP: run concurrent LP
   if (context.problem_ptr->n_integer_vars == 0) {
-    CUOPT_LOG_INFO("Problem reduced to a LP, running PDLP");
-    pdlp_solver_settings_t<i_t, f_t> pdlp_settings{};
-    pdlp_settings.time_limit = timer_.remaining_time();
-    detail::pdlp_solver_t<i_t, f_t> solver(*context.problem_ptr, pdlp_settings, false);
-    auto start_time = std::chrono::high_resolution_clock::now();
-    auto opt_sol    = solver.run_solver(start_time);
+    CUOPT_LOG_INFO("Problem reduced to a LP, running concurrent LP");
+    pdlp_solver_settings_t<i_t, f_t> settings{};
+    settings.time_limit = timer_.remaining_time();
+    settings.method     = method_t::Concurrent;
+
+    auto opt_sol = solve_lp_with_method<i_t, f_t>(
+      *context.problem_ptr->original_problem_ptr, *context.problem_ptr, settings);
+
     solution_t<i_t, f_t> sol(*context.problem_ptr);
-    sol.copy_new_assignment(host_copy(opt_sol.get_primal_solution()));
+    sol.copy_new_assignment(
+      host_copy(opt_sol.get_primal_solution()));  // TODO: check if this is correct
     if (opt_sol.get_termination_status() == pdlp_termination_status_t::Optimal ||
         opt_sol.get_termination_status() == pdlp_termination_status_t::PrimalInfeasible ||
         opt_sol.get_termination_status() == pdlp_termination_status_t::DualInfeasible) {