A Technical Note on the Implementation and Use of PDCS

Zhenwei Lin, Zikai Xiong, Dongdong Ge, Yinyu YearXiv 2026 · arXiv

This technical note introduces PDCS (Primal-Dual Conic Solver), a new open-source, first-order solver designed to tackle the massive conic optimization problems that define modern finance, machine learning, and control systems.

TL;DR

PDCS is a matrix-free, GPU-accelerated solver that overcomes the scalability limits of traditional interior-point methods. By combining the Primal-Dual Hybrid Gradient (PDHG) framework with adaptive step-sizes and "anchored" Halpern iterations, it provides a memory-efficient way to solve conic programs with millions of variables and constraints.

What Problem Does This Paper Address?

Conic programming is a workhorse of mathematical optimization, but it faces a "scaling wall." The industry standard—Interior-Point Methods (IPMs)—relies on heavy matrix factorizations. As problems grow to include millions of variables, the memory and computational cost of these factorizations become prohibitive.

First-order methods (FOMs) offer a way out because they rely only on matrix-vector multiplications, which are memory-light and perfect for GPUs. However, standard FOMs are often slow to converge or require tedious manual parameter tuning. PDCS addresses this by implementing a suite of "adaptive" enhancements that make FOMs robust and fast enough for practical, large-scale use.

Methods

PDCS is built on the Primal-Dual Hybrid Gradient (PDHG) algorithm, but it adds several sophisticated layers to improve performance:

  • Adaptive Step-Size Selection: Instead of using conservative theoretical bounds that slow down progress, PDCS uses a line-search heuristic to pick the largest safe step size at each iteration.
  • Adaptive Reflected Halpern Iteration: To prevent the solver from oscillating (a common issue in primal-dual methods), PDCS uses an "anchoring" mechanism. It extrapolates between the current and previous iterates while tethering them to an anchor point, which stabilizes and accelerates convergence.
  • Adaptive Restarts: The solver monitors a "normalized duality gap." When progress stalls or a specific condition is met, it "restarts" the anchor point to a more promising candidate.
  • Diagonal Preconditioning: It rescales the problem data to improve the "condition number," making the math easier for the solver to digest.
  • Matrix-Free GPU Implementation: The core kernels are written in CUDA, allowing the solver to offload the heavy lifting of matrix-vector math to the GPU.

Datasets

Not discussed in the paper. Note: As this is a technical note focusing on implementation and usage, it does not include a benchmark suite. It refers readers to the primary research paper (arXiv:2505.00311) for experimental results.

Key Insights and Ideas

  • Adaptivity is King: The transition from fixed theoretical parameters to data-driven, iteration-specific adjustments (for step-sizes and reflection coefficients) is what makes PDCS competitive with traditional solvers.
  • The Anchor Effect: The use of Halpern iterations acts as a stabilizer. By essentially "reminding" the algorithm of a previous good point (the anchor), it mitigates the wandering behavior often seen in standard first-order methods.
  • Handling Rescaled Cones: While diagonal rescaling is easy for simple linear programs, it’s mathematically complex for Second-Order and Exponential cones. PDCS solves this by reducing the projection onto these "warped" cones to a simple root-finding problem.
  • Accessibility: By providing high-level interfaces for JuMP (Julia) and CVXPY (Python), the authors have lowered the barrier for researchers to swap out slow CPU-based solvers for this GPU-accelerated alternative.

Key Results

  • Broad Cone Support: PDCS supports Zero, Nonnegative, Second-Order (SOC), Exponential, Rotated SOC, and Dual Exponential cones.
  • Software Availability: The solver is open-source under the Apache License 2.0 and available on GitHub.
  • GPU Efficiency: The implementation allows for solving problems involving millions of variables or constraints that would typically exceed the memory of a standard workstation using IPMs.

Limitations and Future Work

  • Numerical Sensitivity: The authors note that for non-linear cones, the bisection method used to calculate the duality gap can occasionally produce negative values due to floating-point inaccuracies. PDCS handles this by falling back to a weighted KKT error metric.
  • Interface Parity: Currently, the CVXPY interface exclusively supports the GPU backend, whereas the Julia interface supports both CPU and GPU.
  • Root-Finding Overhead: While reducing projections to root-finding problems is efficient, it remains more computationally expensive than the closed-form projections used in standard (unscaled) conic solvers.

Summary updated

Abstract

This technical note documents the implementation and use of the Primal-Dual Conic Programming Solver (PDCS), a first-order solver for large-scale conic optimization problems introduced by Lin et al. (arXiv:2505.00311). It describes the algorithmic and implementation details underlying PDCS, including the restarted primal-dual hybrid gradient method framework, adaptive step-size selection, adaptive reflected Halpern iterations, adaptive restarts, and diagonal preconditioning. It also provides practical instructions for using PDCS, including its interfaces with JuMP and CVXPY, solver options, and illustrative code examples. PDCS is available at https://github.com/ZikaiXiong/PDCS under the Apache License 2.0.
BibTeX
@misc{lin2026technical,
  author = {Zhenwei Lin and Zikai Xiong and Dongdong Ge and Yinyu Ye},
  title = {{A Technical Note on the Implementation and Use of PDCS}},
  year = {2026},
  eprint = {2603.15504},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2603.15504},
}

Loading related content...

Figure