Merge branch 'main' into adjust-bnb-logs

nguidotti · web-flow · commit 98f670f72b0b · 2025-12-18T08:41:02.000Z
diff --git a/conda/environments/all_cuda-129_arch-aarch64.yaml b/conda/environments/all_cuda-129_arch-aarch64.yaml
@@ -44,7 +44,7 @@ dependencies:
 - myst-parser
 - ninja
 - notebook
-- numba-cuda>=0.19.1,<0.20.0a0
+- numba-cuda>=0.22.1,<0.23.0
 - numba>=0.60.0
 - numpy>=1.23.5,<3.0a0
 - numpydoc
diff --git a/conda/environments/all_cuda-129_arch-x86_64.yaml b/conda/environments/all_cuda-129_arch-x86_64.yaml
@@ -44,7 +44,7 @@ dependencies:
 - myst-parser
 - ninja
 - notebook
-- numba-cuda>=0.19.1,<0.20.0a0
+- numba-cuda>=0.22.1,<0.23.0
 - numba>=0.60.0
 - numpy>=1.23.5,<3.0a0
 - numpydoc
diff --git a/conda/environments/all_cuda-130_arch-aarch64.yaml b/conda/environments/all_cuda-130_arch-aarch64.yaml
@@ -44,7 +44,7 @@ dependencies:
 - myst-parser
 - ninja
 - notebook
-- numba-cuda>=0.19.1,<0.20.0a0
+- numba-cuda>=0.22.1,<0.23.0
 - numba>=0.60.0
 - numpy>=1.23.5,<3.0a0
 - numpydoc
diff --git a/conda/environments/all_cuda-130_arch-x86_64.yaml b/conda/environments/all_cuda-130_arch-x86_64.yaml
@@ -44,7 +44,7 @@ dependencies:
 - myst-parser
 - ninja
 - notebook
-- numba-cuda>=0.19.1,<0.20.0a0
+- numba-cuda>=0.22.1,<0.23.0
 - numba>=0.60.0
 - numpy>=1.23.5,<3.0a0
 - numpydoc
diff --git a/conda/recipes/cuopt/recipe.yaml b/conda/recipes/cuopt/recipe.yaml
@@ -77,7 +77,7 @@ requirements:
     - h5py
     - libcuopt =${{ version }}
     - numba >=0.60.0
-    - numba-cuda>=0.19.1,<0.20.0a0
+    - numba-cuda>=0.22.1,<0.23.0
     - numpy >=1.23,<3.0a0
     - pandas >=2.0
     - pylibraft =${{ minor_version }}
