CI crash fixes (#691)

## Summary by CodeRabbit

## Release Notes

* **Performance**
  * Optimized branch-and-bound algorithm with improved search termination conditions
  
* **Improvements**
  * Enhanced concurrency control mechanisms across solver components
  * Improved logger initialization and lifecycle management for better resource handling

<sub>✏️ Tip: You can customize this high-level summary in your review settings.</sub>

Authors:
  - Alice Boucher (https://github.com/aliceb-nv)

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

URL: #691

Author: aliceb-nv

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/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/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;
 

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>

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

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