CHAP: A Hybrid GPU-CPU Heuristic for MIP

Abstract: We present CHAP (Coordinating Heuristics Across Platforms) a GPU-CPU-hybrid primal heuristic framework for mixed-integer programming. CHAP adopts a portfolio approach where it coordinates a set of primal heuristics, including Local Search, Fix-and-Propagate, and Feasibility Pump, via a shared solution pool. The solution pool is used to exchange feasible incumbent solutions, LP solutions, along with promising infeasible solution candidates, enabling a more comprehensive exploration of the solution space. On the GPU side, we implement a native tabu search featuring a novel best-shift algorithm built on sort, scan, and reduce primitives, along with specialized kernel designs. We additionally leverage cuPDLPx as an approximate LP solver. On the CPU side, we employ various Fix-and-Propagate strategies, guided by information from the solution pool, complemented by a CPU-based tabu search and a Feasibility Pump. All components operate collaboratively, iteratively repairing and improving candidate solutions maintained in the pool. We evaluate our framework on the 50-instances benchmark from the 2026 Land-Doig MIP Competition under competition constraints, including a five-minute time limit. In these settings, CHAP finds solutions to 47 instances outperforming both Gurobi (44) in default mode and NVIDIA cuOpt (43) in heuristics-only mode. The results demonstrate that coordinated cross-platform portfolios offer a promising direction for the integration of GPU heuristics into modern high-performance MIP solvers. The code will be made available on GitHub.

• The paper introduces CHAP, a hybrid GPU-CPU MIP heuristic that coordinates tabu search, feasibility pumping, FPR, and approximate LP solving through a shared solution pool.
• GPU components improve solution quality substantially: adding streamed GPU LP iterates and GPU tabu search reduces the shifted geometric mean gap from 19.57% to 8.84% and primal integral from 72.59 to 41.84.
• CHAP finds solutions for 47 of 50 competition instances within five minutes, exceeding default Gurobi’s 44 and cuOpt’s 43, although Gurobi achieves more unique best objectives.

CHAP (Coordinating Heuristics Across Platforms) is a GPU-CPU hybrid primal heuristic framework for mixed-integer linear programming (MIP), developed for the 2026 Land–Doig MIP Competition. Rather than porting a single heuristic to the GPU, CHAP coordinates a portfolio of complementary heuristics across both platforms through a shared solution pool, exchanging feasible incumbents, LP iterates, and deliberately retained infeasible candidate solutions. Under competition constraints (five-minute time limit, 50-instance benchmark), CHAP finds solutions to 47 of 50 instances, exceeding Gurobi 12.0.1 in default mode (44) and NVIDIA cuOpt 25.10 in heuristics-only mode (43) (2605.05086).

Architecture and coordination

The framework consists of CPU workers — Fix-and-Propagate-and-Repair (FPR), Feasibility Pump, and a CPU tabu search — and GPU workers — cuPDLPx as an approximate first-order LP solver and a native GPU tabu search running multiple independent instances in parallel. All components communicate exclusively through a shared solution pool divided into three stores: feasible solutions, partial (infeasible) solutions, and LP solutions. The pool acts as a lightweight coordination mechanism; locking between CPU threads is minimal and restricted primarily to solution writes. Each heuristic accesses the current best-known objective value as a cutoff constraint.

A key design decision is streaming LP iterates: since PDHG convergence can be slow and primal heuristics do not require highly accurate LP solutions (consistent with prior findings on FOM-guided fixing), cuPDLPx snapshots primal solutions, duals, and reduced costs at $10^2$, $10^3$, $10^4$, and $10^5$ PDHG iteration checkpoints, warm-starting each phase from the previous iterate. This gives all heuristics essentially zero-latency access to relaxation information, following Rothberg's concurrent-processing idea from crossover (Rothberg, 28 Oct 2025).

The repair pipeline closes the loop between components: tabu search deposits promising infeasible solutions into the pool; FeasPump performs limited iterations to move them toward feasibility; and FPR fixes variables according to LP-based strategies and repairs residual infeasibility. This diversifies FPR beyond pure LP-guided fixing and helps escape local minima.

GPU tabu search and the best-shift algorithm

The GPU tabu search builds on LocalMIP's scoring function [Lin et al., AIJ 2025], where constraint weights reward or penalize transitions between satisfied and violated states, with half-weight adjustments for changes in violation magnitude. The central algorithmic contribution is a best-shift move computation: rather than evaluating sampled subsets of breakpoints as in LocalMIP or cuOpt's prior work (Çördük et al., 23 Oct 2025), CHAP computes the globally optimal shift value for every variable at every iteration. This exploits the fact that the score function is piecewise constant in the shifted variable, with steps only at constraint-implied breakpoints (floored or ceilinged for integer variables), bounds, and the incumbent value.

