Cross-Backend QIEO: Universal Runtime Portability across OpenMP5, CUDA, HIP, and Multi-Language Interfaces

Aman Mittal; Ferdin Sagai Don Bosco; Kasturi Venkata Srikanth; Abhishek Singh; Aditya Singh; Abhishek Chopra

cs.DCSep 25, 2026

Cross-Backend QIEO: Universal Runtime Portability across OpenMP5, CUDA, HIP, and Multi-Language Interfaces

Authors: Aman Mittal, Ferdin Sagai Don Bosco, Kasturi Venkata Srikanth, Abhishek Singh, Aditya Singh, Abhishek Chopra

Organizations: BQP Bengaluru, India

Abstract

Quantum-inspired algorithms emulate quantum mechanical principles, such as, superposition, interference, and probabilistic amplitude evolution, on classical hardware by representing candidate solutions as qubit vectors and evolving them through rotation-gate operators. This approach offers higher optimization performance without physical qubits, and has been shown to achieve order-of-magnitude speedups (10--80 $\times$ ) over traditional solvers on combinatorial, high-dimensional NP-hard problems. A critical barrier to adoption, however, is the lack of a unified execution framework that delivers both algorithmic performance and hardware portability. We present Cross-Backend Quantum Inspired Evolutionary Optimizer (QIEO), the runtime core of BQP's BQPhy solver, which addresses this gap through a single-source-of-truth architecture. One C++ implementation of the QIEO algorithm is compiled once per hardware target and exposed to multiple high-level languages via thin binding layers. The framework dispatches to CPU (sequential), OpenMP~5 (multi-core), CUDA (NVIDIA), and HIP (AMD) backends at runtime, adapting kernels to each device's memory hierarchy and warp/wavefront execution model. The framework's real-world utility is validated through binding demonstrations that share the identical C++ runtime. BQPhy's Python library is demonstrated on a neural network hyperparameter optimisation achieving 88.60% test accuracy on MNIST. BQPhy's MATLAB's Toolkit is tested on wind farm layout optimisation attaining $365\,399 \pm 4\,552$ ~MWh/yr, which is statistically indistinguishable from particle swarm optimisation and $+7.6\%$ above genetic algorithms on a 32-variable constrained engineering problem. The Julia package tackles the Lotka--Volterra parameter estimation where BQPhy replaces native Julia solvers on the same residual, cutting mean SSE by $2.1\times$ .

Figures & tables

Mode	Target	Parallelism Model	Best For	Compile Flag
CPU	Single-core CPU	Sequential (scalar)	Debugging, correctness validation, small problems	Default (no flag)
OpenMP	Multi-core CPU	Loop parallelism via #pragma omp parallel for ; SIMD vectorisation	Mid-scale problems ( $P=10^{2}$ – $10^{4}$ ) on multi-socket servers	-DUSE_OPENMP=ON
GPU/CUDA	NVIDIA GPU (cc $\geq$ 7.0)	Warp-level parallelism + Thrust reduction algorithms	Large-scale problems ( $P>10^{4}$ ) where PCIe transfer is amortised	-DUSE_CUDA=ON
GPU/HIP	AMD GPU (GFX9+)	Wavefront-level parallelism; mirrors CUDA kernel structure	Same as CUDA target on AMD hardware	-DUSE_HIP=ON

TABLE I: Execution Modes Supported by the Hardware Abstraction Layer (HAL)

Panel of Figure 2 — Fig. 1: Layered architecture of the BQPhy ® QuantumNOW™ framework. A single C++ implementation is compiled once per hardware target and shared across all language bindings, realising the single-source-of-truth principle.

Language	Library	Mechanism	Role
C++	Header-only	Direct inclusion	Zero-overhead integration; exposes full API including template parameters for custom fitness functors.
Python	pybind11 [ 9 ]	C++ template-based Python–C interoperability	Converts Python dict and callable objects into C++ data structures; exposes core runtime as Python classes.
MATLAB	MEX API [ 10 ]	Native MATLAB C++ interface	Receives struct and function_handle arguments, invokes C++ runtime, returns results as native MATLAB arrays.
Julia	CxxWrap [ 11 ]	Automatic C++ wrappers around libBQPhy_Optimiser.so	Converts Julia Dict and Function objects into C++ data structures; exposes the runtime as a native Julia module.

