Merge branch 'main' of github.com:NVIDIA/cuopt into fea/sccache-dist

Author: trxcllnt

.github/release.yml

@@ -0,0 +1,24 @@
+changelog:
+  exclude:
+    labels:
+      - ignore-for-release
+      - dependencies
+    authors:
+      - rapids-bot[bot]
+      - dependabot[bot]
+  categories:
+    - title: "\U0001F6A8 Breaking Changes"
+      labels:
+        - breaking
+    - title: "\U0001F41B Bug Fixes"
+      labels:
+        - bug
+    - title: "\U0001F4D6 Documentation"
+      labels:
+        - doc
+    - title: "\U0001F680 New Features"
+      labels:
+        - feature request
+    - title: "\U0001F6E0\uFE0F Improvements"
+      labels:
+        - improvement

.github/workflows/nightly.yaml

@@ -17,7 +17,7 @@ jobs:
       matrix:
         cuopt_branch:
           - "main"
-          - "release/26.02"
+          - "release/26.04"
     steps:
       - uses: actions/checkout@v4
       - name: Trigger Pipeline

benchmarks/linear_programming/cuopt/run_pdlp.cu

@@ -70,15 +70,23 @@ static void parse_arguments(argparse::ArgumentParser& program)
       "Path to PDLP hyper-params file to configure PDLP solver. Has priority over PDLP solver "
       "modes.");
 
-  program.add_argument("--presolve")
-    .help("enable/disable presolve (default: true for MIP problems, false for LP problems)")
-    .default_value(0)
-    .scan<'i', int>()
-    .choices(0, 1);
+  program.add_argument("--presolver")
+    .help("Presolver to use. Possible values: None, Papilo, PSLP, Default")
+    .default_value("Default")
+    .choices("None", "Papilo", "PSLP", "Default");
 
   program.add_argument("--solution-path").help("Path where solution file will be generated");
 }
 
+static cuopt::linear_programming::presolver_t string_to_presolver(const std::string& presolver)
+{
+  if (presolver == "None") return cuopt::linear_programming::presolver_t::None;
+  if (presolver == "Papilo") return cuopt::linear_programming::presolver_t::Papilo;
+  if (presolver == "PSLP") return cuopt::linear_programming::presolver_t::PSLP;
+  if (presolver == "Default") return cuopt::linear_programming::presolver_t::Default;
+  return cuopt::linear_programming::presolver_t::Default;
+}
+
 static cuopt::linear_programming::pdlp_solver_mode_t string_to_pdlp_solver_mode(
   const std::string& mode)
 {
@@ -107,7 +115,7 @@ static cuopt::linear_programming::pdlp_solver_settings_t<int, double> create_sol
     string_to_pdlp_solver_mode(program.get<std::string>("--pdlp-solver-mode"));
   settings.method = static_cast<cuopt::linear_programming::method_t>(program.get<int>("--method"));
   settings.crossover = program.get<int>("--crossover");
-  settings.presolve  = program.get<int>("--presolve");
+  settings.presolver = string_to_presolver(program.get<std::string>("--presolver"));
 
   return settings;
 }

cpp/src/branch_and_bound/branch_and_bound.cpp

@@ -1886,6 +1886,7 @@ lp_status_t branch_and_bound_t<i_t, f_t>::solve_root_relaxation(
                                                         root_crossover_settings,
                                                         original_lp_.lower,
                                                         original_lp_.upper,
+                                                        exploration_stats_.start_time,
                                                         basic_list,
                                                         nonbasic_list,
                                                         crossover_vstatus_);
