Objective cut in recombiners #628

akifcorduk · 2025-11-25T15:16:03Z

This PR extends the objective cut of the problem to the recombiners as well. There is also some cleanup of unused functions.

Pending: benchmark results/comparison.
Not critical for 25.12

Summary by CodeRabbit

Refactor
- More consistent propagation of cutting‑plane context and problem‑variant handling across local search, recombination, and population flows for improved solution evaluation and stability.
- Moved CPU‑thread initialization to later, mode‑specific points for more predictable resource behavior.
New Features
- Dual‑problem support enabling seamless switching between original and cut‑enhanced problem contexts.
Chores
- Updated copyright year to 2026.

_{✏️ Tip: You can customize this high-level summary in your review settings.}

This reverts commit d1413c8.

…iner

akifcorduk · 2025-11-27T14:39:38Z

@aliceb-nv the point in keeping track of problem pointers is for two reasons:

Prevent incompatibility between B&B and incumbent callbacks.
Keep population invariants stable. If we also keep objective cut at population sorting and recombiners, everything will work on infeasible logic and also we won't show feasible solutions in the population (the cut is a bit tighter than the best).

aliceb-nv · 2025-11-27T14:50:50Z

Thanks Akif!
I see no issue in maintaining multiple problem pointers, the need is sound :) We just need to make sure the semantics are well communicated and safeguards are added

coderabbitai

Actionable comments posted: 4

♻️ Duplicate comments (1)

cpp/src/mip/diversity/population.cuh (1)

174-174: Dual-pointer and dual-weights state management requires careful synchronization.

As noted in past review comments, maintaining problem_ptr_with_cuts/weights_with_cuts alongside problem_ptr/weights introduces risk of broken invariants. Consider documenting the ownership semantics and lifecycle of these members. The planned robust architecture for managing cuts (mentioned in past discussion) should address this.

Also applies to: 184-184

🧹 Nitpick comments (7)

cpp/src/mip/diversity/diversity_config.hpp (1)

31-31: Good change for consistency.

Increasing lp_run_time_if_infeasible from 1.0 to 2.0 makes it consistent with lp_run_time_if_feasible (line 30). This symmetry is sensible, especially when extending objective cuts to recombiners (per the PR objective), which may increase encounters with infeasible intermediate solutions.

Consider adding a brief comment documenting the rationale for these time limits (e.g., "// LP time limits balanced to handle both feasible and infeasible cases during recombination"), especially since the PR description notes that benchmark results are pending.
conda/environments/all_cuda-129_arch-x86_64.yaml (1)
22-22: Simplify redundant version constraint pattern.

All updated RAPIDS packages use the pattern package==26.2.*,>=0.0.0a0. The >=0.0.0a0 constraint is redundant; 26.2.* already implies a lower bound of 26.2.0. Simplify these to package==26.2.* unless there's a specific reason to include pre-release versions.

Apply this diff to remove redundant constraints (example shown for one package; apply to all affected lines):
- cudf==26.2.*,>=0.0.0a0
+ cudf==26.2.*
- libraft-headers==26.2.*,>=0.0.0a0
+ libraft-headers==26.2.*
- librmm==26.2.*,>=0.0.0a0
+ librmm==26.2.*
- pylibraft==26.2.*,>=0.0.0a0
+ pylibraft==26.2.*
- rapids-dask-dependency==26.2.*,>=0.0.0a0
+ rapids-dask-dependency==26.2.*
- rmm==26.2.*,>=0.0.0a0
+ rmm==26.2.*
Also applies to: 38-39, 56-56, 62-62, 65-65
docs/cuopt/source/project.json (1)
1-1: Version metadata is correct; optional wording tweak

The version field is correctly updated to 26.02.00 and matches the rest of the release metadata.

Optionally, you might clean up the description grammar:
-{"name": "cuopt", "version": "26.02.00", "url": "https://github.com/nvidia/cuopt", "description": "NVIDIA cuOpt is a optimization engine"}
+{"name": "cuopt", "version": "26.02.00", "url": "https://github.com/nvidia/cuopt", "description": "NVIDIA cuOpt is an optimization engine"}
README.md (1)

68-108: Install instructions now consistently target 26.02.*

The pip and conda examples for CUDA 12.x / 13.x have been updated to use cuopt-server[-cu12/-cu13]==26.02.* and cuopt-sh-client==26.02.*, which aligns the user-facing docs with the new release line.

Please confirm that the 26.02.* wheels and conda packages for these names are actually published for all supported CUDA/Python combos, so the copy‑paste commands work as written.

If you want the README to always highlight the latest release, you might optionally update the container example tag (currently 25.10.0) to a 26.02.00-based example in a follow-up.
benchmarks/linear_programming/cuopt/run_mip.cpp (1)
416-416: Edge case: division may yield zero threads.

If n_gpus exceeds omp_get_max_threads(), integer division will result in num_cpu_threads = 0, which may cause issues downstream. Consider adding a floor of 1:
-    if (num_cpu_threads < 0) { num_cpu_threads = omp_get_max_threads() / n_gpus; }
+    if (num_cpu_threads < 0) { num_cpu_threads = std::max(1, omp_get_max_threads() / n_gpus); }
cpp/src/mip/local_search/local_search.cu (2)
258-270: Remove or document commented-out code.

This block of commented-out time limit adjustment logic should either be removed or have a clear TODO/FIXME explaining why it's being kept. Leaving dead code in comments can cause maintenance confusion.
-  // if (!solution.get_feasible()) {
-  //   if (ls_config.at_least_one_parent_feasible) {
-  //     fj_settings.time_limit = 0.5;
-  //     timer                  = timer_t(fj_settings.time_limit);
-  //   } else {
-  //     fj_settings.time_limit = 0.25;
-  //     timer                  = timer_t(fj_settings.time_limit);
-  //   }
-  // } else {
-  //   fj_settings.time_limit = std::min(1., timer.remaining_time());
-  // }
   fj_settings.time_limit      = std::min(1., timer.remaining_time());
   timer                       = timer_t(fj_settings.time_limit);
601-618: Duplicated cutting plane logic - consider reusing handle_cutting_plane_and_weights.

Lines 601-618 in run_recombiners duplicate most of the logic from handle_cutting_plane_and_weights (lines 548-569). The only difference is that handle_cutting_plane_and_weights also calls apply_problem_ptr_to_all_solutions() at the end. Consider refactoring to reuse the helper:
   population_ptr->add_external_solutions_to_population();
   if (population_ptr->is_feasible()) {
-    if (!cutting_plane_added_for_active_run) {
-      solution.set_problem_ptr(&problem_with_objective_cut);
-      population_ptr->set_problem_ptr_with_cuts(&problem_with_objective_cut);
-      resize_to_new_problem();
-      cutting_plane_added_for_active_run = true;
-      raft::copy(population_ptr->weights.cstr_weights.data(),
-                 fj.cstr_weights.data(),
-                 population_ptr->weights.cstr_weights.size(),
-                 solution.handle_ptr->get_stream());
-      raft::copy(population_ptr->weights_with_cuts.cstr_weights.data(),
-                 fj.cstr_weights.data(),
-                 fj.cstr_weights.size(),
-                 solution.handle_ptr->get_stream());
-    }
-    population_ptr->update_weights();
-    save_solution_and_add_cutting_plane(population_ptr->best_feasible(), solution, best_objective);
+    handle_cutting_plane_and_weights(solution, population_ptr, best_objective);
   }

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 0802827 and 67f5008.

📒 Files selected for processing (45)

.github/workflows/build.yaml (13 hunks)
.github/workflows/build_test_publish_images.yaml (1 hunks)
.github/workflows/nightly.yaml (1 hunks)
.github/workflows/pr.yaml (11 hunks)
.github/workflows/test.yaml (5 hunks)
.github/workflows/trigger-breaking-change-alert.yaml (1 hunks)
RAPIDS_BRANCH (1 hunks)
README.md (2 hunks)
VERSION (1 hunks)
benchmarks/linear_programming/cuopt/run_mip.cpp (2 hunks)
ci/release/update-version.sh (1 hunks)
ci/test_cpp.sh (1 hunks)
ci/test_cpp_memcheck.sh (1 hunks)
ci/test_python.sh (1 hunks)
conda/environments/all_cuda-129_arch-aarch64.yaml (4 hunks)
conda/environments/all_cuda-129_arch-x86_64.yaml (4 hunks)
conda/environments/all_cuda-130_arch-aarch64.yaml (4 hunks)
conda/environments/all_cuda-130_arch-x86_64.yaml (4 hunks)
cpp/CMakeLists.txt (3 hunks)
cpp/src/mip/diversity/diversity_config.hpp (1 hunks)
cpp/src/mip/diversity/diversity_manager.cu (3 hunks)
cpp/src/mip/diversity/population.cu (7 hunks)
cpp/src/mip/diversity/population.cuh (4 hunks)
cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh (4 hunks)
cpp/src/mip/diversity/recombiners/fp_recombiner.cuh (2 hunks)
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh (2 hunks)
cpp/src/mip/diversity/recombiners/sub_mip.cuh (2 hunks)
cpp/src/mip/local_search/local_search.cu (8 hunks)
cpp/src/mip/local_search/local_search.cuh (1 hunks)
cpp/src/mip/solution/solution.cu (4 hunks)
cpp/src/mip/solution/solution.cuh (2 hunks)
dependencies.yaml (17 hunks)
docs/cuopt/source/cuopt-c/quick-start.rst (3 hunks)
docs/cuopt/source/cuopt-python/quick-start.rst (3 hunks)
docs/cuopt/source/cuopt-python/routing/routing-example.ipynb (1 hunks)
docs/cuopt/source/cuopt-server/quick-start.rst (3 hunks)
docs/cuopt/source/faq.rst (1 hunks)
docs/cuopt/source/project.json (1 hunks)
docs/cuopt/source/versions1.json (1 hunks)
helmchart/cuopt-server/Chart.yaml (2 hunks)
helmchart/cuopt-server/values.yaml (1 hunks)
python/cuopt/pyproject.toml (2 hunks)
python/cuopt_self_hosted/pyproject.toml (1 hunks)
python/cuopt_server/pyproject.toml (1 hunks)
python/libcuopt/pyproject.toml (2 hunks)

🧰 Additional context used

📓 Path-based instructions (8)

docs/**/*

⚙️ CodeRabbit configuration file

docs/**/*: For documentation changes, focus on:

Accuracy: Verify code examples compile and run correctly

Completeness: Check if API changes (parameters, return values, errors) are documented

Clarity: Flag confusing explanations, missing prerequisites, or unclear examples

Consistency: Version numbers, parameter types, and terminology match code

Examples: Suggest adding examples for complex features or new APIs

Missing docs: If PR changes public APIs without updating docs, flag as HIGH priority

When code changes affect docs:

Suggest specific doc files that need updates (e.g., docs/cuopt/api.rst)

Identify outdated information contradicting the code changes

Recommend documenting performance characteristics, GPU requirements, or numerical tolerances

Files:

docs/cuopt/source/cuopt-python/routing/routing-example.ipynb
docs/cuopt/source/faq.rst
docs/cuopt/source/cuopt-python/quick-start.rst
docs/cuopt/source/cuopt-server/quick-start.rst
docs/cuopt/source/versions1.json
docs/cuopt/source/cuopt-c/quick-start.rst
docs/cuopt/source/project.json

docs/**/*.{rst,md}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

docs/**/*.{rst,md}: Update documentation in docs/ for API changes (new parameters, return values, error codes), new public functions/classes, and changed algorithm behavior
Document numerical tolerances, parameter ranges, and algorithm phase descriptions in API documentation when solver behavior or tolerances change
Update version numbers and deprecation notices in documentation for breaking API changes; provide migration guidance for deprecated APIs

Files:

docs/cuopt/source/faq.rst
docs/cuopt/source/cuopt-python/quick-start.rst
docs/cuopt/source/cuopt-server/quick-start.rst
docs/cuopt/source/cuopt-c/quick-start.rst

**/*.{cu,cuh,cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh,cpp,hpp,h}: Track GPU device memory allocations and deallocations to prevent memory leaks; ensure cudaMalloc/cudaFree balance and cleanup of streams/events
Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results
Check numerical stability: prevent overflow/underflow, precision loss, division by zero/near-zero, and use epsilon comparisons for floating-point equality checks
Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)
Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations
For concurrent CUDA operations (barriers, async operations), explicitly create and manage dedicated streams instead of reusing the default stream; document stream lifecycle
Eliminate unnecessary host-device synchronization (cudaDeviceSynchronize) in hot paths that blocks GPU pipeline; use streams and events for async execution
Assess algorithmic complexity for large-scale problems (millions of variables/constraints); ensure O(n log n) or better complexity, not O(n²) or worse
Verify correct problem size checks before expensive GPU/CPU operations; prevent resource exhaustion on oversized problems
Identify assertions with overly strict numerical tolerances that fail on legitimate degenerate/edge cases (near-zero pivots, singular matrices, empty problems)
Ensure race conditions are absent in multi-GPU code and multi-threaded server implementations; verify proper synchronization of shared state
Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication
Check that hard-coded GPU de...

Files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/recombiners/fp_recombiner.cuh
cpp/src/mip/diversity/diversity_manager.cu
cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
cpp/src/mip/diversity/diversity_config.hpp
cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh
cpp/src/mip/local_search/local_search.cu
cpp/src/mip/solution/solution.cuh
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cuh
cpp/src/mip/diversity/population.cuh

**/*.{cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cpp,hpp,h}: Check for unclosed file handles when reading MPS/QPS problem files; ensure RAII patterns or proper cleanup in exception paths
Validate input sanitization to prevent buffer overflows and resource exhaustion attacks; avoid unsafe deserialization of problem files
Prevent thread-unsafe use of global and static variables; use proper mutex/synchronization in server code accessing shared solver state