The best-shift algorithm proceeds in four phases built on sort, scan, and reduce primitives: (1) breakpoint generation with two scalar accumulators capturing the asymptotic score and an asymmetry correction around the incumbent; (2) lexicographic sorting of breakpoint entries so that scores are evaluated before post-breakpoint penalties apply; (3) an inclusive scan accumulating score deltas; and (4) a parallel argmax restricted to feasible values. Prior implementations treated full best-shift evaluation as prohibitively expensive; this paper demonstrates it is tractable on GPU via these primitives.

Several engineering choices support this design:

• Residual storage: penalties depend on constraint activity only through the residual $r_i = \bar{y}_i - b_i$, halving global memory reads per nonzero.
• Uniform constraint normalization to $\le$ form eliminates divergent branching within warps.
• Row-wise (CSR) nonzero traversal was empirically faster than column-wise for full binary-score recomputation, since threads share residuals and weights broadcastable from L1; a consequence is that lazy selective reevaluation of affected columns, as proposed by Çördük et al., becomes expensive because affected columns are not contiguous in CSR.
• L2-pinned bitset incumbents via cudaAccessPropertyPersisting keep all parallel climbers' incumbents resident in the H100's ~50 MB L2 despite many instances sharing the device.
• Kernel specialization: short vectors are packed multiple-per-warp using data-independent bitonic sorting networks; dispatch by vector length ranges from warp-level packing up to grid-wide sorts beyond length 1024; CUDA Graphs batch kernel submissions across tabu search iterations.

Computational results

Experiments use the 50-instance competition set with a five-minute limit, on an Intel Xeon Platinum 8481C and an NVIDIA H100 HBM3, against Gurobi 12.0.1, Xpress 9.8.0 (used internally for final LP solves after FPR fixing), and cuOpt 25.10. Quality references are the best solutions found by Gurobi or Xpress within eight hours.

An ablation isolates the contribution of GPU components:

Configuration	Found	Wins	Gap%	PI
Pure CPU	47	3	19.57%	72.59
CPU + GPU LP	46	13	12.17%	51.01
CPU + GPU LP + GPU Tabu	47	22	8.84%	41.84

All configurations solve nearly identical instance counts (one instance proved unstable), but solution quality improves substantially with each GPU addition: the shifted geometric mean gap drops from 19.57% to 8.84%, and the primal integral from 72.59 to 41.84. The GPU tabu search contributes the largest share of wins (22 versus 3), indicating that fast large-neighborhood improvement on GPU is the dominant quality driver, while streamed GPU LP iterates mainly accelerate convergence.

Against external solvers under the same five-minute limit:

Solver	Found	Wins	Only
CHAP	47	11	1
Gurobi (default)	44	25	1
cuOpt (heuristics-only)	43	6	0

CHAP solves the most instances and finds one solution no other solver finds within the limit. However, Gurobi attains the most unique-best objective values (25), reflecting stronger per-instance solution quality among commercial solvers; CHAP secures 11 wins. Against cuOpt directly, CHAP is better on 24 instances, worse on 19, tied on 5 — the paper notes the two approaches are complementary rather than dominant over one another. These results should be read with the caveat that they cover a single curated 50-instance competition set chosen to be challenging, not a broad public benchmark such as MIPLIB.

Limitations and open questions

The evaluation is confined to one benchmark and one hardware configuration (single H100, single CPU socket), and the paper does not report sensitivity to instance characteristics such as the density of non-binary integer variables, which its CSR-oriented design implicitly assumes are secondary. The claim that approximate LP solutions suffice for guiding heuristics rests on prior evidence rather than a systematic study within this framework. The interaction between portfolio components is evaluated only at the configuration level (CPU-only vs. +GPU LP vs. +GPU tabu); the marginal contribution of individual mechanisms — streaming checkpoints, FeasPump-mediated repair, warmstarting — is not isolated. Finally, integration into a complete branch-and-bound solver, where primal heuristics interact with dual bounding, remains explicitly future work.

Conclusion

CHAP demonstrates that a coordinated heterogeneous portfolio — GPU-native large-neighborhood tabu search with exact best-shift evaluation, streamed first-order LP iterates, and CPU-side repair heuristics coupled through a shared solution pool — can outperform both a commercial CPU MIP solver and a dedicated GPU heuristic solver on feasibility coverage within short time limits, while trailing commercial solvers on per-instance solution quality. The main open question the paper leaves is whether these gains persist when the framework is embedded in a full MIP solver rather than run standalone.