[Draft] Move root relaxation solve call to Branch and Bound

cpp/src/branch_and_bound/CMakeLists.txt

@@ -5,6 +5,7 @@
 
 set(BRANCH_AND_BOUND_SRC_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/branch_and_bound.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/concurrent_root_solver.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/pseudo_costs.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/diving_heuristics.cpp
   )

cpp/src/branch_and_bound/branch_and_bound.cpp

@@ -6,6 +6,7 @@
 /* clang-format on */
 
 #include <branch_and_bound/branch_and_bound.hpp>
+#include <branch_and_bound/concurrent_root_solver.hpp>
 #include <branch_and_bound/diving_heuristics.hpp>
 #include <branch_and_bound/mip_node.hpp>
 #include <branch_and_bound/pseudo_costs.hpp>
@@ -2808,9 +2809,53 @@ lp_status_t branch_and_bound_t<i_t, f_t>::solve_root_relaxation(
                                                            root_vstatus_,
                                                            edge_norms_,
                                                            nullptr);
+    // Dual simplex has finished; stop the GPU competitors if they are still running.
+    gpu_root_concurrent_halt_.store(1, std::memory_order_release);
   }
 
-  // Wait for the root relaxation solution to be sent by the diversity manager or dual simplex
+  // The diversity manager prepares the GPU problem while dual simplex starts on the CPU.
+  // Once the GPU problem is ready, launch PDLP and barrier from here so all root-LP
+  // competitors are owned by this function.
+  while (!concurrent_root_problem_ready_.load(std::memory_order_acquire) &&
+         *get_root_concurrent_halt() == 0) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+#pragma omp taskyield
+  }
+
+  if (*get_root_concurrent_halt() == 0 &&
+      concurrent_root_problem_ready_.load(std::memory_order_acquire)) {
+    cuopt_assert(concurrent_root_problem_ != nullptr, "Concurrent root problem is not configured");
+    gpu_root_concurrent_halt_.store(0, std::memory_order_release);
+    try {
+      cuopt_assert(concurrent_root_settings_ != nullptr,
+                   "Concurrent root settings are not configured");
+      const f_t remaining_time =
+        std::max<f_t>(settings_.time_limit - toc(exploration_stats_.start_time), 0);
+      const f_t root_time_limit =
+        std::min(concurrent_root_max_time_, remaining_time * concurrent_root_time_ratio_);
+      auto result = solve_concurrent_root_relaxation(concurrent_root_problem_,
+                                                     *concurrent_root_settings_,
+                                                     root_time_limit,
+                                                     &gpu_root_concurrent_halt_);
+      if (result.usable) {
+        set_root_relaxation_solution(result.primal,
+                                     result.dual,
+                                     result.reduced_cost,
+                                     result.solver_objective,
+                                     result.user_objective,
+                                     result.iterations,
+                                     result.method);
+        // Same as the old diversity-manager path: an Optimal GPU root LP is a
+        // valid MIP dual bound even if dual simplex / crossover has not finished.
+        if (result.optimal) { update_user_bound(result.solver_objective); }
+      }
+    } catch (const std::exception& e) {
+      settings_.log.printf("Concurrent GPU root LP failed: %s\n", e.what());
+    }
+  }
+
+  // Wait until either the GPU root solve supplies a crossover point or CPU dual
+  // simplex finishes. If dual simplex wins, stop and join the GPU solve.
   while (!root_crossover_solution_set_.load(std::memory_order_acquire) &&
          *get_root_concurrent_halt() == 0) {
     std::this_thread::sleep_for(std::chrono::milliseconds(1));

cpp/src/branch_and_bound/branch_and_bound.hpp

@@ -81,6 +81,9 @@ struct clique_table_t;
 template <typename i_t, typename f_t>
 struct mip_symmetry_t;
 
+template <typename i_t, typename f_t>
+class problem_t;
+
 template <typename i_t, typename f_t>
 struct nondeterministic_policy_t;
 template <typename i_t, typename f_t, typename WorkerT>
@@ -145,6 +148,21 @@ class branch_and_bound_t {
   }
 
   void set_concurrent_lp_root_solve(bool enable) { enable_concurrent_lp_root_solve_ = enable; }
+  void configure_concurrent_lp_root_solve(problem_t<i_t, f_t>* problem,
+                                          const pdlp_solver_settings_t<i_t, f_t>& settings,
+                                          f_t max_time,
+                                          f_t time_ratio)
+  {
+    concurrent_root_problem_         = problem;
+    concurrent_root_settings_        = std::make_unique<pdlp_solver_settings_t<i_t, f_t>>(settings);
+    concurrent_root_max_time_        = max_time;
+    concurrent_root_time_ratio_      = time_ratio;
+    enable_concurrent_lp_root_solve_ = true;
+  }
+  void notify_concurrent_root_problem_ready()
+  {
+    concurrent_root_problem_ready_.store(true, std::memory_order_release);
+  }
 
   // Seed the global upper bound from an external source (e.g., early FJ during presolve).
   // `bound` must be in B&B's internal objective space.
@@ -255,6 +273,12 @@ class branch_and_bound_t {
   omp_atomic_t<f_t> root_lp_current_lower_bound_;
   omp_atomic_t<bool> solving_root_relaxation_{false};
   bool enable_concurrent_lp_root_solve_{false};
+  problem_t<i_t, f_t>* concurrent_root_problem_{nullptr};
+  std::unique_ptr<pdlp_solver_settings_t<i_t, f_t>> concurrent_root_settings_;
+  f_t concurrent_root_max_time_{0};
+  f_t concurrent_root_time_ratio_{0};
+  std::atomic<bool> concurrent_root_problem_ready_{false};
+  std::atomic<int> gpu_root_concurrent_halt_{0};
   std::atomic<int> root_concurrent_halt_{0};
   std::atomic<int> node_concurrent_halt_{0};
   bool is_root_solution_set{false};

cpp/src/branch_and_bound/concurrent_root_solver.cu

@@ -0,0 +1,61 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <branch_and_bound/concurrent_root_solver.hpp>
+#include <utilities/timer.hpp>
+
+#include <mip_heuristics/problem/problem.cuh>
+#include <pdlp/solve.cuh>
+
+#include <raft/util/cudart_utils.hpp>
+
+namespace cuopt::mathematical_optimization::mip {
+
+template <typename i_t, typename f_t>
+concurrent_root_solution_t<i_t, f_t> solve_concurrent_root_relaxation(
+  problem_t<i_t, f_t>* problem,
+  const pdlp_solver_settings_t<i_t, f_t>& settings,
+  f_t time_limit,
+  std::atomic<int>* concurrent_halt)
+{
+  concurrent_root_solution_t<i_t, f_t> result;
+  auto root_settings            = settings;
+  root_settings.time_limit      = time_limit;
+  root_settings.concurrent_halt = concurrent_halt;
+
+  timer_t root_timer(time_limit);
+  auto lp_result = solve_lp_with_method<i_t, f_t>(*problem, root_settings, root_timer);
+  const auto status = lp_result.get_termination_status();
+  result.usable =
+    status != pdlp_termination_status_t::NumericalError &&
+    status != pdlp_termination_status_t::ConcurrentLimit &&
+    lp_result.get_primal_solution().size() == static_cast<size_t>(problem->n_variables) &&
+    lp_result.get_dual_solution().size() == static_cast<size_t>(problem->n_constraints);
+  result.optimal = status == pdlp_termination_status_t::Optimal;
+  if (!result.usable) { return result; }
+
+  auto& d_primal       = lp_result.get_primal_solution();
+  auto& d_dual         = lp_result.get_dual_solution();
+  auto& d_reduced_cost = lp_result.get_reduced_cost();
+  result.primal.resize(d_primal.size());
+  result.dual.resize(d_dual.size());
+  result.reduced_cost.resize(d_reduced_cost.size());
+  auto stream = problem->handle_ptr->get_stream();
+  raft::copy(result.primal.data(), d_primal.data(), d_primal.size(), stream);
+  raft::copy(result.dual.data(), d_dual.data(), d_dual.size(), stream);
+  raft::copy(result.reduced_cost.data(), d_reduced_cost.data(), d_reduced_cost.size(), stream);
+  problem->handle_ptr->sync_stream();
+
+  result.user_objective   = lp_result.get_objective_value();
+  result.solver_objective = problem->get_solver_obj_from_user_obj(result.user_objective);
+  result.iterations = lp_result.get_additional_termination_information().number_of_steps_taken;
+  result.method     = lp_result.get_additional_termination_information().solved_by;
+  return result;
+}
+
+template concurrent_root_solution_t<int, double> solve_concurrent_root_relaxation(
+  problem_t<int, double>*, const pdlp_solver_settings_t<int, double>&, double, std::atomic<int>*);
+
+}  // namespace cuopt::mathematical_optimization::mip

cpp/src/branch_and_bound/concurrent_root_solver.hpp

@@ -0,0 +1,37 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include <cuopt/mathematical_optimization/pdlp/solver_settings.hpp>
+
+#include <atomic>
+#include <vector>
+
+namespace cuopt::mathematical_optimization::mip {
+
+template <typename i_t, typename f_t>
+class problem_t;
+
+template <typename i_t, typename f_t>
+struct concurrent_root_solution_t {
+  bool usable{false};
+  bool optimal{false};
+  std::vector<f_t> primal;
+  std::vector<f_t> dual;
+  std::vector<f_t> reduced_cost;
+  f_t solver_objective{0};
+  f_t user_objective{0};
+  i_t iterations{0};
+  method_t method{method_t::Unset};
+};
+
+template <typename i_t, typename f_t>
+concurrent_root_solution_t<i_t, f_t> solve_concurrent_root_relaxation(
+  problem_t<i_t, f_t>* problem,
+  const pdlp_solver_settings_t<i_t, f_t>& settings,
+  f_t time_limit,
+  std::atomic<int>* concurrent_halt);
+
+}  // namespace cuopt::mathematical_optimization::mip