Merge branch 'main' into remove-alpha-specs

Author: gforsyth

RELEASE-NOTES.md

@@ -1,5 +1,46 @@
 # Release Notes
 
+
+
+## Release Notes 25.12
+
+### New Features (25.12)
+
+- New quadratic programming solver using the barrier method (currently in beta).
+- Support for quadratic objectives added to the C and Python modeling APIs.
+- LP concurrent mode now supports multiple GPUs. PDLP and barrier can now be run on separate GPUs.
+- MIP root relaxation solves now use concurrent mode: PDLP, barrier, and dual simplex.
+
+### Improvements (25.12)
+
+- RINS heuristic adds a new improvement strategy in the MIP solver.
+- Basis factorizations are now reused in the branch and bound tree.
+- Improvement in propagating bounds from parent to child nodes in the branch and bound tree.
+- GMRES with Cholesky/LDL preconditioning is now used for iterative refinement on QPs.
+- Improved numerical stability of dual simplex when the basis is ill-conditioned.
+- Improved robustness in barrier and PDLP: fixed cuSPARSE related leaks and added RAII-style wrappers for cuSPARSE structures.
+- Papilo-based presolve carries over implied integer information from reductions, improving consistency of integrality handling.
+- Build and CI workflows improved through assertion-default changes, better handling of git-hash rebuilds, and fixes to the nightly build matrix.
+- Reduced package sizes by adjusting build outputs and test-only library linkage, and the TSP dataset download logic disables unneeded downloads.
+
+### Bug Fixes (25.12)
+
+- A crash in the incumbent test is resolved.
+- Fixed memory leaks in Barrier and PDLP's cuSPARSE usage.
+- The explored nodes in the MIP log now correctly reflects the actual nodes examined.
+- A compilation issue in the solve_MIP benchmarking executable is fixed, restoring benchmark builds.
+- A logger bug when log_to_console is false is fixed.
+- Routing fixes improve TSP behavior when order locations are set.
+- Nightly container testing and CI handling fix issues in the nightly container test suite and build jobs.
+- A cuDF build_column deprecation issue fixed to keep compatibility with newer cuDF versions.
+
+### Documentation (25.12)
+
+- Missing parameters added to the documentation for LP and MILP.
+- Release notes added to the main repository for easy access.
+- Examples in the documentation improved.
+- The openapi spec for the service showed the 'status' value for LP/MILP results as an int but it is actually a string.
+
 ## Release Notes 25.10
 
 ### New Features (25.10)

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

