Objective cut in recombiners

benchmarks/linear_programming/cuopt/run_mip.cpp

@@ -383,8 +383,6 @@ int main(int argc, char* argv[])
   double memory_limit    = program.get<double>("--memory-limit");
   bool track_allocations = program.get<std::string>("--track-allocations")[0] == 't';
 
-  if (num_cpu_threads < 0) { num_cpu_threads = omp_get_max_threads() / n_gpus; }
-
   if (program.is_used("--out-dir")) {
     out_dir     = program.get<std::string>("--out-dir");
     result_file = out_dir + "/final_result.csv";
@@ -421,6 +419,7 @@ int main(int argc, char* argv[])
         paths.push_back(entry.path());
       }
     }
+    if (num_cpu_threads < 0) { num_cpu_threads = omp_get_max_threads() / n_gpus; }
     // if batch_num is given, trim the paths to only concerned batch
     if (batch_num != -1) {
       if (n_batches <= 0) {
@@ -487,6 +486,7 @@ int main(int argc, char* argv[])
     }
     merge_result_files(out_dir, result_file, n_gpus, batch_num);
   } else {
+    if (num_cpu_threads < 0) { num_cpu_threads = omp_get_max_threads(); }
     auto memory_resource = make_async();
     if (memory_limit > 0) {
       auto limiting_adaptor =

cpp/CMakeLists.txt

@@ -178,7 +178,6 @@ if(DEFINE_ASSERT)
   add_definitions(-UNDEBUG)
 endif()
 
-
 # ##################################################################################################
 # - find CPM based dependencies  ------------------------------------------------------------------
 rapids_cpm_init()

cpp/src/mip/diversity/diversity_manager.cu

@@ -495,8 +495,7 @@ void diversity_manager_t<i_t, f_t>::diversity_step(i_t max_iterations_without_im
     improved = false;
     while (k-- > 0) {
       if (check_b_b_preemption()) { return; }
-      auto new_sol_vector = population.get_external_solutions();
-      recombine_and_ls_with_all(new_sol_vector);
+      population.add_external_solutions_to_population();
       population.adjust_weights_according_to_best_feasible();
       cuopt_assert(population.test_invariant(), "");
       if (population.current_size() < 2) {

cpp/src/mip/diversity/population.cu

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -24,7 +24,6 @@ constexpr double weight_decrease_ratio       = 0.9;
 constexpr double max_infeasibility_weight    = 1e12;
 constexpr double min_infeasibility_weight    = 1.;
 constexpr double infeasibility_balance_ratio = 1.1;
-constexpr double halving_skip_ratio          = 0.75;
 
 template <typename i_t, typename f_t>
 population_t<i_t, f_t>::population_t(std::string const& name_,
@@ -42,7 +41,6 @@ population_t<i_t, f_t>::population_t(std::string const& name_,
     infeasibility_importance(infeasibility_weight_),
     weights(0, context.problem_ptr->handle_ptr),
     rng(cuopt::seed_generator::get_seed()),
-    early_exit_primal_generation(false),
     population_hash_map(*problem_ptr),
     timer(0)
 {
@@ -109,12 +107,11 @@ std::pair<solution_t<i_t, f_t>, solution_t<i_t, f_t>> population_t<i_t, f_t>::ge
   auto second_solution = solutions[indices[j].first].second;
   // if best feasible and best are the same, take the second index instead of best
   if (i == 0 && j == 1) {
-    bool same =
-      check_integer_equal_on_indices(first_solution.problem_ptr->integer_indices,
-                                     first_solution.assignment,
-                                     second_solution.assignment,
-                                     first_solution.problem_ptr->tolerances.integrality_tolerance,
-                                     first_solution.handle_ptr);
+    bool same = check_integer_equal_on_indices(problem_ptr->integer_indices,
+                                               first_solution.assignment,
+                                               second_solution.assignment,
+                                               problem_ptr->tolerances.integrality_tolerance,
+                                               first_solution.handle_ptr);
     if (same) {
       auto new_sol    = solutions[indices[2].first].second;
       second_solution = std::move(new_sol);
@@ -172,7 +169,6 @@ void population_t<i_t, f_t>::add_external_solution(const std::vector<f_t>& solut
     CUOPT_LOG_DEBUG("Found new best solution %g in external queue",
                     problem_ptr->get_user_obj_from_solver_obj(objective));
   }
-  if (external_solution_queue.size() >= 5) { early_exit_primal_generation = true; }
   solutions_in_external_queue_ = true;
 }
 
@@ -192,7 +188,6 @@ template <typename i_t, typename f_t>
 void population_t<i_t, f_t>::preempt_heuristic_solver()
 {
   context.preempt_heuristic_solver_ = true;
-  early_exit_primal_generation      = true;
 }
 
 template <typename i_t, typename f_t>
@@ -668,42 +663,6 @@ std::vector<solution_t<i_t, f_t>> population_t<i_t, f_t>::population_to_vector()
   return sol_vec;
 }
 
-template <typename i_t, typename f_t>
-void population_t<i_t, f_t>::halve_the_population()
-{
-  raft::common::nvtx::range fun_scope("halve_the_population");
-  // try 3/4 here
-  if (current_size() <= (max_solutions * halving_skip_ratio)) { return; }
-  CUOPT_LOG_DEBUG("Halving the population, current size: %lu", current_size());
-  // put population into a vector
-  auto sol_vec                  = population_to_vector();
-  i_t counter                   = 0;
-  constexpr i_t max_adjustments = 4;
-  size_t max_var_threshold      = get_max_var_threshold(problem_ptr->n_integer_vars);
-
-  std::lock_guard<std::recursive_mutex> lock(write_mutex);
-  while (current_size() > max_solutions / 2) {
-    clear_except_best_feasible();
-    var_threshold = std::max(var_threshold * 0.97, 0.5 * problem_ptr->n_integer_vars);
-    for (auto& sol : sol_vec) {
-      add_solution(solution_t<i_t, f_t>(sol));
-    }
-    if (counter++ > max_adjustments) break;
-  }
-  counter = 0;
-  // if we removed too many decrease the diversity a little
-  while (current_size() < max_solutions / 4) {
-    clear_except_best_feasible();
-    var_threshold = std::min(
-      max_var_threshold,
-      std::min((size_t)(var_threshold * 1.02), (size_t)(0.995 * problem_ptr->n_integer_vars)));
-    for (auto& sol : sol_vec) {
-      add_solution(solution_t<i_t, f_t>(sol));
-    }
-    if (counter++ > max_adjustments) break;
-  }
-}
-
 template <typename i_t, typename f_t>
 size_t population_t<i_t, f_t>::find_free_solution_index()
 {

cpp/src/mip/diversity/population.cuh

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -151,7 +151,6 @@ class population_t {
   void find_diversity(std::vector<solution_t<i_t, f_t>>& initial_sol_vector, bool avg);
 
   std::vector<solution_t<i_t, f_t>> population_to_vector();
-  void halve_the_population();
 
   void run_solution_callbacks(solution_t<i_t, f_t>& sol);
 
@@ -202,7 +201,7 @@ class population_t {
   i_t update_iter = 0;
   std::recursive_mutex write_mutex;
   std::mutex solution_mutex;
-  std::atomic<bool> early_exit_primal_generation = false;
+  std::atomic<bool> preempt_heuristic_solver_    = false;
   std::atomic<bool> solutions_in_external_queue_ = false;
   f_t best_feasible_objective                    = std::numeric_limits<f_t>::max();
   assignment_hash_map_t<i_t, f_t> population_hash_map;

cpp/src/mip/diversity/recombiners/sub_mip.cuh

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -148,7 +148,6 @@ class sub_mip_recombiner_t : public recombiner_t<i_t, f_t> {
     }
     cuopt_func_call(offspring.test_variable_bounds());
     cuopt_assert(offspring.test_number_all_integer(), "All must be integers after offspring");
-    offspring.compute_feasibility();
     // bool same_as_parents = this->check_if_offspring_is_same_as_parents(offspring, a, b);
     // adjust the max_n_of_vars_from_other
     if (n_different_vars > (i_t)sub_mip_recombiner_config_t::max_n_of_vars_from_other) {
@@ -175,6 +174,10 @@ class sub_mip_recombiner_t : public recombiner_t<i_t, f_t> {
       sol.unfix_variables(fixed_assignment, variable_map);
       sol.clamp_within_bounds();  // Scaling might bring some very slight variable bound violations
       sol.compute_feasibility();
+      // the current problem is the proble with objective cut
+      // to add to the population, swap problem to original
+      cuopt_assert(sol.compute_feasibility(), "Solution must be feasible");
+      cuopt_assert(sol.get_feasible(), "Solution must be feasible");
       cuopt_func_call(sol.test_variable_bounds());
       population.add_solution(std::move(sol));
     }