Skip to content

Main merge release/26.02 5#836

Merged
rgsl888prabhu merged 2 commits intoNVIDIA:mainfrom
rgsl888prabhu:main-merge-release/26.02_5
Feb 6, 2026
Merged

Main merge release/26.02 5#836
rgsl888prabhu merged 2 commits intoNVIDIA:mainfrom
rgsl888prabhu:main-merge-release/26.02_5

Conversation

@rgsl888prabhu
Copy link
Collaborator

@rgsl888prabhu rgsl888prabhu commented Feb 6, 2026

Description

Issue

Checklist

  • I am familiar with the Contributing Guidelines.
  • Testing
    • New or existing tests cover these changes
    • Added tests
    • Created an issue to follow-up
    • NA
  • Documentation
    • The documentation is up to date with these changes
    • Added new documentation
    • NA

Summary by CodeRabbit

  • New Features

    • Added reliability_branching parameter to control reliability-based variable selection strategy in MIP solver.
  • Improvements

    • Enhanced branch variable selection through improved pseudocost scoring and reliable selection mechanisms.
    • Refined multi-threaded branch-and-bound execution with worker pool-based architecture.
    • Simplified configuration for sub-problem solving in diversity heuristics.
  • Refactor

    • Reorganized internal branch-and-bound worker management for improved parallel execution coordination.

nguidotti and others added 2 commits February 6, 2026 14:58
This PR implements the schedule-worker model for B&B, where one thread (the scheduler) is responsible for scheduling tasks to the other threads (the workers). With this model, the CPU resources can be shared efficiently among the different tasks within the MIP solver. It also allows the scheduling policy to be changed in runtime (e.g., in the future, the solver can dynamically set the number of workers allocated to each diving heuristics at runtime). 

This also implements a parallel reliability branching (Section 5.7 from [1]). This also fixes the incorrect pseudocost update in each node in the B&B tree.

Closes NVIDIA#526.
Closes NVIDIA#445.
Closes NVIDIA#700.

Performance over the MIPLIB2017 dataset (GH200):

```
================================================================================
main - 046eafd (1) vs reliability-branching-cuts (2)
================================================================================
Feasible solutions = 225 vs 224 (-1)
Optimal solutions = 44 vs 68 (+24)
Solutions with <0.1% primal gap = 109 vs 125 (+16)
Average nodes explored = 7298973 vs 4300451 (-2998522, -41.081%)
Shifted geomean for MIP gap = 0.2979 vs 0.2374 (-0.0605, -20.302%)
Average primal gap = 11.9935 vs 11.0833 (-0.9102, -7.589%)
Average primal integral per time = 19.3326 vs 30.7054 (+11.3728, +37.038%)
================================================================================

```

## Reference 
[1] T. Achterberg, “Constraint Integer Programming,” PhD, Technischen Universität Berlin, Berlin, 2007. doi: [10.14279/depositonce-1634](https://doi.org/10.14279/depositonce-1634).

Authors:
  - Nicolas L. Guidotti (https://github.com/nguidotti)
  - Chris Maes (https://github.com/chris-maes)

Approvers:
  - Chris Maes (https://github.com/chris-maes)

URL: NVIDIA#766
@rgsl888prabhu rgsl888prabhu requested a review from a team as a code owner February 6, 2026 15:59
@rgsl888prabhu rgsl888prabhu merged commit 4c419cc into NVIDIA:main Feb 6, 2026
7 of 9 checks passed
@coderabbitai
Copy link

coderabbitai bot commented Feb 6, 2026

Caution

Review failed

The pull request is closed.

📝 Walkthrough

Walkthrough

This PR introduces a scheduler-worker paradigm for branch-and-bound optimization, adds reliability branching parameter configuration, refactors diving/best-first threading logic, enhances pseudo-cost calculations, and updates utility classes for thread safety. Key changes span solver settings, worker pool management, pseudo-cost strategies, and configuration simplification in related solvers.

Changes

Cohort / File(s) Summary
Reliability Branching Configuration
benchmarks/linear_programming/cuopt/run_mip.cpp, cpp/include/cuopt/linear_programming/constants.h, cpp/include/cuopt/linear_programming/mip/solver_settings.hpp, cpp/src/dual_simplex/simplex_solver_settings.hpp, cpp/src/math_optimization/solver_settings.cu
Added reliability_branching parameter as a new configurable integer (-1 default) throughout the MIP solver, enabling control over reliability-based variable selection strategy.
Branch-and-Bound Worker Architecture
cpp/src/dual_simplex/branch_and_bound_worker.hpp, cpp/src/dual_simplex/branch_and_bound.hpp, cpp/src/dual_simplex/branch_and_bound.cpp
Introduced new worker-pool and scheduler-based design replacing per-thread enum model; added branch_and_bound_worker_t, branch_and_bound_worker_pool_t, and search_strategy_t; refactored core solving API to use worker pointers and new orchestration methods (run_scheduler, single_threaded_solve, plunge_with, dive_with); removed bnb_worker_type_t and bnb_stats_t.
Pseudo-Cost and Variable Selection
cpp/src/dual_simplex/pseudo_costs.hpp, cpp/src/dual_simplex/pseudo_costs.cpp
Added reliable_variable_selection method with dynamic reliability threshold, trial_branching helper, atomic-backed pseudo-cost containers with per-variable mutexes, and calculate_pseudocost_score function; refactored objective estimation and strong branching handling.
Diving Heuristics Updates
cpp/src/dual_simplex/diving_heuristics.cpp
Removed mutex acquisition in pseudocost and guided diving; added fallback mechanism to select first fractional variable when all scores yield NONE; changed max_score initialization from lowest() to -1.
Core Utilities
cpp/src/utilities/omp_helpers.hpp, cpp/src/utilities/pcgenerator.hpp
Refactored omp_mutex_t to use unique_ptr with move semantics and explicit rule-of-five; made omp_atomic_t conversion operator const-qualified; introduced new CPU-side PCG random number generator (pcgenerator_t).
Solver Settings and Configuration
cpp/src/mip/diversity/lns/rins.cu, cpp/src/mip/diversity/recombiners/sub_mip.cuh, cpp/src/mip/solver.cu, cpp/src/dual_simplex/simplex_solver_settings.hpp
Simplified RINS and SubMIP branch-and-bound configurations to single-threaded setup with reliability_branching; removed num_bfs_workers and num_diving_workers; updated solver to wire reliability_branching and mip_batch_pdlp_strong_branching; refined thread count computation.
Data Structure Updates
cpp/src/dual_simplex/solution.hpp, cpp/src/dual_simplex/node_queue.hpp, cpp/src/dual_simplex/mip_node.hpp, cpp/src/dual_simplex/basis_updates.hpp, cpp/src/dual_simplex/presolve.cpp
Widened nodes_explored and simplex_iterations to int64_t; made node_queue pop methods thread-safe with mutex; rewrote mip_node detach_copy for explicit field copying; added copy/move constructors and set_refactor_frequency to basis_update_mpf_t; changed bounds strengthening to compile-time conditional.

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~65 minutes

Possibly related PRs

  • Scheduler-Worker Model + Reliability Branching #766: Directly related implementation of scheduler–worker refactoring and reliability_branching parameter wiring across branch-and-bound, pseudo-costs, and solver settings with matching file/function signature changes.

Suggested labels

improvement, mip

Suggested reviewers

  • akifcorduk
  • chris-maes
✨ Finishing touches
  • 📝 Generate docstrings
🧪 Generate unit tests (beta)
  • Create PR with unit tests
  • Post copyable unit tests in a comment

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

Comment @coderabbitai help to get the list of available commands and usage tips.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants