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

Optimal FALQON for Quantum Approximate Optimization via Layer-wise Parameter Tuning
May 8, 2026Michael Mancini, Shabnam SodagariQuantum Approximate Optimization Algorithm
Computer Engineering & Computer Science, California State University, Long Beach, CA 90840
Landscape Limits of Quantum-Inspired Evolutionary Optimization across 256 continuous functions
Sep 25, 2026Rishi Govind, Ferdin Sagai Don Bosco, Kasturi Venkata Srikanth +4Fitness Landscape Analysis Evolutionary Optimization
BosonQ Psi Corporation, Bangalore, Karnataka, India
DQAOA-GPT: AI-Accelerated Distributed Quantum Optimization for Combinatorial Problems
Jul 22, 2026Seongmin Kim, Abhinav Rijal, Yuri Alexeev +5Distributed Optimization Combinatorial Optimization
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

May 8, 2026J/K move · Enter open · S save

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

Michael Mancini, Shabnam Sodagari

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

Quantum Approximate Optimization Algorithm

Open paper AskPDF arXiv

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.

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