Files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/diversity_config.hpp

**/*.{cu,cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

Avoid inappropriate use of exceptions in performance-critical GPU operation paths; prefer error codes or CUDA error checking for latency-sensitive code

Files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/diversity_manager.cu
cpp/src/mip/diversity/diversity_config.hpp
cpp/src/mip/local_search/local_search.cu
cpp/src/mip/diversity/population.cu

**/*.{cu,cuh}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh}: Every CUDA kernel launch and memory operation must have error checking with CUDA_CHECK or equivalent verification
Avoid reinventing functionality already available in Thrust, CCCL, or RMM libraries; prefer standard library utilities over custom implementations

Files:

cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/recombiners/fp_recombiner.cuh
cpp/src/mip/diversity/diversity_manager.cu
cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh
cpp/src/mip/local_search/local_search.cu
cpp/src/mip/solution/solution.cuh
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cuh
cpp/src/mip/diversity/population.cuh

**/*.cu

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.cu: Verify race conditions and correctness of GPU kernel shared memory, atomics, and warp-level operations
Detect inefficient GPU kernel launches with low occupancy or poor memory access patterns; optimize for coalesced memory access and minimize warp divergence in hot paths

Files:

cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/diversity_manager.cu
cpp/src/mip/local_search/local_search.cu
cpp/src/mip/diversity/population.cu

**/*.{h,hpp,py}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

Verify C API does not break ABI stability (no struct layout changes, field reordering); maintain backward compatibility in Python and server APIs with deprecation warnings

Files:

cpp/src/mip/diversity/diversity_config.hpp

🧠 Learnings (24)

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to docs/**/*.{rst,md} : Update documentation in docs/ for API changes (new parameters, return values, error codes), new public functions/classes, and changed algorithm behavior

Applied to files:

docs/cuopt/source/faq.rst

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Check that hard-coded GPU device IDs and resource limits are made configurable; abstract multi-backend support for different CUDA versions

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/CMakeLists.txt

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Verify correct problem size checks before expensive GPU/CPU operations; prevent resource exhaustion on oversized problems

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/population.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure race conditions are absent in multi-GPU code and multi-threaded server implementations; verify proper synchronization of shared state

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.cu : Detect inefficient GPU kernel launches with low occupancy or poor memory access patterns; optimize for coalesced memory access and minimize warp divergence in hot paths

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/CMakeLists.txt

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*benchmark*.{cpp,cu,py} : Include performance benchmarks and regression detection for GPU operations; verify near real-time performance on million-variable problems

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/CMakeLists.txt

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/diversity_manager.cu
cpp/src/mip/local_search/local_search.cu
cpp/src/mip/solution/solution.cuh
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/recombiners/fp_recombiner.cuh
cpp/src/mip/diversity/diversity_manager.cu
cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/diversity_config.hpp
cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh
cpp/src/mip/local_search/local_search.cu
cpp/src/mip/solution/solution.cuh
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cuh
cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/local_search/local_search.cu
cpp/src/mip/solution/solution.cuh
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cuh
cpp/src/mip/diversity/population.cuh
cpp/CMakeLists.txt

📚 Learning: 2025-10-22T14:25:22.899Z

Learnt from: aliceb-nv
Repo: NVIDIA/cuopt PR: 527
File: cpp/src/mip/diversity/lns/rins.cu:167-175
Timestamp: 2025-10-22T14:25:22.899Z
Learning: In MIP (Mixed Integer Programming) problems in the cuOPT codebase, `n_integer_vars == 0` is impossible by definition—MIP problems must have at least one integer variable. If there are no integer variables, it would be a pure Linear Programming (LP) problem, not a MIP problem.

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/recombiners/fp_recombiner.cuh
cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh
cpp/src/mip/local_search/local_search.cu
cpp/src/mip/solution/solution.cuh
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cuh
cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Track GPU device memory allocations and deallocations to prevent memory leaks; ensure cudaMalloc/cudaFree balance and cleanup of streams/events

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/CMakeLists.txt

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for problem transformations: verify correctness of original→transformed→postsolve mappings and index consistency across problem representations

Applied to files:

cpp/src/mip/solution/solution.cu
cpp/src/mip/solution/solution.cuh
cpp/src/mip/diversity/population.cu
cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for algorithm phase transitions: verify correct initialization of bounds and state when transitioning from presolve to simplex to diving to crossover

Applied to files:

cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/diversity_manager.cu
cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/local_search/local_search.cu
cpp/src/mip/solution/solution.cuh
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cuh
cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cpp,hpp,h} : Check for unclosed file handles when reading MPS/QPS problem files; ensure RAII patterns or proper cleanup in exception paths

Applied to files:

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

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Reduce tight coupling between solver components (presolve, simplex, basis, barrier); increase modularity and reusability of optimization algorithms

Applied to files:

cpp/src/mip/local_search/local_search.cu
cpp/src/mip/solution/solution.cuh
cpp/src/mip/local_search/local_search.cuh
cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh} : Avoid reinventing functionality already available in Thrust, CCCL, or RMM libraries; prefer standard library utilities over custom implementations

Applied to files:

cpp/src/mip/diversity/population.cu
cpp/CMakeLists.txt

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Test with free variables, singleton problems, and extreme problem dimensions near resource limits to validate edge case handling

Applied to files:

cpp/src/mip/diversity/population.cu
cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cpp,hpp,h} : Prevent thread-unsafe use of global and static variables; use proper mutex/synchronization in server code accessing shared solver state

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Assess algorithmic complexity for large-scale problems (millions of variables/constraints); ensure O(n log n) or better complexity, not O(n²) or worse

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Identify assertions with overly strict numerical tolerances that fail on legitimate degenerate/edge cases (near-zero pivots, singular matrices, empty problems)

Applied to files:

cpp/CMakeLists.txt

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh} : Every CUDA kernel launch and memory operation must have error checking with CUDA_CHECK or equivalent verification

Applied to files:

cpp/CMakeLists.txt

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Verify error propagation from CUDA to user-facing APIs is complete; ensure CUDA errors are caught and mapped to meaningful user error codes

Applied to files:

cpp/CMakeLists.txt

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cpp,hpp,h} : Avoid inappropriate use of exceptions in performance-critical GPU operation paths; prefer error codes or CUDA error checking for latency-sensitive code

Applied to files:

cpp/CMakeLists.txt

🧬 Code graph analysis (1)

cpp/src/mip/solution/solution.cu (1)

cpp/include/cuopt/linear_programming/pdlp/solver_solution.hpp (1)

handle_ptr (282-283)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (10)

GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.12, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.10, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.12, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.13, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.11, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.11, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.10, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.13, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-sh-client / 13.0.2, 3.10, amd64, rockylinux8
GitHub Check: checks / check-style

dependencies.yaml

helmchart/cuopt-server/values.yaml

python/cuopt_self_hosted/pyproject.toml

python/cuopt/pyproject.toml

…at_recombiner

coderabbitai

Actionable comments posted: 0

🧹 Nitpick comments (3)

cpp/src/linear_programming/restart_strategy/localized_duality_gap_container.cu (1)
40-47: Minor: cudaMemsetAsync second argument should be 0, not f_t(0.0).

cudaMemsetAsync takes a byte value (int) as the second parameter, not a floating-point value. While this works correctly since 0 and f_t(0.0) both result in zero-bytes being written, using f_t(0.0) is misleading and relies on implicit conversion.
-  RAFT_CUDA_TRY(cudaMemsetAsync(primal_solution_.data(),
-                                f_t(0.0),
-                                sizeof(f_t) * primal_solution_.size(),
-                                handle_ptr->get_stream()));
-  RAFT_CUDA_TRY(cudaMemsetAsync(dual_solution_.data(),
-                                f_t(0.0),
-                                sizeof(f_t) * dual_solution_.size(),
-                                handle_ptr->get_stream()));
+  RAFT_CUDA_TRY(cudaMemsetAsync(primal_solution_.data(),
+                                0,
+                                sizeof(f_t) * primal_solution_.size(),
+                                handle_ptr->get_stream()));
+  RAFT_CUDA_TRY(cudaMemsetAsync(dual_solution_.data(),
+                                0,
+                                sizeof(f_t) * dual_solution_.size(),
+                                handle_ptr->get_stream()));
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu (2)
115-135: Stale comment on line 125.

The comment says "If KKT restart, call the empty cusparse_view constructor" but the condition now checks !is_trust_region_restart(). The comment should be updated to reflect the new semantics.
-    // If KKT restart, call the empty cusparse_view constructor
+    // If trust region restart is not used, call the empty cusparse_view constructor
     avg_duality_gap_cusparse_view_{
158-194: Consider caching or extracting the repeated pattern (optional).

The pattern (!is_trust_region_restart<i_t, f_t>()) ? 0 : static_cast<size_t>(size) appears many times. While member initializer lists don't allow local variables, a small helper function could improve readability:
template <typename i_t, typename f_t>
constexpr size_t trust_region_size_or_zero(i_t size) {
  return is_trust_region_restart<i_t, f_t>() ? static_cast<size_t>(size) : 0;
}
However, since is_trust_region_restart reads a runtime hyperparameter, this optimization is minor and can be deferred.

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 67f5008 and 1695286.

📒 Files selected for processing (8)

cpp/CMakeLists.txt (2 hunks)
cpp/src/dual_simplex/branch_and_bound.cpp (23 hunks)
cpp/src/dual_simplex/branch_and_bound.hpp (4 hunks)
cpp/src/dual_simplex/phase2.cpp (1 hunks)
cpp/src/linear_programming/restart_strategy/localized_duality_gap_container.cu (1 hunks)
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu (6 hunks)
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cuh (1 hunks)
cpp/src/utilities/omp_helpers.hpp (1 hunks)

🚧 Files skipped from review as they are similar to previous changes (1)

cpp/CMakeLists.txt

🧰 Additional context used

📓 Path-based instructions (6)

**/*.{cu,cuh}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh}: Every CUDA kernel launch and memory operation must have error checking with CUDA_CHECK or equivalent verification
Avoid reinventing functionality already available in Thrust, CCCL, or RMM libraries; prefer standard library utilities over custom implementations

Files:

cpp/src/linear_programming/restart_strategy/localized_duality_gap_container.cu
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cuh

**/*.cu

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.cu: Verify race conditions and correctness of GPU kernel shared memory, atomics, and warp-level operations
Detect inefficient GPU kernel launches with low occupancy or poor memory access patterns; optimize for coalesced memory access and minimize warp divergence in hot paths

Files:

cpp/src/linear_programming/restart_strategy/localized_duality_gap_container.cu
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu

**/*.{cu,cuh,cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh,cpp,hpp,h}: Track GPU device memory allocations and deallocations to prevent memory leaks; ensure cudaMalloc/cudaFree balance and cleanup of streams/events
Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results
Check numerical stability: prevent overflow/underflow, precision loss, division by zero/near-zero, and use epsilon comparisons for floating-point equality checks
Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)
Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations
For concurrent CUDA operations (barriers, async operations), explicitly create and manage dedicated streams instead of reusing the default stream; document stream lifecycle
Eliminate unnecessary host-device synchronization (cudaDeviceSynchronize) in hot paths that blocks GPU pipeline; use streams and events for async execution
Assess algorithmic complexity for large-scale problems (millions of variables/constraints); ensure O(n log n) or better complexity, not O(n²) or worse
Verify correct problem size checks before expensive GPU/CPU operations; prevent resource exhaustion on oversized problems
Identify assertions with overly strict numerical tolerances that fail on legitimate degenerate/edge cases (near-zero pivots, singular matrices, empty problems)
Ensure race conditions are absent in multi-GPU code and multi-threaded server implementations; verify proper synchronization of shared state
Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication
Check that hard-coded GPU de...

Files:

cpp/src/linear_programming/restart_strategy/localized_duality_gap_container.cu
cpp/src/dual_simplex/phase2.cpp
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu
cpp/src/dual_simplex/branch_and_bound.cpp
cpp/src/utilities/omp_helpers.hpp
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cuh
cpp/src/dual_simplex/branch_and_bound.hpp

**/*.{cu,cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

Avoid inappropriate use of exceptions in performance-critical GPU operation paths; prefer error codes or CUDA error checking for latency-sensitive code

Files:

cpp/src/linear_programming/restart_strategy/localized_duality_gap_container.cu
cpp/src/dual_simplex/phase2.cpp
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu
cpp/src/dual_simplex/branch_and_bound.cpp
cpp/src/utilities/omp_helpers.hpp
cpp/src/dual_simplex/branch_and_bound.hpp

**/*.{cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cpp,hpp,h}: Check for unclosed file handles when reading MPS/QPS problem files; ensure RAII patterns or proper cleanup in exception paths
Validate input sanitization to prevent buffer overflows and resource exhaustion attacks; avoid unsafe deserialization of problem files
Prevent thread-unsafe use of global and static variables; use proper mutex/synchronization in server code accessing shared solver state

Files:

cpp/src/dual_simplex/phase2.cpp
cpp/src/dual_simplex/branch_and_bound.cpp
cpp/src/utilities/omp_helpers.hpp
cpp/src/dual_simplex/branch_and_bound.hpp

**/*.{h,hpp,py}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

Verify C API does not break ABI stability (no struct layout changes, field reordering); maintain backward compatibility in Python and server APIs with deprecation warnings

Files:

cpp/src/utilities/omp_helpers.hpp
cpp/src/dual_simplex/branch_and_bound.hpp

🧠 Learnings (12)

📓 Common learnings

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Reduce tight coupling between solver components (presolve, simplex, basis, barrier); increase modularity and reusability of optimization algorithms

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)

Applied to files:

cpp/src/linear_programming/restart_strategy/localized_duality_gap_container.cu
cpp/src/dual_simplex/phase2.cpp
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu
cpp/src/dual_simplex/branch_and_bound.cpp
cpp/src/dual_simplex/branch_and_bound.hpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results

Applied to files:

cpp/src/linear_programming/restart_strategy/localized_duality_gap_container.cu
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu
cpp/src/dual_simplex/branch_and_bound.cpp
cpp/src/dual_simplex/branch_and_bound.hpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication

Applied to files:

cpp/src/linear_programming/restart_strategy/localized_duality_gap_container.cu
cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu
cpp/src/utilities/omp_helpers.hpp
cpp/src/dual_simplex/branch_and_bound.hpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for algorithm phase transitions: verify correct initialization of bounds and state when transitioning from presolve to simplex to diving to crossover

Applied to files:

cpp/src/dual_simplex/phase2.cpp
cpp/src/dual_simplex/branch_and_bound.cpp
cpp/src/dual_simplex/branch_and_bound.hpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Check that hard-coded GPU device IDs and resource limits are made configurable; abstract multi-backend support for different CUDA versions

Applied to files:

cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh} : Avoid reinventing functionality already available in Thrust, CCCL, or RMM libraries; prefer standard library utilities over custom implementations