TABLE II: Binding Architecture Overview

Step	C++ Core	Python	MATLAB	Julia
Initialize	opt.initialize(params)	opt.initialize(dict)	BQPhy_MEX("init", struct)	Optimizer(Dict)
Set model	opt.setModel(fn)	opt.set_model(callable)	Pass @function_handle	set_fitness_function!(opt, fn)
Run	opt.runOptimization(acc)	opt.run_optimization(acc)	BQPhy_MEX("run", ...)	optimize!(opt; device)
Get result	opt.getBestDesign()	opt.get_result()	BQPhy_MEX("result")	get_best_design(opt)

TABLE III: Unified Interface Contract Across Language Bindings

Problem	OpenMP	CUDA (A100)	HIP (MI300X)
Knapsack-512	14.3 $\times$	58.7 $\times$	51.2 $\times$
Rastrigin-200	11.8 $\times$	72.1 $\times$	63.4 $\times$
Rosenbrock-200	12.6 $\times$	68.3 $\times$	60.8 $\times$
Antenna Synth.	16.1 $\times$	65.9 $\times$	57.3 $\times$
Geometric mean	13.6 $\times$	66.1 $\times$	57.9 $\times$

TABLE IV: Speedup Over Sequential CPU Baseline (

P=10{,}000

G=1{,}000

)

Variable	Type	Range / Choices
Learning rate	Continuous	$[10^{-5},\;10^{-1}]$ (log-uniform)
Hidden units	Integer	$[32,256]$
Hidden layers	Integer	$\{1,2,3,4\}$
Activation	Categorical	{ReLU, Tanh, Sigmoid, LeakyReLU}
Dropout rate	Continuous	$[0.0,\;0.5]$

TABLE V: Hyperparameter Search Space for MNIST Optimization

Method	Evals	Accuracy	Time (s)	s/Eval
BQPhy (QIEO)	240	0.8740	46.42	0.19
Ray Tune	12	0.8760	206.92	17.24
Optuna	12	0.8640	3.41	0.28
Grid Search	12	0.8700	2.71	0.23

TABLE VI: Variable-Budget Results on MNIST

Method	Lr	Hidden	Layers	Activation	Dropout	Accuracy	Time (s)
BQPhy (QIEO)	$1.92\times 10^{-2}$	238	1	LeakyReLU	0.011	0.8860	45.05
Ray Tune [ 28 ]	$1.20\times 10^{-2}$	223	3	LeakyReLU	0.101	0.8720	5389.79
Optuna [ 29 ]	$1.94\times 10^{-2}$	227	1	LeakyReLU	0.398	0.8920	63.30
Grid Search [ 30 ]	$1.00\times 10^{-2}$	200	1	ReLU	0.300	0.8760	56.60
Note: Grid Search exhausted its discrete grid at 216 evaluations (could not reach 240).

TABLE VII: Iso-Budget Results on MNIST (240 Evaluations, All Methods)

Fig. 2: Test accuracy under variable and iso-budget (240 evaluations) conditions. BQPhy improves by $+1.20$ pp; Ray Tune degrades by $-0.40$ pp under serialised execution.

Fig. 3: Wall-clock time (log scale) for variable and iso-budget conditions. Ray Tune requires $119\times$ more wall time than BQPhy under serialized execution at 240 evaluations.

Method	Time (s)	s/Eval	Accuracy	Speedup vs. RT
BQPhy (QIEO)	45.05	0.19	0.8860	$\mathbf{119.6\times}$
Ray Tune	5389.79	22.46	0.8720	$1\times$ (ref.)
Optuna	63.30	0.26	0.8920	$85.1\times$
Grid Search	56.60 †	0.26 †	0.8760	$95.2\times$
† Grid Search exhausted at 216 evaluations.

TABLE VIII: Iso-Budget Efficiency Metrics (240 Evaluations)