diff --git a/cpp/include/cuopt/linear_programming/pdlp/solver_settings.hpp b/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:
diff --git a/cpp/src/dual_simplex/branch_and_bound.cpp b/cpp/src/dual_simplex/branch_and_bound.cpp
@@ -1147,6 +1147,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);
@@ -1164,6 +1165,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,
@@ -1177,6 +1180,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) {
diff --git a/cpp/src/dual_simplex/branch_and_bound.hpp b/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_;
diff --git a/cpp/src/dual_simplex/simplex_solver_settings.hpp b/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
diff --git a/cpp/src/linear_programming/solve.cu b/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(
diff --git a/cpp/src/mip/diversity/diversity_manager.cuh b/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;
 
diff --git a/cpp/src/mip/relaxed_lp/relaxed_lp.cuh b/cpp/src/mip/relaxed_lp/relaxed_lp.cuh
@@ -17,14 +17,14 @@
 namespace cuopt::linear_programming::detail {
 
 struct relaxed_lp_settings_t {
-  double tolerance              = 1e-4;
-  double time_limit             = 1.0;
-  bool check_infeasibility      = true;
-  bool return_first_feasible    = false;
-  bool save_state               = true;
-  bool per_constraint_residual  = true;
-  bool has_initial_primal       = true;
-  volatile int* concurrent_halt = nullptr;
+  double tolerance                  = 1e-4;
+  double time_limit                 = 1.0;
+  bool check_infeasibility          = true;
+  bool return_first_feasible        = false;
+  bool save_state                   = true;
+  bool per_constraint_residual      = true;
+  bool has_initial_primal           = true;
+  std::atomic<int>* concurrent_halt = nullptr;
 };
 
 template <typename i_t, typename f_t>
diff --git a/cpp/src/utilities/logger.cpp b/cpp/src/utilities/logger.cpp
@@ -137,9 +137,26 @@ void reset_default_logger()
   default_logger().flush_on(rapids_logger::level_enum::debug);
 }
 
+// Guard object whose destructor resets the logger
+struct logger_config_guard {
+  ~logger_config_guard() { cuopt::reset_default_logger(); }
+};
+
+// Weak reference to detect if any init_logger_t instance is still alive
+static std::weak_ptr<logger_config_guard> g_active_guard;
+static std::mutex g_guard_mutex;
+
 init_logger_t::init_logger_t(std::string log_file, bool log_to_console)
 {
-  // until this function is called, the default sink is the buffer sink
+  std::lock_guard<std::mutex> lock(g_guard_mutex);
+
+  auto existing_guard = g_active_guard.lock();
+  if (existing_guard) {
+    // Reuse existing configuration, just hold a reference to keep it alive
+    guard_ = existing_guard;
+    return;
+  }
+
   cuopt::default_logger().sinks().clear();
 
   // re-initialize sinks
@@ -164,8 +181,11 @@ init_logger_t::init_logger_t(std::string log_file, bool log_to_console)
   for (const auto& entry : buffered_messages) {
     cuopt::default_logger().log(entry.level, entry.msg.c_str());
   }
-}
 
-init_logger_t::~init_logger_t() { cuopt::reset_default_logger(); }
+  // Create guard and store weak reference for future instances to find
+  auto guard     = std::make_shared<logger_config_guard>();
+  g_active_guard = guard;
+  guard_         = guard;
+}
 
 }  // namespace cuopt
diff --git a/cpp/src/utilities/logger.hpp b/cpp/src/utilities/logger.hpp
@@ -33,11 +33,13 @@ rapids_logger::logger& default_logger();
  */
 void reset_default_logger();
 
+// Ref-counted logger initializer
 class init_logger_t {
+  // Using shared_ptr for ref-counting
+  std::shared_ptr<void> guard_;
+
  public:
   init_logger_t(std::string log_file, bool log_to_console);
-
-  ~init_logger_t();
 };
 
 }  // namespace cuopt
diff --git a/dependencies.yaml b/dependencies.yaml
@@ -348,7 +348,7 @@ dependencies:
     common:
       - output_types: [conda, requirements, pyproject]
         packages:
-          - numba-cuda>=0.19.1,<0.20.0a0
+          - numba-cuda>=0.22.1,<0.23.0
           - numba>=0.60.0
           - rapids-dask-dependency==26.2.*,>=0.0.0a0
           - &pandas pandas>=2.0
diff --git a/python/cuopt/cuopt/linear_programming/problem.py b/python/cuopt/cuopt/linear_programming/problem.py
@@ -935,7 +935,7 @@ def __mul__(self, other):
                 return other * self
 
     def __rmul__(self, other):
-        return other * self
+        return self * other
 
     def __itruediv__(self, other):
         # Compute expr /= constant
diff --git a/python/cuopt/pyproject.toml b/python/cuopt/pyproject.toml
@@ -24,7 +24,7 @@ dependencies = [
     "cuopt-mps-parser==26.2.*,>=0.0.0a0",
     "cupy-cuda13x>=13.6.0",
     "libcuopt==26.2.*,>=0.0.0a0",
-    "numba-cuda>=0.19.1,<0.20.0a0",
+    "numba-cuda>=0.22.1,<0.23.0",
     "numba>=0.60.0",
     "numpy>=1.23.5,<3.0a0",
     "pandas>=2.0",

Original file line number	Diff line number	Diff line change
`@@ -306,7 +306,7 @@ void setup_device_symbols(rmm::cuda_stream_view stream_view)`
`306`	`306`	`detail::set_pdlp_hyper_parameters(stream_view);`
`307`	`307`	`}`
`308`	`308`
`309`		`-volatile int global_concurrent_halt;`
	`309`	`+std::atomic<int> global_concurrent_halt{0};`
`310`	`310`
`311`	`311`	`template <typename i_t, typename f_t>`
`312`	`312`	`optimization_problem_solution_t<i_t, f_t> convert_dual_simplex_sol(`