Merge branch 'main' into remove-alpha-specs

Author: rgsl888prabhu

cpp/include/cuopt/linear_programming/pdlp/pdlp_warm_start_data.hpp

@@ -67,8 +67,8 @@ struct pdlp_warm_start_data_t {
                          rmm::cuda_stream_view stream_view);
 
   // Copy constructor for when copying the solver_settings object in the PDLP object
-  pdlp_warm_start_data_t(const pdlp_warm_start_data_t<i_t, f_t>& other,
-                         rmm::cuda_stream_view stream_view);
+  pdlp_warm_start_data_t(const pdlp_warm_start_data_t<i_t, f_t>& other);
+  pdlp_warm_start_data_t& operator=(pdlp_warm_start_data_t<i_t, f_t>&& other) = default;
 
  private:
   // Check sizes through assertion

cpp/include/cuopt/linear_programming/pdlp/solver_settings.hpp

@@ -65,8 +65,6 @@ class pdlp_solver_settings_t {
  public:
   pdlp_solver_settings_t() = default;
 
-  // Copy constructor for when copying in the PDLP object
-  pdlp_solver_settings_t(const pdlp_solver_settings_t& other, rmm::cuda_stream_view stream_view);
   /**
    * @brief Set both absolute and relative tolerance on the primal feasibility,
    dual feasibility and gap.

cpp/src/dual_simplex/diving_queue.hpp

@@ -31,13 +31,13 @@ struct diving_root_t {
 };
 
 // A min-heap for storing the starting nodes for the dives.
-// This has a maximum size of INT16_MAX, such that the container
+// This has a maximum size of 1024, such that the container
 // will discard the least promising node if the queue is full.
 template <typename i_t, typename f_t>
 class diving_queue_t {
  private:
   std::vector<diving_root_t<i_t, f_t>> buffer;
-  static constexpr i_t max_size_ = INT16_MAX;
+  static constexpr i_t max_size_ = 1024;
 
  public:
   diving_queue_t() { buffer.reserve(max_size_); }

cpp/src/linear_programming/pdlp.cu

@@ -65,7 +65,7 @@ pdlp_solver_t<i_t, f_t>::pdlp_solver_t(problem_t<i_t, f_t>& op_problem,
     step_size_{(f_t)pdlp_hyper_params::initial_step_size_scaling, stream_view_},
     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_),
+    settings_(settings),
     initial_scaling_strategy_{handle_ptr_,
                               op_problem_scaled_,
                               pdlp_hyper_params::default_l_inf_ruiz_iterations,
@@ -313,7 +313,8 @@ std::optional<optimization_problem_solution_t<i_t, f_t>> pdlp_solver_t<i_t, f_t>
   }
 
   // Check for concurrent limit
-  if (settings_.concurrent_halt != nullptr && *settings_.concurrent_halt == 1) {
+  if (settings_.method == method_t::Concurrent && settings_.concurrent_halt != nullptr &&
+      *settings_.concurrent_halt == 1) {
 #ifdef PDLP_VERBOSE_MODE
     RAFT_CUDA_TRY(cudaDeviceSynchronize());
     std::cout << "Concurrent Limit reached, returning current solution" << std::endl;

cpp/src/linear_programming/pdlp_warm_start_data.cu

@@ -138,19 +138,20 @@ pdlp_warm_start_data_t<i_t, f_t>::pdlp_warm_start_data_t(
 }
 
 template <typename i_t, typename f_t>
-pdlp_warm_start_data_t<i_t, f_t>::pdlp_warm_start_data_t(const pdlp_warm_start_data_t& other,
-                                                         rmm::cuda_stream_view stream_view)
-  : current_primal_solution_(other.current_primal_solution_, stream_view),
-    current_dual_solution_(other.current_dual_solution_, stream_view),
-    initial_primal_average_(other.initial_primal_average_, stream_view),
-    initial_dual_average_(other.initial_dual_average_, stream_view),
-    current_ATY_(other.current_ATY_, stream_view),
-    sum_primal_solutions_(other.sum_primal_solutions_, stream_view),
-    sum_dual_solutions_(other.sum_dual_solutions_, stream_view),
-    last_restart_duality_gap_primal_solution_(other.last_restart_duality_gap_primal_solution_,
-                                              stream_view),
+pdlp_warm_start_data_t<i_t, f_t>::pdlp_warm_start_data_t(const pdlp_warm_start_data_t& other)
+  : current_primal_solution_(other.current_primal_solution_,
+                             other.current_primal_solution_.stream()),
+    current_dual_solution_(other.current_dual_solution_, other.current_dual_solution_.stream()),
+    initial_primal_average_(other.initial_primal_average_, other.initial_primal_average_.stream()),
+    initial_dual_average_(other.initial_dual_average_, other.initial_dual_average_.stream()),
+    current_ATY_(other.current_ATY_, other.current_ATY_.stream()),
+    sum_primal_solutions_(other.sum_primal_solutions_, other.sum_primal_solutions_.stream()),
+    sum_dual_solutions_(other.sum_dual_solutions_, other.sum_dual_solutions_.stream()),
+    last_restart_duality_gap_primal_solution_(
+      other.last_restart_duality_gap_primal_solution_,
+      other.last_restart_duality_gap_primal_solution_.stream()),
     last_restart_duality_gap_dual_solution_(other.last_restart_duality_gap_dual_solution_,
-                                            stream_view),
+                                            other.last_restart_duality_gap_dual_solution_.stream()),
     initial_primal_weight_(other.initial_primal_weight_),
     initial_step_size_(other.initial_step_size_),
     total_pdlp_iterations_(other.total_pdlp_iterations_),

cpp/src/linear_programming/solve.cu

@@ -621,8 +621,8 @@ optimization_problem_solution_t<i_t, f_t> run_pdlp(detail::problem_t<i_t, f_t>&
     sol.copy_from(problem.handle_ptr, sol_crossover);
     CUOPT_LOG_INFO("Crossover status %s", sol.get_termination_status_string().c_str());
   }
-  if (settings.concurrent_halt != nullptr && crossover_info == 0 &&
-      sol.get_termination_status() == pdlp_termination_status_t::Optimal) {
+  if (settings.method == method_t::Concurrent && settings.concurrent_halt != nullptr &&
+      crossover_info == 0 && sol.get_termination_status() == pdlp_termination_status_t::Optimal) {
     // We finished. Tell dual simplex to stop if it is still running.
     CUOPT_LOG_INFO("PDLP finished. Telling others to stop");
     *settings.concurrent_halt = 1;
@@ -657,8 +657,7 @@ optimization_problem_solution_t<i_t, f_t> run_concurrent(
   timer_t timer_concurrent(timer.remaining_time());
 
   // Copy the settings so that we can set the concurrent halt pointer
-  pdlp_solver_settings_t<i_t, f_t> settings_pdlp(settings,
-                                                 op_problem.get_handle_ptr()->get_stream());
+  pdlp_solver_settings_t<i_t, f_t> settings_pdlp(settings);
 
   // Set the concurrent halt pointer
   global_concurrent_halt        = 0;

cpp/src/linear_programming/solver_settings.cu

@@ -22,34 +22,6 @@
 
 namespace cuopt::linear_programming {
 
-template <typename i_t, typename f_t>
-pdlp_solver_settings_t<i_t, f_t>::pdlp_solver_settings_t(const pdlp_solver_settings_t& other,
-                                                         rmm::cuda_stream_view stream_view)
-  : tolerances(other.tolerances),
-    detect_infeasibility(other.detect_infeasibility),
-    strict_infeasibility(other.strict_infeasibility),
-    iteration_limit(other.iteration_limit),
-    time_limit(other.time_limit),
-    pdlp_solver_mode(other.pdlp_solver_mode),
-    log_file(other.log_file),
-    sol_file(other.sol_file),
-    per_constraint_residual(other.per_constraint_residual),
-    crossover(other.crossover),
-    folding(other.folding),
-    augmented(other.augmented),
-    dualize(other.dualize),
-    ordering(other.ordering),
-    barrier_dual_initial_point(other.barrier_dual_initial_point),
-    cudss_deterministic(other.cudss_deterministic),
-    eliminate_dense_columns(other.eliminate_dense_columns),
-    save_best_primal_so_far(other.save_best_primal_so_far),
-    first_primal_feasible(other.first_primal_feasible),
-    pdlp_warm_start_data_(other.pdlp_warm_start_data_, stream_view),
-    concurrent_halt(other.concurrent_halt),
-    num_gpus(other.num_gpus)
-{
-}
-
 template <typename i_t, typename f_t>
 void pdlp_solver_settings_t<i_t, f_t>::set_optimality_tolerance(f_t eps_optimal)
 {

dependencies.yaml

@@ -46,6 +46,7 @@ files:
   test_python:
     output: none
     includes:
+      - cuda_version
       - py_version
       - depends_on_libcuopt
       - depends_on_cuopt