Azimuth ( ∘ )	Probability	Azimuth ( ∘ )	Probability
0	0.03	180	0.10
30	0.04	210	0.12
60	0.05	240	0.14
90	0.06	270	0.18
120	0.07	300	0.08
150	0.10	330	0.03

TABLE IX: 12-sector wind rose used in the benchmark. Azimuth in meteorological convention (

0^{\circ}=\text{North}

Fig. 4: Convergence comparison (mean $\pm 1\sigma$ over 20 runs). BQPhy overtakes PSO at generation 150 and sustains the highest final AEP. GA exhibits the slowest convergence and the widest variance.

Fig. 5: Final AEP distribution over 20 independent runs (box-and-whisker with individual scatter overlay). BQPhy and PSO are statistically indistinguishable; GA suffers severe outlier runs.

Fig. 6: Best turbine layout discovered by each solver. Dashed circles indicate the minimum separation radius ( $1D$ shown). BQPhy’s irregular pattern exploits the domain more effectively than PSO’s grid-like pattern arrangement or GA’s clustered configuration.

Method	SSE (mean $\pm$ std)	SSE med.	$\theta$ RMSE	Success	Best SSE	Time (s)
BQPhy (QIEO)	$8223\pm 8760$	$3948$	$0.325\pm 0.298$	$20\%$	$381$	$0.22$
Optim.NelderMead [ 14 ]	$17506\pm 9225$	$21486$	$0.514\pm 0.292$	$20\%$	$26.3$	$0.01$
Optim.ParticleSwarm [ 14 ]	$4367\pm 7242$	$1487$	$0.452\pm 0.365$	$30\%$	$26.3$	$0.10$
BlackBoxOptim.DE [ 15 ]	$\mathbf{1790\pm 954}$	$2083$	$\mathbf{0.175\pm 0.165}$	$\mathbf{50\%}$	$276$	$0.08$
CMA-ES [ 17 ]	$16443\pm 11918$	$21931$	$0.444\pm 0.322$	$30\%$	$\mathbf{26.3}$	$0.06$

TABLE X: Iso-Budget Lotka–Volterra Calibration (2,000 Evaluations, 10 Restarts)

Fig. 7: Residual SSE over 10 restarts (log scale). NelderMead and CMA-ES collapse to a high-SSE mode near the bound; BQPhy and the Julia population methods occupy the lower band.

Fig. 8: Parameter RMSE $\|\hat{\boldsymbol{\theta}}-\boldsymbol{\theta}^{\star}\|_{2}$ over the same restarts. BlackBoxOptim is the most consistent recovery; BQPhy matches NelderMead’s success rate while avoiding its catastrophic failures.

Fig. 9: Best BQPhy restart: true Lotka–Volterra orbits, noisy observations, and the QIEO-fitted trajectory. Phase and amplitude are recovered from the same native Julia residual passed to the C++ runtime.

Evolutionary Optimization

Evolutionary optimization searches for strong solutions through population-based variation, selection, and adaptation.

See all 293 papers

May 8, 2026

Optimal FALQON for Quantum Approximate Optimization via Layer-wise Parameter Tuning

Feedback-based adaptive quantum optimization (FALQON) is a promising approach for solving combinatorial problems on noisy intermediate-scale quantum (NISQ) devices, requiring only single circuit evaluations per layer. However, standard FALQON relies on fixed hyperparameters that severely limit convergence speed, requiring hundreds to thousands of layers for acceptable solutions. This paper proposes Optimal FALQON, an optimization-based formulation that treats the per-layer time step (

δ_k

) and scaling factor (

M_k

) as decision variables optimized via classical methods. We present a comprehensive empirical study on all 94 non-isomorphic 3-regular graphs with 12 vertices, comparing Optimal FALQON with standard FALQON and multiple QAOA variants. Results demonstrate statistically significant improvements in success probability, evaluation efficiency, and depth-normalized cost across the evaluated benchmarks. Furthermore, initializing QAOA with parameters from Optimal FALQON yields superior warm-start performance compared to fixed initialization.

Michael Mancini, Shabnam Sodagari

Computer Engineering & Computer Science, California State University, Long Beach, CA 90840

Quantum Approximate Optimization Algorithm

Ask PDF

Sep 25, 2026

Landscape Limits of Quantum-Inspired Evolutionary Optimization across 256 continuous functions

Quantum-inspired evolutionary optimization (QIEO) represents design variables as a set of qubits and searches a continuous, multi-dimensional landscape through rotation of the qubit's amplitude pair. Every generation rotates those amplitudes toward a single elite, which corresponds to that generation's best. The update is cheap, almost parameter-free, and well-suited for massive parallel implementation, which has encouraged its adoption in engineering, design, and planning applications. However, there are critical issues with this formulation, principally, the treatment of design variables as independent probability components which make it incapable of exploiting local curvature, anisotropy, or variable coupling. Despite this, QIEO is believed to hold promise, and has been used extensively to solve real-world problems, with significant qualitative and computational advantage over its classical counterpart, Genetic Algorithm (GA). A collection of 256 (actually 508; 256 unshifted + 252 shifted, 4 could not be shifted) continuous function are selected from the prior works, in such a way that they represent eleven landscape characteristics, namely continuity, differentiability, separability, scalability, modality, convexity, conditioning, symmetry, maximum dimensionality, dimension dependency, and the coupling pattern of the design variables. These functions are then solved by three QIEO variants, two GA encodings and Hansen's Covariance Matrix Adaptation Evolution Strategy (CMA-ES). The results are evaluated in terms of computational cost, solution precision, and specialization across landscape characteristics. They identify the conditions under which QIEO provides competitive performance, clarify where its independent-variable representation becomes limiting, and establish whether particular QIEO variants offer advantages for specific landscape characteristics.

Rishi Govind, Ferdin Sagai Don Bosco, Kasturi Venkata Srikanth +4

BosonQ Psi Corporation, Bangalore, Karnataka, India

Fitness Landscape Analysis Evolutionary Optimization Black-Box Optimization

Ask PDF

Jul 22, 2026

DQAOA-GPT: AI-Accelerated Distributed Quantum Optimization for Combinatorial Problems

While combinatorial optimization problems are central to many scientific and engineering applications, their solution remains challenging due to exponentially large search spaces. Variational quantum algorithms offer a promising route for tackling such problems, yet their practical performance is limited by repeated quantum circuit evaluations and classical parameter updates. In this work, we introduce DQAOA-GPT, a hybrid framework that integrates the distributed quantum approximate optimization algorithm (DQAOA), which decomposes a large optimization problem into smaller sub-problems, with GPT-based quantum circuit generation for solving those sub-problems. Rather than relying on iterative variational optimization, the proposed approach uses a trained generative model to directly generate high-quality quantum circuits for the decomposed sub-problems. As a benchmark, we evaluate DQAOA-GPT against conventional DQAOA on dense HUBO optimization problems with up to 100 decision variables. The results demonstrate that DQAOA-GPT significantly reduces computational cost while maintaining competitive solution quality, with larger acceleration observed for larger sub-problem sizes. Although this work focuses on benchmark-scale validation, the framework provides a promising foundation for larger-scale combinatorial optimization in hybrid HPC-QC environments through increased GPU resources and parallel computing capability.

Seongmin Kim, Abhinav Rijal, Yuri Alexeev +5

National Center for Computational Sciences, Oak Ridge National Laboratory, Oak Ridge, TN, USA · Department of Physics & Astronomy, University of Tennessee, Knoxville, TN, USA · NVIDIA Corporation, Santa Clara, CA, USA +3

Distributed Optimization Combinatorial Optimization Quantum Circuit Synthesis Quantum Approximate Optimization Algorithm

Ask PDF

Abstract

Evolutionary Optimization

Explore similar work

Optimal FALQON for Quantum Approximate Optimization via Layer-wise Parameter Tuning

Landscape Limits of Quantum-Inspired Evolutionary Optimization across 256 continuous functions

DQAOA-GPT: AI-Accelerated Distributed Quantum Optimization for Combinatorial Problems