@@ -2285,6 +2286,7 @@ mip_status_t branch_and_bound_t<i_t, f_t>::solve(mip_solution_t<i_t, f_t>& solut
       mutex_original_lp_.lock();
       remove_cuts(original_lp_,
                   settings_,
+                  exploration_stats_.start_time,
                   Arow_,
                   new_slacks_,
                   original_rows,

cpp/src/branch_and_bound/branch_and_bound.hpp

@@ -106,6 +106,8 @@ class branch_and_bound_t {
 
   void set_concurrent_lp_root_solve(bool enable) { enable_concurrent_lp_root_solve_ = enable; }
 
+  bool stop_for_time_limit(mip_solution_t<i_t, f_t>& solution);
+
   // Repair a low-quality solution from the heuristics.
   bool repair_solution(const std::vector<f_t>& leaf_edge_norms,
                        const std::vector<f_t>& potential_solution,

cpp/src/branch_and_bound/pseudo_costs.cpp

@@ -314,6 +314,9 @@ void strong_branching(const user_problem_t<i_t, f_t>& original_problem,
   pc.strong_branch_up.assign(fractional.size(), 0);
   pc.num_strong_branches_completed = 0;
 
+  const f_t elapsed_time = toc(start_time);
+  if (elapsed_time > settings.time_limit) { return; }
+
   if (settings.mip_batch_pdlp_strong_branching) {
     settings.log.printf("Batch PDLP strong branching enabled\n");
 
@@ -334,9 +337,16 @@ void strong_branching(const user_problem_t<i_t, f_t>& original_problem,
       fraction_values.push_back(original_root_soln_x[j]);
     }
 
-    const auto mps_model = simplex_problem_to_mps_data_model(original_problem);
+    const auto mps_model         = simplex_problem_to_mps_data_model(original_problem);
+    const f_t batch_elapsed_time = toc(start_time);
+    const f_t batch_remaining_time =
+      std::max(static_cast<f_t>(0.0), settings.time_limit - batch_elapsed_time);
+    if (batch_remaining_time <= 0.0) { return; }
+    pdlp_solver_settings_t<i_t, f_t> pdlp_settings;
+    pdlp_settings.time_limit = batch_remaining_time;
+    const raft::handle_t batch_pdlp_handle;
     const auto solutions =
-      batch_pdlp_solve(original_problem.handle_ptr, mps_model, fractional, fraction_values);
+      batch_pdlp_solve(&batch_pdlp_handle, mps_model, fractional, fraction_values, pdlp_settings);
     f_t batch_pdlp_strong_branching_time = toc(start_batch);
 
     // Find max iteration on how many are done accross the batch

cpp/src/cuts/cuts.cpp

@@ -2501,20 +2501,21 @@ i_t add_cuts(const simplex_solver_settings_t<i_t, f_t>& settings,
 }
 
 template <typename i_t, typename f_t>
-void remove_cuts(lp_problem_t<i_t, f_t>& lp,
-                 const simplex_solver_settings_t<i_t, f_t>& settings,
-                 csr_matrix_t<i_t, f_t>& Arow,
-                 std::vector<i_t>& new_slacks,
-                 i_t original_rows,
-                 std::vector<variable_type_t>& var_types,
-                 std::vector<variable_status_t>& vstatus,
-                 std::vector<f_t>& edge_norms,
-                 std::vector<f_t>& x,
-                 std::vector<f_t>& y,
-                 std::vector<f_t>& z,
-                 std::vector<i_t>& basic_list,
-                 std::vector<i_t>& nonbasic_list,
-                 basis_update_mpf_t<i_t, f_t>& basis_update)
+i_t remove_cuts(lp_problem_t<i_t, f_t>& lp,
+                const simplex_solver_settings_t<i_t, f_t>& settings,
+                f_t start_time,
+                csr_matrix_t<i_t, f_t>& Arow,
+                std::vector<i_t>& new_slacks,
+                i_t original_rows,
+                std::vector<variable_type_t>& var_types,
+                std::vector<variable_status_t>& vstatus,
+                std::vector<f_t>& edge_norms,
+                std::vector<f_t>& x,
+                std::vector<f_t>& y,
+                std::vector<f_t>& z,
+                std::vector<i_t>& basic_list,
+                std::vector<i_t>& nonbasic_list,
+                basis_update_mpf_t<i_t, f_t>& basis_update)
 {
   std::vector<i_t> cuts_to_remove;
   cuts_to_remove.reserve(lp.num_rows - original_rows);
@@ -2644,9 +2645,13 @@ void remove_cuts(lp_problem_t<i_t, f_t>& lp,
                        lp.A.col_start[lp.A.n]);
 
     basis_update.resize(lp.num_rows);
-    basis_update.refactor_basis(
-      lp.A, settings, lp.lower, lp.upper, basic_list, nonbasic_list, vstatus);
+    i_t refactor_status = basis_update.refactor_basis(
+      lp.A, settings, lp.lower, lp.upper, start_time, basic_list, nonbasic_list, vstatus);
+    if (refactor_status == CONCURRENT_HALT_RETURN) { return CONCURRENT_HALT_RETURN; }
+    if (refactor_status == TIME_LIMIT_RETURN) { return TIME_LIMIT_RETURN; }
   }
+
+  return 0;
 }
 
 template <typename i_t, typename f_t>
@@ -2793,20 +2798,21 @@ template int add_cuts(const simplex_solver_settings_t<int, double>& settings,
                       std::vector<variable_status_t>& vstatus,
                       std::vector<double>& edge_norms);
 
-template void remove_cuts<int, double>(lp_problem_t<int, double>& lp,
-                                       const simplex_solver_settings_t<int, double>& settings,
-                                       csr_matrix_t<int, double>& Arow,
-                                       std::vector<int>& new_slacks,
-                                       int original_rows,
-                                       std::vector<variable_type_t>& var_types,
-                                       std::vector<variable_status_t>& vstatus,
-                                       std::vector<double>& edge_norms,
-                                       std::vector<double>& x,
-                                       std::vector<double>& y,
-                                       std::vector<double>& z,
-                                       std::vector<int>& basic_list,
-                                       std::vector<int>& nonbasic_list,
-                                       basis_update_mpf_t<int, double>& basis_update);
+template int remove_cuts<int, double>(lp_problem_t<int, double>& lp,
+                                      const simplex_solver_settings_t<int, double>& settings,
+                                      double start_time,
+                                      csr_matrix_t<int, double>& Arow,
+                                      std::vector<int>& new_slacks,
+                                      int original_rows,
+                                      std::vector<variable_type_t>& var_types,
+                                      std::vector<variable_status_t>& vstatus,
+                                      std::vector<double>& edge_norms,
+                                      std::vector<double>& x,
+                                      std::vector<double>& y,
+                                      std::vector<double>& z,
+                                      std::vector<int>& basic_list,
+                                      std::vector<int>& nonbasic_list,
+                                      basis_update_mpf_t<int, double>& basis_update);
 
 template void read_saved_solution_for_cut_verification<int, double>(
   const lp_problem_t<int, double>& lp,

cpp/src/cuts/cuts.hpp

@@ -461,19 +461,20 @@ i_t add_cuts(const simplex_solver_settings_t<i_t, f_t>& settings,
              std::vector<f_t>& edge_norms);
 
 template <typename i_t, typename f_t>
-void remove_cuts(lp_problem_t<i_t, f_t>& lp,
-                 const simplex_solver_settings_t<i_t, f_t>& settings,
-                 csr_matrix_t<i_t, f_t>& Arow,
-                 std::vector<i_t>& new_slacks,
-                 i_t original_rows,
-                 std::vector<variable_type_t>& var_types,
-                 std::vector<variable_status_t>& vstatus,
-                 std::vector<f_t>& edge_norms,
-                 std::vector<f_t>& x,
-                 std::vector<f_t>& y,
-                 std::vector<f_t>& z,
-                 std::vector<i_t>& basic_list,
-                 std::vector<i_t>& nonbasic_list,
-                 basis_update_mpf_t<i_t, f_t>& basis_update);
+i_t remove_cuts(lp_problem_t<i_t, f_t>& lp,
+                const simplex_solver_settings_t<i_t, f_t>& settings,
+                f_t start_time,
+                csr_matrix_t<i_t, f_t>& Arow,
+                std::vector<i_t>& new_slacks,
+                i_t original_rows,
+                std::vector<variable_type_t>& var_types,
+                std::vector<variable_status_t>& vstatus,
+                std::vector<f_t>& edge_norms,
+                std::vector<f_t>& x,
+                std::vector<f_t>& y,
+                std::vector<f_t>& z,
+                std::vector<i_t>& basic_list,
+                std::vector<i_t>& nonbasic_list,
+                basis_update_mpf_t<i_t, f_t>& basis_update);
 
 }  // namespace cuopt::linear_programming::dual_simplex

cpp/src/dual_simplex/basis_solves.cpp

@@ -160,6 +160,7 @@ template <typename i_t, typename f_t>
 i_t factorize_basis(const csc_matrix_t<i_t, f_t>& A,
                     const simplex_solver_settings_t<i_t, f_t>& settings,
                     const std::vector<i_t>& basic_list,
+                    f_t start_time,
                     csc_matrix_t<i_t, f_t>& L,
                     csc_matrix_t<i_t, f_t>& U,
                     std::vector<i_t>& p,
@@ -383,15 +384,16 @@ i_t factorize_basis(const csc_matrix_t<i_t, f_t>& A,
                                  settings,
                                  settings.threshold_partial_pivoting_tol,
                                  identity,
+                                 start_time,
                                  S_col_perm,
                                  SL,
                                  SU,
                                  S_perm_inv,
                                  work_estimate);
         if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) {
-          settings.log.printf("Concurrent halt\n");
           return CONCURRENT_HALT_RETURN;
         }
+        if (Srank < 0) { return Srank; }
         if (Srank != Sdim) {
           // Get the rank deficient columns
           deficient.clear();
@@ -618,7 +620,14 @@ i_t factorize_basis(const csc_matrix_t<i_t, f_t>& A,
   q.resize(m);
   work_estimate += m;
   f_t fact_start = tic();
-  rank = right_looking_lu(A, settings, medium_tol, basic_list, q, L, U, pinv, work_estimate);
+  rank =
+    right_looking_lu(A, settings, medium_tol, basic_list, start_time, q, L, U, pinv, work_estimate);
+  if (rank < 0) {
+    if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) {
+      return CONCURRENT_HALT_RETURN;
+    }
+    return rank;
+  }
   inverse_permutation(pinv, p);
   work_estimate += 3 * pinv.size();
 
@@ -638,7 +647,6 @@ i_t factorize_basis(const csc_matrix_t<i_t, f_t>& A,
     work_estimate += 3 * (m - rank);
   }
   if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) {
-    settings.log.printf("Concurrent halt\n");
     return CONCURRENT_HALT_RETURN;
   }
   if (verbose) {
@@ -938,6 +946,7 @@ template void get_basis_from_vstatus<int>(int m,
 template int factorize_basis<int>(const csc_matrix_t<int, double>& A,
                                   const simplex_solver_settings_t<int, double>& settings,
                                   const std::vector<int>& basis_list,
+                                  double start_time,
                                   csc_matrix_t<int, double>& L,
                                   csc_matrix_t<int, double>& U,
                                   std::vector<int>& p,

cpp/src/dual_simplex/basis_solves.hpp

@@ -30,6 +30,7 @@ template <typename i_t, typename f_t>
 i_t factorize_basis(const csc_matrix_t<i_t, f_t>& A,
                     const simplex_solver_settings_t<i_t, f_t>& settings,
                     const std::vector<i_t>& basis_list,
+                    f_t start_time,
                     csc_matrix_t<i_t, f_t>& L,
                     csc_matrix_t<i_t, f_t>& U,
                     std::vector<i_t>& p,