Applied to files:

cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu
cpp/src/utilities/omp_helpers.hpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations

Applied to files:

cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu
cpp/src/dual_simplex/branch_and_bound.cpp
cpp/src/dual_simplex/branch_and_bound.hpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Reduce tight coupling between solver components (presolve, simplex, basis, barrier); increase modularity and reusability of optimization algorithms

Applied to files:

cpp/src/dual_simplex/branch_and_bound.cpp
cpp/src/dual_simplex/branch_and_bound.hpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.cu : Verify race conditions and correctness of GPU kernel shared memory, atomics, and warp-level operations

Applied to files:

cpp/src/utilities/omp_helpers.hpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cpp,hpp,h} : Prevent thread-unsafe use of global and static variables; use proper mutex/synchronization in server code accessing shared solver state

Applied to files:

cpp/src/dual_simplex/branch_and_bound.hpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Assess algorithmic complexity for large-scale problems (millions of variables/constraints); ensure O(n log n) or better complexity, not O(n²) or worse

Applied to files:

cpp/src/dual_simplex/branch_and_bound.hpp

🧬 Code graph analysis (2)

cpp/src/linear_programming/restart_strategy/localized_duality_gap_container.cu (1)

cpp/include/cuopt/linear_programming/pdlp/solver_solution.hpp (1)

handle_ptr (282-283)

cpp/src/dual_simplex/branch_and_bound.hpp (2)

cpp/src/dual_simplex/branch_and_bound.cpp (6)

node_presolver (837-837)

node_presolver (1048-1048)

node_presolver (1117-1117)

basic_list (841-841)

basic_list (1052-1052)

basic_list (1121-1121)

cpp/src/dual_simplex/phase2.cpp (1)

basic_list (2176-2176)

🔇 Additional comments (23)

cpp/src/utilities/omp_helpers.hpp (2)

94-101: I'm unable to proceed with verification due to repository access issues. The cloning of NVIDIA/cuopt failed, which prevents me from:

Searching for existing member function calls to fetch_min and fetch_max

Reading the full implementation context (lines 108-131)

Identifying all usages across the codebase

Confirming whether this is truly a breaking API change

Manual verification required: Cannot confirm if the API change is breaking without codebase access.

The review comment claims changing from member functions fetch_min() and fetch_max() to free functions represents a breaking API change, contradicting the PR's "non-breaking" label. However, this cannot be validated automatically:

