No cuda graph in batched pdlp (#225)

Temporarly disable cuda graph in batched PDLP until we find the root cause.

This allows use to re-enable the tests on the Python side

Closes #207

Authors:
  - Nicolas Blin (https://github.com/Kh4ster)

Approvers:
  - Akif ÇÖRDÜK (https://github.com/akifcorduk)
  - Trevor McKay (https://github.com/tmckayus)

URL: #225

Author: Kh4ster

cpp/include/cuopt/linear_programming/solve.hpp

@@ -51,7 +51,8 @@ optimization_problem_solution_t<i_t, f_t> solve_lp(
   optimization_problem_t<i_t, f_t>& op_problem,
   pdlp_solver_settings_t<i_t, f_t> const& settings = pdlp_solver_settings_t<i_t, f_t>{},
   bool problem_checking                            = true,
-  bool use_pdlp_solver_mode                        = true);
+  bool use_pdlp_solver_mode                        = true,
+  bool is_batch_mode                               = false);
 
 /**
  * @brief Linear programming solve function.

cpp/include/cuopt/linear_programming/utilities/cython_solve.hpp

@@ -104,7 +104,8 @@ struct solver_ret_t {
 
 std::unique_ptr<solver_ret_t> call_solve(cuopt::mps_parser::data_model_view_t<int, double>*,
                                          linear_programming::solver_settings_t<int, double>*,
-                                         unsigned int flags = cudaStreamNonBlocking);
+                                         unsigned int flags = cudaStreamNonBlocking,
+                                         bool is_batch_mode = false);
 
 std::pair<std::vector<std::unique_ptr<solver_ret_t>>, double> call_batch_solve(
   std::vector<cuopt::mps_parser::data_model_view_t<int, double>*>,

cpp/src/linear_programming/pdhg.cu

@@ -35,7 +35,8 @@ namespace cuopt::linear_programming::detail {
 
 template <typename i_t, typename f_t>
 pdhg_solver_t<i_t, f_t>::pdhg_solver_t(raft::handle_t const* handle_ptr,
-                                       problem_t<i_t, f_t>& op_problem_scaled)
+                                       problem_t<i_t, f_t>& op_problem_scaled,
+                                       bool is_batch_mode)
   : handle_ptr_(handle_ptr),
     stream_view_(handle_ptr_->get_stream()),
     problem_ptr(&op_problem_scaled),
@@ -57,8 +58,8 @@ pdhg_solver_t<i_t, f_t>::pdhg_solver_t(raft::handle_t const* handle_ptr,
     reusable_device_scalar_value_0_{0.0, stream_view_},
     reusable_device_scalar_value_neg_1_{f_t(-1.0), stream_view_},
     reusable_device_scalar_1_{stream_view_},
-    graph_all{stream_view_},
-    graph_prim_proj_gradient_dual{stream_view_},
+    graph_all{stream_view_, is_batch_mode},
+    graph_prim_proj_gradient_dual{stream_view_, is_batch_mode},
     d_total_pdhg_iterations_{0, stream_view_}
 {
 }

cpp/src/linear_programming/pdhg.hpp

@@ -31,7 +31,9 @@ namespace cuopt::linear_programming::detail {
 template <typename i_t, typename f_t>
 class pdhg_solver_t {
  public:
-  pdhg_solver_t(raft::handle_t const* handle_ptr, problem_t<i_t, f_t>& op_problem);
+  pdhg_solver_t(raft::handle_t const* handle_ptr,
+                problem_t<i_t, f_t>& op_problem,
+                bool is_batch_mode = false);
 
   saddle_point_state_t<i_t, f_t>& get_saddle_point_state();
   cusparse_view_t<i_t, f_t>& get_cusparse_view();

cpp/src/linear_programming/pdlp.cu

@@ -53,7 +53,8 @@ void set_pdlp_hyper_parameters(rmm::cuda_stream_view stream_view)
 
 template <typename i_t, typename f_t>
 pdlp_solver_t<i_t, f_t>::pdlp_solver_t(problem_t<i_t, f_t>& op_problem,
-                                       pdlp_solver_settings_t<i_t, f_t> const& settings)
+                                       pdlp_solver_settings_t<i_t, f_t> const& settings,
+                                       bool is_batch_mode)
   : handle_ptr_(op_problem.handle_ptr),
     stream_view_(handle_ptr_->get_stream()),
     problem_ptr(&op_problem),
@@ -67,8 +68,8 @@ pdlp_solver_t<i_t, f_t>::pdlp_solver_t(problem_t<i_t, f_t>& op_problem,
     dual_step_size_{stream_view_},
     primal_weight_{stream_view_},
     step_size_{(f_t)pdlp_hyper_params::initial_step_size_scaling, stream_view_},
-    step_size_strategy_{handle_ptr_, &primal_weight_, &step_size_},
-    pdhg_solver_{handle_ptr_, op_problem_scaled_},
+    step_size_strategy_{handle_ptr_, &primal_weight_, &step_size_, is_batch_mode},
+    pdhg_solver_{handle_ptr_, op_problem_scaled_, is_batch_mode},
     settings_(settings, stream_view_),
     initial_scaling_strategy_{handle_ptr_,
                               op_problem_scaled_,
@@ -100,7 +101,8 @@ pdlp_solver_t<i_t, f_t>::pdlp_solver_t(problem_t<i_t, f_t>& op_problem,
                       op_problem,
                       average_op_problem_evaluation_cusparse_view_,
                       primal_size_h_,
-                      dual_size_h_},
+                      dual_size_h_,
+                      is_batch_mode},
     average_termination_strategy_{handle_ptr_,
                                   op_problem,
                                   average_op_problem_evaluation_cusparse_view_,

cpp/src/linear_programming/pdlp.cuh

@@ -65,7 +65,8 @@ class pdlp_solver_t {
    */
   pdlp_solver_t(
     problem_t<i_t, f_t>& op_problem,
-    pdlp_solver_settings_t<i_t, f_t> const& settings = pdlp_solver_settings_t<i_t, f_t>{});
+    pdlp_solver_settings_t<i_t, f_t> const& settings = pdlp_solver_settings_t<i_t, f_t>{},
+    bool is_batch_mode                               = false);
 
   optimization_problem_solution_t<i_t, f_t> run_solver(
     const std::chrono::high_resolution_clock::time_point& start_time);

cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu

@@ -108,10 +108,11 @@ pdlp_restart_strategy_t<i_t, f_t>::pdlp_restart_strategy_t(
   problem_t<i_t, f_t>& op_problem,
   const cusparse_view_t<i_t, f_t>& cusparse_view,
   const i_t primal_size,
-  const i_t dual_size)
+  const i_t dual_size,
+  bool is_batch_mode)
   : handle_ptr_(handle_ptr),
     stream_view_(handle_ptr_->get_stream()),
-    weighted_average_solution_{handle_ptr_, primal_size, dual_size},
+    weighted_average_solution_{handle_ptr_, primal_size, dual_size, is_batch_mode},
     primal_size_h_(primal_size),
     dual_size_h_(dual_size),
     problem_ptr(&op_problem),

cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cuh

@@ -101,7 +101,8 @@ class pdlp_restart_strategy_t {
                           problem_t<i_t, f_t>& op_problem,
                           const cusparse_view_t<i_t, f_t>& cusparse_view,
                           const i_t primal_size,
-                          const i_t dual_size);
+                          const i_t dual_size,
+                          bool is_batch_mode = false);
 
   // Compute kkt score on passed argument using the container tmp_kkt score and stream view
   f_t compute_kkt_score(const rmm::device_scalar<f_t>& l2_primal_residual,

cpp/src/linear_programming/restart_strategy/weighted_average_solution.cu

@@ -29,7 +29,8 @@ namespace cuopt::linear_programming::detail {
 template <typename i_t, typename f_t>
 weighted_average_solution_t<i_t, f_t>::weighted_average_solution_t(raft::handle_t const* handle_ptr,
                                                                    i_t primal_size,
-                                                                   i_t dual_size)
+                                                                   i_t dual_size,
+                                                                   bool is_batch_mode)
   : handle_ptr_(handle_ptr),
     stream_view_(handle_ptr_->get_stream()),
     primal_size_h_(primal_size),
@@ -39,7 +40,7 @@ weighted_average_solution_t<i_t, f_t>::weighted_average_solution_t(raft::handle_
     sum_primal_solution_weights_{0.0, stream_view_},
     sum_dual_solution_weights_{0.0, stream_view_},
     iterations_since_last_restart_{0},
-    graph(stream_view_)
+    graph(stream_view_, is_batch_mode)
 {
   RAFT_CUDA_TRY(
     cudaMemsetAsync(sum_primal_solutions_.data(), 0.0, sizeof(f_t) * primal_size_h_, stream_view_));

cpp/src/linear_programming/restart_strategy/weighted_average_solution.hpp

@@ -29,7 +29,10 @@ namespace cuopt::linear_programming::detail {
 template <typename i_t, typename f_t>
 class weighted_average_solution_t {
  public:
-  weighted_average_solution_t(raft::handle_t const* handle_ptr, i_t primal_size, i_t dual_size);
+  weighted_average_solution_t(raft::handle_t const* handle_ptr,
+                              i_t primal_size,
+                              i_t dual_size,
+                              bool is_batch_mode);
 
   void reset_weighted_average_solution();
   void add_current_solution_to_weighted_average_solution(const f_t* primal_solution,