@@ -212,7 +212,7 @@ class pdlp_solver_settings_t {
   method_t method{method_t::Concurrent};
   bool inside_mip{false};
   // For concurrent termination
-  volatile int* concurrent_halt{nullptr};
+  std::atomic<int>* concurrent_halt{nullptr};
   static constexpr f_t minimal_absolute_tolerance = 1.0e-12;
 
  private:

cpp/src/dual_simplex/branch_and_bound.cpp

@@ -1135,6 +1135,7 @@ void branch_and_bound_t<i_t, f_t>::diving_thread(const csr_matrix_t<i_t, f_t>& A
       if (get_upper_bound() < start_node->node.lower_bound) { continue; }
 
       bool recompute_bounds_and_basis = true;
+      i_t nodes_explored              = 0;
       search_tree_t<i_t, f_t> subtree(std::move(start_node->node));
       std::deque<mip_node_t<i_t, f_t>*> stack;
       stack.push_front(&subtree.root);
@@ -1152,6 +1153,8 @@ void branch_and_bound_t<i_t, f_t>::diving_thread(const csr_matrix_t<i_t, f_t>& A
 
         if (toc(exploration_stats_.start_time) > settings_.time_limit) { return; }
 
+        if (nodes_explored >= 1000) { break; }
+
         node_solve_info_t status = solve_node(node_ptr,
                                               subtree,
                                               leaf_problem,
@@ -1165,6 +1168,8 @@ void branch_and_bound_t<i_t, f_t>::diving_thread(const csr_matrix_t<i_t, f_t>& A
                                               start_node->upper,
                                               log);
 
+        nodes_explored++;
+
         recompute_bounds_and_basis = !has_children(status);
 
         if (status == node_solve_info_t::TIME_LIMIT) {

cpp/src/dual_simplex/branch_and_bound.hpp

@@ -113,7 +113,7 @@ class branch_and_bound_t {
   f_t get_lower_bound();
   i_t get_heap_size();
   bool enable_concurrent_lp_root_solve() const { return enable_concurrent_lp_root_solve_; }
-  volatile int* get_root_concurrent_halt() { return &root_concurrent_halt_; }
+  std::atomic<int>* get_root_concurrent_halt() { return &root_concurrent_halt_; }
   void set_root_concurrent_halt(int value) { root_concurrent_halt_ = value; }
   lp_status_t solve_root_relaxation(simplex_solver_settings_t<i_t, f_t> const& lp_settings);
 
@@ -170,7 +170,7 @@ class branch_and_bound_t {
   std::vector<f_t> edge_norms_;
   std::atomic<bool> root_crossover_solution_set_{false};
   bool enable_concurrent_lp_root_solve_{false};
-  volatile int root_concurrent_halt_{0};
+  std::atomic<int> root_concurrent_halt_{0};
 
   // Pseudocosts
   pseudo_costs_t<i_t, f_t> pc_;

cpp/src/dual_simplex/pseudo_costs.cpp

@@ -70,9 +70,10 @@ void strong_branch_helper(i_t start,
                                           iter,
                                           child_edge_norms);
 
-      f_t obj = std::numeric_limits<f_t>::infinity();
+      f_t obj = std::numeric_limits<f_t>::quiet_NaN();
       if (status == dual::status_t::DUAL_UNBOUNDED) {
         // LP was infeasible
+        obj = std::numeric_limits<f_t>::infinity();
       } else if (status == dual::status_t::OPTIMAL || status == dual::status_t::ITERATION_LIMIT) {
         obj = compute_objective(child_problem, solution.x);
       } else {
@@ -227,11 +228,17 @@ void pseudo_costs_t<i_t, f_t>::initialized(i_t& num_initialized_down,
   for (i_t j = 0; j < n; j++) {
     if (pseudo_cost_num_down[j] > 0) {
       num_initialized_down++;
-      pseudo_cost_down_avg += pseudo_cost_sum_down[j] / pseudo_cost_num_down[j];
+      if (std::isfinite(pseudo_cost_sum_down[j])) {
+        pseudo_cost_down_avg += pseudo_cost_sum_down[j] / pseudo_cost_num_down[j];
+      }
     }
+
     if (pseudo_cost_num_up[j] > 0) {
       num_initialized_up++;
-      pseudo_cost_up_avg += pseudo_cost_sum_up[j] / pseudo_cost_num_up[j];
+
+      if (std::isfinite(pseudo_cost_sum_up[j])) {
+        pseudo_cost_up_avg += pseudo_cost_sum_up[j] / pseudo_cost_num_up[j];
+      }
     }
   }
   if (num_initialized_down > 0) {
@@ -317,14 +324,16 @@ void pseudo_costs_t<i_t, f_t>::update_pseudo_costs_from_strong_branching(
   for (i_t k = 0; k < fractional.size(); k++) {
     const i_t j = fractional[k];
     for (i_t branch = 0; branch < 2; branch++) {
-      const f_t frac = branch == 0 ? root_soln[j] - std::floor(root_soln[j])
-                                   : std::ceil(root_soln[j]) - root_soln[j];
       if (branch == 0) {
         f_t change_in_obj = strong_branch_down[k];
+        if (std::isnan(change_in_obj)) { continue; }
+        f_t frac = root_soln[j] - std::floor(root_soln[j]);
         pseudo_cost_sum_down[j] += change_in_obj / frac;
         pseudo_cost_num_down[j]++;
       } else {
         f_t change_in_obj = strong_branch_up[k];
+        if (std::isnan(change_in_obj)) { continue; }
+        f_t frac = std::ceil(root_soln[j]) - root_soln[j];
         pseudo_cost_sum_up[j] += change_in_obj / frac;
         pseudo_cost_num_up[j]++;
       }

cpp/src/dual_simplex/simplex_solver_settings.hpp

@@ -145,8 +145,8 @@ struct simplex_solver_settings_t {
   std::function<void()> heuristic_preemption_callback;
   std::function<void(std::vector<f_t>&, std::vector<f_t>&, f_t)> set_simplex_solution_callback;
   mutable logger_t log;
-  volatile int* concurrent_halt;  // if nullptr ignored, if !nullptr, 0 if solver should
-                                  // continue, 1 if solver should halt
+  std::atomic<int>* concurrent_halt;  // if nullptr ignored, if !nullptr, 0 if solver should
+                                      // continue, 1 if solver should halt
 };
 
 }  // namespace cuopt::linear_programming::dual_simplex

cpp/src/linear_programming/solve.cu

@@ -306,7 +306,7 @@ void setup_device_symbols(rmm::cuda_stream_view stream_view)
   detail::set_pdlp_hyper_parameters(stream_view);
 }
 
-volatile int global_concurrent_halt;
+std::atomic<int> global_concurrent_halt{0};
 
 template <typename i_t, typename f_t>
 optimization_problem_solution_t<i_t, f_t> convert_dual_simplex_sol(

cpp/src/linear_programming/translate.hpp

@@ -82,7 +82,11 @@ static dual_simplex::user_problem_t<i_t, f_t> cuopt_problem_to_simplex_problem(
   if (model.var_names.size() > 0) {
     user_problem.col_names.resize(n);
     for (int j = 0; j < n; ++j) {
-      user_problem.col_names[j] = model.var_names[j];
+      if (j < (int)model.var_names.size()) {
+        user_problem.col_names[j] = model.var_names[j];
+      } else {
+        user_problem.col_names[j] = "_CUOPT_x" + std::to_string(j);
+      }
     }
   }
   user_problem.obj_constant = model.presolve_data.objective_offset;

cpp/src/mip/diversity/diversity_manager.cu

@@ -357,18 +357,24 @@ solution_t<i_t, f_t> diversity_manager_t<i_t, f_t>::run_solver()
     pdlp_settings.pdlp_solver_mode                     = pdlp_solver_mode_t::Stable2;
     pdlp_settings.num_gpus                             = context.settings.num_gpus;
 
-    rmm::device_uvector<f_t> lp_optimal_solution_copy(lp_optimal_solution.size(),
-                                                      problem_ptr->handle_ptr->get_stream());
     timer_t lp_timer(lp_time_limit);
     auto lp_result = solve_lp_with_method<i_t, f_t>(*problem_ptr, pdlp_settings, lp_timer);
 
     {
       std::lock_guard<std::mutex> guard(relaxed_solution_mutex);
       if (!simplex_solution_exists.load()) {
+        cuopt_assert(lp_result.get_primal_solution().size() == lp_optimal_solution.size(),
+                     "LP optimal solution size mismatch");
+        cuopt_assert(lp_result.get_dual_solution().size() == lp_dual_optimal_solution.size(),
+                     "LP dual optimal solution size mismatch");
         raft::copy(lp_optimal_solution.data(),
-                   lp_optimal_solution_copy.data(),
+                   lp_result.get_primal_solution().data(),
                    lp_optimal_solution.size(),
                    problem_ptr->handle_ptr->get_stream());
+        raft::copy(lp_dual_optimal_solution.data(),
+                   lp_result.get_dual_solution().data(),
+                   lp_dual_optimal_solution.size(),
+                   problem_ptr->handle_ptr->get_stream());
       } else {
         // copy the lp state
         raft::copy(lp_state.prev_primal.data(),
@@ -382,6 +388,11 @@ solution_t<i_t, f_t> diversity_manager_t<i_t, f_t>::run_solver()
       }
       problem_ptr->handle_ptr->sync_stream();
     }
+    cuopt_assert(thrust::all_of(problem_ptr->handle_ptr->get_thrust_policy(),
+                                lp_optimal_solution.begin(),
+                                lp_optimal_solution.end(),
+                                [] __host__ __device__(f_t val) { return std::isfinite(val); }),
+                 "LP optimal solution contains non-finite values");
     ls.lp_optimal_exists = true;
     if (lp_result.get_termination_status() == pdlp_termination_status_t::Optimal) {
       set_new_user_bound(lp_result.get_objective_value());

cpp/src/mip/diversity/diversity_manager.cuh

@@ -95,7 +95,7 @@ class diversity_manager_t {
   // mutex for the simplex solution update
   std::mutex relaxed_solution_mutex;
   // atomic for signalling pdlp to stop
-  volatile int global_concurrent_halt{0};
+  std::atomic<int> global_concurrent_halt{0};
 
   rins_t<i_t, f_t> rins;