No existing calls to .fetch_min( or .fetch_max( could be found to confirm the claim

The full implementation context (lines 108-131) could not be reviewed

The impact assessment depends on actual usage patterns in the codebase

Recommendation: Manually verify:

Whether fetch_min and fetch_max were previously public member functions

Whether any existing code calls them as member functions

Whether the PR should be re-labeled or if the caller interface was intentionally changed

108-131: Based on the verification results, I found a critical issue with the review comment:

The clang bug #127466 referenced in the code comment cannot be verified as a valid public LLVM bug report.

The web search found no public record of this bug in:

bugs.llvm.org (LLVM's official bug tracker)

LLVM/Clang documentation

Any publicly accessible sources

Since the repository cloning failed, I cannot verify the codebase usage patterns directly. However, the unverifiable bug reference is itself a significant concern that should be raised.

Verify the clang 20 bug reference before accepting the workaround.

The code comment cites clang 20 bug #127466 as justification for converting templated member functions to non-templated free functions. However, this bug report does not appear in LLVM's public bug tracker (bugs.llvm.org) or official documentation.

Unverified bug reference: The clang bug #127466 is not publicly documented. Before accepting this architectural workaround (which loses template generality and introduces API inconsistency), confirm:

The bug number and source (bugs.llvm.org, GitHub issue, or Phabricator URL)

Whether it affects production-relevant clang versions

The timeline for a fix

Loss of type generality: Specializing to double only narrows the API surface. Verify that no current or planned code uses fetch_min/fetch_max with other numeric types (e.g., int, float, long).

API inconsistency: These functions now break the pattern established by fetch_add, fetch_sub, exchange, load, and store (which are member functions). Document the expectation that this will be reverted once the compiler bug is resolved.

cpp/src/linear_programming/restart_strategy/localized_duality_gap_container.cu (1)

31-38: Logic inversion looks correct for the trust-region-based approach.

The change from is_KKT_restart() to !is_trust_region_restart() correctly allocates these gradient and solution vectors only when trust-region restart is active. This is consistent with the header changes where the predicate now checks exclusively for TRUST_REGION_RESTART.

cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cu (1)

860-894: Explicit restart strategy dispatch is cleaner and more maintainable.

The change from using the is_KKT_restart() helper to explicit enum comparisons makes the restart logic clearer and easier to extend. The fallback error case handles unexpected values appropriately.

cpp/src/linear_programming/restart_strategy/pdlp_restart_strategy.cuh (1)

348-354: I'm encountering persistent issues accessing the repository. Let me analyze what can be verified from the information provided in the review comment itself.

Based on the review comment:

The code snippet provided (lines 348-354) clearly shows is_trust_region_restart() checking for TRUST_REGION_RESTART enum value.

The review's claims state this is a semantic change from is_KKT_restart() checking for KKT_RESTART.

Evidence mentioned in the review: The localized_duality_gap_container.cu file uses !is_trust_region_restart(), which the review says "aligns with the new semantics."

However, without access to the repository, I cannot:

Verify if is_KKT_restart() has been completely removed

Confirm all call sites have been updated

Validate that the inversion of semantics is correct across all usages

Check for any orphaned references to the old function

The review comment raises a valid concern about semantic changes and call-site verification, but I cannot definitively confirm or refute the claim due to repository access limitations. Manual verification by inspecting:

All occurrences of is_KKT_restart (should be zero if fully migrated)

All occurrences of is_trust_region_restart to confirm correct inverted logic at each call site

The enum definition to confirm KKT_RESTART and TRUST_REGION_RESTART are distinct values

is necessary to resolve this review comment.

cpp/src/dual_simplex/phase2.cpp (1)

2238-2240: Good defensive initialization of nonbasic_list.

Clearing and reserving capacity before population ensures no stale data remains from prior calls when the vector is reused across multiple dual_phase2_with_advanced_basis invocations. This aligns with the broader PR goal of threading basis data through solve paths.

cpp/src/dual_simplex/branch_and_bound.hpp (4)

130-132: Thread-safe logging state management.

Converting last_log to omp_atomic_t<f_t> addresses potential data races when multiple threads access this field. Combined with the new should_report_ flag, this enables safe coordination of progress reporting across threads.

162-163: Atomic flag for coordinated reporting.

The should_report_ flag enables a single thread to report progress while preventing duplicate logging from concurrent threads. The exchange-based pattern used in the implementation (seen in branch_and_bound.cpp) is a correct lock-free coordination mechanism.

189-196: Extended explore_subtree signature for basis reuse.

Threading basis_update_mpf_t, basic_list, and nonbasic_list through the exploration path allows reusing basis factorization data across sibling nodes in a subtree, reducing redundant factorization work. This aligns with the learning to reduce tight coupling by making solver components more modular and reusable.

209-220: Extended solve_node signature with basis-aware parameters.

The addition of basis-related parameters enables warm-starting LP solves from a previous basis when exploring sibling nodes. The renamed recompute_basis_and_bounds parameter clarifies that both bounds and basis may need recomputation, not just general recompute.

cpp/src/dual_simplex/branch_and_bound.cpp (13)

627-663: Correct basis/bounds initialization based on recompute flag.

When recompute_bounds_and_basis is true, bounds are reset from root and the basis is reinitialized. When false (continuing down a path), only the branched variable bounds are updated. This optimization reduces redundant work when exploring sibling nodes.

665-678: Numerical recovery now uses advanced basis path.

The fallback for numerical issues now uses solve_linear_program_with_advanced_basis to maintain consistency with the primary solve path. This ensures the basis data structures remain in a consistent state after recovery.

733-733: Added missing tree update for branched nodes.

Adding search_tree.update(node_ptr, node_status_t::HAS_CHILDREN) ensures the search tree correctly tracks nodes that produced children.

803-826: Thread-safe progress reporting with exchange pattern.

The should_report_.exchange(false) pattern ensures only one thread reports progress at a time, preventing duplicate log lines. The flag is reset to true after reporting completes.

839-859: Consistent basis initialization in exploration_ramp_up.

The basis structures are initialized with correct dimensions before solving nodes during the ramp-up phase. This matches the pattern used in other thread entry points.

896-980: Basis reuse logic in explore_subtree.

The recompute_bounds_and_basis flag is set to !has_children(status) after solving a node. This means:

When a node produces children: the basis is reused for the next child (optimal case)

When a node is pruned/fathomed: the basis must be recomputed for the next unrelated node

This correctly captures the warm-start optimization for subtree traversal.

1006-1014: Clear bounds_changed before computing node bounds.

Resetting bounds_changed before calling get_variable_bounds ensures accurate tracking of which bounds were modified for this specific node, preventing stale markers from affecting bounds strengthening.

1050-1088: Basis initialization in best_first_thread.

The basis structures are properly initialized before the exploration loop. The basis is then reused across nodes within the same subtree exploration via the explore_subtree call.

1119-1166: Basis initialization and reuse in diving_thread.

The diving thread properly initializes basis structures once and reuses them across the dive. The recompute_bounds_and_basis flag is correctly managed to allow warm-starting when continuing down a path and force recomputation when switching to a different branch.

1187-1198: Clear bounds_changed before detaching dive node.

Same pattern as line 1008-1010: resetting bounds_changed before computing bounds for the new diving root ensures accurate tracking.

1368-1368: Initialize should_report_ at solver start.

Setting should_report_ = true at the start of the solve ensures the first progress report will be generated by one of the exploration threads.

754-761: Unable to complete verification — repository not accessible.

The codebase cannot be accessed for direct verification. However, web search indicates that cuOpt's branch-and-bound solver runs on CPU with parallel threads, which makes atomic operations for thread-safe updates appropriate. The review comment's claim about fetch_min ensuring thread-safe updates to lower_bound_ceiling_ is contextually plausible for a multi-threaded CPU-side implementation.

However, critical details cannot be confirmed:

Whether fetch_min is properly defined and available

Type of lower_bound_ceiling_ (must be atomic type for correctness)

Actual implementation correctness at lines 754-761

Whether the operation semantics match the stated intent

600-604: Based on my verification attempt, I found that:

Repository Access Issue: The codebase cannot be cloned to perform direct verification of the code context and surrounding logic.

Web Search Findings: cuOpt's documentation confirms that:

Column scaling is enabled by default and improves numerical stability

Scaling rescales the matrix and vectors (A, b, c) using scaling factors

The scale_columns setting controls this feature

Review Comment Assessment: The original comment correctly identifies that scale_columns = false disables column scaling. However, without accessing the actual codebase, I cannot verify:

Whether this change is intentional or documented with comments

The context for why scaling is disabled specifically for node LP solves

Whether there are conditions or guards around this setting

If there are any numerical stability issues being addressed

Verify with maintainers whether scale_columns = false for node LP solves is intentional.

The setting correctly disables column scaling, which typically improves numerical stability. Confirm the rationale: Is this optimization for performance in node subproblems, or is there a specific numerical reason? If intentional, add a clarifying comment explaining the trade-off.

coderabbitai

Actionable comments posted: 1

♻️ Duplicate comments (1)

cpp/src/mip/local_search/local_search.cu (1)
549-571: Centralize problem-with-cuts pointer/weights handling to avoid drift and subtle invariants

You now have two places that partially manage the “problem with objective cuts” state:

handle_cutting_plane_and_weights:

Sets population_ptr->set_problem_ptr_with_cuts.

Calls solution.set_problem_ptr(&problem_with_objective_cut, /*is_cuts_problem=*/true).

Calls resize_to_new_problem().

Copies weights from both population_ptr->weights and weights_with_cuts into fj.cstr_weights.

Calls population_ptr->update_weights().

Calls save_solution_and_add_cutting_plane and then apply_problem_ptr_to_all_solutions().

run_recombiners (feasible branch):

Re-implements a very similar if (!cutting_plane_added_for_active_run) block (but calls solution.set_problem_ptr(&problem_with_objective_cut) without the is_cuts_problem flag and does not call apply_problem_ptr_to_all_solutions() in that branch).

Then calls population_ptr->update_weights() and save_solution_and_add_cutting_plane(...).

Only later, under stagnation, calls apply_problem_ptr_to_all_solutions() and a second save_solution_and_add_cutting_plane(...).

This duplication makes it easy for the two paths (FP vs. recombiners) to diverge in behavior, especially wrt:

Whether solution and all population members have their problem pointer and “is cut” state updated consistently.

When apply_problem_ptr_to_all_solutions() is invoked relative to external solutions being injected.

The exact semantics of copying weights and weights_with_cuts onto fj.cstr_weights (the second copy currently overwrites the first; if this is intentional, it deserves to live in a single well‑documented helper).

Given earlier concerns about coupling between problem modifications and pointer updates, it would be safer to funnel all “activate / update objective cut + weights” behavior through one helper instead of open‑coding it twice.

For example, in run_recombiners you could delegate to the existing helper:
if (population_ptr->is_feasible()) {
  handle_cutting_plane_and_weights(solution, population_ptr, best_objective);
}
and drop the custom if (!cutting_plane_added_for_active_run) block there, relying on handle_cutting_plane_and_weights to manage:

First-time initialization of the cuts problem,

Weight synchronization,

And apply_problem_ptr_to_all_solutions() after new solutions enter the population.

This would align FP and recombiner semantics and keep the “problem_with_objective_cut invariants” in one place, which is especially important for maintaining correct problem context mappings across transformations.

Also applies to: 591-619, 656-659, 684-708, 711-713

🧹 Nitpick comments (1)

cpp/src/mip/local_search/local_search.cu (1)
268-273: Timer handling change is fine; consider removing commented legacy code

Special‑casing fj_settings.time_limit and resetting timer only in the feasible branch improves clarity, and the logic is consistent with the intended behavior.

The old, now‑redundant lines kept as comments:
// fj_settings.time_limit      = std::min(1., timer.remaining_time());
// timer                       = timer_t(fj_settings.time_limit);
can likely be dropped to avoid confusion once you are confident in the new behavior.

Also applies to: 270-271

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 1695286 and aa78fa6.

📒 Files selected for processing (2)

cpp/src/mip/diversity/diversity_manager.cu (2 hunks)
cpp/src/mip/local_search/local_search.cu (8 hunks)

🚧 Files skipped from review as they are similar to previous changes (1)

cpp/src/mip/diversity/diversity_manager.cu

🧰 Additional context used

📓 Path-based instructions (4)

**/*.{cu,cuh}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh}: Every CUDA kernel launch and memory operation must have error checking with CUDA_CHECK or equivalent verification
Avoid reinventing functionality already available in Thrust, CCCL, or RMM libraries; prefer standard library utilities over custom implementations

Files:

cpp/src/mip/local_search/local_search.cu

**/*.cu

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.cu: Verify race conditions and correctness of GPU kernel shared memory, atomics, and warp-level operations
Detect inefficient GPU kernel launches with low occupancy or poor memory access patterns; optimize for coalesced memory access and minimize warp divergence in hot paths

Files:

cpp/src/mip/local_search/local_search.cu

**/*.{cu,cuh,cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh,cpp,hpp,h}: Track GPU device memory allocations and deallocations to prevent memory leaks; ensure cudaMalloc/cudaFree balance and cleanup of streams/events
Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results
Check numerical stability: prevent overflow/underflow, precision loss, division by zero/near-zero, and use epsilon comparisons for floating-point equality checks
Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)
Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations
For concurrent CUDA operations (barriers, async operations), explicitly create and manage dedicated streams instead of reusing the default stream; document stream lifecycle
Eliminate unnecessary host-device synchronization (cudaDeviceSynchronize) in hot paths that blocks GPU pipeline; use streams and events for async execution
Assess algorithmic complexity for large-scale problems (millions of variables/constraints); ensure O(n log n) or better complexity, not O(n²) or worse
Verify correct problem size checks before expensive GPU/CPU operations; prevent resource exhaustion on oversized problems
Identify assertions with overly strict numerical tolerances that fail on legitimate degenerate/edge cases (near-zero pivots, singular matrices, empty problems)
Ensure race conditions are absent in multi-GPU code and multi-threaded server implementations; verify proper synchronization of shared state
Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication
Check that hard-coded GPU de...

Files:

cpp/src/mip/local_search/local_search.cu

**/*.{cu,cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

Avoid inappropriate use of exceptions in performance-critical GPU operation paths; prefer error codes or CUDA error checking for latency-sensitive code

Files:

cpp/src/mip/local_search/local_search.cu

🧠 Learnings (8)

📓 Common learnings

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Reduce tight coupling between solver components (presolve, simplex, basis, barrier); increase modularity and reusability of optimization algorithms

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for algorithm phase transitions: verify correct initialization of bounds and state when transitioning from presolve to simplex to diving to crossover

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for algorithm phase transitions: verify correct initialization of bounds and state when transitioning from presolve to simplex to diving to crossover

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Assess algorithmic complexity for large-scale problems (millions of variables/constraints); ensure O(n log n) or better complexity, not O(n²) or worse

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Reduce tight coupling between solver components (presolve, simplex, basis, barrier); increase modularity and reusability of optimization algorithms

Applied to files:

cpp/src/mip/local_search/local_search.cu

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (10)

GitHub Check: conda-cpp-build / compute-matrix
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.10, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.11, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.12, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.10, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.12, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.11, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.13, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.0.2, 3.13, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-sh-client / 13.0.2, 3.10, amd64, rockylinux8

🔇 Additional comments (2)

cpp/src/mip/local_search/local_search.cu (2)

27-38: FP constructor wiring with LP optimal solution looks consistent

Passing lp_optimal_solution_ into fp(context, fj, constraint_prop, line_segment_search, lp_optimal_solution_) keeps FP aligned with the LP reference solution used elsewhere in local search. No correctness or lifetime issues apparent here.

172-187: CPU fallback solution handling in do_fj_solve is sound

Introducing solution_t<i_t, f_t> solution_cpu(solution); and using it as an isolated container for the best CPU FJ assignment keeps GPU and CPU paths cleanly separated and avoids mutating solution until you know CPU is better. The copy plus compute_feasibility() before comparing objectives is a reasonable pattern here.

cpp/src/mip/local_search/local_search.cu

coderabbitai

Actionable comments posted: 2

♻️ Duplicate comments (1)

cpp/src/mip/local_search/local_search.cu (1)
627-628: Critical: Type mismatch for best_objective will break float instantiation.

Line 627 declares best_objective as double, but the helper functions save_solution_and_add_cutting_plane (line 506), reset_alpha_and_save_solution (line 565), and run_recombiners (line 583) all expect f_t& best_objective. For f_t = float, this will not compile (cannot bind float& to double).

This was flagged in a previous review. Apply this fix:
-  double best_objective =
-    is_feasible ? solution.get_objective() : std::numeric_limits<double>::max();
+  f_t best_objective =
+    is_feasible ? solution.get_objective() : std::numeric_limits<f_t>::max();
Also applies to: lines 670-671, 689-690, 693-694 where best_objective is passed as a reference parameter.

🧹 Nitpick comments (1)

cpp/src/mip/local_search/local_search.cu (1)
505-519: Make best_in_population const to clarify intent.

The parameter best_in_population is not modified in this function. Making it const documents that it's read-only and prevents accidental mutation.

Apply this diff:
-void local_search_t<i_t, f_t>::save_solution_and_add_cutting_plane(
-  solution_t<i_t, f_t>& best_in_population, solution_t<i_t, f_t>& solution, f_t& best_objective)
+void local_search_t<i_t, f_t>::save_solution_and_add_cutting_plane(
+  const solution_t<i_t, f_t>& best_in_population, solution_t<i_t, f_t>& solution, f_t& best_objective)

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between aa78fa6 and 7fb2ed5.

📒 Files selected for processing (1)

cpp/src/mip/local_search/local_search.cu (8 hunks)

🧰 Additional context used

📓 Path-based instructions (4)

**/*.{cu,cuh}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh}: Every CUDA kernel launch and memory operation must have error checking with CUDA_CHECK or equivalent verification
Avoid reinventing functionality already available in Thrust, CCCL, or RMM libraries; prefer standard library utilities over custom implementations

Files:

cpp/src/mip/local_search/local_search.cu

**/*.cu

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.cu: Verify race conditions and correctness of GPU kernel shared memory, atomics, and warp-level operations
Detect inefficient GPU kernel launches with low occupancy or poor memory access patterns; optimize for coalesced memory access and minimize warp divergence in hot paths

Files:

cpp/src/mip/local_search/local_search.cu

**/*.{cu,cuh,cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh,cpp,hpp,h}: Track GPU device memory allocations and deallocations to prevent memory leaks; ensure cudaMalloc/cudaFree balance and cleanup of streams/events
Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results
Check numerical stability: prevent overflow/underflow, precision loss, division by zero/near-zero, and use epsilon comparisons for floating-point equality checks
Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)
Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations
For concurrent CUDA operations (barriers, async operations), explicitly create and manage dedicated streams instead of reusing the default stream; document stream lifecycle
Eliminate unnecessary host-device synchronization (cudaDeviceSynchronize) in hot paths that blocks GPU pipeline; use streams and events for async execution
Assess algorithmic complexity for large-scale problems (millions of variables/constraints); ensure O(n log n) or better complexity, not O(n²) or worse
Verify correct problem size checks before expensive GPU/CPU operations; prevent resource exhaustion on oversized problems
Identify assertions with overly strict numerical tolerances that fail on legitimate degenerate/edge cases (near-zero pivots, singular matrices, empty problems)
Ensure race conditions are absent in multi-GPU code and multi-threaded server implementations; verify proper synchronization of shared state
Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication
Check that hard-coded GPU de...

Files:

cpp/src/mip/local_search/local_search.cu

**/*.{cu,cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

Avoid inappropriate use of exceptions in performance-critical GPU operation paths; prefer error codes or CUDA error checking for latency-sensitive code

Files:

cpp/src/mip/local_search/local_search.cu

🧠 Learnings (9)

📓 Common learnings

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for algorithm phase transitions: verify correct initialization of bounds and state when transitioning from presolve to simplex to diving to crossover

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Reduce tight coupling between solver components (presolve, simplex, basis, barrier); increase modularity and reusability of optimization algorithms

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Reduce tight coupling between solver components (presolve, simplex, basis, barrier); increase modularity and reusability of optimization algorithms

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for algorithm phase transitions: verify correct initialization of bounds and state when transitioning from presolve to simplex to diving to crossover

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Assess algorithmic complexity for large-scale problems (millions of variables/constraints); ensure O(n log n) or better complexity, not O(n²) or worse

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Write tests validating numerical correctness of optimization results (not just 'runs without error'); test degenerate cases (infeasible, unbounded, empty, singleton problems)

Applied to files:

cpp/src/mip/local_search/local_search.cu

🔇 Additional comments (6)

cpp/src/mip/local_search/local_search.cu (6)

37-37: LGTM: Constructor initialization updated correctly.

The addition of lp_optimal_solution_ to the fp initialization aligns with the broader objective cut propagation changes.

172-172: LGTM: Solution copy for CPU/GPU comparison.

The copy constructor usage is appropriate for comparing CPU and GPU solver results.

257-258: LGTM: Timer reset pattern is appropriate.

The timer is constrained to the computed limit. This pattern ensures the local search respects the tighter of the two bounds (1 second or remaining time).

559-575: LGTM: Problem pointer management in solution save is correct.

The function correctly:

Resets FP state

Creates a copy with the original problem pointer for population storage

Handles cutting plane updates on the working solution

This maintains proper problem context separation.

643-645: LGTM: Problem pointer propagation is correct.

The code properly updates both the working solution and the population with the cutting plane problem, then applies the pointer to all solutions. This maintains problem context consistency.

698-699: LGTM: Problem pointer cleanup is correct.

The solution is properly restored to the original problem context at the end of run_fp, with corresponding internal state resizing. This maintains proper resource management symmetry.

cpp/src/mip/local_search/local_search.cu

github-actions · 2025-12-09T09:09:21Z

🔔 Hi @anandhkb, this pull request has had no activity for 7 days. Please update or let us know if it can be closed. Thank you!

If this is an "epic" issue, then please add the "epic" label to this issue.
If it is a PR and not ready for review, then please convert this to draft.
If you just want to switch off this notification, then use the "skip inactivity reminder" label.

github-actions · 2025-12-16T09:10:18Z

🔔 Hi @anandhkb, this pull request has had no activity for 7 days. Please update or let us know if it can be closed. Thank you!

If this is an "epic" issue, then please add the "epic" label to this issue.
If it is a PR and not ready for review, then please convert this to draft.
If you just want to switch off this notification, then use the "skip inactivity reminder" label.

github-actions · 2025-12-24T09:10:19Z

🔔 Hi @anandhkb, this pull request has had no activity for 7 days. Please update or let us know if it can be closed. Thank you!

If this is an "epic" issue, then please add the "epic" label to this issue.
If it is a PR and not ready for review, then please convert this to draft.
If you just want to switch off this notification, then use the "skip inactivity reminder" label.

github-actions · 2026-01-01T09:10:29Z

🔔 Hi @anandhkb, this pull request has had no activity for 7 days. Please update or let us know if it can be closed. Thank you!

If this is an "epic" issue, then please add the "epic" label to this issue.
If it is a PR and not ready for review, then please convert this to draft.
If you just want to switch off this notification, then use the "skip inactivity reminder" label.

github-actions · 2026-01-08T09:11:16Z

🔔 Hi @anandhkb, this pull request has had no activity for 7 days. Please update or let us know if it can be closed. Thank you!

If this is an "epic" issue, then please add the "epic" label to this issue.
If it is a PR and not ready for review, then please convert this to draft.
If you just want to switch off this notification, then use the "skip inactivity reminder" label.

…iner

coderabbitai

Actionable comments posted: 4

🤖 Fix all issues with AI agents

In @benchmarks/linear_programming/cuopt/run_mip.cpp:
- Line 416: Add an early validation that ensures n_gpus is >= 1 before it's used
to compute num_cpu_threads (i.e., before the expression that calls
omp_get_max_threads() / n_gpus); if n_gpus <= 0, print a clear error to
std::cerr and return a non-zero exit code so the program aborts cleanly. Locate
the check near the initialization/parse area where n_gpus is set (before the
line that assigns num_cpu_threads using omp_get_max_threads()) and ensure the
validation prevents the subsequent division by zero.

In @cpp/src/mip/diversity/population.cu:
- Around line 83-95: The call to set_problem_ptr_with_cuts resizes
weights_with_cuts.cstr_weights but does not copy the original constraint weights
into the first problem_ptr->n_constraints slots, leaving them uninitialized;
after the resize/fill in population_t<i_t,f_t>::set_problem_ptr_with_cuts (or
immediately after the call site where population_ptr is used) add a raft::copy
from the original fj.cstr_weights (or population_ptr->weights) into
population_ptr->weights_with_cuts.cstr_weights for the first
fj.cstr_weights.size() elements and use solution.handle_ptr->get_stream() (or
problem_ptr_with_cuts->handle_ptr->get_stream()) for the stream to match the
other call sites.

In @cpp/src/mip/diversity/recombiners/sub_mip.cuh:
- Around line 177-184: Remove the redundant initial call to
sol.compute_feasibility() before the assertion and change the assertion to use
sol.get_feasible(); after calling sol.swap_problem_pointers() call
sol.compute_feasibility() again to recompute feasibility against the original
problem (so the cached is_feasible is correct), keep the
cuopt_func_call(sol.test_variable_bounds()) and
population.add_solution(std::move(sol)), and fix the typo "proble" → "problem"
in the comment.

In @cpp/src/mip/local_search/local_search.cu:
- Line 597: The call to solution.set_problem_ptr(&problem_with_objective_cut) is
missing the required second parameter indicating a cuts problem; update the call
to include the is_cuts_problem flag (e.g., pass true) so it becomes
solution.set_problem_ptr(&problem_with_objective_cut, true) to properly
initialize the dual-pointer/cuts state for the Solution object.

🧹 Nitpick comments (1)

cpp/src/mip/local_search/local_search.cu (1)
542-563: Significant code duplication between handle_cutting_plane_and_weights and run_recombiners.

Lines 545-558 in handle_cutting_plane_and_weights are nearly identical to lines 596-608 in run_recombiners. Consider extracting the common logic into a shared helper to reduce maintenance burden and potential for divergence.
♻️ Suggested refactor

Extract the common initialization logic:
void init_cutting_plane_context(solution_t<i_t, f_t>& solution, 
                                 population_t<i_t, f_t>* population_ptr) {
  population_ptr->set_problem_ptr_with_cuts(&problem_with_objective_cut);
  constexpr bool is_cuts_problem = true;
  solution.set_problem_ptr(&problem_with_objective_cut, is_cuts_problem);
  resize_to_new_problem();
  cutting_plane_added_for_active_run = true;
  raft::copy(population_ptr->weights.cstr_weights.data(),
             fj.cstr_weights.data(),
             population_ptr->weights.cstr_weights.size(),
             solution.handle_ptr->get_stream());
  raft::copy(population_ptr->weights_with_cuts.cstr_weights.data(),
             fj.cstr_weights.data(),
             fj.cstr_weights.size(),
             solution.handle_ptr->get_stream());
}
Then call this helper from both locations.
Also applies to: 595-612

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 7fb2ed5 and fd701f6.

📒 Files selected for processing (13)

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/CMakeLists.txt
cpp/src/mip/diversity/diversity_manager.cu
cpp/src/mip/diversity/population.cu
cpp/src/mip/diversity/population.cuh
cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh
cpp/src/mip/diversity/recombiners/fp_recombiner.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/local_search/local_search.cu
cpp/src/mip/local_search/local_search.cuh
cpp/src/mip/solution/solution.cu
cpp/src/mip/solution/solution.cuh

🚧 Files skipped from review as they are similar to previous changes (6)

cpp/CMakeLists.txt
cpp/src/mip/solution/solution.cuh
cpp/src/mip/diversity/population.cuh
cpp/src/mip/diversity/recombiners/fp_recombiner.cuh
cpp/src/mip/diversity/diversity_manager.cu
cpp/src/mip/local_search/local_search.cuh

🧰 Additional context used

📓 Path-based instructions (5)

**/*.{cu,cuh}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh}: Every CUDA kernel launch and memory operation must have error checking with CUDA_CHECK or equivalent verification
Avoid reinventing functionality already available in Thrust, CCCL, or RMM libraries; prefer standard library utilities over custom implementations

Files:

cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh
cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cu

**/*.{cu,cuh,cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh,cpp,hpp,h}: Track GPU device memory allocations and deallocations to prevent memory leaks; ensure cudaMalloc/cudaFree balance and cleanup of streams/events
Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results
Check numerical stability: prevent overflow/underflow, precision loss, division by zero/near-zero, and use epsilon comparisons for floating-point equality checks
Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)
Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations
For concurrent CUDA operations (barriers, async operations), explicitly create and manage dedicated streams instead of reusing the default stream; document stream lifecycle
Eliminate unnecessary host-device synchronization (cudaDeviceSynchronize) in hot paths that blocks GPU pipeline; use streams and events for async execution
Assess algorithmic complexity for large-scale problems (millions of variables/constraints); ensure O(n log n) or better complexity, not O(n²) or worse
Verify correct problem size checks before expensive GPU/CPU operations; prevent resource exhaustion on oversized problems
Identify assertions with overly strict numerical tolerances that fail on legitimate degenerate/edge cases (near-zero pivots, singular matrices, empty problems)
Ensure race conditions are absent in multi-GPU code and multi-threaded server implementations; verify proper synchronization of shared state
Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication
Check that hard-coded GPU de...

Files:

cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh
cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cu

**/*.{cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cpp,hpp,h}: Check for unclosed file handles when reading MPS/QPS problem files; ensure RAII patterns or proper cleanup in exception paths
Validate input sanitization to prevent buffer overflows and resource exhaustion attacks; avoid unsafe deserialization of problem files
Prevent thread-unsafe use of global and static variables; use proper mutex/synchronization in server code accessing shared solver state

Files:

benchmarks/linear_programming/cuopt/run_mip.cpp

**/*.{cu,cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

Avoid inappropriate use of exceptions in performance-critical GPU operation paths; prefer error codes or CUDA error checking for latency-sensitive code

Files:

benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cu

**/*.cu

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.cu: Verify race conditions and correctness of GPU kernel shared memory, atomics, and warp-level operations
Detect inefficient GPU kernel launches with low occupancy or poor memory access patterns; optimize for coalesced memory access and minimize warp divergence in hot paths

Files:

cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cu

🧠 Learnings (21)

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)

Applied to files:

cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh
cpp/src/mip/diversity/recombiners/sub_mip.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations

Applied to files:

cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh
cpp/src/mip/diversity/recombiners/sub_mip.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for algorithm phase transitions: verify correct initialization of bounds and state when transitioning from presolve to simplex to diving to crossover

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Check that hard-coded GPU device IDs and resource limits are made configurable; abstract multi-backend support for different CUDA versions

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/population.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Track GPU device memory allocations and deallocations to prevent memory leaks; ensure cudaMalloc/cudaFree balance and cleanup of streams/events

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/population.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure race conditions are absent in multi-GPU code and multi-threaded server implementations; verify proper synchronization of shared state

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/population.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cpp,hpp,h} : Avoid inappropriate use of exceptions in performance-critical GPU operation paths; prefer error codes or CUDA error checking for latency-sensitive code

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/population.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Verify error propagation from CUDA to user-facing APIs is complete; ensure CUDA errors are caught and mapped to meaningful user error codes

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/population.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/population.cu
cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.cu : Verify race conditions and correctness of GPU kernel shared memory, atomics, and warp-level operations

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/population.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Verify correct problem size checks before expensive GPU/CPU operations; prevent resource exhaustion on oversized problems

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/population.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Eliminate unnecessary host-device synchronization (cudaDeviceSynchronize) in hot paths that blocks GPU pipeline; use streams and events for async execution

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/population.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Ensure test isolation: prevent GPU state, cached memory, and global variables from leaking between test cases; verify each test independently initializes its environment

Applied to files:

cpp/src/mip/diversity/recombiners/sub_mip.cuh
cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh
benchmarks/linear_programming/cuopt/run_mip.cpp
cpp/src/mip/diversity/population.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : For concurrent CUDA operations (barriers, async operations), explicitly create and manage dedicated streams instead of reusing the default stream; document stream lifecycle

Applied to files:

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

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*benchmark*.{cpp,cu,py} : Include performance benchmarks and regression detection for GPU operations; verify near real-time performance on million-variable problems

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.cu : Detect inefficient GPU kernel launches with low occupancy or poor memory access patterns; optimize for coalesced memory access and minimize warp divergence in hot paths

Applied to files:

benchmarks/linear_programming/cuopt/run_mip.cpp

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for problem transformations: verify correctness of original→transformed→postsolve mappings and index consistency across problem representations

Applied to files:

cpp/src/mip/solution/solution.cu
cpp/src/mip/diversity/population.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Reduce tight coupling between solver components (presolve, simplex, basis, barrier); increase modularity and reusability of optimization algorithms

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Assess algorithmic complexity for large-scale problems (millions of variables/constraints); ensure O(n log n) or better complexity, not O(n²) or worse

Applied to files:

cpp/src/mip/local_search/local_search.cu

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Write tests validating numerical correctness of optimization results (not just 'runs without error'); test degenerate cases (infeasible, unbounded, empty, singleton problems)

Applied to files:

cpp/src/mip/local_search/local_search.cu

🧬 Code graph analysis (2)

cpp/src/mip/solution/solution.cu (1)

cpp/include/cuopt/linear_programming/pdlp/solver_solution.hpp (1)

handle_ptr (282-283)

cpp/src/mip/local_search/local_search.cu (4)

cpp/src/mip/solve.cu (1)

solution (73-73)

cpp/src/mip/solver.cu (6)

solution (64-68)

solution (64-64)

solution (70-75)

solution (70-72)

solution (77-80)

solution (77-77)

cpp/src/mip/diversity/recombiners/recombiner_stats.hpp (1)

i (94-100)

cpp/src/routing/diversity/diverse_solver.hpp (3)

i (108-114)

i (301-307)

i (553-558)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (10)

GitHub Check: wheel-build-cuopt-sh-client / 13.1.0, 3.10, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.13, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.10, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.13, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.12, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.12, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.11, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.10, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.11, amd64, rockylinux8
GitHub Check: checks / check-style

🔇 Additional comments (24)

benchmarks/linear_programming/cuopt/run_mip.cpp (2)

1-6: LGTM!

Copyright year update is appropriate.

483-483: LGTM!

In single-file mode, using all available CPU threads is the correct approach since there's no multi-GPU parallelism to account for.

cpp/src/mip/solution/solution.cu (5)

43-46: LGTM: Constructor properly initializes new dual-pointer fields.

The initialization of problem_with_cuts_ptr to the same problem and current_problem_is_cut to false establishes a safe initial state for the dual-pointer mechanism.

62-65: LGTM: Copy constructor correctly propagates dual-pointer state.

Both problem_with_cuts_ptr and current_problem_is_cut are properly copied from the source solution, maintaining state consistency.

92-98: LGTM: copy_from propagates the new pointer fields correctly.

The method now copies problem_with_cuts_ptr and current_problem_is_cut in addition to the existing fields, ensuring complete state transfer.

132-141: LGTM: swap_problem_pointers has appropriate defensive assertions.

The assertions ensure the swap operation is only performed when problem_with_cuts_ptr is valid and different from problem_ptr, preventing invalid state. The method correctly toggles the flag, resizes buffers, and recomputes feasibility.

143-163: Clarify intended behavior for set_problem_ptr and swap_problem_pointers interaction.

The concern is valid: set_problem_ptr(..., false) nullifies problem_with_cuts_ptr (line 158), yet swap_problem_pointers() asserts it is non-null (line 136). While current code avoids triggering this through apply_problem_ptr_to_all_solutions() restoring problem_with_cuts_ptr before any swap, the API contract is fragile. The FIXME comment at line 147 suggests this logic needs revision for ping-pong cut problems.

Consider either:

Documenting the precondition that swap cannot be called after set_problem_ptr with a non-cut problem, or

Preserving problem_with_cuts_ptr instead of nullifying it, allowing solutions to transition between cut and non-cut problems safely without loss of state.

cpp/src/mip/diversity/population.cu (5)

43-43: LGTM: weights_with_cuts properly initialized in constructor.

The new weights_with_cuts member is correctly initialized using the same pattern as weights.

66-72: LGTM: apply_problem_ptr_to_all_solutions propagates the cuts-aware problem pointer.

This method ensures all solutions in the population have a consistent problem_with_cuts_ptr, enabling proper cuts-aware evaluation.

111-116: LGTM: weights_with_cuts properly initialized alongside weights in initialize_population.

The initialization mirrors the weights initialization pattern, ensuring both weight vectors start with the same default value of 10.

139-143: LGTM: Consistency improvement in get_two_random.

Using problem_ptr->integer_indices directly instead of first_solution.problem_ptr ensures the sameness check uses a consistent problem reference regardless of individual solution state.

212-212: LGTM: External solutions now receive the cuts-aware problem pointer.

Calling apply_problem_ptr_to_all_solutions() after adding external solutions ensures newly added solutions are properly synchronized with the cuts context.

cpp/src/mip/local_search/local_search.cu (6)

37-37: LGTM: Constructor updated to remove fj_tree dependency.

The FP constructor change aligns with the broader refactoring.

178-178: LGTM: solution_cpu now constructed from solution directly.

This ensures the CPU solution copy inherits the same problem context as the GPU solution.

263-264: Simplified timing logic may limit local search duration.

The time limit is now unconditionally capped to 1 second (std::min(1., timer.remaining_time())). Verify this is intentional and doesn't overly restrict local search in scenarios where more time would be beneficial.

511-525: LGTM: save_solution_and_add_cutting_plane now sources from population's best.

The signature change to accept best_in_population makes the intent clearer and ensures the cutting plane is based on the population's best feasible solution.

704-704: Verify problem pointer restoration logic.

solution.set_problem_ptr(old_problem_ptr) is called without the is_cuts_problem parameter (defaults to false). Per the implementation in solution.cu, this will set problem_with_cuts_ptr = nullptr. Ensure this is the intended behavior and that no subsequent code path expects problem_with_cuts_ptr to remain valid after run_fp completes.

676-677: LGTM: Updated calls to reset_alpha_and_save_solution and run_recombiners.

The updated function signatures with old_problem_ptr and population_ptr parameters enable proper problem context management.

Also applies to: 695-696, 699-700

cpp/src/mip/diversity/recombiners/line_segment_recombiner.cuh (1)

78-78: LGTM: Symmetric swap_problem_pointers calls ensure correct problem context during recombination.

The first swap (line 78) switches from the cuts-aware context to the original problem for the line segment search operation. The second swap (line 103) restores the cuts context before returning. This pattern ensures the recombiner evaluates solutions against the original problem constraints while maintaining the cuts context for population management.

Also applies to: 103-103

cpp/src/mip/diversity/recombiners/bound_prop_recombiner.cuh (2)

143-143: LGTM: Symmetric problem pointer swaps maintain correct context during bound propagation.

The swap at construction (line 143) and before return (line 224) follow the same pattern as other recombiners, ensuring the recombiner operates on the appropriate problem context.

Also applies to: 224-224

185-187: LGTM: Manual problem_ptr management for fixed_problem is appropriate.

The manual save/restore of orig_problem_ptr around the fixed_problem operations is correct. This differs from the cuts-aware pattern because fixed_problem is a temporary local variable, not the persistent cuts problem. The sequence properly:

Saves the original pointer

Redirects to the fixed problem for bounds propagation

Restores the original pointer before unfixing variables

Also applies to: 204-206

cpp/src/mip/diversity/recombiners/sub_mip.cuh (3)

1-6: LGTM!

Copyright year update is appropriate.

48-49: LGTM — swapping to objective-cut context for sub-MIP solving.

Correctly swaps the offspring to use the problem-with-objective-cut context before the sub-MIP solving phase. The pointer is properly swapped back at line 186 before returning to the population.

186-196: Remove this concern—feasibility is properly computed.

The methods unfix_variables() and clamp_within_bounds() both internally call compute_feasibility(). More importantly, swap_problem_pointers() at line 186 explicitly calls compute_feasibility() after restoring the original problem context, ensuring the feasibility flag is fresh for the original problem before the get_feasible() check at line 190.

Likely an incorrect or invalid review comment.

coderabbitai · 2026-01-13T11:19:11Z

benchmarks/linear_programming/cuopt/run_mip.cpp

        paths.push_back(entry.path());
      }
    }
+    if (num_cpu_threads < 0) { num_cpu_threads = omp_get_max_threads() / n_gpus; }


⚠️ Potential issue | 🟡 Minor

Potential division by zero if n_gpus is 0.

While n_gpus defaults to 1, there's no validation preventing a user from passing --n-gpus 0, which would cause undefined behavior here. Consider adding an early validation check.

🛡️ Suggested validation (add after line 367)

if (n_gpus <= 0) { std::cerr << "Error: --n-gpus must be >= 1" << std::endl; return 1; }

🤖 Prompt for AI Agents

In @benchmarks/linear_programming/cuopt/run_mip.cpp at line 416, Add an early validation that ensures n_gpus is >= 1 before it's used to compute num_cpu_threads (i.e., before the expression that calls omp_get_max_threads() / n_gpus); if n_gpus <= 0, print a clear error to std::cerr and return a non-zero exit code so the program aborts cleanly. Locate the check near the initialization/parse area where n_gpus is set (before the line that assigns num_cpu_threads using omp_get_max_threads()) and ensure the validation prevents the subsequent division by zero.

coderabbitai · 2026-01-13T11:19:11Z

cpp/src/mip/diversity/population.cu

+template <typename i_t, typename f_t>
+void population_t<i_t, f_t>::set_problem_ptr_with_cuts(problem_t<i_t, f_t>* problem_ptr_with_cuts)
+{
+  constexpr f_t ten           = 10.;
+  this->problem_ptr_with_cuts = problem_ptr_with_cuts;
+  weights_with_cuts.cstr_weights.resize(problem_ptr_with_cuts->n_constraints,
+                                        problem_ptr_with_cuts->handle_ptr->get_stream());
+  // fill last element with default
+  thrust::uninitialized_fill(problem_ptr_with_cuts->handle_ptr->get_thrust_policy(),
+                             weights_with_cuts.cstr_weights.begin() + problem_ptr->n_constraints,
+                             weights_with_cuts.cstr_weights.end(),
+                             ten);
+}


⚠️ Potential issue | 🟠 Major

🧩 Analysis chain

🏁 Script executed:

# Search for calls to set_problem_ptr_with_cuts rg -n -B5 -A10 'set_problem_ptr_with_cuts\(' --type cpp --type cu

Repository: NVIDIA/cuopt

Length of output: 82

🏁 Script executed:

# Look at the population class definition and weight initialization fd -e cu -e cpp -path "*population*" | head -20

Repository: NVIDIA/cuopt

Length of output: 224

🏁 Script executed:

# Search for weights_with_cuts initialization rg -n 'weights_with_cuts' --type cpp --type cu -A2 -B2

Repository: NVIDIA/cuopt

Length of output: 82

🏁 Script executed:

# Search for calls to set_problem_ptr_with_cuts using corrected syntax rg -n -B5 -A10 'set_problem_ptr_with_cuts\('

Repository: NVIDIA/cuopt

Length of output: 7170

🏁 Script executed:

# Find population files fd 'population' -e cu -e cpp -e h -e hpp

Repository: NVIDIA/cuopt

Length of output: 132

🏁 Script executed:

# Search for weights_with_cuts references rg -n 'weights_with_cuts' -A2 -B2

Repository: NVIDIA/cuopt

Length of output: 4894

🏁 Script executed:

# Let's look at the specific context around the three call sites to understand the flow better sed -n '540,560p' cpp/src/mip/local_search/local_search.cu

Repository: NVIDIA/cuopt

Length of output: 1021

🏁 Script executed:

# Check the second call site context sed -n '595,610p' cpp/src/mip/local_search/local_search.cu

Repository: NVIDIA/cuopt

Length of output: 829

🏁 Script executed:

# Check the third call site context sed -n '645,660p' cpp/src/mip/local_search/local_search.cu

Repository: NVIDIA/cuopt

Length of output: 836

🏁 Script executed:

# Look at the diversity_manager call context sed -n '645,660p' cpp/src/mip/diversity/diversity_manager.cu

Repository: NVIDIA/cuopt

Length of output: 962

🏁 Script executed:

# Check the constructor/initialization of weights_with_cuts sed -n '35,50p' cpp/src/mip/diversity/population.cu

Repository: NVIDIA/cuopt

Length of output: 539

🏁 Script executed:

# Check the apply_problem_ptr_to_all_solutions method to understand state changes rg -n 'apply_problem_ptr_to_all_solutions' -A 20

Repository: NVIDIA/cuopt

Length of output: 10454

🏁 Script executed:

# Check the update_weights method and other weight-related methods sed -n '180,220p' cpp/src/mip/diversity/population.cu

Repository: NVIDIA/cuopt

Length of output: 1669

🏁 Script executed:

# Check if weights_with_cuts is used before being properly initialized at call site 3 rg -n 'weights_with_cuts' cpp/src/mip/local_search/local_search.cu -B3 -A3 | head -80

Repository: NVIDIA/cuopt

Length of output: 826

🏁 Script executed:

# Verify what happens between fj.copy_weights and set_problem_ptr_with_cuts at line 648-650 sed -n '645,655p' cpp/src/mip/local_search/local_search.cu

Repository: NVIDIA/cuopt

Length of output: 661

🏁 Script executed:

# Let's check if weights_with_cuts is actually used right after set_problem_ptr_with_cuts at call site 3 sed -n '648,700p' cpp/src/mip/local_search/local_search.cu | head -60

Repository: NVIDIA/cuopt

Length of output: 2370

🏁 Script executed:

# Check if there's a pattern where weights are supposed to be copied elsewhere # Look for update_weights or other weight-related operations sed -n '117,140p' cpp/src/mip/diversity/population.cu

Repository: NVIDIA/cuopt

Length of output: 1255

🏁 Script executed:

# Check if weights_with_cuts is used after call site 3 and understand the intent # Look for uses of weights_with_cuts in the local_search context rg -n 'weights_with_cuts' cpp/src/mip/local_search/local_search.cu -B2 -A2

Repository: NVIDIA/cuopt

Length of output: 626

🏁 Script executed:

# Check what copy_weights does - it should help understand what should happen rg -n 'copy_weights' -A 15 cpp/src/mip/diversity/

Repository: NVIDIA/cuopt

Length of output: 2107

🏁 Script executed:

# Let's understand the code flow at call site 3 more clearly # Check what happens right before and after set_problem_ptr_with_cuts at line 650 sed -n '643,655p' cpp/src/mip/local_search/local_search.cu

Repository: NVIDIA/cuopt

Length of output: 771

🏁 Script executed:

# Now let's verify: does weights_with_cuts actually need the old constraint weights? # Check how it's used after being set rg -n 'weights_with_cuts' cpp/src/mip/diversity/ cpp/src/mip/local_search/ -B1 -A1 | grep -E '(run_local_search|update_weights|diversity_step)'

Repository: NVIDIA/cuopt

Length of output: 197

🏁 Script executed:

# Check the third call site more carefully - look for any subsequent copy operations sed -n '645,670p' cpp/src/mip/local_search/local_search.cu

Repository: NVIDIA/cuopt

Length of output: 1338

🏁 Script executed:

# Let's check what happens in the loop after set_problem_ptr_with_cuts at call site 3 # Specifically, does weights_with_cuts get used before being properly initialized? sed -n '630,670p' cpp/src/mip/local_search/local_search.cu | head -40

Repository: NVIDIA/cuopt

Length of output: 2151

🏁 Script executed:

# Let's trace the full context of whether weights_with_cuts is initialized at call site 3 # Check if there's any copy between fj.copy_weights and the loop that uses weights_with_cuts sed -n '643,680p' cpp/src/mip/local_search/local_search.cu

Repository: NVIDIA/cuopt

Length of output: 1837

🏁 Script executed:

# Search for where weights_with_cuts is actually used in this context rg -n 'weights_with_cuts' cpp/src/mip/local_search/ -C 5

Repository: NVIDIA/cuopt

Length of output: 2062

🏁 Script executed:

# Let's verify the issue by checking what resize does to the existing data # and understand the memory state more clearly rg -n 'resize\(' cpp/src/mip/diversity/population.cu -B2 -A2

Repository: NVIDIA/cuopt

Length of output: 1043

🏁 Script executed:

# Check if there's any documentation or comments about weights_with_cuts initialization rg -n 'weights_with_cuts' cpp/src/mip/diversity/population.cuh -B1 -A1

Repository: NVIDIA/cuopt

Length of output: 184

🏁 Script executed:

# Confirm the exact problem: at call site 3, is weights_with_cuts actually used? # Check if it's used in the subsequent code path sed -n '650,680p' cpp/src/mip/local_search/local_search.cu

Repository: NVIDIA/cuopt

Length of output: 1398

🏁 Script executed:

# Let's check if weights_with_cuts is used anywhere in the fp loop after call site 3 rg -n 'weights_with_cuts' cpp/src/mip/local_search/local_search.cu -B5 -A5

Repository: NVIDIA/cuopt

Length of output: 1160

🏁 Script executed:

# Check what resize_to_new_problem does and if it uses weights_with_cuts rg -n 'resize_to_new_problem' cpp/src/mip/local_search/local_search.cu -A 20 | head -50

Repository: NVIDIA/cuopt

Length of output: 2615

🏁 Script executed:

# Let's check the weight_t class to understand what resize does fd -e h -e hpp | xargs grep -l 'class weight_t' | head -3

Repository: NVIDIA/cuopt

Length of output: 38

🏁 Script executed:

# Let's check the weight_t class definition to understand the resize behavior fd weight_t -e h -e hpp -e cu | head -5

Repository: NVIDIA/cuopt

Length of output: 38

🏁 Script executed:

# Search for weight_t definition rg -n 'class weight_t\|struct weight_t' -A 10

Repository: NVIDIA/cuopt

Length of output: 38

🏁 Script executed:

# Search for weight_t definition more broadly rg 'weight_t' -A 5 cpp/src/mip/diversity/ | grep -E '(struct|class|resize)' | head -20

Repository: NVIDIA/cuopt

Length of output: 175

🏁 Script executed:

# Let's check the actual behavior: when resize is called on an existing vector # The key question is whether the existing data is preserved or overwritten # Let's look at the cstr_weights member rg -n 'cstr_weights' cpp/src/mip/diversity/ -B2 -A2 | head -50

Repository: NVIDIA/cuopt

Length of output: 4275

🏁 Script executed:

# Critical check: at call site 3 (line 650), after resize, what are the first problem_ptr->n_constraints elements? # They should either be: (1) preserved from before, or (2) uninitialized # Let's verify by checking if there's any copy_weights or similar before the loop sed -n '630,660p' cpp/src/mip/local_search/local_search.cu

Repository: NVIDIA/cuopt

Length of output: 1704

🏁 Script executed:

# Now let's check the weight_t struct to understand the resize behavior cat cpp/src/mip/diversity/weights.cuh | head -100

Repository: NVIDIA/cuopt

Length of output: 1069

🏁 Script executed:

# Check if weights_with_cuts is used after call site 3 in any way rg -n 'population_ptr->weights_with_cuts\|population\.weights_with_cuts' cpp/src/mip/local_search/ -B2 -A2

Repository: NVIDIA/cuopt

Length of output: 38

🏁 Script executed:

# Let's check what rmm::device_uvector::resize does # And let's verify whether weights_with_cuts is actually used after call site 3 rg -n 'reset_alpha_and_save_solution' cpp/src/mip/local_search/local_search.cu -A 5

Repository: NVIDIA/cuopt

Length of output: 1537

🏁 Script executed:

# Look for the actual issue: at call site 3, after set_problem_ptr_with_cuts, # is there any guarantee that the first problem_ptr->n_constraints elements are initialized? # Let's check the state of weights_with_cuts before each call site sed -n '540,565p' cpp/src/mip/local_search/local_search.cu

Repository: NVIDIA/cuopt

Length of output: 1216

🏁 Script executed:

# Final verification: Check the state at call site 3 - is weights_with_cuts used later in the loop? sed -n '650,700p' cpp/src/mip/local_search/local_search.cu | grep -i weight

Repository: NVIDIA/cuopt

Length of output: 38

🏁 Script executed:

# Check if there's supposed to be a copy similar to call sites 1 & 2 # Look at the pattern in call sites 1 and 2 right after set_problem_ptr_with_cuts sed -n '545,562p' cpp/src/mip/local_search/local_search.cu

Repository: NVIDIA/cuopt

Length of output: 974

Add raft::copy call after set_problem_ptr_with_cuts at line 650 to initialize constraint weights.

At line 650, set_problem_ptr_with_cuts() resizes weights_with_cuts but only fills the newly added cutting plane constraints. Unlike the other two call sites (lines 546 and 598), there is no subsequent raft::copy() to populate the first problem_ptr->n_constraints elements, leaving them uninitialized. The comment at line 646-648 mentions copying weights, but it only updates weights, not weights_with_cuts. Add:

raft::copy(population_ptr->weights_with_cuts.cstr_weights.data(), fj.cstr_weights.data(), fj.cstr_weights.size(), solution.handle_ptr->get_stream());

after line 650 to match the pattern used at the other call sites.

🤖 Prompt for AI Agents

In @cpp/src/mip/diversity/population.cu around lines 83 - 95, The call to set_problem_ptr_with_cuts resizes weights_with_cuts.cstr_weights but does not copy the original constraint weights into the first problem_ptr->n_constraints slots, leaving them uninitialized; after the resize/fill in population_t<i_t,f_t>::set_problem_ptr_with_cuts (or immediately after the call site where population_ptr is used) add a raft::copy from the original fj.cstr_weights (or population_ptr->weights) into population_ptr->weights_with_cuts.cstr_weights for the first fj.cstr_weights.size() elements and use solution.handle_ptr->get_stream() (or problem_ptr_with_cuts->handle_ptr->get_stream()) for the stream to match the other call sites.

coderabbitai · 2026-01-13T11:19:11Z

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

      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");
+      sol.swap_problem_pointers();
+      cuopt_assert(sol.get_feasible(), "Solution must be feasible");
      cuopt_func_call(sol.test_variable_bounds());
      population.add_solution(std::move(sol));


⚠️ Potential issue | 🟡 Minor

🧩 Analysis chain

🏁 Script executed:

# First, let's examine the actual code at the specified lines cat -n cpp/src/mip/diversity/recombiners/sub_mip.cuh | sed -n '170,190p'

Repository: NVIDIA/cuopt

Length of output: 1370

🏁 Script executed:

# Search for the Solution class and its methods fd . -type f \( -name "*.cuh" -o -name "*.hpp" -o -name "*.h" \) | head -20

Repository: NVIDIA/cuopt

Length of output: 226

🏁 Script executed:

# Find where compute_feasibility, swap_problem_pointers, get_feasible are defined rg -n "compute_feasibility\|swap_problem_pointers\|get_feasible" cpp/src --type cpp --type h --type cuh | head -30

Repository: NVIDIA/cuopt

Length of output: 83

🏁 Script executed:

# Search for Solution class and method definitions rg -n "class Solution" cpp/src --type-list | head -5

Repository: NVIDIA/cuopt

Length of output: 445

🏁 Script executed:

# Search for compute_feasibility method rg -n "compute_feasibility" cpp/src -A 3 | head -50

Repository: NVIDIA/cuopt

Length of output: 2814

🏁 Script executed:

# Search for swap_problem_pointers and get_feasible rg -n "swap_problem_pointers|get_feasible" cpp/src -B 2 -A 2 | head -60

Repository: NVIDIA/cuopt

Length of output: 3904

🏁 Script executed:

# Look for Solution class definition fd -e h -e hpp -e cuh | xargs rg -l "class Solution" | head -5

Repository: NVIDIA/cuopt

Length of output: 283

🏁 Script executed:

# Search for context on cut problem and objective constraint rg -n "objective cut|objective_cut" cpp/src -B 2 -A 2 | head -50

Repository: NVIDIA/cuopt

Length of output: 4096

🏁 Script executed:

# Look for set_problem_ptr and is_cuts_problem parameter rg -n "set_problem_ptr|is_cuts_problem" cpp/src -B 2 -A 3 | head -60

Repository: NVIDIA/cuopt

Length of output: 4752

🏁 Script executed:

# Search for the add_objective_cut or similar method rg -n "add_objective|objective.*cut" cpp/src -B 1 -A 2 | head -60

Repository: NVIDIA/cuopt

Length of output: 4488

🏁 Script executed:

# Let's understand the broader context of sub_mip.cuh and the solution lifecycle cat -n cpp/src/mip/diversity/recombiners/sub_mip.cuh | sed -n '150,195p'

Repository: NVIDIA/cuopt

Length of output: 3062

🏁 Script executed:

# Look at how add_cutting_plane_at_objective is implemented rg -n "add_cutting_plane_at_objective" cpp/src -B 2 -A 5 | head -40

Repository: NVIDIA/cuopt

Length of output: 3015

🏁 Script executed:

# Check if compute_feasibility uses the current problem_ptr internally rg -n "void compute_feasibility\|bool compute_feasibility" cpp/src/mip/solution -B 5 -A 15 | head -80

Repository: NVIDIA/cuopt

Length of output: 38

🏁 Script executed:

# Get the full implementation of compute_feasibility cat -n cpp/src/mip/solution/solution.cu | sed -n '364,415p'

Repository: NVIDIA/cuopt

Length of output: 2431

🏁 Script executed:

# Search for how compute_constraints and is_feasible flag are set rg -n "compute_constraints|is_feasible =" cpp/src/mip/solution/solution.cu -B 1 -A 2 | head -60

Repository: NVIDIA/cuopt

Length of output: 766

🏁 Script executed:

# Look at the compute_feasibility_kernel to understand what problem it operates on cat -n cpp/src/mip/solution/solution_kernels.cuh | sed -n '42,120p'

Repository: NVIDIA/cuopt

Length of output: 976

🏁 Script executed:

# Let's verify the exact nature of objective cut constraint cat -n cpp/src/mip/problem/problem.cu | sed -n '1801,1825p'

Repository: NVIDIA/cuopt

Length of output: 1182

🏁 Script executed:

# Check how many constraints are in the problem before and after cut rg -n "constraint_upper_bounds\|constraint_lower_bounds\|n_constraints" cpp/src/mip/problem/problem.cu | grep -A 2 -B 2 "add_cutting_plane_at_objective" | head -20

Repository: NVIDIA/cuopt

Length of output: 38

🏁 Script executed:

# Verify in solve.cu how feasibility is handled after problem changes cat -n cpp/src/mip/solve.cu | sed -n '260,270p'

Repository: NVIDIA/cuopt

Length of output: 655

Remove redundant compute_feasibility() call and recompute feasibility after problem swap.

Redundant call: Line 177 computes feasibility; line 180 repeats the call just to assert. Remove the call on line 180 and use get_feasible() in the assertion instead.

Feasibility not recomputed after swap: The objective-cut constraint adds one constraint to the problem. Line 177 computes feasibility against the cut-problem (with the additional constraint). After swap_problem_pointers() at line 181, the solution's problem context switches to the original problem without that constraint, but the cached is_feasible flag is not recomputed. Add sol.compute_feasibility() after the swap to revalidate against the original problem.

Typo: Line 178 has "proble" → "problem".

Proposed fix

sol.compute_feasibility(); - // the current problem is the proble with objective cut + // the current problem is the problem 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 in cut-problem"); sol.swap_problem_pointers(); + sol.compute_feasibility(); // Recompute feasibility for original problem cuopt_assert(sol.get_feasible(), "Solution must be feasible in original problem");

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

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");

sol.swap_problem_pointers();

cuopt_assert(sol.get_feasible(), "Solution must be feasible");

cuopt_func_call(sol.test_variable_bounds());

population.add_solution(std::move(sol));

sol.compute_feasibility();

// the current problem is the problem with objective cut

// to add to the population, swap problem to original

cuopt_assert(sol.get_feasible(), "Solution must be feasible in cut-problem");

sol.swap_problem_pointers();

sol.compute_feasibility(); // Recompute feasibility for original problem

cuopt_assert(sol.get_feasible(), "Solution must be feasible in original problem");

cuopt_func_call(sol.test_variable_bounds());

population.add_solution(std::move(sol));

🤖 Prompt for AI Agents

In @cpp/src/mip/diversity/recombiners/sub_mip.cuh around lines 177 - 184, Remove the redundant initial call to sol.compute_feasibility() before the assertion and change the assertion to use sol.get_feasible(); after calling sol.swap_problem_pointers() call sol.compute_feasibility() again to recompute feasibility against the original problem (so the cached is_feasible is correct), keep the cuopt_func_call(sol.test_variable_bounds()) and population.add_solution(std::move(sol)), and fix the typo "proble" → "problem" in the comment.

coderabbitai · 2026-01-13T11:19:12Z

cpp/src/mip/local_search/local_search.cu

  population_ptr->add_external_solutions_to_population();
+  if (population_ptr->is_feasible()) {
+    if (!cutting_plane_added_for_active_run) {
+      solution.set_problem_ptr(&problem_with_objective_cut);


⚠️ Potential issue | 🟠 Major

Missing is_cuts_problem parameter in set_problem_ptr call.

At line 597, solution.set_problem_ptr(&problem_with_objective_cut) is called without the second bool is_cuts_problem parameter. Based on the declaration, this should likely be set_problem_ptr(&problem_with_objective_cut, true) to indicate this is a cuts problem and properly set up the dual-pointer state.

🐛 Proposed fix

- solution.set_problem_ptr(&problem_with_objective_cut); + constexpr bool is_cuts_problem = true; + solution.set_problem_ptr(&problem_with_objective_cut, is_cuts_problem);

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

solution.set_problem_ptr(&problem_with_objective_cut);

constexpr bool is_cuts_problem = true;

solution.set_problem_ptr(&problem_with_objective_cut, is_cuts_problem);

🤖 Prompt for AI Agents

In @cpp/src/mip/local_search/local_search.cu at line 597, The call to solution.set_problem_ptr(&problem_with_objective_cut) is missing the required second parameter indicating a cuts problem; update the call to include the is_cuts_problem flag (e.g., pass true) so it becomes solution.set_problem_ptr(&problem_with_objective_cut, true) to properly initialize the dual-pointer/cuts state for the Solution object.

coderabbitai

Actionable comments posted: 0

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

cpp/src/mip/diversity/population.cuh (1)
10-11: Remove self-include on line 11.

The file population.cuh includes itself: #include "population.cuh". While #pragma once prevents infinite recursion, this is a merge artifact that should be removed. No other population.cuh file exists in the repository, confirming this is a direct self-reference.
Proposed fix
 #include "assignment_hash_map.cuh"
-#include "population.cuh"

🧹 Nitpick comments (1)

cpp/src/mip/diversity/population.cuh (1)

173-174: Consider documenting the semantic difference between the two problem pointers.

The dual-pointer design (problem_ptr vs problem_ptr_with_cuts) is sound for maintaining B&B and incumbent callback compatibility as discussed in the PR. However, having two raw pointers to potentially different problem states could cause confusion for future maintainers.

Consider adding a brief comment clarifying when each pointer should be used (e.g., problem_ptr for original problem context, problem_ptr_with_cuts for sorting/recombiner operations with objective cuts applied).

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between fd701f6 and b22e3a4.

📒 Files selected for processing (1)

cpp/src/mip/diversity/population.cuh

🧰 Additional context used

📓 Path-based instructions (2)

**/*.{cu,cuh}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh}: Every CUDA kernel launch and memory operation must have error checking with CUDA_CHECK or equivalent verification
Avoid reinventing functionality already available in Thrust, CCCL, or RMM libraries; prefer standard library utilities over custom implementations

Files:

cpp/src/mip/diversity/population.cuh

**/*.{cu,cuh,cpp,hpp,h}

📄 CodeRabbit inference engine (.github/.coderabbit_review_guide.md)

**/*.{cu,cuh,cpp,hpp,h}: Track GPU device memory allocations and deallocations to prevent memory leaks; ensure cudaMalloc/cudaFree balance and cleanup of streams/events
Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results
Check numerical stability: prevent overflow/underflow, precision loss, division by zero/near-zero, and use epsilon comparisons for floating-point equality checks
Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)
Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations
For concurrent CUDA operations (barriers, async operations), explicitly create and manage dedicated streams instead of reusing the default stream; document stream lifecycle
Eliminate unnecessary host-device synchronization (cudaDeviceSynchronize) in hot paths that blocks GPU pipeline; use streams and events for async execution
Assess algorithmic complexity for large-scale problems (millions of variables/constraints); ensure O(n log n) or better complexity, not O(n²) or worse
Verify correct problem size checks before expensive GPU/CPU operations; prevent resource exhaustion on oversized problems
Identify assertions with overly strict numerical tolerances that fail on legitimate degenerate/edge cases (near-zero pivots, singular matrices, empty problems)
Ensure race conditions are absent in multi-GPU code and multi-threaded server implementations; verify proper synchronization of shared state
Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication
Check that hard-coded GPU de...

Files:

cpp/src/mip/diversity/population.cuh

🧠 Learnings (19)

📓 Common learnings

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for algorithm phase transitions: verify correct initialization of bounds and state when transitioning from presolve to simplex to diving to crossover

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure variables and constraints are accessed from the correct problem context (original vs presolve vs folded vs postsolve); verify index mapping consistency across problem transformations

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for algorithm phase transitions: verify correct initialization of bounds and state when transitioning from presolve to simplex to diving to crossover

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate correct initialization of variable bounds, constraint coefficients, and algorithm state before solving; ensure reset when transitioning between algorithm phases (presolve, simplex, diving, crossover)

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Validate algorithm correctness in optimization logic: simplex pivots, branch-and-bound decisions, routing heuristics, and constraint/objective handling must produce correct results

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Check that hard-coded GPU device IDs and resource limits are made configurable; abstract multi-backend support for different CUDA versions

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Track GPU device memory allocations and deallocations to prevent memory leaks; ensure cudaMalloc/cudaFree balance and cleanup of streams/events

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Ensure race conditions are absent in multi-GPU code and multi-threaded server implementations; verify proper synchronization of shared state

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Refactor code duplication in solver components (3+ occurrences) into shared utilities; for GPU kernels, use templated device functions to avoid duplication

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.cu : Verify race conditions and correctness of GPU kernel shared memory, atomics, and warp-level operations

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cpp,hpp,h} : Avoid inappropriate use of exceptions in performance-critical GPU operation paths; prefer error codes or CUDA error checking for latency-sensitive code

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Eliminate unnecessary host-device synchronization (cudaDeviceSynchronize) in hot paths that blocks GPU pipeline; use streams and events for async execution

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Ensure test isolation: prevent GPU state, cached memory, and global variables from leaking between test cases; verify each test independently initializes its environment

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : Verify error propagation from CUDA to user-facing APIs is complete; ensure CUDA errors are caught and mapped to meaningful user error codes

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cu,cuh,cpp,hpp,h} : For concurrent CUDA operations (barriers, async operations), explicitly create and manage dedicated streams instead of reusing the default stream; document stream lifecycle

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Add tests for problem transformations: verify correctness of original→transformed→postsolve mappings and index consistency across problem representations

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*test*.{cpp,cu,py} : Test with free variables, singleton problems, and extreme problem dimensions near resource limits to validate edge case handling

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-10-22T14:25:22.899Z

Learnt from: aliceb-nv
Repo: NVIDIA/cuopt PR: 527
File: cpp/src/mip/diversity/lns/rins.cu:167-175
Timestamp: 2025-10-22T14:25:22.899Z
Learning: In MIP (Mixed Integer Programming) problems in the cuOPT codebase, `n_integer_vars == 0` is impossible by definition—MIP problems must have at least one integer variable. If there are no integer variables, it would be a pure Linear Programming (LP) problem, not a MIP problem.

Applied to files:

cpp/src/mip/diversity/population.cuh

📚 Learning: 2025-11-25T10:20:49.822Z

Learnt from: CR
Repo: NVIDIA/cuopt PR: 0
File: .github/.coderabbit_review_guide.md:0-0
Timestamp: 2025-11-25T10:20:49.822Z
Learning: Applies to **/*.{cpp,hpp,h} : Prevent thread-unsafe use of global and static variables; use proper mutex/synchronization in server code accessing shared solver state

Applied to files:

cpp/src/mip/diversity/population.cuh

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (9)

GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.12, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.13, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.13, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.10, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.11, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.10, amd64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.12, arm64, rockylinux8
GitHub Check: wheel-build-cuopt-mps-parser / 13.1.0, 3.11, arm64, rockylinux8
GitHub Check: checks / check-style

🔇 Additional comments (4)

cpp/src/mip/diversity/population.cuh (4)

3-3: LGTM!

Copyright year update is appropriate.

163-165: LGTM!

The new API methods set_problem_ptr_with_cuts and apply_problem_ptr_to_all_solutions clearly support the dual-problem pointer design for propagating cuts-aware context. This aligns well with the coding guidelines for ensuring correct problem context access across transformations.

183-184: LGTM!

The parallel structure of weights / weights_with_cuts mirroring problem_ptr / problem_ptr_with_cuts maintains consistency in the dual-pointer design.

209-210: LGTM!

The renamed flag preempt_heuristic_solver_ improves clarity by aligning with the corresponding method name. The std::atomic<bool> usage is appropriate for thread-safe access in the multi-threaded solver context.

aliceb-nv · 2026-01-14T09:50:15Z

cpp/CMakeLists.txt

 elseif(CMAKE_CUDA_LINEINFO)
  message(STATUS "Enabling line info")
  list(APPEND CUOPT_CUDA_FLAGS -lineinfo)
+  list(APPEND CUOPT_CXX_FLAGS  -lineinfo)


Would that work with the host compiler instead of nvcc? iirc we already have a switch for turning lineinfo on for host code - --host-lineinfo in build.sh

I couldn't find --host-lineinfo. I think xcompile should propagate lineinfo option, but I am not sure if it is working.

Oh it is a cmake arg, found it. Let me try some configs to see what works.

Here in build.sh :)

cuopt/build.sh

Line 255 in ce3c759

if hasArg --host-lineinfo; then

aliceb-nv

LGTM!
Let's track the need for a more robust refactor as the next step, as cuts are coming. But let's get this merged first

…iner

akifcorduk added 20 commits October 22, 2025 08:36

no recombiner

00ae695

temporary test on obj cut

049d07e

fix few issues

b1e7e85

handle weight mismatch

11d853e

ls time always 1 s

5570016

fix timer

300ad96

shorter fj, longer lp

6f557c0

best in population, restart fp, longer fj

b99ed04

return first feas

d1413c8

Revert "return first feas"

60c2620

This reverts commit d1413c8.

only do weights on FJ

30375e2

sqrt diversiyt

9dc0ace

fix external solutions adding

58b7b2a

fix cut issues

28ac0e8

old diversity

50f3d8e

run submip with cuts

dca499e

add cutting plane to line segment

aaa1097

added bounds prop

a99d0f4

add also FP

550635f

old diversity and no objective cut on population

f1c977b

akifcorduk added this to the 25.12 milestone Nov 25, 2025

akifcorduk requested review from a team as code owners November 25, 2025 15:16

akifcorduk added the non-breaking Introduces a non-breaking change label Nov 25, 2025

akifcorduk requested a review from Iroy30 November 25, 2025 15:16

akifcorduk added the improvement Improves an existing functionality label Nov 25, 2025

akifcorduk requested review from Kh4ster, jakirkham and nguidotti November 25, 2025 15:16

Merge branch 'main' of github.com:NVIDIA/cuopt into obj_cut_at_recomb…

de8d2c3

…iner

akifcorduk added 2 commits November 27, 2025 08:49

fix few merge conflicts

47c62fa

handle review comments

67f5008

coderabbitai bot reviewed Nov 28, 2025

View reviewed changes

dependencies.yaml Outdated Show resolved Hide resolved

helmchart/cuopt-server/values.yaml Show resolved Hide resolved

python/cuopt_self_hosted/pyproject.toml Show resolved Hide resolved

python/cuopt/pyproject.toml Show resolved Hide resolved

Merge branch 'release/25.12' of github.com:NVIDIA/cuopt into obj_cut_…

2a72dde

…at_recombiner

akifcorduk changed the base branch from release/25.12 to main November 28, 2025 14:36

build run_mip off

1695286

coderabbitai bot reviewed Nov 28, 2025

View reviewed changes

akifcorduk added 2 commits December 1, 2025 02:56

fix lp time and population insert

0acb5be

revert timer changes

aa78fa6

coderabbitai bot reviewed Dec 1, 2025

View reviewed changes

cpp/src/mip/local_search/local_search.cu Show resolved Hide resolved

fix timer

7fb2ed5

coderabbitai bot reviewed Dec 1, 2025

View reviewed changes

cpp/src/mip/local_search/local_search.cu Show resolved Hide resolved

cpp/src/mip/local_search/local_search.cu Show resolved Hide resolved

akifcorduk added 2 commits January 13, 2026 03:11

Merge branch 'main' of github.com:NVIDIA/cuopt into obj_cut_at_recomb…

e10e419

…iner

license precommit runs

fd701f6

coderabbitai bot reviewed Jan 13, 2026

View reviewed changes

fix merge conflicts

b22e3a4

coderabbitai bot reviewed Jan 13, 2026

View reviewed changes

aliceb-nv reviewed Jan 14, 2026

View reviewed changes

revert lineinfo

6b26c1b

aliceb-nv approved these changes Jan 15, 2026

View reviewed changes

akifcorduk added 2 commits January 16, 2026 02:03

revert cmake pos change

79e71a1

Merge branch 'main' of github.com:NVIDIA/cuopt into obj_cut_at_recomb…

82a6020

…iner

	solution.set_problem_ptr(&problem_with_objective_cut);
	constexpr bool is_cuts_problem = true;
	solution.set_problem_ptr(&problem_with_objective_cut, is_cuts_problem);

Objective cut in recombiners #628

Are you sure you want to change the base?

Objective cut in recombiners #628

Uh oh!

Conversation

akifcorduk commented Nov 25, 2025 • edited by coderabbitai bot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary by CodeRabbit

Uh oh!

akifcorduk commented Nov 27, 2025

Uh oh!

aliceb-nv commented Nov 27, 2025

Uh oh!

coderabbitai bot left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

coderabbitai bot left a comment

Choose a reason for hiding this comment

Uh oh!

coderabbitai bot left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

coderabbitai bot left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

github-actions bot commented Dec 9, 2025

Uh oh!

github-actions bot commented Dec 16, 2025

Uh oh!

github-actions bot commented Dec 24, 2025

Uh oh!

github-actions bot commented Jan 1, 2026

Uh oh!

github-actions bot commented Jan 8, 2026

Uh oh!

coderabbitai bot left a comment

Choose a reason for hiding this comment

Uh oh!

coderabbitai bot Jan 13, 2026

Choose a reason for hiding this comment

Uh oh!

coderabbitai bot Jan 13, 2026

Choose a reason for hiding this comment

Uh oh!

coderabbitai bot Jan 13, 2026

Choose a reason for hiding this comment

Uh oh!

coderabbitai bot Jan 13, 2026

Choose a reason for hiding this comment

Uh oh!

coderabbitai bot left a comment

Choose a reason for hiding this comment

Uh oh!

aliceb-nv Jan 14, 2026

Choose a reason for hiding this comment

Uh oh!

akifcorduk Jan 14, 2026

Choose a reason for hiding this comment

Uh oh!

akifcorduk Jan 14, 2026

Choose a reason for hiding this comment

Uh oh!

aliceb-nv Jan 14, 2026

Choose a reason for hiding this comment

Uh oh!

aliceb-nv left a comment

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

akifcorduk commented Nov 25, 2025 •

edited by coderabbitai bot

Loading