From 3f20ca65fb0943e5021bef29b1d20baa8478f5d2 Mon Sep 17 00:00:00 2001 From: Ramakrishna Prabhu Date: Tue, 22 Sep 2026 10:09:05 -0500 Subject: [PATCH 01/80] docs: scaffold Release Notes 26.10 section Adds the section header and subsection placeholders for the in-progress 26.10 cycle so subsequent PRs can append their own entries instead of each one deciding whether to create the section. Co-Authored-By: Claude Sonnet 5 --- RELEASE-NOTES.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index c3b322e69d..add58ac96a 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -1,5 +1,15 @@ # Release Notes +## Release Notes 26.10 + +### New Features (26.10) + +### Breaking Changes (26.10) + +### Improvements (26.10) + +### Bug Fixes (26.10) + ## Release Notes 26.08 ### New Features (26.08) From 791c53ca1014e7cc8a6f2d2ed8c807f07e665f03 Mon Sep 17 00:00:00 2001 From: Ramakrishna Prabhu Date: Wed, 7 Oct 2026 16:26:30 -0500 Subject: [PATCH 02/80] docs: draft Release Notes 26.10 Fill in the 26.10 section of RELEASE-NOTES.md from the PRs merged to main since v26.10.00a (New Features, Breaking Changes, Improvements, Bug Fixes, Documentation, New Contributors). Internal CI, packaging, test and refactor PRs are left out, and PR numbers are kept next to each entry for review. Co-Authored-By: Claude Sonnet 5.5 Signed-off-by: Ramakrishna Prabhu --- RELEASE-NOTES.md | 143 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 143 insertions(+) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index add58ac96a..9920fd4e92 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -4,12 +4,155 @@ ### New Features (26.10) +- C API: expose solver statistics as scalar solution attributes (#1715) +- Add a barrier setting to control adaptive regularization (enabled for cone problems by default) (#1743) +- Add Java bindings for LP, MIP and QP (#1524) +- Routing: add distance breaks (#1196) +- gRPC: add cancel and status APIs to the routing client (#1886) +- Add solver caching to support re-solves for barrier QP (#1821) +- Add Curtis-Reid scaling (#1934) +- gRPC: accept solver parameters as a map in the server (#2010) +- C API: add multi-GPU PDLP support (the problem must fit in the memory of a single GPU) (#1958) +- gRPC: send solver parameters as a map from the client (#2022) +- Add Curtis-Reid scaling to multi-GPU PDLP (#2004) +- gRPC: add a GPU health check before each job and after idle (#2031) +- gRPC: add the standard health-probe endpoints and configure the Helm chart probes by server type (#2047) +- New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server (#1892, #1917, #1874, #1876) +- Add VRP support over gRPC, with a compiled C++/Cython client (#1597) +- C API: add `cuOptSetLogCallback` and a `CUOPT_LOG_LEVEL` environment variable to control log verbosity (#1636) +- Add `DataModel.update_rhs` to update the right-hand side for barrier sequence solves, reusing the cached presolve and scaling (#1941) +- Add the RENS (Relaxation Enforced Neighborhood Search) heuristic for MIP (#1719) +- Add a primal heuristic for arc-flow formulations in MIP (#1833) +- Add Implied Indicator and Capacity Lifting presolve reductions for fixed-charge MIP models (#1983) + ### Breaking Changes (26.10) +- Don't install libcuopt into conda env by default (#1650) +- Presolve work and iteration limits (#1656) +- Migrate stream APIs from rmm::cuda_stream_view to cuda::stream_ref (#1828) +- `libcuopt` is split into client, mathopt and routing components, available as separate wheels and conda packages; `libcuopt` is now a thin metapackage (#1622, #1926, #1928, #1929, #1967, #2013) +- Rename CUOPT_DISTRIBUTED_PDLP_PARTITIONER to CUOPT_MULTIGPU_PDLP_PARTITIONER; remove CUOPT_USE_DISTRIBUTED_PDLP (#1984) +- standardize interface and remote solves on solver_settings_t (#2034) +- Reject unsupported mixed-integer quadratic problems before solving (#2032) +- The container image now runs the proxy and gRPC servers by default; the legacy HTTP server is an optional start command (#2007) + ### Improvements (26.10) +- Add iterative refinement to the GPU ADAT solve path (#1680) +- Add a hyperparameter that controls bounding of free variables (#1713) +- Barrier: print the cumulative setup time before the barrier solve (#1714) +- Release pslp presolve memory (#1735) +- Mod-2 cut separator for zero-half cuts (#1726) +- Block Bounded Value Elimination presolving pass for binary problems (#1683) +- Add a binary 2opt move fed from the probing cache into CPUFJ (#1738) +- Give each solver its own seed instead of a process-wide counter (#1717) +- MIP: make root heuristics modular with support for more workers, and run recursive RINS at the root node (#1700) +- Add a dual aggregation presolver for binary variables with a single lock (#901) +- Allow stopping B&B through `concurrent_halt` in the simplex solver settings, including during cut passes (#1760) +- Add parameters for tuning barrier primal and dual regularization (#1807) +- Make MIP root relaxation honor LP method (#1829) +- Reduce Python API overhead on repeated solves (#1615) +- Add more strategies of init point computation in barrier (#1577) +- Reduce GPU/host synchronization overhead in barrier termination check (#1808) +- Exhaustive coefficient reduction for binary rows (#1686) +- RoutingClient: match Client's (host, port, tls=...) signature (#1840) +- Diving on cut passes (#1812) +- Replace process-wide seed_generator with per-worker RNGs in MIP heuristics (#1809) +- Improve duplicate cut detection (#1764) +- Reduce memory and time in QCQP canonicalization and the symmetry check (#1864) +- Presolve: remove empty columns with a diagonal quadratic term (#1885) +- Improve time-to-first-incumbent, unify solution callback publication, scaffolding changes (#1880) +- Add a fast-path to the CPUFJ engine for binary problems with integer activities (#1881) +- Speedup barrier second-order cone conversion in general path (#1914) +- Standardize cost terminology (#1299) +- Barrier: show residual information only in debug mode (#1866) +- Pre-scale QP/SOCP columns by variable bound magnitude before Ruiz equilibration (#1652) +- Fuse the Halpern update into PDLP projection kernels for faster solves (#1904) +- Update PSLP to v0.0.12 (#1943) +- Add NNZ cutoff for concurrent mode (#1932) +- Modular CPUFJ engine, simple portfolio (#1950) +- Improve primal and dual simplex performance, and make primal simplex a first-class method for LPs (#1889) +- Eliminate zero-cost free variables by equality substitution in QP/SOCP barrier presolve (#1912) +- Fix O(n^2) loop in the flow cover cut generation (#1842) +- Structure-aware starts and repairs for CPUFJ (#1951) +- Include objective gap in QP termination criteria (#1733) +- Portfolio diversification, more starts, move batching (#1953) +- Move Ruiz scaling and building KKT system to the GPU (#1913) +- Add the mutation heuristic for MIP (#2001) + ### Bug Fixes (26.10) +- GF2 presolve rank-deficiency fix (#1660) +- Fix an out-of-bounds access when symmetry generators are pruned between restarts (#1689) +- Fix uninitialized FJ constraint weights when the problem grows (#1698) +- Use configured feasibility tolerance in Papilo (#1688) +- Fix GF2 incorrectly treating some one-sided rows as equality (#1707) +- Fix dual residual computation in final solution output (#1718) +- Report absent solution values instead of returning success (#1734) +- Avoid uncapturable RMM copies inside routing CUDA graph captures (#1753) +- Keep host sources alive for async route-view copies (#1759) +- Fix QCQP dual solution overrun and constraint count reporting (#1761) +- Use an absolute instead of relative tolerance for mod-2 row integrality (#1770) +- Return reduced costs for the default PDLP preset (Stable3) (#1797) +- Add missing TransactionGuard in the SLDA presolver (#1815) +- Fix asynchronous clique table handoff (#1834) +- Disable clique/zero-half cuts in determinism mode (#1841) +- Forward routing gRPC settings and map node name strings to ints (#1837) +- Python gRPC client: run the wait loop in Python so other threads are not blocked by the GIL (#1857) +- Fix a barrier crash when concurrent LP solving returned from cuDSS before its asynchronous work finished (#1810) +- Routing: avoid division by zero when vehicle capacity is zero (#1853) +- Guard against nullptr dereference when checking concurrent solver status (#1845) +- Routing: Guard diagonal element lookup against negative offsets in top_k (#1855) +- Refresh the cached linear column count after removing empty… (#1923) +- Fix issue in dual simplex where cut off used perturbed objective; use original objective and require dual feasibility (#1901) +- grpc server align ping handling with client behavior (#1937) +- gRPC: transfer MIP initial solutions to the server (#1868) +- Correctly stop sub-MIP when main solve finishes (#1911) +- Recompute dual variables and check dual feasibility after basis repair (#1965) +- Fix false optimality declaration in the determinsitic mode (#1954) +- Escape parser error messages (#1947) +- Handle cuda graph errors (#1945) +- Restore logging of `cuopt_cli` arguments (#1996) +- Fix run-to-run nondeterminism in barrier with `--cudss-deterministic 1` (#1856) +- Fix concurrent clique table publication (#1775) +- Limit the population solution queue to 50 solutions to prevent memory overflow (#2002) +- Fix delayed termination during root loop (#2003) +- Fix long interval between progress report (#2019) +- Fix ranged constraint conversion and MPS round trips (#2027) +- Fix early termination caused by an uninitialized dual bound before B&B starts (#2037) +- Fix/mip time limit overruns (#2046) +- gRPC: transmit PDLP warmstart data and apply it on the server (#2041) +- Barrier: keep the [linear | slacks | cone] column layout for range rows in presolve (#2029) +- Fix MPS writing for empty CSR constraint matrices (#2039) +- Fix knapsack rational coefficient scaling (#1754) +- grpc server add a check for successful cuda init in worker (#2063) +- Fix MIP presolve fixing continuous variables with the integer-variable tolerance (#2066) +- Add extra termination checks in LP, and bound sub-MIP time by the global time limit (#2054) +- Dual simplex: account for bound flips and use original costs consistently in objective logging (#2072) +- Fix `cuopt_cli` printing no log when `--num-gpu` exceeds the available GPUs (#1935) +- Upgrade CMake to include the PSLP objective offset fix (#1695) +- Exec the binary from the `cuopt_cli` and `cuopt_grpc_server` console-script wrappers so signals reach it (#1723) +- Fix vendored PSLP writing a stray infeasible-message printf to native stdout (#1836) +- Handle PSLP false-infeasible on badly-scaled LPs (#1922) +- Multi-GPU PDLP: add the missing header to the solve log (#2017) +- Make the cuDSS threading layer robust in barrier: fix a teardown race, no longer abort the process when the plugin fails to load, resolve the plugin path at runtime, and use cuOpt's own OpenMP runtime in wheels (#1883, #1897, #1905, #1982) + +### Documentation (26.10) + +- Show mamba commands directly instead of a conda-then-swap note (#1827) +- Document the VRP gRPC client (RoutingClient) (#1838) +- Update NVIDIA Brev documentation links (#1925) + +### New Contributors (26.10) + +- @nvidiacbrissette (#1524) +- @vgong-nv (#1888) +- @Juan-Francisco-Robles (#1299) +- @ZedingZhang (#1925) +- @vuule (#1900) +- @neuriv (#1947) +- @derluke (#1775) + ## Release Notes 26.08 ### New Features (26.08) From 5de6aa168129fad78c9080a9779ead1518fb4d3f Mon Sep 17 00:00:00 2001 From: Ramakrishna Prabhu Date: Thu, 8 Oct 2026 09:59:07 -0500 Subject: [PATCH 03/80] docs: document new 26.10 settings and sequence solves Add the 26.10 settings that were missing from the docs: primal simplex and its pricing and perturbation settings, the concurrent NNZ cutoff, barrier bound-free-variables, regularization, initial point safeguard and SeDuMi initial point, RENS, mutation, and CUOPT_SEQUENCE_SOLVE. Add the matching C API constants, the solver log callback, and short feature sections for primal simplex and sequence solves. Settings with HYPER in the name stay undocumented on purpose. Also correct the cuOptSetLogCallback release note, which described a CUOPT_LOG_LEVEL variable that is not in the code, and drop the Helm mention from the gRPC health-probe entry. Co-Authored-By: Claude Sonnet 5.5 Signed-off-by: Ramakrishna Prabhu --- RELEASE-NOTES.md | 4 +- docs/cuopt/source/convex-features.rst | 9 ++ docs/cuopt/source/convex-settings.rst | 105 +++++++++++++++++- .../source/cuopt-c/convex/convex-c-api.rst | 44 ++++++++ docs/cuopt/source/cuopt-c/mip/mip-c-api.rst | 2 + docs/cuopt/source/mip-settings.rst | 23 ++++ 6 files changed, 183 insertions(+), 4 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 9920fd4e92..709ab8772e 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -16,10 +16,10 @@ - gRPC: send solver parameters as a map from the client (#2022) - Add Curtis-Reid scaling to multi-GPU PDLP (#2004) - gRPC: add a GPU health check before each job and after idle (#2031) -- gRPC: add the standard health-probe endpoints and configure the Helm chart probes by server type (#2047) +- gRPC: add the standard gRPC health-probe endpoints (#2047) - New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server (#1892, #1917, #1874, #1876) - Add VRP support over gRPC, with a compiled C++/Cython client (#1597) -- C API: add `cuOptSetLogCallback` and a `CUOPT_LOG_LEVEL` environment variable to control log verbosity (#1636) +- C API: add `cuOptSetLogCallback` to receive solver log lines in a user callback (#1636) - Add `DataModel.update_rhs` to update the right-hand side for barrier sequence solves, reusing the cached presolve and scaling (#1941) - Add the RENS (Relaxation Enforced Neighborhood Search) heuristic for MIP (#1719) - Add a primal heuristic for arc-flow formulations in MIP (#1833) diff --git a/docs/cuopt/source/convex-features.rst b/docs/cuopt/source/convex-features.rst index 5120b1ca9e..595c16da63 100644 --- a/docs/cuopt/source/convex-features.rst +++ b/docs/cuopt/source/convex-features.rst @@ -249,6 +249,8 @@ Method .. note:: Dual Simplex solves to 1e-6 absolute accuracy by default. +**Primal Simplex**: Primal simplex is the simplex method applied directly to the primal linear program. It is also used by dual simplex when the cost perturbation cannot be removed. Primal simplex is available as a method, but it is not recommended: it is typically slower than dual simplex (about 2.3x slower on NETLIB in internal testing). Select dual simplex or the default concurrent method unless you have a specific reason to use primal simplex. + Crossover --------- @@ -313,6 +315,13 @@ Users can submit a set of problems which will be solved in a batch. Problems wil parallel today; callers may see a ``DeprecationWarning`` or a deprecation message in server ``warnings``. +Sequence Solves +--------------- + +When the same quadratic program is solved repeatedly with small changes, cuOpt can reuse the work from the first solve. Enable ``sequence_solve`` in the solver settings and solve with the barrier method. After the first solve finishes with an optimal solution, cuOpt keeps the converted and presolved problem and the barrier workspace on the data model. You can then change the linear objective with :meth:`~cuopt.linear_programming.data_model.DataModel.update_linear_objective` or the constraint right-hand side with :meth:`~cuopt.linear_programming.data_model.DataModel.update_rhs`, and solve again. The next solve skips conversion, presolve, and scaling. + +The quadratic objective, the constraint matrix, the row senses, and the variable bounds must stay unchanged between solves. See ``CUOPT_SEQUENCE_SOLVE`` in :doc:`convex-settings` for details and limits. + PDLP Precision Modes -------------------- diff --git a/docs/cuopt/source/convex-settings.rst b/docs/cuopt/source/convex-settings.rst index cb5a78a789..b40778732c 100644 --- a/docs/cuopt/source/convex-settings.rst +++ b/docs/cuopt/source/convex-settings.rst @@ -78,15 +78,18 @@ We now describe the parameter settings used to control cuOpt's Linear Programmin Method ^^^^^^ -``CUOPT_METHOD`` controls the method to solve the linear programming problem. Four methods are available: +``CUOPT_METHOD`` controls the method to solve the linear programming problem. Five methods are available: * ``Concurrent``: Use PDLP, dual simplex, and barrier in parallel (default). * ``PDLP``: Use the PDLP method. * ``Dual Simplex``: Use the dual simplex method. * ``Barrier``: Use the barrier (interior-point) method. +* ``Primal Simplex``: Use the primal simplex method. .. note:: The default method is ``Concurrent``. +.. note:: Primal simplex is available but not recommended. In internal testing on NETLIB it was about 2.3x slower than dual simplex. + Default accuracy for each method: * PDLP solves to 1e-4 relative accuracy by default. @@ -97,6 +100,16 @@ C API users should use the constants defined in :ref:`method-constants` for this Server Thin client users should use the :class:`cuopt_sh_client.SolverMethod` for this parameter. +Concurrent NNZ Cutoff +^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_CONCURRENT_NNZ_CUTOFF`` controls when concurrent mode stops running the CPU-based solvers. When the number of +nonzeros in the (presolved) constraint matrix is at or above this value, barrier and dual simplex are skipped and +only PDLP runs. Set it to ``-1`` to disable the cutoff, so that barrier and dual simplex run regardless of problem size. +The same setting is also accepted for MIP problems. + +.. note:: The default value is ``50000000``. + PDLP Solver Mode ^^^^^^^^^^^^^^^^ @@ -230,6 +243,45 @@ available: .. note:: The default value is 0 (default precision). +Simplex Settings +^^^^^^^^^^^^^^^^ + +The following settings control the behavior of the simplex methods: + +Primal Simplex Pricing +"""""""""""""""""""""" + +``CUOPT_PRIMAL_SIMPLEX_PRICING`` controls the pricing rule used by the primal simplex algorithm. + +* ``0``: Dantzig pricing +* ``1``: Devex pricing (default) + +.. note:: The default value is ``1`` (Devex). + +Dual Simplex Initial Perturbation +""""""""""""""""""""""""""""""""" + +``CUOPT_DUAL_SIMPLEX_INITIAL_PERTURBATION`` controls whether the dual simplex method perturbs the problem costs at the start of the solve +to reduce dual degeneracy. + +* ``-1``: Automatic (default) - cuOpt decides whether and how strongly to perturb +* ``0``: Do not perturb +* ``1``: Perturb + +.. note:: The default value is ``-1`` (automatic). + +Dual Simplex Remove Perturbation +"""""""""""""""""""""""""""""""" + +``CUOPT_DUAL_SIMPLEX_REMOVE_PERTURBATION`` controls whether the dual simplex method removes the cost perturbation during the solve, when variables leave the basis, +rather than only at the end. Removing the perturbation earlier helps avoid falling back to the slower primal simplex algorithm at the end of the solve. + +* ``-1``: Automatic (default) +* ``0``: Disabled +* ``1``: Enabled + +.. note:: The default value is ``-1`` (automatic). + Barrier Solver Settings ^^^^^^^^^^^^^^^^^^^^^^^^ @@ -309,9 +361,10 @@ Dual Initial Point ``CUOPT_BARRIER_DUAL_INITIAL_POINT`` controls the method used to compute the dual initial point for the barrier solver. The choice of initial point will affect the number of iterations performed by barrier. -* ``-1``: Automatic (default) - cuOpt selects the best method +* ``-1``: Automatic (default) - cuOpt selects the best method: the Lustig-Marsten-Shanno heuristic for linear and quadratic problems, and the SeDuMi mu-based point for conic problems * ``0``: Use an initial point from a heuristic approach based on the paper "On Implementing Mehrotra's Predictor–Corrector Interior-Point Method for Linear Programming" (SIAM J. Optimization, 1992) by Lustig, Martsten, Shanno. * ``1``: Use an initial point from solving a least squares problem that minimizes the norms of the dual variables and reduced costs while statisfying the dual equality constraints. +* ``2``: Use the SeDuMi (Sturm) mu-based primal and dual initial point. This point is computed without a factorization. .. note:: The default value is ``-1`` (automatic). @@ -419,3 +472,51 @@ Barrier Adaptive Regularization * ``1``: Enable adaptive regularization .. note:: The default value is ``-1`` (automatic). + +Barrier Presolve Bound Free Variables +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_BARRIER_PRESOLVE_BOUND_FREE_VARIABLES`` controls whether the barrier presolve bounds free variables. + +* ``-1``: Automatic (default) - cuOpt decides based on the problem +* ``0``: Disable bounding of free variables +* ``1``: Enable bounding of free variables + +.. note:: The default value is ``-1`` (automatic). + +Barrier Primal and Dual Regularization +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_BARRIER_PRIMAL_REGULARIZATION`` and ``CUOPT_BARRIER_DUAL_REGULARIZATION`` set the initial primal and dual regularization +applied to the barrier method's augmented system. They apply to the first factorization only. If adaptive regularization is enabled +(see ``CUOPT_BARRIER_ADAPTIVE_REGULARIZATION``), it can still scale the regularization up or down in later iterations. + +* ``-1``: Automatic (default) - cuOpt uses its built-in heuristic +* A value greater than or equal to ``0``: Use this value as the starting regularization + +.. note:: The default value of both settings is ``-1`` (automatic). + +Barrier Initial Point Safeguard +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_BARRIER_INITIAL_POINT_SAFEGUARD`` sets the margin used to push the barrier method's initial point into the interior of the +nonnegative orthant and, for second-order cone problems, into the interior of the cones. The initial point is shifted so that it is +at least this far from the boundary. The value must be greater than or equal to ``0``. + +.. note:: The default value is ``10.0``. + +Sequence Solve +^^^^^^^^^^^^^^ + +``CUOPT_SEQUENCE_SOLVE`` controls whether cuOpt caches the barrier workspace so that a sequence of related solves can reuse it. +When enabled, and the first solve of a quadratic program with the barrier method finishes with an optimal solution, cuOpt keeps the converted and presolved problem and the +barrier workspace on the problem's data model. After the linear objective or the constraint right-hand side is changed with :meth:`~cuopt.linear_programming.data_model.DataModel.update_linear_objective` or +:meth:`~cuopt.linear_programming.data_model.DataModel.update_rhs`, the next solve skips the conversion, presolve, and scaling steps and restarts the barrier method from a new initial point. + +* ``true``: Cache the barrier workspace for later solves +* ``false``: Do not cache the barrier workspace (default) + +.. note:: The default value is ``false``. + +.. note:: Reuse requires that the quadratic objective, the constraint matrix, the row senses, and the variable bounds stay unchanged between solves. Quadratic constraints take a full solve, + and models with range rows or folding in the first solve are not supported. When sequence solve is enabled, the automatic value of ``CUOPT_BARRIER_PRESOLVE_BOUND_FREE_VARIABLES`` resolves to disabled. diff --git a/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst b/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst index 650b306bb1..ead7009f8f 100644 --- a/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst +++ b/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst @@ -172,6 +172,16 @@ The following functions are used to set and get parameters. You can find more de .. doxygenfunction:: cuOptSetFloatParameter .. doxygenfunction:: cuOptGetFloatParameter +Solver Log Callback +------------------- + +A callback can be registered on the solver settings to receive each standard solver log line, for example to display or forward solver output in a GUI. +The callback is invoked in addition to any console or file logging enabled with ``CUOPT_LOG_TO_CONSOLE`` and ``CUOPT_LOG_FILE``. +Pass ``NULL`` to remove a registered callback. + +.. doxygentypedef:: cuOptLogCallback +.. doxygenfunction:: cuOptSetLogCallback + .. _parameter-constants: Parameter Constants @@ -194,6 +204,10 @@ These constants are used as parameter names in the :c:func:`cuOptSetParameter`, .. doxygendefine:: CUOPT_TIME_LIMIT .. doxygendefine:: CUOPT_PDLP_SOLVER_MODE .. doxygendefine:: CUOPT_METHOD +.. doxygendefine:: CUOPT_CONCURRENT_NNZ_CUTOFF +.. doxygendefine:: CUOPT_PRIMAL_SIMPLEX_PRICING +.. doxygendefine:: CUOPT_DUAL_SIMPLEX_INITIAL_PERTURBATION +.. doxygendefine:: CUOPT_DUAL_SIMPLEX_REMOVE_PERTURBATION .. doxygendefine:: CUOPT_PER_CONSTRAINT_RESIDUAL .. doxygendefine:: CUOPT_SAVE_BEST_PRIMAL_SO_FAR .. doxygendefine:: CUOPT_FIRST_PRIMAL_FEASIBLE @@ -210,6 +224,12 @@ These constants are used as parameter names in the :c:func:`cuOptSetParameter`, .. doxygendefine:: CUOPT_BARRIER_DUAL_INITIAL_POINT .. doxygendefine:: CUOPT_BARRIER_ITERATIVE_REFINEMENT .. doxygendefine:: CUOPT_BARRIER_STEP_SCALE +.. doxygendefine:: CUOPT_BARRIER_ADAPTIVE_REGULARIZATION +.. doxygendefine:: CUOPT_BARRIER_PRESOLVE_BOUND_FREE_VARIABLES +.. doxygendefine:: CUOPT_BARRIER_PRIMAL_REGULARIZATION +.. doxygendefine:: CUOPT_BARRIER_DUAL_REGULARIZATION +.. doxygendefine:: CUOPT_BARRIER_INITIAL_POINT_SAFEGUARD +.. doxygendefine:: CUOPT_SEQUENCE_SOLVE .. doxygendefine:: CUOPT_DUAL_POSTSOLVE .. doxygendefine:: CUOPT_SOLUTION_FILE .. doxygendefine:: CUOPT_NUM_CPU_THREADS @@ -254,8 +274,32 @@ These constants are used to configure `CUOPT_METHOD` via :c:func:`cuOptSetIntege .. doxygendefine:: CUOPT_METHOD_PDLP .. doxygendefine:: CUOPT_METHOD_DUAL_SIMPLEX .. doxygendefine:: CUOPT_METHOD_BARRIER +.. doxygendefine:: CUOPT_METHOD_PRIMAL .. doxygendefine:: CUOPT_METHOD_UNSET +.. _barrier-dual-initial-point-constants: + +Barrier Dual Initial Point Constants +------------------------------------ + +These constants are used to configure `CUOPT_BARRIER_DUAL_INITIAL_POINT` via :c:func:`cuOptSetIntegerParameter`. + +.. doxygendefine:: CUOPT_BARRIER_DUAL_INITIAL_POINT_AUTOMATIC +.. doxygendefine:: CUOPT_BARRIER_DUAL_INITIAL_POINT_LUSTIG_MARSTEN_SHANNO +.. doxygendefine:: CUOPT_BARRIER_DUAL_INITIAL_POINT_LEAST_SQUARES +.. doxygendefine:: CUOPT_BARRIER_DUAL_INITIAL_POINT_SEDUMI_MU + +.. _multigpu-pdlp-partitioner-constants: + +Multi-GPU PDLP Partitioner Constants +------------------------------------ + +These constants are used to configure `CUOPT_MULTIGPU_PDLP_PARTITIONER` via :c:func:`cuOptSetIntegerParameter`. + +.. doxygendefine:: CUOPT_MULTIGPU_PDLP_PARTITIONER_AUTO +.. doxygendefine:: CUOPT_MULTIGPU_PDLP_PARTITIONER_KAMINPAR +.. doxygendefine:: CUOPT_MULTIGPU_PDLP_PARTITIONER_ROUND_ROBIN + .. _barrier-iterative-refinement-constants: Barrier Iterative Refinement Constants diff --git a/docs/cuopt/source/cuopt-c/mip/mip-c-api.rst b/docs/cuopt/source/cuopt-c/mip/mip-c-api.rst index 85592bb766..c0bf053e5d 100644 --- a/docs/cuopt/source/cuopt-c/mip/mip-c-api.rst +++ b/docs/cuopt/source/cuopt-c/mip/mip-c-api.rst @@ -63,6 +63,8 @@ These constants configure MIP-specific solver behavior. Use them with :c:func:`c .. doxygendefine:: CUOPT_MIP_BATCH_PDLP_RELIABILITY_BRANCHING .. doxygendefine:: CUOPT_MIP_STRONG_BRANCHING_SIMPLEX_ITERATION_LIMIT .. doxygendefine:: CUOPT_MIP_SEMICONTINUOUS_BIG_M +.. doxygendefine:: CUOPT_MIP_RENS +.. doxygendefine:: CUOPT_MIP_MUTATION .. _mip-determinism-mode-constants: diff --git a/docs/cuopt/source/mip-settings.rst b/docs/cuopt/source/mip-settings.rst index d2ff84be53..8a0e711ef7 100644 --- a/docs/cuopt/source/mip-settings.rst +++ b/docs/cuopt/source/mip-settings.rst @@ -361,6 +361,29 @@ Set this to a positive value that is at least as large as the upper bound of any .. note:: By default cuOpt derives the Big-M from the variable's upper bound. +RENS +^^^^ + +``CUOPT_MIP_RENS`` controls whether the RENS (Relaxation Enforced Neighborhood Search) heuristic is used. RENS builds a sub-MIP from the solution of the LP relaxation: +integer variables that already take integral values in the relaxation are fixed, and the remaining integer variables are restricted to their neighboring integer values. +The sub-MIP is then solved to look for improved feasible solutions. +The default value of ``-1`` (automatic) means that the solver will decide whether to use RENS. +Set this value to 0 to disable RENS. +Set this value to 1 to enable RENS. + +.. note:: The default value is ``-1`` (automatic). + +Mutation +^^^^^^^^ + +``CUOPT_MIP_MUTATION`` controls whether the mutation heuristic is used. Mutation fixes a random subset of the integer variables to their values in the current incumbent +and solves the resulting sub-MIP. It only runs once an incumbent solution is available, and it is not run inside a sub-MIP. +The default value of ``-1`` (automatic) means that the solver will decide whether to use mutation. +Set this value to 0 to disable mutation. +Set this value to 1 to enable mutation. + +.. note:: The default value is ``-1`` (automatic). + Work Limit ^^^^^^^^^^ From 5f921cb8bc0378c1dc889a7ec0138ab896c3f096 Mon Sep 17 00:00:00 2001 From: Ramakrishna Prabhu Date: Thu, 8 Oct 2026 10:04:08 -0500 Subject: [PATCH 04/80] docs: mark component packages as beta in the 26.10 release notes Co-Authored-By: Claude Sonnet 5.5 Signed-off-by: Ramakrishna Prabhu --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 709ab8772e..8183ff7731 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -30,7 +30,7 @@ - Don't install libcuopt into conda env by default (#1650) - Presolve work and iteration limits (#1656) - Migrate stream APIs from rmm::cuda_stream_view to cuda::stream_ref (#1828) -- `libcuopt` is split into client, mathopt and routing components, available as separate wheels and conda packages; `libcuopt` is now a thin metapackage (#1622, #1926, #1928, #1929, #1967, #2013) +- `libcuopt` is split into client, mathopt and routing components, with separate wheels and conda packages (beta); `libcuopt` is now a thin metapackage (#1622, #1926, #1928, #1929, #1967, #2013) - Rename CUOPT_DISTRIBUTED_PDLP_PARTITIONER to CUOPT_MULTIGPU_PDLP_PARTITIONER; remove CUOPT_USE_DISTRIBUTED_PDLP (#1984) - standardize interface and remote solves on solver_settings_t (#2034) - Reject unsupported mixed-integer quadratic problems before solving (#2032) From c2f92ea37e0e820c659f805adb956695a259ec72 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 09:19:23 -0700 Subject: [PATCH 05/80] Update convex-features.rst --- docs/cuopt/source/convex-features.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/cuopt/source/convex-features.rst b/docs/cuopt/source/convex-features.rst index 595c16da63..3e127cddc8 100644 --- a/docs/cuopt/source/convex-features.rst +++ b/docs/cuopt/source/convex-features.rst @@ -239,17 +239,17 @@ Method .. note:: PDLP solves to 1e-4 relative accuracy by default. -**Barrier**: The barrier method (also known as interior-point method) solves linear and quadratic programs using a primal-dual predictor-corrector algorithm. This method uses GPU-accelerated sparse Cholesky and sparse LDLT solves via cuDSS, and GPU-accelerated sparse matrix-vector and matrix-matrix operations via cuSparse. Barrier is particularly effective for large-scale problems and can automatically apply techniques like folding, dualization, and dense column elimination to improve performance. This method solves the linear systems at each iteration using the augmented system or the normal equations (ADAT). Enable crossover to obtain a highly accurate basic solution from a barrier solution. +**Barrier**: The barrier method (also known as interior-point) solves linear, quadratic, and second-order cone programs using a primal-dual predictor-corrector algorithm. This method uses GPU-accelerated sparse Cholesky and sparse LDLT solves via cuDSS, and GPU-accelerated sparse matrix-vector and matrix-matrix operations via cuSparse. Barrier is particularly effective for large-scale problems and can automatically apply techniques like folding, dualization, and dense column elimination to improve performance. This method solves the linear systems at each iteration using the augmented system or the normal equations (ADAT). Enable crossover to obtain a highly accurate basic solution from a barrier solution. .. note:: Barrier solves to 1e-8 relative accuracy by default. -**Dual Simplex**: Dual simplex is the simplex method applied to the dual of the linear program. Dual simplex requires the basis factorization of linear program fit into memory. Select this method if your LP is small to medium sized, or if you require a high-quality basic solution. +**Dual Simplex**: Dual simplex begins with a dual feasible point and iterates until primal feasibility and optimality is established. Dual simplex requires the basis factorization of linear program fit into memory. Select this method if your LP is small to medium sized, or if you require a high-quality basic solution. .. note:: Dual Simplex solves to 1e-6 absolute accuracy by default. -**Primal Simplex**: Primal simplex is the simplex method applied directly to the primal linear program. It is also used by dual simplex when the cost perturbation cannot be removed. Primal simplex is available as a method, but it is not recommended: it is typically slower than dual simplex (about 2.3x slower on NETLIB in internal testing). Select dual simplex or the default concurrent method unless you have a specific reason to use primal simplex. +**Primal Simplex**: Primal simplex begins with a primal feasible point and iterates until dual feasibility and optimality is established. Primal simplex is also used by dual simplex to remove cost perturbations. Primal simplex is typically slower than dual simplex (about 2.3x in internal testing). Select dual simplex or the default concurrent method unless you have a specific reason to use primal simplex. Crossover From c6035a6b500746733a70e1618bf2fb3cf5f6503a Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 09:21:33 -0700 Subject: [PATCH 06/80] Update convex-settings.rst --- docs/cuopt/source/convex-settings.rst | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/cuopt/source/convex-settings.rst b/docs/cuopt/source/convex-settings.rst index b40778732c..d870c53036 100644 --- a/docs/cuopt/source/convex-settings.rst +++ b/docs/cuopt/source/convex-settings.rst @@ -88,7 +88,6 @@ Method .. note:: The default method is ``Concurrent``. -.. note:: Primal simplex is available but not recommended. In internal testing on NETLIB it was about 2.3x slower than dual simplex. Default accuracy for each method: From be44a7933b3ff317688fab58faf3909497e355e2 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 09:35:20 -0700 Subject: [PATCH 07/80] Update convex-settings.rst --- docs/cuopt/source/convex-settings.rst | 37 +++++++++++---------------- 1 file changed, 15 insertions(+), 22 deletions(-) diff --git a/docs/cuopt/source/convex-settings.rst b/docs/cuopt/source/convex-settings.rst index d870c53036..fc47d75629 100644 --- a/docs/cuopt/source/convex-settings.rst +++ b/docs/cuopt/source/convex-settings.rst @@ -88,12 +88,11 @@ Method .. note:: The default method is ``Concurrent``. - Default accuracy for each method: * PDLP solves to 1e-4 relative accuracy by default. * Barrier solves to 1e-8 relative accuracy by default. -* Dual Simplex solves to 1e-6 *absolute* accuracy by default. +* Simplex solves to 1e-6 *absolute* accuracy by default. C API users should use the constants defined in :ref:`method-constants` for this parameter. @@ -102,10 +101,10 @@ Server Thin client users should use the :class:`cuopt_sh_client.SolverMethod` fo Concurrent NNZ Cutoff ^^^^^^^^^^^^^^^^^^^^^ -``CUOPT_CONCURRENT_NNZ_CUTOFF`` controls when concurrent mode stops running the CPU-based solvers. When the number of +``CUOPT_CONCURRENT_NNZ_CUTOFF`` controls when concurrent mode stops running barrier and dual simplex. When the number of nonzeros in the (presolved) constraint matrix is at or above this value, barrier and dual simplex are skipped and only PDLP runs. Set it to ``-1`` to disable the cutoff, so that barrier and dual simplex run regardless of problem size. -The same setting is also accepted for MIP problems. +The same setting is also accepted for the root relaxation in MIP. .. note:: The default value is ``50000000``. @@ -156,11 +155,7 @@ Multi-GPU PDLP Partitioner ``CUOPT_MULTIGPU_PDLP_PARTITIONER`` selects how multi-GPU PDLP splits the problem across GPUs: ``0`` Auto (default; RoundRobin on 1 GPU, KaMinPar otherwise), ``1`` KaMinPar (multi-threaded graph partitioner, better balanced shards at the cost of extra partitioning time), or ``2`` -RoundRobin (no partitioning graph built). This constant was previously named -``CUOPT_DISTRIBUTED_PDLP_PARTITIONER`` (``distributed_pdlp_partitioner`` as a Server Thin client -key, now ``multigpu_pdlp_partitioner``); the separate ``CUOPT_USE_DISTRIBUTED_PDLP`` toggle has -been removed. - +RoundRobin (no partitioning graph built). Infeasibility Detection ^^^^^^^^^^^^^^^^^^^^^^^^ @@ -260,8 +255,7 @@ Primal Simplex Pricing Dual Simplex Initial Perturbation """"""""""""""""""""""""""""""""" -``CUOPT_DUAL_SIMPLEX_INITIAL_PERTURBATION`` controls whether the dual simplex method perturbs the problem costs at the start of the solve -to reduce dual degeneracy. +``CUOPT_DUAL_SIMPLEX_INITIAL_PERTURBATION`` controls whether the dual simplex method perturbs the objective at the start of solve. * ``-1``: Automatic (default) - cuOpt decides whether and how strongly to perturb * ``0``: Do not perturb @@ -272,8 +266,8 @@ to reduce dual degeneracy. Dual Simplex Remove Perturbation """""""""""""""""""""""""""""""" -``CUOPT_DUAL_SIMPLEX_REMOVE_PERTURBATION`` controls whether the dual simplex method removes the cost perturbation during the solve, when variables leave the basis, -rather than only at the end. Removing the perturbation earlier helps avoid falling back to the slower primal simplex algorithm at the end of the solve. +``CUOPT_DUAL_SIMPLEX_REMOVE_PERTURBATION`` controls whether dual simplex removes the cost perturbation during the solve, when variables leave the basis, +rather than only at the end. Removing perturbations earlier helps avoid clean up at the end of the solve. * ``-1``: Automatic (default) * ``0``: Disabled @@ -363,7 +357,7 @@ Dual Initial Point * ``-1``: Automatic (default) - cuOpt selects the best method: the Lustig-Marsten-Shanno heuristic for linear and quadratic problems, and the SeDuMi mu-based point for conic problems * ``0``: Use an initial point from a heuristic approach based on the paper "On Implementing Mehrotra's Predictor–Corrector Interior-Point Method for Linear Programming" (SIAM J. Optimization, 1992) by Lustig, Martsten, Shanno. * ``1``: Use an initial point from solving a least squares problem that minimizes the norms of the dual variables and reduced costs while statisfying the dual equality constraints. -* ``2``: Use the SeDuMi (Sturm) mu-based primal and dual initial point. This point is computed without a factorization. +* ``2``: Use an initial point from a heurisitic approach based on SeDuMi by Jos Sturm. .. note:: The default value is ``-1`` (automatic). @@ -507,15 +501,14 @@ at least this far from the boundary. The value must be greater than or equal to Sequence Solve ^^^^^^^^^^^^^^ -``CUOPT_SEQUENCE_SOLVE`` controls whether cuOpt caches the barrier workspace so that a sequence of related solves can reuse it. -When enabled, and the first solve of a quadratic program with the barrier method finishes with an optimal solution, cuOpt keeps the converted and presolved problem and the -barrier workspace on the problem's data model. After the linear objective or the constraint right-hand side is changed with :meth:`~cuopt.linear_programming.data_model.DataModel.update_linear_objective` or -:meth:`~cuopt.linear_programming.data_model.DataModel.update_rhs`, the next solve skips the conversion, presolve, and scaling steps and restarts the barrier method from a new initial point. +``CUOPT_SEQUENCE_SOLVE`` controls whether cuOpt caches the ordering and symbolic factorization so that a sequence of related barrier solves can reuse it. +When enabled, and the first solve with the barrier method finishes with an optimal solution, cuOpt stores information about the factorization. In subsequent solves, +the linear objective and the right-hand side of the linear equality constraints may be changed with :meth:`~cuopt.linear_programming.data_model.DataModel.update_linear_objective` or +:meth:`~cuopt.linear_programming.data_model.DataModel.update_rhs` without requiring new ordering or symbolic factorization. -* ``true``: Cache the barrier workspace for later solves -* ``false``: Do not cache the barrier workspace (default) +* ``true``: Cache the ordering and symbolic factorization for later solves +* ``false``: Do not cache (default) .. note:: The default value is ``false``. -.. note:: Reuse requires that the quadratic objective, the constraint matrix, the row senses, and the variable bounds stay unchanged between solves. Quadratic constraints take a full solve, - and models with range rows or folding in the first solve are not supported. When sequence solve is enabled, the automatic value of ``CUOPT_BARRIER_PRESOLVE_BOUND_FREE_VARIABLES`` resolves to disabled. +.. note:: Reuse requires that the quadratic objective, the constraint matrix, the row senses, and the variable bounds stay unchanged between solves. Problems with range rows or folding in the first solve are not supported. When sequence solve is enabled, the automatic value of ``CUOPT_BARRIER_PRESOLVE_BOUND_FREE_VARIABLES`` resolves to disabled. From b49f1a0ca1922d709c163fead8eaa0102bdc3b99 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 09:37:44 -0700 Subject: [PATCH 08/80] Update mip-settings.rst --- docs/cuopt/source/mip-settings.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cuopt/source/mip-settings.rst b/docs/cuopt/source/mip-settings.rst index 8a0e711ef7..e042b6dfc0 100644 --- a/docs/cuopt/source/mip-settings.rst +++ b/docs/cuopt/source/mip-settings.rst @@ -377,7 +377,7 @@ Mutation ^^^^^^^^ ``CUOPT_MIP_MUTATION`` controls whether the mutation heuristic is used. Mutation fixes a random subset of the integer variables to their values in the current incumbent -and solves the resulting sub-MIP. It only runs once an incumbent solution is available, and it is not run inside a sub-MIP. +and solves the resulting sub-MIP. It only runs once an incumbent solution is available. The default value of ``-1`` (automatic) means that the solver will decide whether to use mutation. Set this value to 0 to disable mutation. Set this value to 1 to enable mutation. From 861e1bc3b862364cd69d1f902a99e9a07802d3df Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 09:43:37 -0700 Subject: [PATCH 09/80] Update convex-settings.rst --- docs/cuopt/source/convex-settings.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cuopt/source/convex-settings.rst b/docs/cuopt/source/convex-settings.rst index fc47d75629..b377ce8417 100644 --- a/docs/cuopt/source/convex-settings.rst +++ b/docs/cuopt/source/convex-settings.rst @@ -78,7 +78,7 @@ We now describe the parameter settings used to control cuOpt's Linear Programmin Method ^^^^^^ -``CUOPT_METHOD`` controls the method to solve the linear programming problem. Five methods are available: +``CUOPT_METHOD`` controls the method to solve the linear program. Five methods are available: * ``Concurrent``: Use PDLP, dual simplex, and barrier in parallel (default). * ``PDLP``: Use the PDLP method. From edcd46f64ea20845592553e273465ccb7336ef7f Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 09:44:51 -0700 Subject: [PATCH 10/80] Update convex-settings.rst --- docs/cuopt/source/convex-settings.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/cuopt/source/convex-settings.rst b/docs/cuopt/source/convex-settings.rst index b377ce8417..893824d50c 100644 --- a/docs/cuopt/source/convex-settings.rst +++ b/docs/cuopt/source/convex-settings.rst @@ -354,10 +354,10 @@ Dual Initial Point ``CUOPT_BARRIER_DUAL_INITIAL_POINT`` controls the method used to compute the dual initial point for the barrier solver. The choice of initial point will affect the number of iterations performed by barrier. -* ``-1``: Automatic (default) - cuOpt selects the best method: the Lustig-Marsten-Shanno heuristic for linear and quadratic problems, and the SeDuMi mu-based point for conic problems -* ``0``: Use an initial point from a heuristic approach based on the paper "On Implementing Mehrotra's Predictor–Corrector Interior-Point Method for Linear Programming" (SIAM J. Optimization, 1992) by Lustig, Martsten, Shanno. -* ``1``: Use an initial point from solving a least squares problem that minimizes the norms of the dual variables and reduced costs while statisfying the dual equality constraints. -* ``2``: Use an initial point from a heurisitic approach based on SeDuMi by Jos Sturm. +* ``-1``: Automatic (default) - cuOpt selects the best method +* ``0``: Use an initial point from a heuristic approach based on the paper "On Implementing Mehrotra's Predictor–Corrector Interior-Point Method for Linear Programming" (SIAM J. Optimization, 1992) by Lustig, Martsten, Shanno +* ``1``: Use an initial point from solving a least squares problem that minimizes the norms of the dual variables and reduced costs while statisfying the dual equality constraints +* ``2``: Use an initial point from a heurisitic approach based on SeDuMi by Jos Sturm .. note:: The default value is ``-1`` (automatic). From 0e04e31d201d7e608ddd89e149bcb8ccfeb2b002 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 09:57:18 -0700 Subject: [PATCH 11/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 29 ++++++++++++++--------------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 8183ff7731..24649f240a 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -4,26 +4,25 @@ ### New Features (26.10) -- C API: expose solver statistics as scalar solution attributes (#1715) -- Add a barrier setting to control adaptive regularization (enabled for cone problems by default) (#1743) -- Add Java bindings for LP, MIP and QP (#1524) +- New Java interface for LP, QP, QCQP, SOCP and MIP +- New Curtis-Reid scaling for PDLP +- Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides +- New RENS (Relaxation Enforced Neighboorhood Search) for MIP +- New Primal Simplex method for LPs +- New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server +- VRP is now supported over gRPC, with a compiled C++/Cython client +- New `cuOptSetLogCallback` for capturing solver logs in C API +- New barrier setting to control adaptive regularization (enabled for cone problems by default) +- Add a primal heuristic for arc-flow formulations in MIP (#1833) +- Add Implied Indicator and Capacity Lifting presolve reductions for fixed-charge MIP models (#1983) +- The C API now exposes solver statistics as scalar solution attributes - Routing: add distance breaks (#1196) - gRPC: add cancel and status APIs to the routing client (#1886) -- Add solver caching to support re-solves for barrier QP (#1821) -- Add Curtis-Reid scaling (#1934) -- gRPC: accept solver parameters as a map in the server (#2010) -- C API: add multi-GPU PDLP support (the problem must fit in the memory of a single GPU) (#1958) - gRPC: send solver parameters as a map from the client (#2022) -- Add Curtis-Reid scaling to multi-GPU PDLP (#2004) - gRPC: add a GPU health check before each job and after idle (#2031) - gRPC: add the standard gRPC health-probe endpoints (#2047) -- New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server (#1892, #1917, #1874, #1876) -- Add VRP support over gRPC, with a compiled C++/Cython client (#1597) -- C API: add `cuOptSetLogCallback` to receive solver log lines in a user callback (#1636) -- Add `DataModel.update_rhs` to update the right-hand side for barrier sequence solves, reusing the cached presolve and scaling (#1941) -- Add the RENS (Relaxation Enforced Neighborhood Search) heuristic for MIP (#1719) -- Add a primal heuristic for arc-flow formulations in MIP (#1833) -- Add Implied Indicator and Capacity Lifting presolve reductions for fixed-charge MIP models (#1983) +- gRPC: accept solver parameters as a map in the server (#2010) + ### Breaking Changes (26.10) From 675d742ba857f8e0f0353afc7026042e742f4b03 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 10:01:39 -0700 Subject: [PATCH 12/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 24649f240a..e6bdafec34 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -37,6 +37,10 @@ ### Improvements (26.10) +- Significant performance improvements in MIP heuristics +- Significant performance improvements on QP +- Significant performance improvements on SOCP +- Significant performance improvements in dual simplex - Add iterative refinement to the GPU ADAT solve path (#1680) - Add a hyperparameter that controls bounding of free variables (#1713) - Barrier: print the cumulative setup time before the barrier solve (#1714) From 9ee614f88e68813faf0c177bed0fb876cc23b16b Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 14:29:45 -0700 Subject: [PATCH 13/80] Update convex-features.rst --- docs/cuopt/source/convex-features.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cuopt/source/convex-features.rst b/docs/cuopt/source/convex-features.rst index 3e127cddc8..d8d80658f6 100644 --- a/docs/cuopt/source/convex-features.rst +++ b/docs/cuopt/source/convex-features.rst @@ -318,7 +318,7 @@ Users can submit a set of problems which will be solved in a batch. Problems wil Sequence Solves --------------- -When the same quadratic program is solved repeatedly with small changes, cuOpt can reuse the work from the first solve. Enable ``sequence_solve`` in the solver settings and solve with the barrier method. After the first solve finishes with an optimal solution, cuOpt keeps the converted and presolved problem and the barrier workspace on the data model. You can then change the linear objective with :meth:`~cuopt.linear_programming.data_model.DataModel.update_linear_objective` or the constraint right-hand side with :meth:`~cuopt.linear_programming.data_model.DataModel.update_rhs`, and solve again. The next solve skips conversion, presolve, and scaling. +When a sequence of convex optimization problems with the same constraint matrix are solved, cuOpt can reuse work from the first solve. To enable this, set the ``sequence_solve`` setting to true and solve with the barrier method. After the first solve you can change the linear objective with :meth:`~cuopt.linear_programming.data_model.DataModel.update_linear_objective` or the constraint right-hand side with :meth:`~cuopt.linear_programming.data_model.DataModel.update_rhs`, and solve again. Subsequent solves skip ordering and symbolic factorization. The quadratic objective, the constraint matrix, the row senses, and the variable bounds must stay unchanged between solves. See ``CUOPT_SEQUENCE_SOLVE`` in :doc:`convex-settings` for details and limits. From be9bbea3399f084ebe2c8f2579958a6a6f65a8dc Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 14:39:04 -0700 Subject: [PATCH 14/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index e6bdafec34..a94530e974 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -40,7 +40,7 @@ - Significant performance improvements in MIP heuristics - Significant performance improvements on QP - Significant performance improvements on SOCP -- Significant performance improvements in dual simplex +- Dual simplex is 1.4X faster (geomean over MIPLIB root relaxations) - Add iterative refinement to the GPU ADAT solve path (#1680) - Add a hyperparameter that controls bounding of free variables (#1713) - Barrier: print the cumulative setup time before the barrier solve (#1714) From e8d57221290ee11d3f6f092776adc34ecfb62e15 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 14:41:32 -0700 Subject: [PATCH 15/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index a94530e974..be487cdd5e 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -9,6 +9,7 @@ - Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides - New RENS (Relaxation Enforced Neighboorhood Search) for MIP - New Primal Simplex method for LPs +- New Mod-2 cut separator for zero-half cuts (#1726) - New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server - VRP is now supported over gRPC, with a compiled C++/Cython client - New `cuOptSetLogCallback` for capturing solver logs in C API @@ -45,7 +46,6 @@ - Add a hyperparameter that controls bounding of free variables (#1713) - Barrier: print the cumulative setup time before the barrier solve (#1714) - Release pslp presolve memory (#1735) -- Mod-2 cut separator for zero-half cuts (#1726) - Block Bounded Value Elimination presolving pass for binary problems (#1683) - Add a binary 2opt move fed from the probing cache into CPUFJ (#1738) - Give each solver its own seed instead of a process-wide counter (#1717) From 053b2551188d58e253690bf3668c2b31311f5496 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Thu, 8 Oct 2026 15:25:57 -0700 Subject: [PATCH 16/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index be487cdd5e..c2257fbdfc 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -39,8 +39,8 @@ ### Improvements (26.10) - Significant performance improvements in MIP heuristics -- Significant performance improvements on QP -- Significant performance improvements on SOCP +- QP/QCQP problems solve 1.33X faster (geomean over QPLIB and Hans Mittelmann test set) +- SOCP problems solve 1.53X faster (geomean over Hans Mittelmann SOCP test set) - Dual simplex is 1.4X faster (geomean over MIPLIB root relaxations) - Add iterative refinement to the GPU ADAT solve path (#1680) - Add a hyperparameter that controls bounding of free variables (#1713) From a6c70825cae59c27e7892f2fd59c1d710b7f873f Mon Sep 17 00:00:00 2001 From: "Nicolas L. Guidotti" Date: Fri, 9 Oct 2026 15:46:31 +0200 Subject: [PATCH 17/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index c2257fbdfc..5b9e41e008 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -7,7 +7,8 @@ - New Java interface for LP, QP, QCQP, SOCP and MIP - New Curtis-Reid scaling for PDLP - Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides -- New RENS (Relaxation Enforced Neighboorhood Search) for MIP +- Add RENS (Relaxation Enforced Neighboorhood Search) and Mutation heuristics to MIP +- MIP solver now runs a set of heuristics during the cut passes - New Primal Simplex method for LPs - New Mod-2 cut separator for zero-half cuts (#1726) - New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server @@ -81,7 +82,6 @@ - Include objective gap in QP termination criteria (#1733) - Portfolio diversification, more starts, move batching (#1953) - Move Ruiz scaling and building KKT system to the GPU (#1913) -- Add the mutation heuristic for MIP (#2001) ### Bug Fixes (26.10) From faf48baf8d313f0cf7c845edc5def4c8b96f05b5 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 12:27:08 -0700 Subject: [PATCH 18/80] Update convex-c-api.rst --- docs/cuopt/source/cuopt-c/convex/convex-c-api.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst b/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst index ead7009f8f..38bcf360ad 100644 --- a/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst +++ b/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst @@ -274,7 +274,7 @@ These constants are used to configure `CUOPT_METHOD` via :c:func:`cuOptSetIntege .. doxygendefine:: CUOPT_METHOD_PDLP .. doxygendefine:: CUOPT_METHOD_DUAL_SIMPLEX .. doxygendefine:: CUOPT_METHOD_BARRIER -.. doxygendefine:: CUOPT_METHOD_PRIMAL +.. doxygendefine:: CUOPT_METHOD_PRIMAL_SIMPLEX .. doxygendefine:: CUOPT_METHOD_UNSET .. _barrier-dual-initial-point-constants: From 386aaa2d097cc47483e2ca7ae173c5877cabaaa2 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 12:33:35 -0700 Subject: [PATCH 19/80] Update convex-settings.rst --- docs/cuopt/source/convex-settings.rst | 159 +++++++++++++------------- 1 file changed, 81 insertions(+), 78 deletions(-) diff --git a/docs/cuopt/source/convex-settings.rst b/docs/cuopt/source/convex-settings.rst index 893824d50c..544c0e67cd 100644 --- a/docs/cuopt/source/convex-settings.rst +++ b/docs/cuopt/source/convex-settings.rst @@ -88,16 +88,93 @@ Method .. note:: The default method is ``Concurrent``. -Default accuracy for each method: +Default tolerances for each method: -* PDLP solves to 1e-4 relative accuracy by default. -* Barrier solves to 1e-8 relative accuracy by default. -* Simplex solves to 1e-6 *absolute* accuracy by default. +* PDLP solves to 1e-4 relative tolerance by default. +* Barrier solves to 1e-8 relative tolerance by default. +* Simplex solves to 1e-6 *absolute* tolerance by default. + +See below for how to change the default tolerances. C API users should use the constants defined in :ref:`method-constants` for this parameter. Server Thin client users should use the :class:`cuopt_sh_client.SolverMethod` for this parameter. +Absolute Primal Tolerance +^^^^^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_ABSOLUTE_PRIMAL_TOLERANCE`` controls the absolute primal tolerance used in the primal feasibility check. +Changing this value might have a significant impact on accuracy and runtime if the relative part +(the right-hand side vector b L2 norm) is close to, or equal to, 0. + + +The primal feasibility condition is computed as follows:: + + primal_feasiblity < absolute_primal_tolerance + relative_primal_tolerance * l2_norm(b) + +Default value is ``1e-4``. + + +Relative Primal Tolerance +^^^^^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_RELATIVE_PRIMAL_TOLERANCE`` controls the relative primal tolerance used in the primal feasibility check. +Changing this value has a significant impact on accuracy and runtime. +The primal feasibility condition is computed as follows:: + + primal_feasiblity < absolute_primal_tolerance + relative_primal_tolerance * l2_norm(b) + +.. note:: The default value is ``1e-4``. + +Absolute Dual Tolerance +^^^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_ABSOLUTE_DUAL_TOLERANCE`` controls the absolute dual tolerance used in the dual feasibility check. +Changing this value might have a significant impact on accuracy and runtime if the relative part +(the objective vector L2 norm) is close to, or equal to, 0. + +The dual feasibility condition is computed as follows:: + + dual_feasiblity < absolute_dual_tolerance + relative_dual_tolerance * l2_norm(c) + +.. note:: The default value is ``1e-4``. + +Relative Dual Tolerance +^^^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_RELATIVE_DUAL_TOLERANCE`` controls the relative dual tolerance used in the dual feasibility check. +Changing this value has a significant impact on accuracy and runtime. +The dual feasibility condition is computed as follows:: + + dual_feasiblity < absolute_dual_tolerance + relative_dual_tolerance * l2_norm(c) + +.. note:: The default value is ``1e-4``. + + +Absolute Gap Tolerance +^^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_ABSOLUTE_GAP_TOLERANCE`` controls the absolute gap tolerance used in the duality gap check. +Changing this value might have a significant impact on accuracy and runtime if the relative part ``(|primal_objective| + |dual_objective|)`` is close to, or equal to, 0. + +The duality gap is computed as follows:: + + duality_gap < absolute_gap_tolerance + relative_gap_tolerance * (|primal_objective| + |dual_objective|) + +.. note:: The default value is ``1e-4``. + + +Relative Gap Tolerance +^^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_RELATIVE_GAP_TOLERANCE`` controls the relative gap tolerance used in the duality gap check. +Changing this value has a significant impact on accuracy and runtime. +The duality gap is computed as follows:: + + duality_gap < absolute_gap_tolerance + relative_gap_tolerance * (|primal_objective| + |dual_objective|) + +.. note:: The default value is ``1e-4``. + Concurrent NNZ Cutoff ^^^^^^^^^^^^^^^^^^^^^ @@ -361,80 +438,6 @@ Dual Initial Point .. note:: The default value is ``-1`` (automatic). -Absolute Primal Tolerance -^^^^^^^^^^^^^^^^^^^^^^^^^ - -``CUOPT_ABSOLUTE_PRIMAL_TOLERANCE`` controls the absolute primal tolerance used in the primal feasibility check. -Changing this value might have a significant impact on accuracy and runtime if the relative part -(the right-hand side vector b L2 norm) is close to, or equal to, 0. - - -The primal feasibility condition is computed as follows:: - - primal_feasiblity < absolute_primal_tolerance + relative_primal_tolerance * l2_norm(b) - -Default value is ``1e-4``. - - -Relative Primal Tolerance -^^^^^^^^^^^^^^^^^^^^^^^^^ - -``CUOPT_RELATIVE_PRIMAL_TOLERANCE`` controls the relative primal tolerance used in PDLP's primal feasibility check. -Changing this value has a significant impact on accuracy and runtime. -The primal feasibility condition is computed as follows:: - - primal_feasiblity < absolute_primal_tolerance + relative_primal_tolerance * l2_norm(b) - -.. note:: The default value is ``1e-4``. - -Absolute Dual Tolerance -^^^^^^^^^^^^^^^^^^^^^^^ - -``CUOPT_ABSOLUTE_DUAL_TOLERANCE`` controls the absolute dual tolerance used in PDLP's dual feasibility check. -Changing this value might have a significant impact on accuracy and runtime if the relative part -(the objective vector L2 norm) is close to, or equal to, 0. - -The dual feasibility condition is computed as follows:: - - dual_feasiblity < absolute_dual_tolerance + relative_dual_tolerance * l2_norm(c) - -.. note:: The default value is ``1e-4``. - -Relative Dual Tolerance -^^^^^^^^^^^^^^^^^^^^^^^ - -``CUOPT_RELATIVE_DUAL_TOLERANCE`` controls the relative dual tolerance used in PDLP's dual feasibility check. -Changing this value has a significant impact on accuracy and runtime. -The dual feasibility condition is computed as follows:: - - dual_feasiblity < absolute_dual_tolerance + relative_dual_tolerance * l2_norm(c) - -.. note:: The default value is ``1e-4``. - - -Absolute Gap Tolerance -^^^^^^^^^^^^^^^^^^^^^^ - -``CUOPT_ABSOLUTE_GAP_TOLERANCE`` controls the absolute gap tolerance used in PDLP's duality gap check. -Changing this value might have a significant impact on accuracy and runtime if the relative part ``(|primal_objective| + |dual_objective|)`` is close to, or equal to, 0. - -The duality gap is computed as follows:: - - duality_gap < absolute_gap_tolerance + relative_gap_tolerance * (|primal_objective| + |dual_objective|) - -.. note:: The default value is ``1e-4``. - - -Relative Gap Tolerance -^^^^^^^^^^^^^^^^^^^^^^ - -``CUOPT_RELATIVE_GAP_TOLERANCE`` controls the relative gap tolerance used in PDLP's duality gap check. -Changing this value has a significant impact on accuracy and runtime. -The duality gap is computed as follows:: - - duality_gap < absolute_gap_tolerance + relative_gap_tolerance * (|primal_objective| + |dual_objective|) - -.. note:: The default value is ``1e-4``. Barrier Iterative Refinement ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ From acf73739847ed3089f4602235e87d0925a7a2c78 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 12:35:50 -0700 Subject: [PATCH 20/80] Update convex-settings.rst --- docs/cuopt/source/convex-settings.rst | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/docs/cuopt/source/convex-settings.rst b/docs/cuopt/source/convex-settings.rst index 544c0e67cd..44f1a42d94 100644 --- a/docs/cuopt/source/convex-settings.rst +++ b/docs/cuopt/source/convex-settings.rst @@ -438,6 +438,15 @@ Dual Initial Point .. note:: The default value is ``-1`` (automatic). +Barrier Initial Point Safeguard +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_BARRIER_INITIAL_POINT_SAFEGUARD`` sets the margin used to push the barrier method's initial point into the interior of the +nonnegative orthant and, for second-order cone problems, into the interior of the cones. The initial point is shifted so that it is +at least this far from the boundary. The value must be greater than or equal to ``0``. This setting only has an effect when ``CUOPT_BARRIER_DUAL_INITIAL_POINT=0``. + +.. note:: The default value is ``10.0``. + Barrier Iterative Refinement ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -492,14 +501,6 @@ applied to the barrier method's augmented system. They apply to the first factor .. note:: The default value of both settings is ``-1`` (automatic). -Barrier Initial Point Safeguard -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -``CUOPT_BARRIER_INITIAL_POINT_SAFEGUARD`` sets the margin used to push the barrier method's initial point into the interior of the -nonnegative orthant and, for second-order cone problems, into the interior of the cones. The initial point is shifted so that it is -at least this far from the boundary. The value must be greater than or equal to ``0``. - -.. note:: The default value is ``10.0``. Sequence Solve ^^^^^^^^^^^^^^ From cdcb16ff04e728d42e27c5e3ddb4052bd362a4db Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 12:39:43 -0700 Subject: [PATCH 21/80] Update mip-settings.rst --- docs/cuopt/source/mip-settings.rst | 115 ++++++++++++++--------------- 1 file changed, 57 insertions(+), 58 deletions(-) diff --git a/docs/cuopt/source/mip-settings.rst b/docs/cuopt/source/mip-settings.rst index e042b6dfc0..9c442c02f5 100644 --- a/docs/cuopt/source/mip-settings.rst +++ b/docs/cuopt/source/mip-settings.rst @@ -85,25 +85,6 @@ under active development. We now describe parameter settings for the MIP solver. - -Heuristics Only -^^^^^^^^^^^^^^^ - -``CUOPT_MIP_HEURISTICS_ONLY`` controls if only the GPU heuristics should be run for the MIP problem. When set to true, only the primal -bound is improved via the GPU. When set to false, both the GPU and CPU are used and -the dual bound is improved on the CPU. - -.. note:: The default value is false. - -Scaling -^^^^^^^ - -``CUOPT_MIP_SCALING`` controls if scaling should be applied to the MIP problem. - -* ``0``: Scaling is off. -* ``1``: Scaling is on. -* ``2``: Scaling is not applied to the objective (default). - Absolute Tolerance ^^^^^^^^^^^^^^^^^^ @@ -154,6 +135,23 @@ gap is infinity. .. note:: The default value is ``1e-4``. +Heuristics Only +^^^^^^^^^^^^^^^ + +``CUOPT_MIP_HEURISTICS_ONLY`` controls if only the GPU heuristics should be run for the MIP problem. When set to true, only the primal +bound is improved via the GPU. When set to false, both the GPU and CPU are used and the dual bound is improved on the CPU. + +.. note:: The default value is false. + +Scaling +^^^^^^^ + +``CUOPT_MIP_SCALING`` controls if scaling should be applied to the MIP problem. + +* ``0``: Scaling is off. +* ``1``: Scaling is on. +* ``2``: Scaling is not applied to the objective (default). + Node Limit ^^^^^^^^^^ @@ -209,6 +207,46 @@ Set this value to 0 to disable knapsack cuts. .. note:: The default value is ``-1`` (automatic). +Flow Cover Cuts +^^^^^^^^^^^^^^^^ + +``CUOPT_MIP_FLOW_COVER_CUTS`` controls whether to use flow cover cuts. +Set this value to ``-1`` (automatic) to let the solver decide. +Set this value to ``0`` to disable flow cover cuts. +Set this value to ``1`` to enable flow cover cuts. + +.. note:: The default value is ``-1`` (automatic). + +Implied Bound Cuts +^^^^^^^^^^^^^^^^^^^ + +``CUOPT_MIP_IMPLIED_BOUND_CUTS`` controls whether to use implied bound cuts. +Set this value to ``-1`` (automatic) to let the solver decide. +Set this value to ``0`` to disable implied bound cuts. +Set this value to ``1`` to enable implied bound cuts. + +.. note:: The default value is ``-1`` (automatic). + +Clique Cuts +^^^^^^^^^^^^ + +``CUOPT_MIP_CLIQUE_CUTS`` controls whether to use clique cuts. +Set this value to ``-1`` (automatic) to let the solver decide. +Set this value to ``0`` to disable clique cuts. +Set this value to ``1`` to enable clique cuts. + +.. note:: The default value is ``-1`` (automatic). + +Zero-Half Cuts +^^^^^^^^^^^^^^ + +``CUOPT_MIP_ZERO_HALF_CUTS`` controls whether to use zero-half cuts. +Set this value to ``-1`` (automatic) to let the solver decide. +Set this value to ``0`` to disable zero-half cuts. +Set this value to ``1`` to enable zero-half cuts. + +.. note:: The default value is ``-1`` (automatic). + Cut Change Threshold ^^^^^^^^^^^^^^^^^^^^ @@ -302,45 +340,6 @@ MIP Symmetry .. note:: The default value is ``-1`` (automatic). -Flow Cover Cuts -^^^^^^^^^^^^^^^^ - -``CUOPT_MIP_FLOW_COVER_CUTS`` controls whether to use flow cover cuts. -Set this value to ``-1`` (automatic) to let the solver decide. -Set this value to ``0`` to disable flow cover cuts. -Set this value to ``1`` to enable flow cover cuts. - -.. note:: The default value is ``-1`` (automatic). - -Implied Bound Cuts -^^^^^^^^^^^^^^^^^^^ - -``CUOPT_MIP_IMPLIED_BOUND_CUTS`` controls whether to use implied bound cuts. -Set this value to ``-1`` (automatic) to let the solver decide. -Set this value to ``0`` to disable implied bound cuts. -Set this value to ``1`` to enable implied bound cuts. - -.. note:: The default value is ``-1`` (automatic). - -Clique Cuts -^^^^^^^^^^^^ - -``CUOPT_MIP_CLIQUE_CUTS`` controls whether to use clique cuts. -Set this value to ``-1`` (automatic) to let the solver decide. -Set this value to ``0`` to disable clique cuts. -Set this value to ``1`` to enable clique cuts. - -.. note:: The default value is ``-1`` (automatic). - -Zero-Half Cuts -^^^^^^^^^^^^^^ - -``CUOPT_MIP_ZERO_HALF_CUTS`` controls whether to use zero-half cuts. -Set this value to ``-1`` (automatic) to let the solver decide. -Set this value to ``0`` to disable zero-half cuts. -Set this value to ``1`` to enable zero-half cuts. - -.. note:: The default value is ``-1`` (automatic). Objective Step ^^^^^^^^^^^^^^^ From d077dca733855e3e113a94122df8316dc0d8f484 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 12:43:24 -0700 Subject: [PATCH 22/80] Update mip-c-api.rst --- docs/cuopt/source/cuopt-c/mip/mip-c-api.rst | 3 +++ 1 file changed, 3 insertions(+) diff --git a/docs/cuopt/source/cuopt-c/mip/mip-c-api.rst b/docs/cuopt/source/cuopt-c/mip/mip-c-api.rst index c0bf053e5d..6b7f99bb7c 100644 --- a/docs/cuopt/source/cuopt-c/mip/mip-c-api.rst +++ b/docs/cuopt/source/cuopt-c/mip/mip-c-api.rst @@ -65,6 +65,9 @@ These constants configure MIP-specific solver behavior. Use them with :c:func:`c .. doxygendefine:: CUOPT_MIP_SEMICONTINUOUS_BIG_M .. doxygendefine:: CUOPT_MIP_RENS .. doxygendefine:: CUOPT_MIP_MUTATION +.. doxygendefine:: CUOPT_MIP_PRIMAL_DEGENERATE_PIVOTS +.. doxygendefine:: CUOPT_MIP_DUAL_DEGENERATE_PIVOTS +.. doxygendefine:: CUOPT_MIP_DUAL_DEGENERATE_FEASIBILITY_PUMP .. _mip-determinism-mode-constants: From 3c9d2f0ad764317f7d1f0c638d8019094a7ab596 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 13:00:01 -0700 Subject: [PATCH 23/80] Update mip-settings.rst --- docs/cuopt/source/mip-settings.rst | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/docs/cuopt/source/mip-settings.rst b/docs/cuopt/source/mip-settings.rst index 9c442c02f5..612b6ace89 100644 --- a/docs/cuopt/source/mip-settings.rst +++ b/docs/cuopt/source/mip-settings.rst @@ -383,6 +383,35 @@ Set this value to 1 to enable mutation. .. note:: The default value is ``-1`` (automatic). +Primal Degenerate Pivots +^^^^^^^^^^^^^^^^^^^^^^^^ + +``CUOPT_MIP_PRIMAL_DEGENERATE_PIVOTS`` controls whether primal degenerate pivots are performed to improve reduced cost strengthening. These pivots attempt to move +basic integer variables on their bound out of the basis. This can lead to more reduced cost bound strengthening. This setting only has an affect when +``CUOPT_REDUCED_COST_STRENGTHENING`` is enabled. +The default value of ``-1`` (automatic) means the solver will decide whether to do primal degenerate pivots. +Set this value to 0 to disable primal degenerate pivots. +Set this value to 1 to enable primal degenerate pivots. + +Dual Degenerate Pivots +^^^^^^^^^^^^^^^^^^^^^^ +``CUOPT_MIP_DUAL_DEGENERATE_PIVOTS`` controls whether dual degenerate pivots are performed. These pivots attempt to remove fractional integer variables from the basis. +This can lead to less integer infeasibilities. +The default value of ``-1`` (automatic) means the solver will decide whether to do dual degenerate pivots. +Set this value to 0 to disable dual degenerate pivots. +Set this value to 1 to enable dual degenerate pivots at the root node. +Set this value to 2 to enable dual degenerate pivots at all branch and bound nodes. + +Dual Degenerate Feasibility Pump +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +``CUOPT_MIP_DUAL_DEGENERATE_FEASIBILITY_PUMP`` controls whether the dual degenerate feasibility pump is run. If the solution of the root relaxation is dual degenerate, +an auxillarly LP is constructed that is restricted to the optimal face; the feasibility pump is used to alter the objective of the LP to attempt to reduce the number of integer infeasibilities +in the relaxation solution. This LP is solved with the primal simplex method. +The default value of ``-1`` (automatic) means the solver will decide whether to run the dual degenerate feasibility pump. +Set this value to 0 to disable the dual degenerate feasibility pump. +Set this value to 1 to enable the dual degenerate feasibility pump. + + Work Limit ^^^^^^^^^^ From e3bafd4c6c98bb4de5b6e17c27176c31cf2cd9e7 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 14:31:34 -0700 Subject: [PATCH 24/80] Update convex-features.rst --- docs/cuopt/source/convex-features.rst | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/docs/cuopt/source/convex-features.rst b/docs/cuopt/source/convex-features.rst index d8d80658f6..74acccd297 100644 --- a/docs/cuopt/source/convex-features.rst +++ b/docs/cuopt/source/convex-features.rst @@ -336,4 +336,9 @@ By default, PDLP operates in the native precision of the problem type (FP64 for Multi-GPU Mode -------------- -Users can use multiple GPUs to solve a problem by specifying the ``num_gpus`` parameter. The feature is restricted to LP problems that uses concurrent mode and supports up to 2 GPUs at the moment. Using this mode will run PDLP and barrier in parallel on different GPUs to avoid sharing single GPU resources. +Multiple GPUs may be used to solve a linear program by specifying the ``num_gpus`` parameter. Multiple GPUs are used differently depending on the ``method`` parameter: + +* When the PDLP method is specified, multi-GPU PDLP is used to solve LPs faster or solve very large LPs that do not fit in the memory of a single GPU. +* When the concurrent method is specified, setting ``num_gpus=2``, will run PDLP and barrier concurrently on two GPUs to avoid sharing resources on a single GPU. Increasing ``num_gpus`` beyond two has no effect in this mode. + +.. note:: Concurrent is the default method; to run multi-GPU PDLP, users must specify the PDLP method. Multi-GPU mode is not supported on QP, QCQP, or SOCP problems. From 0f28c02fb6a43e42083954fc2397dd0e6d8ab7d3 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 14:33:07 -0700 Subject: [PATCH 25/80] Update convex-features.rst --- docs/cuopt/source/convex-features.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/cuopt/source/convex-features.rst b/docs/cuopt/source/convex-features.rst index 74acccd297..a5c15d6ccd 100644 --- a/docs/cuopt/source/convex-features.rst +++ b/docs/cuopt/source/convex-features.rst @@ -322,6 +322,8 @@ When a sequence of convex optimization problems with the same constraint matrix The quadratic objective, the constraint matrix, the row senses, and the variable bounds must stay unchanged between solves. See ``CUOPT_SEQUENCE_SOLVE`` in :doc:`convex-settings` for details and limits. +.. note:: Sequence solves are currently only supported with the Python API. + PDLP Precision Modes -------------------- From 699395edb61d5bed676bd97f455beaab522a1f1a Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 15:24:45 -0700 Subject: [PATCH 26/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 40 +++++++++++++++++++--------------------- 1 file changed, 19 insertions(+), 21 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 5b9e41e008..9ad68fb023 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -7,15 +7,14 @@ - New Java interface for LP, QP, QCQP, SOCP and MIP - New Curtis-Reid scaling for PDLP - Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides -- Add RENS (Relaxation Enforced Neighboorhood Search) and Mutation heuristics to MIP +- Add RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics to MIP - MIP solver now runs a set of heuristics during the cut passes - New Primal Simplex method for LPs -- New Mod-2 cut separator for zero-half cuts (#1726) - New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server - VRP is now supported over gRPC, with a compiled C++/Cython client - New `cuOptSetLogCallback` for capturing solver logs in C API - New barrier setting to control adaptive regularization (enabled for cone problems by default) -- Add a primal heuristic for arc-flow formulations in MIP (#1833) +- New primal heuristic for MIPs with arc-flow formulations - Add Implied Indicator and Capacity Lifting presolve reductions for fixed-charge MIP models (#1983) - The C API now exposes solver statistics as scalar solution attributes - Routing: add distance breaks (#1196) @@ -43,50 +42,49 @@ - QP/QCQP problems solve 1.33X faster (geomean over QPLIB and Hans Mittelmann test set) - SOCP problems solve 1.53X faster (geomean over Hans Mittelmann SOCP test set) - Dual simplex is 1.4X faster (geomean over MIPLIB root relaxations) -- Add iterative refinement to the GPU ADAT solve path (#1680) +- PDLP now fuses the Halpern update into the projection kernels to improve performance +- Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex +- Free memory after LP presolve: the transpose matrix and PSLP reduced problem are now freed +- Barrier now preforms Ruiz scaling and builds the augmented system on the GPU +- Barrier now scales QCQP/SOCP constraint by variable bounds before Ruiz equilibriation +- Barrier now performs iterative refinement on GPU when using the normal equations +- Barrier now prints the cumulative setup time before the solve +- Barrier now removes empty columns from separable QPs +- Barrier termination check now has reduced GPU/host synchronization overhead +- QCQP to SOCP conversion performance is improved +- MIP root relaxation now honors the LP method selected +- MIP performance improvement in duplicate cut detection +- MIP diving is now performed on separate threads during root cut passes +- New Mod-2 cut separator for zero-half cuts (#1726) - Add a hyperparameter that controls bounding of free variables (#1713) -- Barrier: print the cumulative setup time before the barrier solve (#1714) -- Release pslp presolve memory (#1735) - Block Bounded Value Elimination presolving pass for binary problems (#1683) - Add a binary 2opt move fed from the probing cache into CPUFJ (#1738) -- Give each solver its own seed instead of a process-wide counter (#1717) - MIP: make root heuristics modular with support for more workers, and run recursive RINS at the root node (#1700) - Add a dual aggregation presolver for binary variables with a single lock (#901) - Allow stopping B&B through `concurrent_halt` in the simplex solver settings, including during cut passes (#1760) - Add parameters for tuning barrier primal and dual regularization (#1807) -- Make MIP root relaxation honor LP method (#1829) -- Reduce Python API overhead on repeated solves (#1615) - Add more strategies of init point computation in barrier (#1577) -- Reduce GPU/host synchronization overhead in barrier termination check (#1808) - Exhaustive coefficient reduction for binary rows (#1686) - RoutingClient: match Client's (host, port, tls=...) signature (#1840) -- Diving on cut passes (#1812) - Replace process-wide seed_generator with per-worker RNGs in MIP heuristics (#1809) -- Improve duplicate cut detection (#1764) - Reduce memory and time in QCQP canonicalization and the symmetry check (#1864) -- Presolve: remove empty columns with a diagonal quadratic term (#1885) - Improve time-to-first-incumbent, unify solution callback publication, scaffolding changes (#1880) - Add a fast-path to the CPUFJ engine for binary problems with integer activities (#1881) -- Speedup barrier second-order cone conversion in general path (#1914) - Standardize cost terminology (#1299) - Barrier: show residual information only in debug mode (#1866) -- Pre-scale QP/SOCP columns by variable bound magnitude before Ruiz equilibration (#1652) -- Fuse the Halpern update into PDLP projection kernels for faster solves (#1904) - Update PSLP to v0.0.12 (#1943) -- Add NNZ cutoff for concurrent mode (#1932) - Modular CPUFJ engine, simple portfolio (#1950) - Improve primal and dual simplex performance, and make primal simplex a first-class method for LPs (#1889) - Eliminate zero-cost free variables by equality substitution in QP/SOCP barrier presolve (#1912) -- Fix O(n^2) loop in the flow cover cut generation (#1842) - Structure-aware starts and repairs for CPUFJ (#1951) -- Include objective gap in QP termination criteria (#1733) - Portfolio diversification, more starts, move batching (#1953) -- Move Ruiz scaling and building KKT system to the GPU (#1913) +- Give each solver its own seed instead of a process-wide counter (#1717) ### Bug Fixes (26.10) +- Fix an issue in Barrier on QPs where duality gap was not included in the termination criteria +- Fix an issue in MIP where flow cover cut generation was accidentally O(n^2) (#1842) - GF2 presolve rank-deficiency fix (#1660) -- Fix an out-of-bounds access when symmetry generators are pruned between restarts (#1689) - Fix uninitialized FJ constraint weights when the problem grows (#1698) - Use configured feasibility tolerance in Papilo (#1688) - Fix GF2 incorrectly treating some one-sided rows as equality (#1707) From 7dad52f189704296600fc8957ff00f051606790e Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 15:46:14 -0700 Subject: [PATCH 27/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 9ad68fb023..9296bf006e 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -15,6 +15,7 @@ - New `cuOptSetLogCallback` for capturing solver logs in C API - New barrier setting to control adaptive regularization (enabled for cone problems by default) - New primal heuristic for MIPs with arc-flow formulations +- New techniques for exploiting degeneracy in MIP - Add Implied Indicator and Capacity Lifting presolve reductions for fixed-charge MIP models (#1983) - The C API now exposes solver statistics as scalar solution attributes - Routing: add distance breaks (#1196) @@ -45,39 +46,40 @@ - PDLP now fuses the Halpern update into the projection kernels to improve performance - Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex - Free memory after LP presolve: the transpose matrix and PSLP reduced problem are now freed +- LPs with poor scaling are now attempted without presolve, even if PSLP declares infeasibility +- LP presolve now uses PSLP version 0.1.1 - Barrier now preforms Ruiz scaling and builds the augmented system on the GPU - Barrier now scales QCQP/SOCP constraint by variable bounds before Ruiz equilibriation - Barrier now performs iterative refinement on GPU when using the normal equations - Barrier now prints the cumulative setup time before the solve - Barrier now removes empty columns from separable QPs - Barrier termination check now has reduced GPU/host synchronization overhead -- QCQP to SOCP conversion performance is improved +- Barrier now has parameters for tuning primal and dual regularization +- Barrier now has a parameter to control bounding free variables +- Barrier now has improved performance when computing the initial point +- QCQP to SOCP conversion performance is improved and memory required is reduced +- QCQP/SOCP presolve now eliminates free variables with zero cost - MIP root relaxation now honors the LP method selected - MIP performance improvement in duplicate cut detection - MIP diving is now performed on separate threads during root cut passes -- New Mod-2 cut separator for zero-half cuts (#1726) -- Add a hyperparameter that controls bounding of free variables (#1713) +- MIP root heuristics now use more threads, recursive RINS is now run at the root node +- MIP reduced cost strengthening now stores bound implications based on incumbent objective value +- MIP now includes a new Mod-2 cut separator for zero-half cuts +- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explanations - Block Bounded Value Elimination presolving pass for binary problems (#1683) - Add a binary 2opt move fed from the probing cache into CPUFJ (#1738) -- MIP: make root heuristics modular with support for more workers, and run recursive RINS at the root node (#1700) - Add a dual aggregation presolver for binary variables with a single lock (#901) - Allow stopping B&B through `concurrent_halt` in the simplex solver settings, including during cut passes (#1760) -- Add parameters for tuning barrier primal and dual regularization (#1807) -- Add more strategies of init point computation in barrier (#1577) - Exhaustive coefficient reduction for binary rows (#1686) -- RoutingClient: match Client's (host, port, tls=...) signature (#1840) -- Replace process-wide seed_generator with per-worker RNGs in MIP heuristics (#1809) -- Reduce memory and time in QCQP canonicalization and the symmetry check (#1864) - Improve time-to-first-incumbent, unify solution callback publication, scaffolding changes (#1880) - Add a fast-path to the CPUFJ engine for binary problems with integer activities (#1881) - Standardize cost terminology (#1299) -- Barrier: show residual information only in debug mode (#1866) -- Update PSLP to v0.0.12 (#1943) - Modular CPUFJ engine, simple portfolio (#1950) - Improve primal and dual simplex performance, and make primal simplex a first-class method for LPs (#1889) -- Eliminate zero-cost free variables by equality substitution in QP/SOCP barrier presolve (#1912) - Structure-aware starts and repairs for CPUFJ (#1951) - Portfolio diversification, more starts, move batching (#1953) +- RoutingClient: match Client's (host, port, tls=...) signature (#1840) +- Replace process-wide seed_generator with per-worker RNGs in MIP heuristics (#1809) - Give each solver its own seed instead of a process-wide counter (#1717) ### Bug Fixes (26.10) @@ -134,7 +136,7 @@ - Upgrade CMake to include the PSLP objective offset fix (#1695) - Exec the binary from the `cuopt_cli` and `cuopt_grpc_server` console-script wrappers so signals reach it (#1723) - Fix vendored PSLP writing a stray infeasible-message printf to native stdout (#1836) -- Handle PSLP false-infeasible on badly-scaled LPs (#1922) + - Multi-GPU PDLP: add the missing header to the solve log (#2017) - Make the cuDSS threading layer robust in barrier: fix a teardown race, no longer abort the process when the plugin fails to load, resolve the plugin path at runtime, and use cuOpt's own OpenMP runtime in wheels (#1883, #1897, #1905, #1982) From be8d9df17233ff000d4419a59f89a417b6929a91 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 15:47:14 -0700 Subject: [PATCH 28/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 9296bf006e..f52d4cd4e5 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -8,7 +8,7 @@ - New Curtis-Reid scaling for PDLP - Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides - Add RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics to MIP -- MIP solver now runs a set of heuristics during the cut passes +- MIP solver now runs diving and recursive RINS heuristics during the cut passes - New Primal Simplex method for LPs - New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server - VRP is now supported over gRPC, with a compiled C++/Cython client From bd6703531635d036ba45beca60492a87cc5497b5 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 15:51:12 -0700 Subject: [PATCH 29/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index f52d4cd4e5..690b8c3a67 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -9,11 +9,10 @@ - Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides - Add RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics to MIP - MIP solver now runs diving and recursive RINS heuristics during the cut passes -- New Primal Simplex method for LPs +- New primal simplex method for LPs - New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server - VRP is now supported over gRPC, with a compiled C++/Cython client - New `cuOptSetLogCallback` for capturing solver logs in C API -- New barrier setting to control adaptive regularization (enabled for cone problems by default) - New primal heuristic for MIPs with arc-flow formulations - New techniques for exploiting degeneracy in MIP - Add Implied Indicator and Capacity Lifting presolve reductions for fixed-charge MIP models (#1983) @@ -54,6 +53,7 @@ - Barrier now prints the cumulative setup time before the solve - Barrier now removes empty columns from separable QPs - Barrier termination check now has reduced GPU/host synchronization overhead +- Barrier now has parameters to control adaptive regularization (enabled for SOCP by default) - Barrier now has parameters for tuning primal and dual regularization - Barrier now has a parameter to control bounding free variables - Barrier now has improved performance when computing the initial point From 55d2fd6303e23924ac2aa4819105ce2a5f0b4564 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 15:55:32 -0700 Subject: [PATCH 30/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 690b8c3a67..49ccf7a659 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -9,14 +9,14 @@ - Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides - Add RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics to MIP - MIP solver now runs diving and recursive RINS heuristics during the cut passes -- New primal simplex method for LPs -- New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server -- VRP is now supported over gRPC, with a compiled C++/Cython client -- New `cuOptSetLogCallback` for capturing solver logs in C API - New primal heuristic for MIPs with arc-flow formulations - New techniques for exploiting degeneracy in MIP +- New primal simplex method for LPs - Add Implied Indicator and Capacity Lifting presolve reductions for fixed-charge MIP models (#1983) - The C API now exposes solver statistics as scalar solution attributes +- New `cuOptSetLogCallback` for capturing solver logs in C API +- New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server +- VRP is now supported over gRPC, with a compiled C++/Cython client - Routing: add distance breaks (#1196) - gRPC: add cancel and status APIs to the routing client (#1886) - gRPC: send solver parameters as a map from the client (#2022) From 4a09770642a28e86837d33ee633c57cdedf5012d Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Mon, 12 Oct 2026 16:25:24 -0700 Subject: [PATCH 31/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 76 ++++++++++++++++++++++++------------------------ 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 49ccf7a659..ff32d38c89 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -84,61 +84,61 @@ ### Bug Fixes (26.10) -- Fix an issue in Barrier on QPs where duality gap was not included in the termination criteria -- Fix an issue in MIP where flow cover cut generation was accidentally O(n^2) (#1842) +- Fix issue in MPS writer on problems with no linear constraints +- Fix ranged constraint conversion and MPS writing/reading round trips +- Fix an issue in PDLP where reduced costs where not returned for the default PDLP preset (Stable3) +- Fix a barrier crash when concurrent LP solving returned from cuDSS before its asynchronous work finished +- Fix several issues in barrier related to the cuDSS threading layer +- Fix a bug on QCQP/SOCP problems with ranged rows +- Fix nondeterminism in barrier when `--cudss-deterministic=1` +- Fix an issue with QPs where duality gap was not included in the termination criteria +- Fix QCQP dual solution overrun and constraint count reporting +- Fix an issue in QCQP/SOCP where the dual residual of the final solution was incorrect +- Fix an issue in dual simplex logs where bound flips were not accounted for in objective +- Fix an issue in MIP where flow cover cut generation was accidentally O(n^2) +- Fix issue in dual simplex inside MIP where cut off incorrectly used the perturbed objective +- Fix an issue in dual simplex where dual variables and dual feasibility was not recomputed after basis repair +- Fix several issues in MIP where the time limit was not respected +- Fix MIP presolve incorrectly fixing continuous variables using integer-variable tolerance +- Fix false optimality declaration in MIP determinsitic mode +- Fix issue in MIP where a large amount of time could elapse between logs +- Fix issue in MIP when converting knapsack constraints to rational coefficients could remove integer solutions +- Fix issue in MIP where termination was delayed during root cut passes +- Fix an issue in MIP where the sub-MIP was not correctly stopped when the main solve finished +- XXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explaination +- Fix early termination caused by an uninitialized dual bound before B&B starts (#2037) +- Upgrade CMake to include the PSLP objective offset fix (#1695) +- Fix vendored PSLP writing a stray infeasible-message printf to native stdout (#1836) +- Multi-GPU PDLP: add the missing header to the solve log (#2017) +- Fix asynchronous clique table handoff (#1834) +- Disable clique/zero-half cuts in determinism mode (#1841) +- Guard against nullptr dereference when checking concurrent solver status (#1845) +- Restore logging of `cuopt_cli` arguments (#1996) +- Fix concurrent clique table publication (#1775) +- Limit the population solution queue to 50 solutions to prevent memory overflow (#2002) +- Add extra termination checks in LP, and bound sub-MIP time by the global time limit (#2054) +- Fix `cuopt_cli` printing no log when `--num-gpu` exceeds the available GPUs (#1935) - GF2 presolve rank-deficiency fix (#1660) - Fix uninitialized FJ constraint weights when the problem grows (#1698) - Use configured feasibility tolerance in Papilo (#1688) - Fix GF2 incorrectly treating some one-sided rows as equality (#1707) -- Fix dual residual computation in final solution output (#1718) - Report absent solution values instead of returning success (#1734) - Avoid uncapturable RMM copies inside routing CUDA graph captures (#1753) - Keep host sources alive for async route-view copies (#1759) -- Fix QCQP dual solution overrun and constraint count reporting (#1761) - Use an absolute instead of relative tolerance for mod-2 row integrality (#1770) -- Return reduced costs for the default PDLP preset (Stable3) (#1797) - Add missing TransactionGuard in the SLDA presolver (#1815) -- Fix asynchronous clique table handoff (#1834) -- Disable clique/zero-half cuts in determinism mode (#1841) -- Forward routing gRPC settings and map node name strings to ints (#1837) -- Python gRPC client: run the wait loop in Python so other threads are not blocked by the GIL (#1857) -- Fix a barrier crash when concurrent LP solving returned from cuDSS before its asynchronous work finished (#1810) - Routing: avoid division by zero when vehicle capacity is zero (#1853) -- Guard against nullptr dereference when checking concurrent solver status (#1845) - Routing: Guard diagonal element lookup against negative offsets in top_k (#1855) - Refresh the cached linear column count after removing empty… (#1923) -- Fix issue in dual simplex where cut off used perturbed objective; use original objective and require dual feasibility (#1901) -- grpc server align ping handling with client behavior (#1937) -- gRPC: transfer MIP initial solutions to the server (#1868) -- Correctly stop sub-MIP when main solve finishes (#1911) -- Recompute dual variables and check dual feasibility after basis repair (#1965) -- Fix false optimality declaration in the determinsitic mode (#1954) - Escape parser error messages (#1947) - Handle cuda graph errors (#1945) -- Restore logging of `cuopt_cli` arguments (#1996) -- Fix run-to-run nondeterminism in barrier with `--cudss-deterministic 1` (#1856) -- Fix concurrent clique table publication (#1775) -- Limit the population solution queue to 50 solutions to prevent memory overflow (#2002) -- Fix delayed termination during root loop (#2003) -- Fix long interval between progress report (#2019) -- Fix ranged constraint conversion and MPS round trips (#2027) -- Fix early termination caused by an uninitialized dual bound before B&B starts (#2037) -- Fix/mip time limit overruns (#2046) - gRPC: transmit PDLP warmstart data and apply it on the server (#2041) -- Barrier: keep the [linear | slacks | cone] column layout for range rows in presolve (#2029) -- Fix MPS writing for empty CSR constraint matrices (#2039) -- Fix knapsack rational coefficient scaling (#1754) +- grpc server align ping handling with client behavior (#1937) +- gRPC: transfer MIP initial solutions to the server (#1868) - grpc server add a check for successful cuda init in worker (#2063) -- Fix MIP presolve fixing continuous variables with the integer-variable tolerance (#2066) -- Add extra termination checks in LP, and bound sub-MIP time by the global time limit (#2054) -- Dual simplex: account for bound flips and use original costs consistently in objective logging (#2072) -- Fix `cuopt_cli` printing no log when `--num-gpu` exceeds the available GPUs (#1935) -- Upgrade CMake to include the PSLP objective offset fix (#1695) +- Forward routing gRPC settings and map node name strings to ints (#1837) +- Python gRPC client: run the wait loop in Python so other threads are not blocked by the GIL (#1857) - Exec the binary from the `cuopt_cli` and `cuopt_grpc_server` console-script wrappers so signals reach it (#1723) -- Fix vendored PSLP writing a stray infeasible-message printf to native stdout (#1836) - -- Multi-GPU PDLP: add the missing header to the solve log (#2017) -- Make the cuDSS threading layer robust in barrier: fix a teardown race, no longer abort the process when the plugin fails to load, resolve the plugin path at runtime, and use cuOpt's own OpenMP runtime in wheels (#1883, #1897, #1905, #1982) ### Documentation (26.10) From f8d73ae89cd1d30e46e58a1027adc1496b874b6d Mon Sep 17 00:00:00 2001 From: "Nicolas L. Guidotti" Date: Tue, 13 Oct 2026 10:29:48 +0200 Subject: [PATCH 32/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index ff32d38c89..30262b9aef 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -61,15 +61,12 @@ - QCQP/SOCP presolve now eliminates free variables with zero cost - MIP root relaxation now honors the LP method selected - MIP performance improvement in duplicate cut detection -- MIP diving is now performed on separate threads during root cut passes -- MIP root heuristics now use more threads, recursive RINS is now run at the root node - MIP reduced cost strengthening now stores bound implications based on incumbent objective value - MIP now includes a new Mod-2 cut separator for zero-half cuts - XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explanations - Block Bounded Value Elimination presolving pass for binary problems (#1683) - Add a binary 2opt move fed from the probing cache into CPUFJ (#1738) - Add a dual aggregation presolver for binary variables with a single lock (#901) -- Allow stopping B&B through `concurrent_halt` in the simplex solver settings, including during cut passes (#1760) - Exhaustive coefficient reduction for binary rows (#1686) - Improve time-to-first-incumbent, unify solution callback publication, scaffolding changes (#1880) - Add a fast-path to the CPUFJ engine for binary problems with integer activities (#1881) @@ -105,15 +102,16 @@ - Fix issue in MIP when converting knapsack constraints to rational coefficients could remove integer solutions - Fix issue in MIP where termination was delayed during root cut passes - Fix an issue in MIP where the sub-MIP was not correctly stopped when the main solve finished +- B&B now properly stops after `concurrent_halt` is set to true. +- Fix incorrect global dual bounds during the cut passes +- Guard against nullptr dereference when checking concurrent solver status +- Escape parser error messages +- Disable clique table generation in MIP when running in determinism mode. - XXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explaination -- Fix early termination caused by an uninitialized dual bound before B&B starts (#2037) - Upgrade CMake to include the PSLP objective offset fix (#1695) - Fix vendored PSLP writing a stray infeasible-message printf to native stdout (#1836) - Multi-GPU PDLP: add the missing header to the solve log (#2017) - Fix asynchronous clique table handoff (#1834) -- Disable clique/zero-half cuts in determinism mode (#1841) -- Guard against nullptr dereference when checking concurrent solver status (#1845) -- Restore logging of `cuopt_cli` arguments (#1996) - Fix concurrent clique table publication (#1775) - Limit the population solution queue to 50 solutions to prevent memory overflow (#2002) - Add extra termination checks in LP, and bound sub-MIP time by the global time limit (#2054) @@ -130,7 +128,6 @@ - Routing: avoid division by zero when vehicle capacity is zero (#1853) - Routing: Guard diagonal element lookup against negative offsets in top_k (#1855) - Refresh the cached linear column count after removing empty… (#1923) -- Escape parser error messages (#1947) - Handle cuda graph errors (#1945) - gRPC: transmit PDLP warmstart data and apply it on the server (#2041) - grpc server align ping handling with client behavior (#1937) From a755a94d6fdbd01a360d011a4bef93585f7aec8c Mon Sep 17 00:00:00 2001 From: yuwenchen95 Date: Tue, 13 Oct 2026 02:44:33 -0700 Subject: [PATCH 33/80] Update convex parts Signed-off-by: yuwenchen95 --- docs/cuopt/source/convex-features.rst | 4 ++-- docs/cuopt/source/convex-settings.rst | 10 +++++----- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/cuopt/source/convex-features.rst b/docs/cuopt/source/convex-features.rst index a5c15d6ccd..774b46cc0c 100644 --- a/docs/cuopt/source/convex-features.rst +++ b/docs/cuopt/source/convex-features.rst @@ -341,6 +341,6 @@ Multi-GPU Mode Multiple GPUs may be used to solve a linear program by specifying the ``num_gpus`` parameter. Multiple GPUs are used differently depending on the ``method`` parameter: * When the PDLP method is specified, multi-GPU PDLP is used to solve LPs faster or solve very large LPs that do not fit in the memory of a single GPU. -* When the concurrent method is specified, setting ``num_gpus=2``, will run PDLP and barrier concurrently on two GPUs to avoid sharing resources on a single GPU. Increasing ``num_gpus`` beyond two has no effect in this mode. +* When the concurrent method is specified, setting ``num_gpus=2``, will run PDLP and barrier concurrently on two GPUs to avoid sharing resources on a single GPU. Increasing ``num_gpus`` beyond two has no effect in this mode. -.. note:: Concurrent is the default method; to run multi-GPU PDLP, users must specify the PDLP method. Multi-GPU mode is not supported on QP, QCQP, or SOCP problems. +.. note:: Concurrent is the default method; to run multi-GPU PDLP, users must specify the PDLP method. Multi-GPU mode is not supported on QP, QCQP, or SOCP problems. diff --git a/docs/cuopt/source/convex-settings.rst b/docs/cuopt/source/convex-settings.rst index 44f1a42d94..f9a3455b59 100644 --- a/docs/cuopt/source/convex-settings.rst +++ b/docs/cuopt/source/convex-settings.rst @@ -94,7 +94,7 @@ Default tolerances for each method: * Barrier solves to 1e-8 relative tolerance by default. * Simplex solves to 1e-6 *absolute* tolerance by default. -See below for how to change the default tolerances. +See below for how to change the default tolerances. C API users should use the constants defined in :ref:`method-constants` for this parameter. @@ -344,7 +344,7 @@ Dual Simplex Remove Perturbation """""""""""""""""""""""""""""""" ``CUOPT_DUAL_SIMPLEX_REMOVE_PERTURBATION`` controls whether dual simplex removes the cost perturbation during the solve, when variables leave the basis, -rather than only at the end. Removing perturbations earlier helps avoid clean up at the end of the solve. +rather than only at the end. Removing perturbations earlier helps avoid clean up at the end of the solve. * ``-1``: Automatic (default) * ``0``: Disabled @@ -443,7 +443,7 @@ Barrier Initial Point Safeguard ``CUOPT_BARRIER_INITIAL_POINT_SAFEGUARD`` sets the margin used to push the barrier method's initial point into the interior of the nonnegative orthant and, for second-order cone problems, into the interior of the cones. The initial point is shifted so that it is -at least this far from the boundary. The value must be greater than or equal to ``0``. This setting only has an effect when ``CUOPT_BARRIER_DUAL_INITIAL_POINT=0``. +at least this far from the boundary. The value must be greater than or equal to ``0``. This setting only has an effect when ``CUOPT_BARRIER_DUAL_INITIAL_POINT`` is ``0`` or ``1``. .. note:: The default value is ``10.0``. @@ -506,7 +506,7 @@ Sequence Solve ^^^^^^^^^^^^^^ ``CUOPT_SEQUENCE_SOLVE`` controls whether cuOpt caches the ordering and symbolic factorization so that a sequence of related barrier solves can reuse it. -When enabled, and the first solve with the barrier method finishes with an optimal solution, cuOpt stores information about the factorization. In subsequent solves, +When enabled, and the first solve with the barrier method finishes with an optimal solution, cuOpt stores information about the factorization. In subsequent solves, the linear objective and the right-hand side of the linear equality constraints may be changed with :meth:`~cuopt.linear_programming.data_model.DataModel.update_linear_objective` or :meth:`~cuopt.linear_programming.data_model.DataModel.update_rhs` without requiring new ordering or symbolic factorization. @@ -515,4 +515,4 @@ the linear objective and the right-hand side of the linear equality constraints .. note:: The default value is ``false``. -.. note:: Reuse requires that the quadratic objective, the constraint matrix, the row senses, and the variable bounds stay unchanged between solves. Problems with range rows or folding in the first solve are not supported. When sequence solve is enabled, the automatic value of ``CUOPT_BARRIER_PRESOLVE_BOUND_FREE_VARIABLES`` resolves to disabled. +.. note:: Reuse requires that the quadratic objective, the constraint matrix, the row senses, and the variable bounds stay unchanged between solves. Problems with range rows are not supported. When sequence solve is enabled, ``CUOPT_FOLDING`` and ``CUOPT_BARRIER_PRESOLVE_BOUND_FREE_VARIABLES`` are disabled. From 4fc66bdee10513e64e68bd0f86816efecad25eaf Mon Sep 17 00:00:00 2001 From: yuwenchen95 Date: Tue, 13 Oct 2026 02:49:34 -0700 Subject: [PATCH 34/80] Update RELEASE-NOTES.md Signed-off-by: yuwenchen95 --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 30262b9aef..31d257a9d9 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -53,7 +53,7 @@ - Barrier now prints the cumulative setup time before the solve - Barrier now removes empty columns from separable QPs - Barrier termination check now has reduced GPU/host synchronization overhead -- Barrier now has parameters to control adaptive regularization (enabled for SOCP by default) +- Barrier now has parameters to control adaptive regularization - Barrier now has parameters for tuning primal and dual regularization - Barrier now has a parameter to control bounding free variables - Barrier now has improved performance when computing the initial point From d82db5672fe36d89a05b24e4668ec90e5800d125 Mon Sep 17 00:00:00 2001 From: Ramakrishna Prabhu Date: Tue, 13 Oct 2026 09:44:38 -0500 Subject: [PATCH 35/80] docs: add multi-GPU PDLP examples for the CLI and Python API Signed-off-by: Ramakrishna Prabhu --- docs/cuopt/source/cuopt-cli/cli-examples.rst | 12 ++++ .../lp/examples/multi_gpu_pdlp_example.sh | 56 +++++++++++++++ .../cuopt-python/convex/convex-examples.rst | 11 +++ .../convex/examples/multi_gpu_pdlp_example.py | 69 +++++++++++++++++++ 4 files changed, 148 insertions(+) create mode 100755 docs/cuopt/source/cuopt-cli/examples/lp/examples/multi_gpu_pdlp_example.sh create mode 100644 docs/cuopt/source/cuopt-python/convex/examples/multi_gpu_pdlp_example.py diff --git a/docs/cuopt/source/cuopt-cli/cli-examples.rst b/docs/cuopt/source/cuopt-cli/cli-examples.rst index 62e794285b..12cd128779 100644 --- a/docs/cuopt/source/cuopt-cli/cli-examples.rst +++ b/docs/cuopt/source/cuopt-cli/cli-examples.rst @@ -105,3 +105,15 @@ You can customize the solver behavior using various command line parameters. Her .. literalinclude:: examples/lp/examples/solver_parameters_example.sh :language: bash :linenos: + + +Solving an LP on Multiple GPUs +############################## + +Multi-GPU PDLP shards an LP across GPUs. Select it with ``--method 1`` (PDLP) and set ``--num-gpus`` to ``-1`` (all visible GPUs) or to a value greater than 1. ``--multigpu-pdlp-partitioner`` chooses how the problem is split (``0`` auto, ``1`` KaMinPar, ``2`` round robin). Multi-GPU PDLP supports LPs only, and the number of GPUs cannot exceed the number of visible CUDA devices. + +:download:`multi_gpu_pdlp_example.sh ` + +.. literalinclude:: examples/lp/examples/multi_gpu_pdlp_example.sh + :language: bash + :linenos: diff --git a/docs/cuopt/source/cuopt-cli/examples/lp/examples/multi_gpu_pdlp_example.sh b/docs/cuopt/source/cuopt-cli/examples/lp/examples/multi_gpu_pdlp_example.sh new file mode 100755 index 0000000000..f12a44b877 --- /dev/null +++ b/docs/cuopt/source/cuopt-cli/examples/lp/examples/multi_gpu_pdlp_example.sh @@ -0,0 +1,56 @@ +#!/bin/bash +# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# TEST_SKIP: requires multiple GPUs +# +# Multi-GPU PDLP Example using cuopt_cli +# +# This example shows how to shard an LP across several GPUs with PDLP. +# Multi-GPU PDLP is selected by --method 1 (PDLP) together with --num-gpus set +# to -1 (all visible GPUs) or to a value greater than 1. +# +# Requirements: +# - cuopt_cli installed and available in PATH +# - At least 2 visible GPUs +# - An LP in MPS format (multi-GPU PDLP only supports LPs, and helps most on +# large problems; the tiny model below only illustrates the options) +# + +# Create a sample MPS file +echo "* optimize +* cost = -0.2 * VAR1 + 0.1 * VAR2 +* subject to +* 3 * VAR1 + 4 * VAR2 <= 5.4 +* 2.7 * VAR1 + 10.1 * VAR2 <= 4.9 +NAME SAMPLE +ROWS + N COST + L ROW1 + L ROW2 +COLUMNS + VAR1 COST -0.2 + VAR1 ROW1 3.0 + VAR1 ROW2 2.7 + VAR2 COST 0.1 + VAR2 ROW1 4.0 + VAR2 ROW2 10.1 +RHS + RHS1 ROW1 5.4 + RHS1 ROW2 4.9 +ENDATA" > sample.mps + +echo "=== Example 1: Use all visible GPUs ===" +cuopt_cli --method 1 --num-gpus -1 sample.mps + +echo "" +echo "=== Example 2: Use exactly 2 GPUs ===" +cuopt_cli --method 1 --num-gpus 2 sample.mps + +echo "" +echo "=== Example 3: Choose how the problem is split across GPUs ===" +# 0 = auto (default), 1 = KaMinPar, 2 = round robin +cuopt_cli --method 1 --num-gpus -1 --multigpu-pdlp-partitioner 2 sample.mps + +# Clean up +rm -f sample.mps diff --git a/docs/cuopt/source/cuopt-python/convex/convex-examples.rst b/docs/cuopt/source/cuopt-python/convex/convex-examples.rst index eacdc03bff..f7715db530 100644 --- a/docs/cuopt/source/cuopt-python/convex/convex-examples.rst +++ b/docs/cuopt/source/cuopt-python/convex/convex-examples.rst @@ -263,3 +263,14 @@ The response is as follows: x = 25.001763214569394 y = 0.0 Objective value = 50.00352642913879 + +Solving an LP on Multiple GPUs +------------------------------ + +Multi-GPU PDLP shards an LP across GPUs. Set the method to PDLP and ``CUOPT_NUM_GPUS`` to ``-1`` (all visible GPUs) or to a value greater than 1. This helps most on large LPs, or LPs that do not fit in the memory of a single GPU. It is not supported for QP, QCQP or SOCP problems. + +:download:`multi_gpu_pdlp_example.py ` + +.. literalinclude:: examples/multi_gpu_pdlp_example.py + :language: python + :linenos: diff --git a/docs/cuopt/source/cuopt-python/convex/examples/multi_gpu_pdlp_example.py b/docs/cuopt/source/cuopt-python/convex/examples/multi_gpu_pdlp_example.py new file mode 100644 index 0000000000..dd4158b828 --- /dev/null +++ b/docs/cuopt/source/cuopt-python/convex/examples/multi_gpu_pdlp_example.py @@ -0,0 +1,69 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# TEST_SKIP: requires multiple GPUs + +""" +Multi-GPU PDLP Example + +This example demonstrates: +- Selecting the PDLP method +- Using all visible GPUs (num_gpus = -1) or a fixed number of GPUs +- Choosing how the problem is partitioned across GPUs + +Multi-GPU PDLP shards the problem across GPUs. It helps most on large LPs, +or LPs that do not fit in the memory of a single GPU. The small model below +only illustrates the settings. Multi-GPU PDLP supports LPs only, and needs at +least 2 visible GPUs. + +Problem: + Maximize: 2*x + y + Subject to: + 4*x + 10*y <= 130 + 8*x - 3*y >= 40 + x, y >= 0 +""" + +from cuopt.linear_programming.problem import Problem, CONTINUOUS, MAXIMIZE +from cuopt.linear_programming.solver.solver_parameters import ( + CUOPT_METHOD, + CUOPT_NUM_GPUS, + CUOPT_MULTIGPU_PDLP_PARTITIONER, +) +from cuopt.linear_programming.solver_settings import ( + SolverSettings, + SolverMethod, +) + + +def main(): + """Run the multi-GPU PDLP example.""" + problem = Problem("Simple LP") + + x = problem.addVariable(lb=0, vtype=CONTINUOUS, name="x") + y = problem.addVariable(lb=0, vtype=CONTINUOUS, name="y") + + problem.addConstraint(4 * x + 10 * y <= 130, name="c1") + problem.addConstraint(8 * x - 3 * y >= 40, name="c2") + + problem.setObjective(2 * x + y, sense=MAXIMIZE) + + settings = SolverSettings() + # Multi-GPU PDLP needs the PDLP method + settings.set_parameter(CUOPT_METHOD, SolverMethod.PDLP) + # -1 uses all GPUs visible to the process; a value > 1 uses that many + settings.set_parameter(CUOPT_NUM_GPUS, -1) + # How to split the problem: 0 = auto (default), 1 = KaMinPar, + # 2 = round robin + settings.set_parameter(CUOPT_MULTIGPU_PDLP_PARTITIONER, 0) + + problem.solve(settings) + + print(f"Status: {problem.Status.name}") + print(f"Solved in {problem.SolveTime:.4f} seconds") + print(f"x = {x.getValue()}, y = {y.getValue()}") + print(f"Objective value = {problem.ObjValue}") + + +if __name__ == "__main__": + main() From 46d4e6a8238db5955341eda79c8d6a8f4c873db2 Mon Sep 17 00:00:00 2001 From: Ramakrishna Prabhu Date: Tue, 13 Oct 2026 09:47:57 -0500 Subject: [PATCH 36/80] style: strip trailing whitespace Signed-off-by: Ramakrishna Prabhu --- RELEASE-NOTES.md | 10 +++++----- docs/cuopt/source/mip-settings.rst | 14 +++++++------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 31d257a9d9..5803f817eb 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -8,7 +8,7 @@ - New Curtis-Reid scaling for PDLP - Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides - Add RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics to MIP -- MIP solver now runs diving and recursive RINS heuristics during the cut passes +- MIP solver now runs diving and recursive RINS heuristics during the cut passes - New primal heuristic for MIPs with arc-flow formulations - New techniques for exploiting degeneracy in MIP - New primal simplex method for LPs @@ -55,15 +55,15 @@ - Barrier termination check now has reduced GPU/host synchronization overhead - Barrier now has parameters to control adaptive regularization - Barrier now has parameters for tuning primal and dual regularization -- Barrier now has a parameter to control bounding free variables +- Barrier now has a parameter to control bounding free variables - Barrier now has improved performance when computing the initial point - QCQP to SOCP conversion performance is improved and memory required is reduced -- QCQP/SOCP presolve now eliminates free variables with zero cost +- QCQP/SOCP presolve now eliminates free variables with zero cost - MIP root relaxation now honors the LP method selected - MIP performance improvement in duplicate cut detection - MIP reduced cost strengthening now stores bound implications based on incumbent objective value - MIP now includes a new Mod-2 cut separator for zero-half cuts -- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explanations +- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explanations - Block Bounded Value Elimination presolving pass for binary problems (#1683) - Add a binary 2opt move fed from the probing cache into CPUFJ (#1738) - Add a dual aggregation presolver for binary variables with a single lock (#901) @@ -90,7 +90,7 @@ - Fix nondeterminism in barrier when `--cudss-deterministic=1` - Fix an issue with QPs where duality gap was not included in the termination criteria - Fix QCQP dual solution overrun and constraint count reporting -- Fix an issue in QCQP/SOCP where the dual residual of the final solution was incorrect +- Fix an issue in QCQP/SOCP where the dual residual of the final solution was incorrect - Fix an issue in dual simplex logs where bound flips were not accounted for in objective - Fix an issue in MIP where flow cover cut generation was accidentally O(n^2) - Fix issue in dual simplex inside MIP where cut off incorrectly used the perturbed objective diff --git a/docs/cuopt/source/mip-settings.rst b/docs/cuopt/source/mip-settings.rst index 612b6ace89..416ef2b89f 100644 --- a/docs/cuopt/source/mip-settings.rst +++ b/docs/cuopt/source/mip-settings.rst @@ -387,27 +387,27 @@ Primal Degenerate Pivots ^^^^^^^^^^^^^^^^^^^^^^^^ ``CUOPT_MIP_PRIMAL_DEGENERATE_PIVOTS`` controls whether primal degenerate pivots are performed to improve reduced cost strengthening. These pivots attempt to move -basic integer variables on their bound out of the basis. This can lead to more reduced cost bound strengthening. This setting only has an affect when +basic integer variables on their bound out of the basis. This can lead to more reduced cost bound strengthening. This setting only has an affect when ``CUOPT_REDUCED_COST_STRENGTHENING`` is enabled. -The default value of ``-1`` (automatic) means the solver will decide whether to do primal degenerate pivots. -Set this value to 0 to disable primal degenerate pivots. +The default value of ``-1`` (automatic) means the solver will decide whether to do primal degenerate pivots. +Set this value to 0 to disable primal degenerate pivots. Set this value to 1 to enable primal degenerate pivots. Dual Degenerate Pivots ^^^^^^^^^^^^^^^^^^^^^^ ``CUOPT_MIP_DUAL_DEGENERATE_PIVOTS`` controls whether dual degenerate pivots are performed. These pivots attempt to remove fractional integer variables from the basis. This can lead to less integer infeasibilities. -The default value of ``-1`` (automatic) means the solver will decide whether to do dual degenerate pivots. +The default value of ``-1`` (automatic) means the solver will decide whether to do dual degenerate pivots. Set this value to 0 to disable dual degenerate pivots. Set this value to 1 to enable dual degenerate pivots at the root node. -Set this value to 2 to enable dual degenerate pivots at all branch and bound nodes. +Set this value to 2 to enable dual degenerate pivots at all branch and bound nodes. Dual Degenerate Feasibility Pump ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``CUOPT_MIP_DUAL_DEGENERATE_FEASIBILITY_PUMP`` controls whether the dual degenerate feasibility pump is run. If the solution of the root relaxation is dual degenerate, an auxillarly LP is constructed that is restricted to the optimal face; the feasibility pump is used to alter the objective of the LP to attempt to reduce the number of integer infeasibilities -in the relaxation solution. This LP is solved with the primal simplex method. -The default value of ``-1`` (automatic) means the solver will decide whether to run the dual degenerate feasibility pump. +in the relaxation solution. This LP is solved with the primal simplex method. +The default value of ``-1`` (automatic) means the solver will decide whether to run the dual degenerate feasibility pump. Set this value to 0 to disable the dual degenerate feasibility pump. Set this value to 1 to enable the dual degenerate feasibility pump. From 700eed2df6d6a9876194228cf88041e9fe8dc9ff Mon Sep 17 00:00:00 2001 From: Ramakrishna Prabhu Date: Tue, 13 Oct 2026 10:20:01 -0500 Subject: [PATCH 37/80] docs: add multi-GPU PDLP snippet to the C API examples Signed-off-by: Ramakrishna Prabhu --- .../source/cuopt-c/convex/convex-examples.rst | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/docs/cuopt/source/cuopt-c/convex/convex-examples.rst b/docs/cuopt/source/cuopt-c/convex/convex-examples.rst index 70211660a5..6df2a9e267 100644 --- a/docs/cuopt/source/cuopt-c/convex/convex-examples.rst +++ b/docs/cuopt/source/cuopt-c/convex/convex-examples.rst @@ -466,3 +466,23 @@ output below, ``x1..x5`` are ``a, b, s, p, q`` in column order: x5 = 1.414214 Solver completed successfully! + + +Solving an LP on Multiple GPUs +------------------------------ + +Multi-GPU PDLP shards an LP across GPUs. Set the method to PDLP and ``CUOPT_NUM_GPUS`` to ``-1`` (all visible GPUs) or to a value greater than 1 before calling ``cuOptSolve``. This helps most on large LPs, or LPs that do not fit in the memory of a single GPU. It is not supported for QP, QCQP or SOCP problems, and it needs at least 2 visible GPUs to spread the work. Add the following to the LP example above, after creating the solver settings: + +.. code-block:: c + + // Use PDLP and all GPUs visible to the process + status = cuOptSetIntegerParameter(settings, CUOPT_METHOD, CUOPT_METHOD_PDLP); + status = cuOptSetIntegerParameter(settings, CUOPT_NUM_GPUS, -1); + + // Optional: how the problem is split across GPUs + // (CUOPT_MULTIGPU_PDLP_PARTITIONER_AUTO, _KAMINPAR or _ROUND_ROBIN) + status = cuOptSetIntegerParameter(settings, + CUOPT_MULTIGPU_PDLP_PARTITIONER, + CUOPT_MULTIGPU_PDLP_PARTITIONER_AUTO); + +Check ``status`` against ``CUOPT_SUCCESS`` after each call, as the example above does. From 61dd602170c90608ec9406bd07b0926122b5daa5 Mon Sep 17 00:00:00 2001 From: yuwenchen95 Date: Tue, 13 Oct 2026 09:09:41 -0700 Subject: [PATCH 38/80] Update SOCP results in RELEASE-NOTES.md Signed-off-by: yuwenchen95 --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 5803f817eb..8a195e4eda 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -40,7 +40,7 @@ - Significant performance improvements in MIP heuristics - QP/QCQP problems solve 1.33X faster (geomean over QPLIB and Hans Mittelmann test set) -- SOCP problems solve 1.53X faster (geomean over Hans Mittelmann SOCP test set) +- SOCP problems now solve to a tighter default tolerance of 1e-6 (previously 1e-4) without a performance regression - Dual simplex is 1.4X faster (geomean over MIPLIB root relaxations) - PDLP now fuses the Halpern update into the projection kernels to improve performance - Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex From 208a5fda2a137622f103a4d175e33abe26517e11 Mon Sep 17 00:00:00 2001 From: Trevor McKay Date: Tue, 13 Oct 2026 14:15:55 -0400 Subject: [PATCH 39/80] docs: name the legacy container section in the 26.10 notes without a link The section is documented on a separate change, so the release note refers to it by title. Signed-off-by: Trevor McKay --- RELEASE-NOTES.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 8a195e4eda..6ab9d4be86 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -137,6 +137,10 @@ - Python gRPC client: run the wait loop in Python so other threads are not blocked by the GIL (#1857) - Exec the binary from the `cuopt_cli` and `cuopt_grpc_server` console-script wrappers so signals reach it (#1723) +### Deprecations (26.10) + +- The container's default server is now the HTTP proxy plus `cuopt_grpc_server`, in place of the legacy HTTP server. The legacy HTTP server is still shipped in 26.10 and will be removed in 26.12. See "Starting the Container" on the Legacy HTTP Server page for the legacy container command and for `CUOPT_SERVER_TYPE=legacy` in Kubernetes. That page links to the 26.08 guide. Differences are in "Deprecated Interfaces Not Provided by the Proxy Server". + ### Documentation (26.10) - Show mamba commands directly instead of a conda-then-swap note (#1827) From 05919601c063255a4e31b7d7a18992ac5a85a0c6 Mon Sep 17 00:00:00 2001 From: Trevor McKay Date: Tue, 13 Oct 2026 15:01:38 -0400 Subject: [PATCH 40/80] docs: summarize the gRPC parameter map in the 26.10 notes Name the 26.10 user guide for the legacy container and deprecated-interface sections. Signed-off-by: Trevor McKay --- RELEASE-NOTES.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 6ab9d4be86..73fd0a4245 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -19,10 +19,9 @@ - VRP is now supported over gRPC, with a compiled C++/Cython client - Routing: add distance breaks (#1196) - gRPC: add cancel and status APIs to the routing client (#1886) -- gRPC: send solver parameters as a map from the client (#2022) +- Solver parameters are now sent over gRPC as a string map. A new client requires a new server. An older client still works with a new server. (#2010, #2022, #2057) - gRPC: add a GPU health check before each job and after idle (#2031) - gRPC: add the standard gRPC health-probe endpoints (#2047) -- gRPC: accept solver parameters as a map in the server (#2010) ### Breaking Changes (26.10) @@ -139,7 +138,7 @@ ### Deprecations (26.10) -- The container's default server is now the HTTP proxy plus `cuopt_grpc_server`, in place of the legacy HTTP server. The legacy HTTP server is still shipped in 26.10 and will be removed in 26.12. See "Starting the Container" on the Legacy HTTP Server page for the legacy container command and for `CUOPT_SERVER_TYPE=legacy` in Kubernetes. That page links to the 26.08 guide. Differences are in "Deprecated Interfaces Not Provided by the Proxy Server". +- The container's default server is now the HTTP proxy plus `cuopt_grpc_server`, in place of the legacy HTTP server. The legacy HTTP server is still shipped in 26.10 and will be removed in 26.12. See "Starting the Container" on the Legacy HTTP Server page in the 26.10 user guide for the legacy container command and for `CUOPT_SERVER_TYPE=legacy` in Kubernetes. That page links to the 26.08 guide. Differences are in "Deprecated Interfaces Not Provided by the Proxy Server" in the 26.10 user guide. ### Documentation (26.10) From e2bc523624ffe4b4bf7000f66ac84e72561f0291 Mon Sep 17 00:00:00 2001 From: Ramakrishna Prabhu Date: Tue, 13 Oct 2026 15:34:32 -0500 Subject: [PATCH 41/80] docs: offer the gRPC protos for download List all five protos in the gRPC API reference, including cuopt_remote_data.proto, which was missing. The docs build copies them from cpp/src/grpc into one flat directory and zips them, so the download links track the repository files. Co-Authored-By: Claude Sonnet 5.5 --- .gitignore | 2 ++ docs/cuopt/source/conf.py | 16 ++++++++++++++++ docs/cuopt/source/cuopt-grpc/api.rst | 27 ++++++++++++++++++++++----- 3 files changed, 40 insertions(+), 5 deletions(-) diff --git a/.gitignore b/.gitignore index c9e16fcc5d..e8929667da 100644 --- a/.gitignore +++ b/.gitignore @@ -65,6 +65,8 @@ docs/cuopt/source/cuopt-server/client-api/sh-cli-help.txt docs/cuopt/source/cuopt-server/server-api/server-cli-help.txt docs/cuopt/source/cuopt-cli/cuopt-cli-help.txt docs/cuopt/source/cuopt_spec.yaml +docs/cuopt/source/cuopt-grpc/protos/ +docs/cuopt/source/cuopt-grpc/cuopt-protos.zip python/cuopt_self_hosted/cuopt_sh_client/tests/utils/certs/*.key docs/cuopt/build diff --git a/docs/cuopt/source/conf.py b/docs/cuopt/source/conf.py index 524668ac44..a2a919e73d 100644 --- a/docs/cuopt/source/conf.py +++ b/docs/cuopt/source/conf.py @@ -8,6 +8,7 @@ import cuopt import yaml from packaging.version import Version +import shutil import subprocess import sys import os @@ -35,6 +36,21 @@ ["cuopt_cli", "--help"], stdout=open("cuopt-cli/cuopt-cli-help.txt", "w") ) +# Copy the gRPC protos next to the docs so api.rst can offer them for download. They import +# each other by file name, so they share one directory. +_grpc_src = Path(__file__).resolve().parents[3] / "cpp" / "src" / "grpc" +_proto_dir = Path("cuopt-grpc/protos") +_proto_dir.mkdir(exist_ok=True) +for _proto in ( + "cuopt_remote_service.proto", + "cuopt_remote.proto", + "codegen/generated/cuopt_remote_data.proto", + "routing/cuopt_routing.proto", + "routing/cuopt_routing_solution.proto", +): + shutil.copy(_grpc_src / _proto, _proto_dir) +shutil.make_archive("cuopt-grpc/cuopt-protos", "zip", _proto_dir) + with open("cuopt_spec.yaml", "w") as f: yaml.dump( get_openapi( diff --git a/docs/cuopt/source/cuopt-grpc/api.rst b/docs/cuopt/source/cuopt-grpc/api.rst index 82954b37ef..73a5773bad 100644 --- a/docs/cuopt/source/cuopt-grpc/api.rst +++ b/docs/cuopt/source/cuopt-grpc/api.rst @@ -6,12 +6,29 @@ gRPC API (Reference) ====================== -The **CuOptRemoteService** gRPC API is defined in Protocol Buffers under the ``cuopt.remote`` package. Source files in the repository: +The **CuOptRemoteService** gRPC API is defined in Protocol Buffers under the ``cuopt.remote`` package: -* ``cpp/src/grpc/cuopt_remote_service.proto`` — service and job/chunk/log RPCs -* ``cpp/src/grpc/cuopt_remote.proto`` — LP/MIP problem, settings, and result messages -* ``cpp/src/grpc/routing/cuopt_routing.proto`` — VRP request messages -* ``cpp/src/grpc/routing/cuopt_routing_solution.proto`` — VRP result messages +* :download:`cuopt_remote_service.proto ` — service and job/chunk/log RPCs +* :download:`cuopt_remote.proto ` — LP/MIP problem, settings, and result messages +* :download:`cuopt_remote_data.proto ` — problem and result fields, including the array field ids used by chunked transfer. Generated from ``cpp/src/grpc/codegen/field_registry.yaml`` and committed to the repository. +* :download:`cuopt_routing.proto ` — VRP request messages +* :download:`cuopt_routing_solution.proto ` — VRP result messages + +Download all five as :download:`cuopt-protos.zip `. They import each other by file name, so keep them in one directory. + +The ``libcuopt-client`` wheel and conda package install the same five files: + +* pip: ``/libcuopt_client/share/cuopt/proto`` +* conda: ``$CONDA_PREFIX/share/cuopt/proto`` + +Generate stubs for your language with that directory as the include path, for example for Python: + +.. code-block:: bash + + python -m grpc_tools.protoc -I "$PROTO_DIR" --python_out=. --grpc_python_out=. \ + "$PROTO_DIR"/*.proto + +The same files are in the repository under ``cpp/src/grpc/``, ``cpp/src/grpc/routing/`` and ``cpp/src/grpc/codegen/generated/``. The chunked-transfer wire format is described in `GRPC_INTERFACE.md `_. Most users do **not** call these RPCs directly: From f3afe31a783e9007802354da16bfaa7bfb492889 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 15:47:15 -0700 Subject: [PATCH 42/80] Update convex-c-api.rst --- docs/cuopt/source/cuopt-c/convex/convex-c-api.rst | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst b/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst index 38bcf360ad..cc097008ad 100644 --- a/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst +++ b/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst @@ -204,7 +204,6 @@ These constants are used as parameter names in the :c:func:`cuOptSetParameter`, .. doxygendefine:: CUOPT_TIME_LIMIT .. doxygendefine:: CUOPT_PDLP_SOLVER_MODE .. doxygendefine:: CUOPT_METHOD -.. doxygendefine:: CUOPT_CONCURRENT_NNZ_CUTOFF .. doxygendefine:: CUOPT_PRIMAL_SIMPLEX_PRICING .. doxygendefine:: CUOPT_DUAL_SIMPLEX_INITIAL_PERTURBATION .. doxygendefine:: CUOPT_DUAL_SIMPLEX_REMOVE_PERTURBATION From 7343723e58dc23d96672ea2d2d7c610327b253ce Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 15:50:44 -0700 Subject: [PATCH 43/80] Update convex-settings.rst --- docs/cuopt/source/convex-settings.rst | 9 --------- 1 file changed, 9 deletions(-) diff --git a/docs/cuopt/source/convex-settings.rst b/docs/cuopt/source/convex-settings.rst index f9a3455b59..826d46bc93 100644 --- a/docs/cuopt/source/convex-settings.rst +++ b/docs/cuopt/source/convex-settings.rst @@ -175,15 +175,6 @@ The duality gap is computed as follows:: .. note:: The default value is ``1e-4``. -Concurrent NNZ Cutoff -^^^^^^^^^^^^^^^^^^^^^ - -``CUOPT_CONCURRENT_NNZ_CUTOFF`` controls when concurrent mode stops running barrier and dual simplex. When the number of -nonzeros in the (presolved) constraint matrix is at or above this value, barrier and dual simplex are skipped and -only PDLP runs. Set it to ``-1`` to disable the cutoff, so that barrier and dual simplex run regardless of problem size. -The same setting is also accepted for the root relaxation in MIP. - -.. note:: The default value is ``50000000``. PDLP Solver Mode ^^^^^^^^^^^^^^^^ From ab1e03462135d39cafbe29938bdfb6ecd7dcf61c Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 15:54:33 -0700 Subject: [PATCH 44/80] Update convex-settings.rst --- docs/cuopt/source/convex-settings.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/cuopt/source/convex-settings.rst b/docs/cuopt/source/convex-settings.rst index 826d46bc93..27c4771646 100644 --- a/docs/cuopt/source/convex-settings.rst +++ b/docs/cuopt/source/convex-settings.rst @@ -472,7 +472,7 @@ Barrier Adaptive Regularization Barrier Presolve Bound Free Variables ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -``CUOPT_BARRIER_PRESOLVE_BOUND_FREE_VARIABLES`` controls whether the barrier presolve bounds free variables. +``CUOPT_BARRIER_PRESOLVE_BOUND_FREE_VARIABLES`` controls whether the barrier presolve attempts to put bounds on free variables using the linear constraints. * ``-1``: Automatic (default) - cuOpt decides based on the problem * ``0``: Disable bounding of free variables @@ -484,7 +484,7 @@ Barrier Primal and Dual Regularization ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``CUOPT_BARRIER_PRIMAL_REGULARIZATION`` and ``CUOPT_BARRIER_DUAL_REGULARIZATION`` set the initial primal and dual regularization -applied to the barrier method's augmented system. They apply to the first factorization only. If adaptive regularization is enabled +applied to the augmented system. They apply to the first factorization only. If adaptive regularization is enabled (see ``CUOPT_BARRIER_ADAPTIVE_REGULARIZATION``), it can still scale the regularization up or down in later iterations. * ``-1``: Automatic (default) - cuOpt uses its built-in heuristic @@ -499,7 +499,7 @@ Sequence Solve ``CUOPT_SEQUENCE_SOLVE`` controls whether cuOpt caches the ordering and symbolic factorization so that a sequence of related barrier solves can reuse it. When enabled, and the first solve with the barrier method finishes with an optimal solution, cuOpt stores information about the factorization. In subsequent solves, the linear objective and the right-hand side of the linear equality constraints may be changed with :meth:`~cuopt.linear_programming.data_model.DataModel.update_linear_objective` or -:meth:`~cuopt.linear_programming.data_model.DataModel.update_rhs` without requiring new ordering or symbolic factorization. +:meth:`~cuopt.linear_programming.data_model.DataModel.update_rhs` without recomputing the ordering or the symbolic factorization. * ``true``: Cache the ordering and symbolic factorization for later solves * ``false``: Do not cache (default) From b33908798eab1d03730264838db1431d2895bff9 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 16:38:12 -0700 Subject: [PATCH 45/80] Update convex-c-api.rst --- docs/cuopt/source/cuopt-c/convex/convex-c-api.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst b/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst index cc097008ad..0b7ba54143 100644 --- a/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst +++ b/docs/cuopt/source/cuopt-c/convex/convex-c-api.rst @@ -175,7 +175,7 @@ The following functions are used to set and get parameters. You can find more de Solver Log Callback ------------------- -A callback can be registered on the solver settings to receive each standard solver log line, for example to display or forward solver output in a GUI. +A callback can be registered to receive each solver log line, for example to display or forward solver output in a GUI. The callback is invoked in addition to any console or file logging enabled with ``CUOPT_LOG_TO_CONSOLE`` and ``CUOPT_LOG_FILE``. Pass ``NULL`` to remove a registered callback. From 4e7efed77f54b0d698cceff40e17d9474f3941a7 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 16:42:36 -0700 Subject: [PATCH 46/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 73fd0a4245..027c83d8c9 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -45,7 +45,7 @@ - Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex - Free memory after LP presolve: the transpose matrix and PSLP reduced problem are now freed - LPs with poor scaling are now attempted without presolve, even if PSLP declares infeasibility -- LP presolve now uses PSLP version 0.1.1 +- LP presolve now uses PSLP version 0.1.0 - Barrier now preforms Ruiz scaling and builds the augmented system on the GPU - Barrier now scales QCQP/SOCP constraint by variable bounds before Ruiz equilibriation - Barrier now performs iterative refinement on GPU when using the normal equations @@ -108,7 +108,6 @@ - Disable clique table generation in MIP when running in determinism mode. - XXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explaination - Upgrade CMake to include the PSLP objective offset fix (#1695) -- Fix vendored PSLP writing a stray infeasible-message printf to native stdout (#1836) - Multi-GPU PDLP: add the missing header to the solve log (#2017) - Fix asynchronous clique table handoff (#1834) - Fix concurrent clique table publication (#1775) From 63e140d0c0c83c5cf7f65c88d27b687cb81c8887 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 17:16:10 -0700 Subject: [PATCH 47/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 36 +++++++++++++++++------------------- 1 file changed, 17 insertions(+), 19 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 027c83d8c9..ec6113d8cb 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -45,7 +45,7 @@ - Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex - Free memory after LP presolve: the transpose matrix and PSLP reduced problem are now freed - LPs with poor scaling are now attempted without presolve, even if PSLP declares infeasibility -- LP presolve now uses PSLP version 0.1.0 +- LP presolve now uses PSLP version 0.1.0; this version includes many improvements and bug fixes - Barrier now preforms Ruiz scaling and builds the augmented system on the GPU - Barrier now scales QCQP/SOCP constraint by variable bounds before Ruiz equilibriation - Barrier now performs iterative refinement on GPU when using the normal equations @@ -80,10 +80,14 @@ ### Bug Fixes (26.10) +- Fix a issue in the C API when accessing solutions on infeasible problems - Fix issue in MPS writer on problems with no linear constraints - Fix ranged constraint conversion and MPS writing/reading round trips - Fix an issue in PDLP where reduced costs where not returned for the default PDLP preset (Stable3) +- Fix a missing header in log in Multi-GPU PDLP +- Fix a issue in Multi-GPU where the solver stopped silently when asking for more GPUs than available - Fix a barrier crash when concurrent LP solving returned from cuDSS before its asynchronous work finished +- Fix a segfault in concurrent LP if dual simplex or barrier finished without setting a solution - Fix several issues in barrier related to the cuDSS threading layer - Fix a bug on QCQP/SOCP problems with ranged rows - Fix nondeterminism in barrier when `--cudss-deterministic=1` @@ -92,33 +96,27 @@ - Fix an issue in QCQP/SOCP where the dual residual of the final solution was incorrect - Fix an issue in dual simplex logs where bound flips were not accounted for in objective - Fix an issue in MIP where flow cover cut generation was accidentally O(n^2) -- Fix issue in dual simplex inside MIP where cut off incorrectly used the perturbed objective +- Fix an issue in dual simplex inside MIP where cut off incorrectly used the perturbed objective - Fix an issue in dual simplex where dual variables and dual feasibility was not recomputed after basis repair - Fix several issues in MIP where the time limit was not respected - Fix MIP presolve incorrectly fixing continuous variables using integer-variable tolerance -- Fix false optimality declaration in MIP determinsitic mode -- Fix issue in MIP where a large amount of time could elapse between logs -- Fix issue in MIP when converting knapsack constraints to rational coefficients could remove integer solutions -- Fix issue in MIP where termination was delayed during root cut passes +- Fix false optimality declaration in MIP deterministic mode +- Fix an issue in MIP where a large amount of time could elapse between logs +- Fix an issue in MIP when converting knapsack constraints to rational coefficients could remove integer solutions +- Fix an issue in MIP where termination was delayed during root cut passes - Fix an issue in MIP where the sub-MIP was not correctly stopped when the main solve finished -- B&B now properly stops after `concurrent_halt` is set to true. -- Fix incorrect global dual bounds during the cut passes -- Guard against nullptr dereference when checking concurrent solver status -- Escape parser error messages -- Disable clique table generation in MIP when running in determinism mode. +- Fix an issue in MIP feasibility jump where weights were uninitialized when adding an objective cut +- Fix an issue in MIP GF2 presolve where rank-deficient problems were incorrectly classified as infeasible +- Fix an issue in MIP GF2 presolve where some one-sided rows were treated as equalities +- Fix a memory overflow in MIP when there were many feasible solutions +- Disable clique table generation in MIP when running in determinism mode - XXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explaination -- Upgrade CMake to include the PSLP objective offset fix (#1695) -- Multi-GPU PDLP: add the missing header to the solve log (#2017) +- B&B now properly stops after `concurrent_halt` is set to true (#1760) +- Escape parser error messages - Fix asynchronous clique table handoff (#1834) - Fix concurrent clique table publication (#1775) -- Limit the population solution queue to 50 solutions to prevent memory overflow (#2002) - Add extra termination checks in LP, and bound sub-MIP time by the global time limit (#2054) -- Fix `cuopt_cli` printing no log when `--num-gpu` exceeds the available GPUs (#1935) -- GF2 presolve rank-deficiency fix (#1660) -- Fix uninitialized FJ constraint weights when the problem grows (#1698) - Use configured feasibility tolerance in Papilo (#1688) -- Fix GF2 incorrectly treating some one-sided rows as equality (#1707) -- Report absent solution values instead of returning success (#1734) - Avoid uncapturable RMM copies inside routing CUDA graph captures (#1753) - Keep host sources alive for async route-view copies (#1759) - Use an absolute instead of relative tolerance for mod-2 row integrality (#1770) From cb1563a6454b11376f5a3169d4b52b2f193396b9 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 17:44:49 -0700 Subject: [PATCH 48/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 43 ++++++++++++++++++++----------------------- 1 file changed, 20 insertions(+), 23 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index ec6113d8cb..03f90caf0e 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -83,6 +83,7 @@ - Fix a issue in the C API when accessing solutions on infeasible problems - Fix issue in MPS writer on problems with no linear constraints - Fix ranged constraint conversion and MPS writing/reading round trips +- Fix an issue in LP/MIP presolve where the user specified feasibility tolerance was not propagate to Papilo - Fix an issue in PDLP where reduced costs where not returned for the default PDLP preset (Stable3) - Fix a missing header in log in Multi-GPU PDLP - Fix a issue in Multi-GPU where the solver stopped silently when asking for more GPUs than available @@ -90,6 +91,7 @@ - Fix a segfault in concurrent LP if dual simplex or barrier finished without setting a solution - Fix several issues in barrier related to the cuDSS threading layer - Fix a bug on QCQP/SOCP problems with ranged rows +- Fix corrupted memory in QCQP/SOCP presolve when removing empty columns - Fix nondeterminism in barrier when `--cudss-deterministic=1` - Fix an issue with QPs where duality gap was not included in the termination criteria - Fix QCQP dual solution overrun and constraint count reporting @@ -105,33 +107,28 @@ - Fix an issue in MIP when converting knapsack constraints to rational coefficients could remove integer solutions - Fix an issue in MIP where termination was delayed during root cut passes - Fix an issue in MIP where the sub-MIP was not correctly stopped when the main solve finished +- Fix an issue in MIP with halting cut passes - Fix an issue in MIP feasibility jump where weights were uninitialized when adding an objective cut - Fix an issue in MIP GF2 presolve where rank-deficient problems were incorrectly classified as infeasible - Fix an issue in MIP GF2 presolve where some one-sided rows were treated as equalities +- Fix an issue in MIP presolve when performing single-lock-dual-aggregation +- Fix an issue with tolerances in MIP mod-2 cuts +- Fix a race condition in the asynchronous clique table generator and clique cuts +- Fix an unsynchronized read/write of the MIP clique table - Fix a memory overflow in MIP when there were many feasible solutions -- Disable clique table generation in MIP when running in determinism mode -- XXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explaination -- B&B now properly stops after `concurrent_halt` is set to true (#1760) -- Escape parser error messages -- Fix asynchronous clique table handoff (#1834) -- Fix concurrent clique table publication (#1775) -- Add extra termination checks in LP, and bound sub-MIP time by the global time limit (#2054) -- Use configured feasibility tolerance in Papilo (#1688) -- Avoid uncapturable RMM copies inside routing CUDA graph captures (#1753) -- Keep host sources alive for async route-view copies (#1759) -- Use an absolute instead of relative tolerance for mod-2 row integrality (#1770) -- Add missing TransactionGuard in the SLDA presolver (#1815) -- Routing: avoid division by zero when vehicle capacity is zero (#1853) -- Routing: Guard diagonal element lookup against negative offsets in top_k (#1855) -- Refresh the cached linear column count after removing empty… (#1923) -- Handle cuda graph errors (#1945) -- gRPC: transmit PDLP warmstart data and apply it on the server (#2041) -- grpc server align ping handling with client behavior (#1937) -- gRPC: transfer MIP initial solutions to the server (#1868) -- grpc server add a check for successful cuda init in worker (#2063) -- Forward routing gRPC settings and map node name strings to ints (#1837) -- Python gRPC client: run the wait loop in Python so other threads are not blocked by the GIL (#1857) -- Exec the binary from the `cuopt_cli` and `cuopt_grpc_server` console-script wrappers so signals reach it (#1723) +- Disable clique table generation in MIP when running in deterministic mode +- Fix an issue in routing: keep host sources alive for async route-view copies +- Fix an issue in routing: avoid division by zero when vehicle capacity is zero +- Fix an issue in routing: guard diagonal element lookup against negative offsets in top_k +- Fix an issue in routing: uncapturable RMM copies inside CUDA graph captures +- Fix an issue in routing: handle CUDA graph errors +- Fix an issue in gRPC: transmit PDLP warmstart data and apply it on the server +- Fix an issue in gRPC: server align ping handling with client behavior +- Fix an issue in gRPC: transfer MIP initial solutions to the server +- Fix an issue in gRPC: add a check for successful cuda init in worker +- Fix an issue in gRPC: forward routing settings and map node name strings to ints +- Fix an issue in gRPC: exec the binary from the `cuopt_cli` and `cuopt_grpc_server` console-script wrappers so signals reach it +- Fix an issue in the Python gRPC client: run the wait loop in Python so other threads are not blocked by the GIL (#1857) ### Deprecations (26.10) From 9682aee1d528da2a86f508658d663421c0cd381d Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 17:52:32 -0700 Subject: [PATCH 49/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 03f90caf0e..7e53d854f4 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -26,14 +26,11 @@ ### Breaking Changes (26.10) -- Don't install libcuopt into conda env by default (#1650) -- Presolve work and iteration limits (#1656) -- Migrate stream APIs from rmm::cuda_stream_view to cuda::stream_ref (#1828) -- `libcuopt` is split into client, mathopt and routing components, with separate wheels and conda packages (beta); `libcuopt` is now a thin metapackage (#1622, #1926, #1928, #1929, #1967, #2013) -- Rename CUOPT_DISTRIBUTED_PDLP_PARTITIONER to CUOPT_MULTIGPU_PDLP_PARTITIONER; remove CUOPT_USE_DISTRIBUTED_PDLP (#1984) -- standardize interface and remote solves on solver_settings_t (#2034) -- Reject unsupported mixed-integer quadratic problems before solving (#2032) -- The container image now runs the proxy and gRPC servers by default; the legacy HTTP server is an optional start command (#2007) +- The container image now runs the proxy and gRPC servers by default; the legacy HTTP server is an optional start command +- `libcuopt` is split into client, mathopt and routing components, with separate wheels and conda packages; `libcuopt` is now a thin metapackage +- The CUOPT_DISTRIBUTED_PDLP_PARTITIONER setting introduced in 26.08 is now CUOPT_MULTIGPU_PDLP_PARTITIONER +- The CUOPT_USE_DISTRIBUTED_PDLP setting introduced in 26.08 has been removed; use method and num_gpus instead +- When building from source the build.sh script no longer installs libcuopt into conda env by default ### Improvements (26.10) @@ -136,9 +133,9 @@ ### Documentation (26.10) -- Show mamba commands directly instead of a conda-then-swap note (#1827) -- Document the VRP gRPC client (RoutingClient) (#1838) -- Update NVIDIA Brev documentation links (#1925) +- Show mamba commands directly instead of a conda-then-swap note +- Document the VRP gRPC client (RoutingClient) +- Update NVIDIA Brev documentation links ### New Contributors (26.10) From 73f1fcf64de97d79b4ba24ec92d3b7b8c9a9ab2a Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 18:04:55 -0700 Subject: [PATCH 50/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 7e53d854f4..9ef2176849 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -12,12 +12,13 @@ - New primal heuristic for MIPs with arc-flow formulations - New techniques for exploiting degeneracy in MIP - New primal simplex method for LPs -- Add Implied Indicator and Capacity Lifting presolve reductions for fixed-charge MIP models (#1983) +- New implied indicator and capacity lifting presolve strengthening for fixed-charge MIP models - The C API now exposes solver statistics as scalar solution attributes - New `cuOptSetLogCallback` for capturing solver logs in C API - New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server -- VRP is now supported over gRPC, with a compiled C++/Cython client -- Routing: add distance breaks (#1196) +- VRP is now supported over gRPC with a compiled C++/Cython client +- New per-vehicle distance-based breaks in routing: enabling charging, refueling, or rest stops to be constrained by cumulative travel distance rather than time +- XXXXXXXXXXXXX items below this line needed to be edited - gRPC: add cancel and status APIs to the routing client (#1886) - Solver parameters are now sent over gRPC as a string map. A new client requires a new server. An older client still works with a new server. (#2010, #2022, #2057) - gRPC: add a GPU health check before each job and after idle (#2031) From c34c9619af1ce398353b7eef608b56a76550a3e5 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 18:09:06 -0700 Subject: [PATCH 51/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 9ef2176849..0b6a2ba905 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -36,8 +36,8 @@ ### Improvements (26.10) - Significant performance improvements in MIP heuristics -- QP/QCQP problems solve 1.33X faster (geomean over QPLIB and Hans Mittelmann test set) -- SOCP problems now solve to a tighter default tolerance of 1e-6 (previously 1e-4) without a performance regression +- QP/QCQP solve 1.33X faster (geomean over QPLIB and Hans Mittelmann test set) +- SOCP now use a tighter default tolerance of 1e-6 on the duality gap without a performance regression - Dual simplex is 1.4X faster (geomean over MIPLIB root relaxations) - PDLP now fuses the Halpern update into the projection kernels to improve performance - Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex @@ -84,7 +84,7 @@ - Fix an issue in LP/MIP presolve where the user specified feasibility tolerance was not propagate to Papilo - Fix an issue in PDLP where reduced costs where not returned for the default PDLP preset (Stable3) - Fix a missing header in log in Multi-GPU PDLP -- Fix a issue in Multi-GPU where the solver stopped silently when asking for more GPUs than available +- Fix an issue in Multi-GPU where the solver stopped silently when asking for more GPUs than available - Fix a barrier crash when concurrent LP solving returned from cuDSS before its asynchronous work finished - Fix a segfault in concurrent LP if dual simplex or barrier finished without setting a solution - Fix several issues in barrier related to the cuDSS threading layer From fcaa0ad7c91f18194326667288d2db95afc11d50 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 18:13:05 -0700 Subject: [PATCH 52/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 0b6a2ba905..1cb3a31bdf 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -35,10 +35,10 @@ ### Improvements (26.10) -- Significant performance improvements in MIP heuristics -- QP/QCQP solve 1.33X faster (geomean over QPLIB and Hans Mittelmann test set) -- SOCP now use a tighter default tolerance of 1e-6 on the duality gap without a performance regression +- MIP heuristics improved by 3.2x on primal integral metric (geomean over the feasible MIPLIB2017 instances) +- QP/QCQP solve 1.3X faster (geomean over QPLIB and Hans Mittelmann test set) - Dual simplex is 1.4X faster (geomean over MIPLIB root relaxations) +- SOCP now use a tighter default tolerance on the duality gap without a performance regression - PDLP now fuses the Halpern update into the projection kernels to improve performance - Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex - Free memory after LP presolve: the transpose matrix and PSLP reduced problem are now freed From 08c6af3a167e2b94721dcb8a527ff956494a29e1 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 19:32:29 -0700 Subject: [PATCH 53/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 1cb3a31bdf..df6f11a279 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -41,9 +41,13 @@ - SOCP now use a tighter default tolerance on the duality gap without a performance regression - PDLP now fuses the Halpern update into the projection kernels to improve performance - Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex -- Free memory after LP presolve: the transpose matrix and PSLP reduced problem are now freed +- LP presolve now uses less memory by freeing the transpose matrix and PSLP reduced problem - LPs with poor scaling are now attempted without presolve, even if PSLP declares infeasibility - LP presolve now uses PSLP version 0.1.0; this version includes many improvements and bug fixes +- Dual simplex now perturbs the cost more aggressively and uses primal simplex to remove perturbations +- Dual simplex now attempts to remove perturbations when variables leave the basis +- Dual simplex now tries several initial points on problems with dual degenerate bounded variables +- Dual simplex's bound flipping ratio test is now approximately O(n) and combines Harris ratio test with bound flips - Barrier now preforms Ruiz scaling and builds the augmented system on the GPU - Barrier now scales QCQP/SOCP constraint by variable bounds before Ruiz equilibriation - Barrier now performs iterative refinement on GPU when using the normal equations @@ -60,6 +64,7 @@ - MIP performance improvement in duplicate cut detection - MIP reduced cost strengthening now stores bound implications based on incumbent objective value - MIP now includes a new Mod-2 cut separator for zero-half cuts +- Routing now uses use cost instead of distance terminology when the objective does not represent a physical distance - XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explanations - Block Bounded Value Elimination presolving pass for binary problems (#1683) - Add a binary 2opt move fed from the probing cache into CPUFJ (#1738) @@ -67,9 +72,7 @@ - Exhaustive coefficient reduction for binary rows (#1686) - Improve time-to-first-incumbent, unify solution callback publication, scaffolding changes (#1880) - Add a fast-path to the CPUFJ engine for binary problems with integer activities (#1881) -- Standardize cost terminology (#1299) - Modular CPUFJ engine, simple portfolio (#1950) -- Improve primal and dual simplex performance, and make primal simplex a first-class method for LPs (#1889) - Structure-aware starts and repairs for CPUFJ (#1951) - Portfolio diversification, more starts, move batching (#1953) - RoutingClient: match Client's (host, port, tls=...) signature (#1840) @@ -126,7 +129,7 @@ - Fix an issue in gRPC: add a check for successful cuda init in worker - Fix an issue in gRPC: forward routing settings and map node name strings to ints - Fix an issue in gRPC: exec the binary from the `cuopt_cli` and `cuopt_grpc_server` console-script wrappers so signals reach it -- Fix an issue in the Python gRPC client: run the wait loop in Python so other threads are not blocked by the GIL (#1857) +- Fix an issue in the Python gRPC client: run the wait loop in Python so other threads are not blocked by the GIL ### Deprecations (26.10) From 3f23e40526701df8b9310b76f204bdb8b0109a25 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 19:41:50 -0700 Subject: [PATCH 54/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 1 - 1 file changed, 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index df6f11a279..aabdf47540 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -75,7 +75,6 @@ - Modular CPUFJ engine, simple portfolio (#1950) - Structure-aware starts and repairs for CPUFJ (#1951) - Portfolio diversification, more starts, move batching (#1953) -- RoutingClient: match Client's (host, port, tls=...) signature (#1840) - Replace process-wide seed_generator with per-worker RNGs in MIP heuristics (#1809) - Give each solver its own seed instead of a process-wide counter (#1717) From 3a19a163d0ee85ca3548d0c45ed7429bdeea58e2 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Tue, 13 Oct 2026 19:48:01 -0700 Subject: [PATCH 55/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index aabdf47540..b54e3ceb13 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -64,6 +64,7 @@ - MIP performance improvement in duplicate cut detection - MIP reduced cost strengthening now stores bound implications based on incumbent objective value - MIP now includes a new Mod-2 cut separator for zero-half cuts +- MIP random number generators are now per-worker instead of process wide; eliminating a source of nondeterminism - Routing now uses use cost instead of distance terminology when the objective does not represent a physical distance - XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explanations - Block Bounded Value Elimination presolving pass for binary problems (#1683) @@ -75,8 +76,7 @@ - Modular CPUFJ engine, simple portfolio (#1950) - Structure-aware starts and repairs for CPUFJ (#1951) - Portfolio diversification, more starts, move batching (#1953) -- Replace process-wide seed_generator with per-worker RNGs in MIP heuristics (#1809) -- Give each solver its own seed instead of a process-wide counter (#1717) + ### Bug Fixes (26.10) @@ -117,6 +117,7 @@ - Fix an unsynchronized read/write of the MIP clique table - Fix a memory overflow in MIP when there were many feasible solutions - Disable clique table generation in MIP when running in deterministic mode +- Fix an issue where the random number seed could change if multiple solves were performed within the same process - Fix an issue in routing: keep host sources alive for async route-view copies - Fix an issue in routing: avoid division by zero when vehicle capacity is zero - Fix an issue in routing: guard diagonal element lookup against negative offsets in top_k From e4126f62067e0527ca4f8edce4c7dbf9395328f9 Mon Sep 17 00:00:00 2001 From: yuwenchen95 Date: Wed, 14 Oct 2026 02:00:18 -0700 Subject: [PATCH 56/80] Update QP/QCQP/SOCP/barrier items in 26.10 release notes Correct problem classes (QP vs QCQP/SOCP), describe symptoms for the presolve memory corruption, dual residual and QCQP dual buffer overflow fixes, reword initial point and empty column entries, fix typos, and group QP/SOCP speedups with the barrier items. Co-Authored-By: Claude Sonnet 5.5 Signed-off-by: yuwenchen95 --- RELEASE-NOTES.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index b54e3ceb13..6a4a905a2b 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -36,9 +36,7 @@ ### Improvements (26.10) - MIP heuristics improved by 3.2x on primal integral metric (geomean over the feasible MIPLIB2017 instances) -- QP/QCQP solve 1.3X faster (geomean over QPLIB and Hans Mittelmann test set) - Dual simplex is 1.4X faster (geomean over MIPLIB root relaxations) -- SOCP now use a tighter default tolerance on the duality gap without a performance regression - PDLP now fuses the Halpern update into the projection kernels to improve performance - Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex - LP presolve now uses less memory by freeing the transpose matrix and PSLP reduced problem @@ -48,18 +46,20 @@ - Dual simplex now attempts to remove perturbations when variables leave the basis - Dual simplex now tries several initial points on problems with dual degenerate bounded variables - Dual simplex's bound flipping ratio test is now approximately O(n) and combines Harris ratio test with bound flips -- Barrier now preforms Ruiz scaling and builds the augmented system on the GPU -- Barrier now scales QCQP/SOCP constraint by variable bounds before Ruiz equilibriation +- QP/QCQP solve 1.3X faster (geomean over QPLIB and Hans Mittelmann test set) +- SOCP now use a tighter default tolerance on the duality gap without a performance regression +- Barrier now performs Ruiz scaling and builds the augmented system on the GPU +- Barrier now scales QCQP/SOCP constraints by variable bounds before Ruiz equilibration - Barrier now performs iterative refinement on GPU when using the normal equations - Barrier now prints the cumulative setup time before the solve -- Barrier now removes empty columns from separable QPs +- QP presolve now removes empty columns - Barrier termination check now has reduced GPU/host synchronization overhead - Barrier now has parameters to control adaptive regularization - Barrier now has parameters for tuning primal and dual regularization - Barrier now has a parameter to control bounding free variables -- Barrier now has improved performance when computing the initial point +- Barrier now has more initial point options - QCQP to SOCP conversion performance is improved and memory required is reduced -- QCQP/SOCP presolve now eliminates free variables with zero cost +- QP/SOCP presolve now eliminates free variables with zero cost - MIP root relaxation now honors the LP method selected - MIP performance improvement in duplicate cut detection - MIP reduced cost strengthening now stores bound implications based on incumbent objective value @@ -91,11 +91,11 @@ - Fix a segfault in concurrent LP if dual simplex or barrier finished without setting a solution - Fix several issues in barrier related to the cuDSS threading layer - Fix a bug on QCQP/SOCP problems with ranged rows -- Fix corrupted memory in QCQP/SOCP presolve when removing empty columns +- Fix an issue in QP/SOCP presolve where removing empty columns could corrupt memory, causing heap corruption errors or `cudaErrorLaunchFailure` - Fix nondeterminism in barrier when `--cudss-deterministic=1` - Fix an issue with QPs where duality gap was not included in the termination criteria -- Fix QCQP dual solution overrun and constraint count reporting -- Fix an issue in QCQP/SOCP where the dual residual of the final solution was incorrect +- Fix a buffer overflow when getting the dual solution or reduced costs of a QCQP; dual solutions are not yet available for QCQP, so these requests now return an error +- Fix an issue in QP and SOCP where a large dual residual was reported for the final solution, even at an optimal solution - Fix an issue in dual simplex logs where bound flips were not accounted for in objective - Fix an issue in MIP where flow cover cut generation was accidentally O(n^2) - Fix an issue in dual simplex inside MIP where cut off incorrectly used the perturbed objective From 5094d9780acf445f44be87c1c1d4fbd55769b50e Mon Sep 17 00:00:00 2001 From: Bulle Mostovoi Date: Wed, 14 Oct 2026 11:29:06 +0200 Subject: [PATCH 57/80] update RELEASE-NOTES.md --- RELEASE-NOTES.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 6a4a905a2b..e9f7577329 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -85,8 +85,10 @@ - Fix ranged constraint conversion and MPS writing/reading round trips - Fix an issue in LP/MIP presolve where the user specified feasibility tolerance was not propagate to Papilo - Fix an issue in PDLP where reduced costs where not returned for the default PDLP preset (Stable3) -- Fix a missing header in log in Multi-GPU PDLP -- Fix an issue in Multi-GPU where the solver stopped silently when asking for more GPUs than available +- Fix a missing header in log in mPDLP +- Fix an issue in mPDLP where the solver stopped silently when asking for more GPUs than available +- Fix an issue on the C API where performing a mPDLP solve on a problem built from row types and RHS was not supported +- Fix an issue on mPDLP where project_initial_primal was ignored - Fix a barrier crash when concurrent LP solving returned from cuDSS before its asynchronous work finished - Fix a segfault in concurrent LP if dual simplex or barrier finished without setting a solution - Fix several issues in barrier related to the cuDSS threading layer From 5382b284cefbbe4405c7e5d126485bd4f8c3be45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Akif=20=C3=87=C3=96RD=C3=9CK?= Date: Wed, 14 Oct 2026 15:17:49 +0200 Subject: [PATCH 58/80] Revise RELEASE-NOTES.md for recent updates Updated release notes to reflect new features, improvements, and bug fixes. --- RELEASE-NOTES.md | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index e9f7577329..cb525569c8 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -10,9 +10,15 @@ - Add RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics to MIP - MIP solver now runs diving and recursive RINS heuristics during the cut passes - New primal heuristic for MIPs with arc-flow formulations +- Support for portfolio of CPUFJ heuristics with diversification +- New compound move types in CPUFJ: 2-opt, probing implication chain, clique exchange, set-partitioning row exchange and compound repair +- New LNS heuristic for MIP that uses ruin-and-repair logic - New techniques for exploiting degeneracy in MIP - New primal simplex method for LPs - New implied indicator and capacity lifting presolve strengthening for fixed-charge MIP models +- New MIP presolve: Block Bounded Value Elimination for binary problems +- New MIP presolve: dual aggregation for binary variables with a single lock +- New MIP presolve: exhaustive coefficient reduction for binary rows - The C API now exposes solver statistics as scalar solution attributes - New `cuOptSetLogCallback` for capturing solver logs in C API - New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server @@ -42,6 +48,8 @@ - LP presolve now uses less memory by freeing the transpose matrix and PSLP reduced problem - LPs with poor scaling are now attempted without presolve, even if PSLP declares infeasibility - LP presolve now uses PSLP version 0.1.0; this version includes many improvements and bug fixes +- MIP presolve now uses iteration and work limits rather than time limits +- Set solution callbacks now use presolve and postsolve - Dual simplex now perturbs the cost more aggressively and uses primal simplex to remove perturbations - Dual simplex now attempts to remove perturbations when variables leave the basis - Dual simplex now tries several initial points on problems with dual degenerate bounded variables @@ -65,18 +73,11 @@ - MIP reduced cost strengthening now stores bound implications based on incumbent objective value - MIP now includes a new Mod-2 cut separator for zero-half cuts - MIP random number generators are now per-worker instead of process wide; eliminating a source of nondeterminism -- Routing now uses use cost instead of distance terminology when the objective does not represent a physical distance -- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX PR titles below this line still need to be converted to human readable explanations -- Block Bounded Value Elimination presolving pass for binary problems (#1683) -- Add a binary 2opt move fed from the probing cache into CPUFJ (#1738) -- Add a dual aggregation presolver for binary variables with a single lock (#901) -- Exhaustive coefficient reduction for binary rows (#1686) -- Improve time-to-first-incumbent, unify solution callback publication, scaffolding changes (#1880) -- Add a fast-path to the CPUFJ engine for binary problems with integer activities (#1881) -- Modular CPUFJ engine, simple portfolio (#1950) -- Structure-aware starts and repairs for CPUFJ (#1951) -- Portfolio diversification, more starts, move batching (#1953) - +- Routing now uses cost instead of distance terminology when the objective does not represent a physical distance +- Solution callback publication is now unified across solver components +- Time to first solution is improved by reducing overheads +- CPUFJ now has a fast-path heuristic for binary problems with integer activities +- CPUFJ now has structure-aware starts and repairs ### Bug Fixes (26.10) From b9028d44ccbf62b60079348efa105b4939f169d7 Mon Sep 17 00:00:00 2001 From: Ramakrishna Prabhu Date: Wed, 14 Oct 2026 09:28:03 -0500 Subject: [PATCH 59/80] docs: use LP format in the multi-GPU PDLP CLI example Co-Authored-By: Claude Sonnet 5.5 Signed-off-by: Ramakrishna Prabhu --- .../lp/examples/multi_gpu_pdlp_example.sh | 43 +++++++------------ 1 file changed, 15 insertions(+), 28 deletions(-) diff --git a/docs/cuopt/source/cuopt-cli/examples/lp/examples/multi_gpu_pdlp_example.sh b/docs/cuopt/source/cuopt-cli/examples/lp/examples/multi_gpu_pdlp_example.sh index f12a44b877..197545f453 100755 --- a/docs/cuopt/source/cuopt-cli/examples/lp/examples/multi_gpu_pdlp_example.sh +++ b/docs/cuopt/source/cuopt-cli/examples/lp/examples/multi_gpu_pdlp_example.sh @@ -13,44 +13,31 @@ # Requirements: # - cuopt_cli installed and available in PATH # - At least 2 visible GPUs -# - An LP in MPS format (multi-GPU PDLP only supports LPs, and helps most on -# large problems; the tiny model below only illustrates the options) +# - An LP in LP or MPS format (multi-GPU PDLP only supports LPs, and helps +# most on large problems; the tiny model below only illustrates the options) # -# Create a sample MPS file -echo "* optimize -* cost = -0.2 * VAR1 + 0.1 * VAR2 -* subject to -* 3 * VAR1 + 4 * VAR2 <= 5.4 -* 2.7 * VAR1 + 10.1 * VAR2 <= 4.9 -NAME SAMPLE -ROWS - N COST - L ROW1 - L ROW2 -COLUMNS - VAR1 COST -0.2 - VAR1 ROW1 3.0 - VAR1 ROW2 2.7 - VAR2 COST 0.1 - VAR2 ROW1 4.0 - VAR2 ROW2 10.1 -RHS - RHS1 ROW1 5.4 - RHS1 ROW2 4.9 -ENDATA" > sample.mps +# Create a sample LP file +cat > sample.lp << 'LP' +Minimize + -0.2 VAR1 + 0.1 VAR2 +Subject To + ROW1: 3 VAR1 + 4 VAR2 <= 5.4 + ROW2: 2.7 VAR1 + 10.1 VAR2 <= 4.9 +End +LP echo "=== Example 1: Use all visible GPUs ===" -cuopt_cli --method 1 --num-gpus -1 sample.mps +cuopt_cli --method 1 --num-gpus -1 sample.lp echo "" echo "=== Example 2: Use exactly 2 GPUs ===" -cuopt_cli --method 1 --num-gpus 2 sample.mps +cuopt_cli --method 1 --num-gpus 2 sample.lp echo "" echo "=== Example 3: Choose how the problem is split across GPUs ===" # 0 = auto (default), 1 = KaMinPar, 2 = round robin -cuopt_cli --method 1 --num-gpus -1 --multigpu-pdlp-partitioner 2 sample.mps +cuopt_cli --method 1 --num-gpus -1 --multigpu-pdlp-partitioner 2 sample.lp # Clean up -rm -f sample.mps +rm -f sample.lp From c6ca136f00e7547723ccbd1c35f0cb80dc555df1 Mon Sep 17 00:00:00 2001 From: Trevor McKay Date: Wed, 14 Oct 2026 11:22:35 -0400 Subject: [PATCH 60/80] adjust release notes according to guidelines --- RELEASE-NOTES.md | 43 +++++++++++++++++++------------------------ 1 file changed, 19 insertions(+), 24 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index cb525569c8..2680f5af39 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -21,20 +21,18 @@ - New MIP presolve: exhaustive coefficient reduction for binary rows - The C API now exposes solver statistics as scalar solution attributes - New `cuOptSetLogCallback` for capturing solver logs in C API -- New HTTP proxy server on top of gRPC, replacing the deprecated legacy HTTP server -- VRP is now supported over gRPC with a compiled C++/Cython client -- New per-vehicle distance-based breaks in routing: enabling charging, refueling, or rest stops to be constrained by cumulative travel distance rather than time -- XXXXXXXXXXXXX items below this line needed to be edited -- gRPC: add cancel and status APIs to the routing client (#1886) -- Solver parameters are now sent over gRPC as a string map. A new client requires a new server. An older client still works with a new server. (#2010, #2022, #2057) -- gRPC: add a GPU health check before each job and after idle (#2031) -- gRPC: add the standard gRPC health-probe endpoints (#2047) +- Routing now supports per-vehicle distance-based breaks, so charging, refueling, or rest stops can be constrained by cumulative travel distance rather than time +- The gRPC server now solves routing problems (VRP, TSP, and PDP). The Python client can submit a routing job, check its status, cancel it, and retrieve the solution +- The gRPC server now accepts a MIP starting solution and uses it to begin the search +- Remote gRPC solves now send solver settings as named parameters, so newly added settings are included automatically. A 26.10 client requires a 26.10 server. A client from an earlier release still works with a 26.10 server +- The gRPC server now checks GPU health before each job and while idle. If the GPU is unusable, or CUDA does not initialize, the server shuts down so Kubernetes or another orchestrator can restart it. The server also provides the standard gRPC health check used for readiness and liveness probes +- A new HTTP proxy server provides the cuOpt HTTP interface and forwards LP, MILP, QP, and routing requests to the gRPC server. The 26.10 container starts this proxy together with the gRPC server by default ### Breaking Changes (26.10) - The container image now runs the proxy and gRPC servers by default; the legacy HTTP server is an optional start command -- `libcuopt` is split into client, mathopt and routing components, with separate wheels and conda packages; `libcuopt` is now a thin metapackage +- `libcuopt` is split into client, mathopt and routing components, with separate wheels and conda packages; `libcuopt` is now a thin metapackage - The CUOPT_DISTRIBUTED_PDLP_PARTITIONER setting introduced in 26.08 is now CUOPT_MULTIGPU_PDLP_PARTITIONER - The CUOPT_USE_DISTRIBUTED_PDLP setting introduced in 26.08 has been removed; use method and num_gpus instead - When building from source the build.sh script no longer installs libcuopt into conda env by default @@ -53,7 +51,7 @@ - Dual simplex now perturbs the cost more aggressively and uses primal simplex to remove perturbations - Dual simplex now attempts to remove perturbations when variables leave the basis - Dual simplex now tries several initial points on problems with dual degenerate bounded variables -- Dual simplex's bound flipping ratio test is now approximately O(n) and combines Harris ratio test with bound flips +- Dual simplex's bound flipping ratio test is now approximately O(n) and combines Harris ratio test with bound flips - QP/QCQP solve 1.3X faster (geomean over QPLIB and Hans Mittelmann test set) - SOCP now use a tighter default tolerance on the duality gap without a performance regression - Barrier now performs Ruiz scaling and builds the augmented system on the GPU @@ -73,7 +71,7 @@ - MIP reduced cost strengthening now stores bound implications based on incumbent objective value - MIP now includes a new Mod-2 cut separator for zero-half cuts - MIP random number generators are now per-worker instead of process wide; eliminating a source of nondeterminism -- Routing now uses cost instead of distance terminology when the objective does not represent a physical distance +- Routing now uses cost instead of distance terminology when the objective does not represent a physical distance - Solution callback publication is now unified across solver components - Time to first solution is improved by reducing overheads - CPUFJ now has a fast-path heuristic for binary problems with integer activities @@ -87,7 +85,7 @@ - Fix an issue in LP/MIP presolve where the user specified feasibility tolerance was not propagate to Papilo - Fix an issue in PDLP where reduced costs where not returned for the default PDLP preset (Stable3) - Fix a missing header in log in mPDLP -- Fix an issue in mPDLP where the solver stopped silently when asking for more GPUs than available +- Fix an issue in mPDLP where the solver stopped silently when asking for more GPUs than available - Fix an issue on the C API where performing a mPDLP solve on a problem built from row types and RHS was not supported - Fix an issue on mPDLP where project_initial_primal was ignored - Fix a barrier crash when concurrent LP solving returned from cuDSS before its asynchronous work finished @@ -121,18 +119,15 @@ - Fix a memory overflow in MIP when there were many feasible solutions - Disable clique table generation in MIP when running in deterministic mode - Fix an issue where the random number seed could change if multiple solves were performed within the same process -- Fix an issue in routing: keep host sources alive for async route-view copies -- Fix an issue in routing: avoid division by zero when vehicle capacity is zero -- Fix an issue in routing: guard diagonal element lookup against negative offsets in top_k +- Fix an issue in routing: keep host sources alive for async route-view copies +- Fix an issue in routing: avoid division by zero when vehicle capacity is zero +- Fix an issue in routing: guard diagonal element lookup against negative offsets in top_k - Fix an issue in routing: uncapturable RMM copies inside CUDA graph captures - Fix an issue in routing: handle CUDA graph errors -- Fix an issue in gRPC: transmit PDLP warmstart data and apply it on the server -- Fix an issue in gRPC: server align ping handling with client behavior -- Fix an issue in gRPC: transfer MIP initial solutions to the server -- Fix an issue in gRPC: add a check for successful cuda init in worker -- Fix an issue in gRPC: forward routing settings and map node name strings to ints -- Fix an issue in gRPC: exec the binary from the `cuopt_cli` and `cuopt_grpc_server` console-script wrappers so signals reach it -- Fix an issue in the Python gRPC client: run the wait loop in Python so other threads are not blocked by the GIL +- Fix an issue where a PDLP warm start was ignored on a remote gRPC solve +- Fix an issue where a gRPC connection could be closed during a long or idle solve because the server did not accept the client's keepalive pings +- Fix an issue where stopping `cuopt_cli` or `cuopt_grpc_server` did not stop the solver process +- Fix an issue in the Python gRPC client where waiting for a remote solve blocked other Python threads ### Deprecations (26.10) @@ -141,8 +136,8 @@ ### Documentation (26.10) - Show mamba commands directly instead of a conda-then-swap note -- Document the VRP gRPC client (RoutingClient) -- Update NVIDIA Brev documentation links +- Document the VRP gRPC client (RoutingClient) +- Update NVIDIA Brev documentation links ### New Contributors (26.10) From 74d7af29ab3b15621322241b7e1fbca168d9a87c Mon Sep 17 00:00:00 2001 From: Trevor McKay Date: Wed, 14 Oct 2026 11:33:43 -0400 Subject: [PATCH 61/80] release notes tweak wording about grpc parameter protocol --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 2680f5af39..52fdeaca5d 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -24,7 +24,7 @@ - Routing now supports per-vehicle distance-based breaks, so charging, refueling, or rest stops can be constrained by cumulative travel distance rather than time - The gRPC server now solves routing problems (VRP, TSP, and PDP). The Python client can submit a routing job, check its status, cancel it, and retrieve the solution - The gRPC server now accepts a MIP starting solution and uses it to begin the search -- Remote gRPC solves now send solver settings as named parameters, so newly added settings are included automatically. A 26.10 client requires a 26.10 server. A client from an earlier release still works with a 26.10 server +- The gRPC protocol now carries solver settings as named parameters, and the 26.10 client sends them that way. New solver settings are included without adding a separate field for each one. A 26.10 client requires a 26.10 server. A client from an earlier release still works with a 26.10 server - The gRPC server now checks GPU health before each job and while idle. If the GPU is unusable, or CUDA does not initialize, the server shuts down so Kubernetes or another orchestrator can restart it. The server also provides the standard gRPC health check used for readiness and liveness probes - A new HTTP proxy server provides the cuOpt HTTP interface and forwards LP, MILP, QP, and routing requests to the gRPC server. The 26.10 container starts this proxy together with the gRPC server by default From 235163abb265df2805e192376d3637f1b472beb6 Mon Sep 17 00:00:00 2001 From: Trevor McKay Date: Wed, 14 Oct 2026 11:47:36 -0400 Subject: [PATCH 62/80] release notes shorten grpc descriptions --- RELEASE-NOTES.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 52fdeaca5d..ee461df40c 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -22,11 +22,11 @@ - The C API now exposes solver statistics as scalar solution attributes - New `cuOptSetLogCallback` for capturing solver logs in C API - Routing now supports per-vehicle distance-based breaks, so charging, refueling, or rest stops can be constrained by cumulative travel distance rather than time -- The gRPC server now solves routing problems (VRP, TSP, and PDP). The Python client can submit a routing job, check its status, cancel it, and retrieve the solution +- The gRPC server now solves routing problems (VRP, TSP, and PDP). A Python gRPC routing client is included with cuOpt - The gRPC server now accepts a MIP starting solution and uses it to begin the search -- The gRPC protocol now carries solver settings as named parameters, and the 26.10 client sends them that way. New solver settings are included without adding a separate field for each one. A 26.10 client requires a 26.10 server. A client from an earlier release still works with a 26.10 server -- The gRPC server now checks GPU health before each job and while idle. If the GPU is unusable, or CUDA does not initialize, the server shuts down so Kubernetes or another orchestrator can restart it. The server also provides the standard gRPC health check used for readiness and liveness probes -- A new HTTP proxy server provides the cuOpt HTTP interface and forwards LP, MILP, QP, and routing requests to the gRPC server. The 26.10 container starts this proxy together with the gRPC server by default +- The gRPC client now sends solver settings as a map of named parameters. A 26.10 client requires a 26.10 server +- The gRPC server checks GPU health and shuts down if the GPU is unusable. It also provides the standard gRPC readiness and liveness probes +- A new HTTP proxy forwards requests to the gRPC server. The 26.10 container starts the proxy and gRPC server by default (legacy HTTP server is deprecated) ### Breaking Changes (26.10) From dcea17d76e206851c96cb759d00c9a0f9922730f Mon Sep 17 00:00:00 2001 From: Trevor McKay Date: Wed, 14 Oct 2026 12:22:41 -0400 Subject: [PATCH 63/80] release notes target string map feature at custom clients --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index ee461df40c..084d947e8e 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -24,7 +24,7 @@ - Routing now supports per-vehicle distance-based breaks, so charging, refueling, or rest stops can be constrained by cumulative travel distance rather than time - The gRPC server now solves routing problems (VRP, TSP, and PDP). A Python gRPC routing client is included with cuOpt - The gRPC server now accepts a MIP starting solution and uses it to begin the search -- The gRPC client now sends solver settings as a map of named parameters. A 26.10 client requires a 26.10 server +- Custom gRPC clients should now send solver settings through the `parameters` string map; individual setting fields are deprecated - The gRPC server checks GPU health and shuts down if the GPU is unusable. It also provides the standard gRPC readiness and liveness probes - A new HTTP proxy forwards requests to the gRPC server. The 26.10 container starts the proxy and gRPC server by default (legacy HTTP server is deprecated) From 8da9c581f224df71a5eac8916fbd486fa82edbe5 Mon Sep 17 00:00:00 2001 From: Trevor McKay Date: Wed, 14 Oct 2026 12:27:14 -0400 Subject: [PATCH 64/80] release notes add note about vrp limits for container defaults --- RELEASE-NOTES.md | 1 + 1 file changed, 1 insertion(+) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 084d947e8e..996cf6e029 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -32,6 +32,7 @@ ### Breaking Changes (26.10) - The container image now runs the proxy and gRPC servers by default; the legacy HTTP server is an optional start command +- The proxy and gRPC servers (container defaults) support routing problems of up to 5500 locations with a travel time matrix, or 8000 without one. For larger problems use the legacy HTTP server. - `libcuopt` is split into client, mathopt and routing components, with separate wheels and conda packages; `libcuopt` is now a thin metapackage - The CUOPT_DISTRIBUTED_PDLP_PARTITIONER setting introduced in 26.08 is now CUOPT_MULTIGPU_PDLP_PARTITIONER - The CUOPT_USE_DISTRIBUTED_PDLP setting introduced in 26.08 has been removed; use method and num_gpus instead From 47679c4e343f5a05f04e4bd201c029abbee863ea Mon Sep 17 00:00:00 2001 From: "Nicolas L. Guidotti" Date: Wed, 14 Oct 2026 18:53:52 +0200 Subject: [PATCH 65/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 996cf6e029..69663e1690 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -8,7 +8,7 @@ - New Curtis-Reid scaling for PDLP - Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides - Add RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics to MIP -- MIP solver now runs diving and recursive RINS heuristics during the cut passes +- MIP solver now runs diving and recursive sub-MIP heuristics during the cut passes - New primal heuristic for MIPs with arc-flow formulations - Support for portfolio of CPUFJ heuristics with diversification - New compound move types in CPUFJ: 2-opt, probing implication chain, clique exchange, set-partitioning row exchange and compound repair From 446e05a4718106e488af5a36933fe807007270c1 Mon Sep 17 00:00:00 2001 From: "Nicolas L. Guidotti" Date: Wed, 14 Oct 2026 18:54:26 +0200 Subject: [PATCH 66/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 69663e1690..0f1273905d 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -7,7 +7,7 @@ - New Java interface for LP, QP, QCQP, SOCP and MIP - New Curtis-Reid scaling for PDLP - Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides -- Add RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics to MIP +- New RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics for MIP - MIP solver now runs diving and recursive sub-MIP heuristics during the cut passes - New primal heuristic for MIPs with arc-flow formulations - Support for portfolio of CPUFJ heuristics with diversification From f78eacc422dd43b0e27b5468f31ddccf43c3e67d Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:22:40 -0700 Subject: [PATCH 67/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 0f1273905d..49b4009464 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -10,7 +10,7 @@ - New RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics for MIP - MIP solver now runs diving and recursive sub-MIP heuristics during the cut passes - New primal heuristic for MIPs with arc-flow formulations -- Support for portfolio of CPUFJ heuristics with diversification +- MIP heuristics include new portfolio of CPUFJ heuristics with diversification - New compound move types in CPUFJ: 2-opt, probing implication chain, clique exchange, set-partitioning row exchange and compound repair - New LNS heuristic for MIP that uses ruin-and-repair logic - New techniques for exploiting degeneracy in MIP @@ -23,16 +23,14 @@ - New `cuOptSetLogCallback` for capturing solver logs in C API - Routing now supports per-vehicle distance-based breaks, so charging, refueling, or rest stops can be constrained by cumulative travel distance rather than time - The gRPC server now solves routing problems (VRP, TSP, and PDP). A Python gRPC routing client is included with cuOpt -- The gRPC server now accepts a MIP starting solution and uses it to begin the search -- Custom gRPC clients should now send solver settings through the `parameters` string map; individual setting fields are deprecated -- The gRPC server checks GPU health and shuts down if the GPU is unusable. It also provides the standard gRPC readiness and liveness probes -- A new HTTP proxy forwards requests to the gRPC server. The 26.10 container starts the proxy and gRPC server by default (legacy HTTP server is deprecated) +- A new HTTP proxy forwards requests to the gRPC server. The 26.10 container starts the proxy and gRPC server by default ### Breaking Changes (26.10) - The container image now runs the proxy and gRPC servers by default; the legacy HTTP server is an optional start command - The proxy and gRPC servers (container defaults) support routing problems of up to 5500 locations with a travel time matrix, or 8000 without one. For larger problems use the legacy HTTP server. +- Custom gRPC clients should now send solver settings through the `parameters` string map; individual setting fields are deprecated - `libcuopt` is split into client, mathopt and routing components, with separate wheels and conda packages; `libcuopt` is now a thin metapackage - The CUOPT_DISTRIBUTED_PDLP_PARTITIONER setting introduced in 26.08 is now CUOPT_MULTIGPU_PDLP_PARTITIONER - The CUOPT_USE_DISTRIBUTED_PDLP setting introduced in 26.08 has been removed; use method and num_gpus instead @@ -72,11 +70,13 @@ - MIP reduced cost strengthening now stores bound implications based on incumbent objective value - MIP now includes a new Mod-2 cut separator for zero-half cuts - MIP random number generators are now per-worker instead of process wide; eliminating a source of nondeterminism -- Routing now uses cost instead of distance terminology when the objective does not represent a physical distance +- MIP time to first solution is improved by reducing overheads +- MIP CPUFJ now has a fast-path heuristic for binary problems with integer activities +- MIP CPUFJ now has structure-aware starts and repairs - Solution callback publication is now unified across solver components -- Time to first solution is improved by reducing overheads -- CPUFJ now has a fast-path heuristic for binary problems with integer activities -- CPUFJ now has structure-aware starts and repairs +- Routing now uses cost instead of distance terminology when the objective does not represent a physical distance +- The gRPC server now accepts a MIP starting solution +- The gRPC server now checks GPU health and shuts down if the GPU is unusable. It also provides the standard gRPC readiness and liveness probes ### Bug Fixes (26.10) From d67e42a6871f29e1d0b6fe1432553124878e4b32 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:31:43 -0700 Subject: [PATCH 68/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 49b4009464..28038d2854 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -5,8 +5,6 @@ ### New Features (26.10) - New Java interface for LP, QP, QCQP, SOCP and MIP -- New Curtis-Reid scaling for PDLP -- Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides - New RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics for MIP - MIP solver now runs diving and recursive sub-MIP heuristics during the cut passes - New primal heuristic for MIPs with arc-flow formulations @@ -14,11 +12,13 @@ - New compound move types in CPUFJ: 2-opt, probing implication chain, clique exchange, set-partitioning row exchange and compound repair - New LNS heuristic for MIP that uses ruin-and-repair logic - New techniques for exploiting degeneracy in MIP -- New primal simplex method for LPs - New implied indicator and capacity lifting presolve strengthening for fixed-charge MIP models - New MIP presolve: Block Bounded Value Elimination for binary problems - New MIP presolve: dual aggregation for binary variables with a single lock - New MIP presolve: exhaustive coefficient reduction for binary rows +- New Curtis-Reid scaling for PDLP +- New primal simplex method for LPs +- Support for reusing the barrier ordering and symbolic factorization when solving a sequence of problems with different linear objectives and right-hand sides - The C API now exposes solver statistics as scalar solution attributes - New `cuOptSetLogCallback` for capturing solver logs in C API - Routing now supports per-vehicle distance-based breaks, so charging, refueling, or rest stops can be constrained by cumulative travel distance rather than time From 555b9290537e3e4bf50813fd52d980a0bc6e75e4 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:34:39 -0700 Subject: [PATCH 69/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 1 + 1 file changed, 1 insertion(+) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 28038d2854..346bc79e43 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -40,6 +40,7 @@ - MIP heuristics improved by 3.2x on primal integral metric (geomean over the feasible MIPLIB2017 instances) - Dual simplex is 1.4X faster (geomean over MIPLIB root relaxations) +- PDLP now use column reduction on large problems (~2x faster in geomean over LPFeas addendum instances) - PDLP now fuses the Halpern update into the projection kernels to improve performance - Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex - LP presolve now uses less memory by freeing the transpose matrix and PSLP reduced problem From d4ae755c14dae9cfd5ff352aee5cf3ac5deaf98f Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:39:32 -0700 Subject: [PATCH 70/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 346bc79e43..2a9bef0948 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -39,8 +39,9 @@ ### Improvements (26.10) - MIP heuristics improved by 3.2x on primal integral metric (geomean over the feasible MIPLIB2017 instances) +- QP/QCQP solve 1.3X faster (geomean over QPLIB and Hans Mittelmann test set) +- PDLP now uses column reduction on large problems (~2x faster in geomean over LPFeas addendum instances) - Dual simplex is 1.4X faster (geomean over MIPLIB root relaxations) -- PDLP now use column reduction on large problems (~2x faster in geomean over LPFeas addendum instances) - PDLP now fuses the Halpern update into the projection kernels to improve performance - Concurrent LP now uses a threshold on the number of nonzeros to decide whether to launch barrier and dual simplex - LP presolve now uses less memory by freeing the transpose matrix and PSLP reduced problem @@ -52,7 +53,7 @@ - Dual simplex now attempts to remove perturbations when variables leave the basis - Dual simplex now tries several initial points on problems with dual degenerate bounded variables - Dual simplex's bound flipping ratio test is now approximately O(n) and combines Harris ratio test with bound flips -- QP/QCQP solve 1.3X faster (geomean over QPLIB and Hans Mittelmann test set) + - SOCP now use a tighter default tolerance on the duality gap without a performance regression - Barrier now performs Ruiz scaling and builds the augmented system on the GPU - Barrier now scales QCQP/SOCP constraints by variable bounds before Ruiz equilibration From c51645132c58a1c8e5b50a096157540f46e587ba Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:40:04 -0700 Subject: [PATCH 71/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 1 - 1 file changed, 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 2a9bef0948..23595ecaf9 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -53,7 +53,6 @@ - Dual simplex now attempts to remove perturbations when variables leave the basis - Dual simplex now tries several initial points on problems with dual degenerate bounded variables - Dual simplex's bound flipping ratio test is now approximately O(n) and combines Harris ratio test with bound flips - - SOCP now use a tighter default tolerance on the duality gap without a performance regression - Barrier now performs Ruiz scaling and builds the augmented system on the GPU - Barrier now scales QCQP/SOCP constraints by variable bounds before Ruiz equilibration From 054386c5bed53607e227e079cc127166facdb7e6 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:44:41 -0700 Subject: [PATCH 72/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 23595ecaf9..68e70e19a2 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -54,21 +54,21 @@ - Dual simplex now tries several initial points on problems with dual degenerate bounded variables - Dual simplex's bound flipping ratio test is now approximately O(n) and combines Harris ratio test with bound flips - SOCP now use a tighter default tolerance on the duality gap without a performance regression +- QCQP to SOCP conversion performance is improved and memory required is reduced +- QP/SOCP presolve now eliminates free variables with zero cost +- QP presolve now removes empty columns - Barrier now performs Ruiz scaling and builds the augmented system on the GPU - Barrier now scales QCQP/SOCP constraints by variable bounds before Ruiz equilibration - Barrier now performs iterative refinement on GPU when using the normal equations - Barrier now prints the cumulative setup time before the solve -- QP presolve now removes empty columns - Barrier termination check now has reduced GPU/host synchronization overhead - Barrier now has parameters to control adaptive regularization - Barrier now has parameters for tuning primal and dual regularization - Barrier now has a parameter to control bounding free variables - Barrier now has more initial point options -- QCQP to SOCP conversion performance is improved and memory required is reduced -- QP/SOCP presolve now eliminates free variables with zero cost - MIP root relaxation now honors the LP method selected - MIP performance improvement in duplicate cut detection -- MIP reduced cost strengthening now stores bound implications based on incumbent objective value +- MIP reduced cost strengthening now stores lurking bounds based on incumbent objective value - MIP now includes a new Mod-2 cut separator for zero-half cuts - MIP random number generators are now per-worker instead of process wide; eliminating a source of nondeterminism - MIP time to first solution is improved by reducing overheads @@ -86,10 +86,10 @@ - Fix ranged constraint conversion and MPS writing/reading round trips - Fix an issue in LP/MIP presolve where the user specified feasibility tolerance was not propagate to Papilo - Fix an issue in PDLP where reduced costs where not returned for the default PDLP preset (Stable3) -- Fix a missing header in log in mPDLP -- Fix an issue in mPDLP where the solver stopped silently when asking for more GPUs than available -- Fix an issue on the C API where performing a mPDLP solve on a problem built from row types and RHS was not supported -- Fix an issue on mPDLP where project_initial_primal was ignored +- Fix a missing header in log in multi-GPU PDLP +- Fix an issue in multi-GPU PDLP where the solver stopped silently when asking for more GPUs than available +- Fix an issue on the C API where performing a multi-GPU PDLP solve on a problem built from row types and RHS was not supported +- Fix an issue on multi-GPU PDLP where project_initial_primal was ignored - Fix a barrier crash when concurrent LP solving returned from cuDSS before its asynchronous work finished - Fix a segfault in concurrent LP if dual simplex or barrier finished without setting a solution - Fix several issues in barrier related to the cuDSS threading layer @@ -97,7 +97,7 @@ - Fix an issue in QP/SOCP presolve where removing empty columns could corrupt memory, causing heap corruption errors or `cudaErrorLaunchFailure` - Fix nondeterminism in barrier when `--cudss-deterministic=1` - Fix an issue with QPs where duality gap was not included in the termination criteria -- Fix a buffer overflow when getting the dual solution or reduced costs of a QCQP; dual solutions are not yet available for QCQP, so these requests now return an error +- Fix a buffer overflow when getting the dual solution or reduced costs of a QCQP; these requests now return an error - Fix an issue in QP and SOCP where a large dual residual was reported for the final solution, even at an optimal solution - Fix an issue in dual simplex logs where bound flips were not accounted for in objective - Fix an issue in MIP where flow cover cut generation was accidentally O(n^2) From f1a8b51504e303cea1e2e75a930786087855c471 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:45:31 -0700 Subject: [PATCH 73/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 68e70e19a2..174ede2f13 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -8,7 +8,7 @@ - New RENS (Relaxation Enforced Neighboorhood Search) and mutation heuristics for MIP - MIP solver now runs diving and recursive sub-MIP heuristics during the cut passes - New primal heuristic for MIPs with arc-flow formulations -- MIP heuristics include new portfolio of CPUFJ heuristics with diversification +- MIP solver includes new portfolio of CPUFJ heuristics with diversification - New compound move types in CPUFJ: 2-opt, probing implication chain, clique exchange, set-partitioning row exchange and compound repair - New LNS heuristic for MIP that uses ruin-and-repair logic - New techniques for exploiting degeneracy in MIP From 906c387fb3e7a37e9adca6df5ec4b76c5339fb56 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:46:35 -0700 Subject: [PATCH 74/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 174ede2f13..2796f036bb 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -9,7 +9,7 @@ - MIP solver now runs diving and recursive sub-MIP heuristics during the cut passes - New primal heuristic for MIPs with arc-flow formulations - MIP solver includes new portfolio of CPUFJ heuristics with diversification -- New compound move types in CPUFJ: 2-opt, probing implication chain, clique exchange, set-partitioning row exchange and compound repair +- New compound move types in MIP CPUFJ: 2-opt, probing implication chain, clique exchange, set-partitioning row exchange and compound repair - New LNS heuristic for MIP that uses ruin-and-repair logic - New techniques for exploiting degeneracy in MIP - New implied indicator and capacity lifting presolve strengthening for fixed-charge MIP models From b250f91352d18c8ba8ab952c34ecf06eccd24e98 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:48:02 -0700 Subject: [PATCH 75/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 2796f036bb..6d24268eea 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -30,7 +30,6 @@ - The container image now runs the proxy and gRPC servers by default; the legacy HTTP server is an optional start command - The proxy and gRPC servers (container defaults) support routing problems of up to 5500 locations with a travel time matrix, or 8000 without one. For larger problems use the legacy HTTP server. -- Custom gRPC clients should now send solver settings through the `parameters` string map; individual setting fields are deprecated - `libcuopt` is split into client, mathopt and routing components, with separate wheels and conda packages; `libcuopt` is now a thin metapackage - The CUOPT_DISTRIBUTED_PDLP_PARTITIONER setting introduced in 26.08 is now CUOPT_MULTIGPU_PDLP_PARTITIONER - The CUOPT_USE_DISTRIBUTED_PDLP setting introduced in 26.08 has been removed; use method and num_gpus instead @@ -134,6 +133,7 @@ ### Deprecations (26.10) - The container's default server is now the HTTP proxy plus `cuopt_grpc_server`, in place of the legacy HTTP server. The legacy HTTP server is still shipped in 26.10 and will be removed in 26.12. See "Starting the Container" on the Legacy HTTP Server page in the 26.10 user guide for the legacy container command and for `CUOPT_SERVER_TYPE=legacy` in Kubernetes. That page links to the 26.08 guide. Differences are in "Deprecated Interfaces Not Provided by the Proxy Server" in the 26.10 user guide. +- Custom gRPC clients should now send solver settings through the `parameters` string map; individual setting fields are deprecated ### Documentation (26.10) From 80428f3feb7108d93e1f57819a3d153c05df0de5 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:50:11 -0700 Subject: [PATCH 76/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 6d24268eea..75a4e8e81b 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -83,7 +83,7 @@ - Fix a issue in the C API when accessing solutions on infeasible problems - Fix issue in MPS writer on problems with no linear constraints - Fix ranged constraint conversion and MPS writing/reading round trips -- Fix an issue in LP/MIP presolve where the user specified feasibility tolerance was not propagate to Papilo +- Fix an issue in LP/MIP presolve where the user specified feasibility tolerance was not propagated to Papilo - Fix an issue in PDLP where reduced costs where not returned for the default PDLP preset (Stable3) - Fix a missing header in log in multi-GPU PDLP - Fix an issue in multi-GPU PDLP where the solver stopped silently when asking for more GPUs than available From ad179dfc29b7810b956e1b3f685c36c92c7be37b Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:50:44 -0700 Subject: [PATCH 77/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 75a4e8e81b..7dd72f178c 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -85,7 +85,7 @@ - Fix ranged constraint conversion and MPS writing/reading round trips - Fix an issue in LP/MIP presolve where the user specified feasibility tolerance was not propagated to Papilo - Fix an issue in PDLP where reduced costs where not returned for the default PDLP preset (Stable3) -- Fix a missing header in log in multi-GPU PDLP +- Fix a missing header in log for multi-GPU PDLP - Fix an issue in multi-GPU PDLP where the solver stopped silently when asking for more GPUs than available - Fix an issue on the C API where performing a multi-GPU PDLP solve on a problem built from row types and RHS was not supported - Fix an issue on multi-GPU PDLP where project_initial_primal was ignored From df434239e7aa5bdee165aead001428fde5aa3aee Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:52:16 -0700 Subject: [PATCH 78/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 7dd72f178c..831b48a0cc 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -99,10 +99,10 @@ - Fix a buffer overflow when getting the dual solution or reduced costs of a QCQP; these requests now return an error - Fix an issue in QP and SOCP where a large dual residual was reported for the final solution, even at an optimal solution - Fix an issue in dual simplex logs where bound flips were not accounted for in objective -- Fix an issue in MIP where flow cover cut generation was accidentally O(n^2) - Fix an issue in dual simplex inside MIP where cut off incorrectly used the perturbed objective - Fix an issue in dual simplex where dual variables and dual feasibility was not recomputed after basis repair - Fix several issues in MIP where the time limit was not respected +- Fix an issue in MIP where flow cover cut generation was accidentally O(n^2) - Fix MIP presolve incorrectly fixing continuous variables using integer-variable tolerance - Fix false optimality declaration in MIP deterministic mode - Fix an issue in MIP where a large amount of time could elapse between logs From 994795f5fc1608a8099785dc3043c5ac9fa80b90 Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:53:58 -0700 Subject: [PATCH 79/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 831b48a0cc..8a63d11b2c 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -101,10 +101,10 @@ - Fix an issue in dual simplex logs where bound flips were not accounted for in objective - Fix an issue in dual simplex inside MIP where cut off incorrectly used the perturbed objective - Fix an issue in dual simplex where dual variables and dual feasibility was not recomputed after basis repair -- Fix several issues in MIP where the time limit was not respected -- Fix an issue in MIP where flow cover cut generation was accidentally O(n^2) - Fix MIP presolve incorrectly fixing continuous variables using integer-variable tolerance - Fix false optimality declaration in MIP deterministic mode +- Fix several issues in MIP where the time limit was not respected +- Fix an issue in MIP where flow cover cut generation was accidentally O(n^2) - Fix an issue in MIP where a large amount of time could elapse between logs - Fix an issue in MIP when converting knapsack constraints to rational coefficients could remove integer solutions - Fix an issue in MIP where termination was delayed during root cut passes From ff863e5fb025ab4bb63c07a031bfce6a1d3ed94d Mon Sep 17 00:00:00 2001 From: Chris Maes Date: Wed, 14 Oct 2026 10:54:36 -0700 Subject: [PATCH 80/80] Update RELEASE-NOTES.md --- RELEASE-NOTES.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 8a63d11b2c..0dd202dfa3 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -80,8 +80,8 @@ ### Bug Fixes (26.10) -- Fix a issue in the C API when accessing solutions on infeasible problems -- Fix issue in MPS writer on problems with no linear constraints +- Fix an issue in the C API when accessing solutions on infeasible problems +- Fix an issue in MPS writer on problems with no linear constraints - Fix ranged constraint conversion and MPS writing/reading round trips - Fix an issue in LP/MIP presolve where the user specified feasibility tolerance was not propagated to Papilo - Fix an issue in PDLP where reduced costs where not returned for the default PDLP preset (Stable3)