⚡ electrical engineering

A Native RTL Quantum Statevector Simulator in FP64 on an HBM-Equipped FPGA

Dit artikel presenteert een native Verilog RTL-implementatie van een hoogwaardige FP64 quantum statevector-simulator op een HBM-uitgeruste FPGA die een perfecte getrouwheid bereikt voor tot 15 qubits door een gevalideerde HLS-kernel te vertalen naar handgeschreven logica met gespecialiseerde gate-engines en een geoptimaliseerde HBM-geheugenarchitectuur, terwijl het tevens een specifieke verificatiefout documenteert voor 16 of meer qubits.

Oorspronkelijke auteurs: Nasir Ali Nasir Ali

Gepubliceerd 2026-07-02✓ Author reviewed ⓘ

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Nasir Ali Nasir Ali

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een magische, parallelle wereld probeert te simuleren waarin een enkele munt tegelijkertijd kop én munt kan zijn. In de wereld van quantum computing is deze "munt" een qubit. Om een systeem met veel van deze munten te simuleren op een gewone computer, moet je elke mogelijke combinatie van kop en munt tegelijkertijd bijhouden.

Dit artikel beschrijft een op maat gemaakte machine die precies dat doet, maar met een twist: in plaats van een standaard computerchip, heeft de auteur een gespecialiseerd "brein" gebouwd op een FPGA (een chip die je kunt herprogrammeren als een digitale Lego-set) die volgepropt is met een super-snel, hoogwaardig geheugensysteem genaamd HBM.

Hier is een uitsplitsing van het verhaal uit het paper, gebruikmakend van eenvoudige analogieën:

1. Het Probleem: De "Bibliotheek"-bottleneck

Het simuleren van quantumcomputers is als proberen elk boek in een bibliotheek te lezen die elke keer dat je een nieuwe plank toevoegt, in omvang verdubbelt.

De Wiskunde: Als je 29 qubits hebt, moet je 536 miljoen complexe getallen opslaan. Dat is een enorme hoeveelheid data.
De Bottleneck: De meeste computers zijn snel in rekenen, maar traag in het ophalen van data uit het geheugen. Het is alsof je een geniale chef bent (de processor) die in een seconde een maaltijd kan bereiden, maar de voorraadkast (het geheugen) zo ver weg is dat de chef 99% van de tijd bezig is met heen en weer lopen om ingrediënten te halen.
De Limiet: Hierdoor lopen de meeste simulators tegen een muur aan rond de 29 qubits. Ze raken simpelweg de ruimte of de tijd kwijt.

2. De Oplossing: Een Maatwerk "Super-Librarian"

De auteur, Nasir Ali, heeft een aangepaste motor gebouwd genaamd qsim op een Xilinx Alveo U55C chip. Deze chip is speciaal omdat hij beschikt over HBM2 (High-Bandwidth Memory).

De Analogie: Stel je een bibliotheek voor waar de boeken niet op planken in een kelder staan, maar zijn gerangschikt in 8 verschillende kamers direct naast de chef. De chef heeft 8 assistenten (datapaden) die tegelijkertijd boeken uit alle 8 de kamers kunnen pakken.
De Snelheid: Deze opstelling stelt de machine in staat om data te verplaatsen met ongeveer 460 GB/s. Dat is alsof je het hele internet in een paar seconden downloadt, puur om de processor te voeden.

3. Hoe het Werkt: De Drie Gespecialiseerde Werkers

De machine probeert niet alles met één groot brein te doen. In plaats daarvan gebruikt hij drie gespecialiseerde werkers (engines) die verschillende soorten quantum-"moves" (gates) afhandelen:

De Rekenwerker (Single-Qubit Engine): Wanneer een zet complexe wiskunde vereist (zoals het laten draaien van een munt), gebruikt deze werker een hoogwaardige rekenmachine die 7 stappen nodig heeft om een berekening te voltooien. Het is snel en nauwkeurig.
De Swap-werker (CNOT Engine): Sommige zetten vereisen alleen het wisselen van twee munten. Deze werker doet geen enkele berekening; hij wisselt simpelweg de datapakketten uit. Het is alsof een bibliothecaris twee boeken op een plank wisselt zonder ze te lezen.
De Flip-werker (CZ Engine): Sommige zetten veranderen alleen het "teken" van een getal (een positief getal in een negatief getal veranderen). Deze werker schakelt simpelweg één schakelaar op de data om. Dit is de snelste werker van allemaal.

4. De "Negen-Deuren"-regel (Een Cruciale Ontdekking)

Een van de meest interessante delen van het paper is een les die op de harde manier is geleerd.

De Fout: De auteur probeerde eerst het systeem te ontwerpen met 16 deuren (geheugenpoorten) naar de bibliotheek, in de veronderstelling dat meer deuren snellere toegang zouden betekenen.
De Crash: De interne bedrading van de chip kon 16 deuren die tegelijkertijd openstaan niet aan. Het was alsof je 16 vrachtwagens probeerde te parkeren op een terrein dat ontworpen is voor 8; ze botsten tegen elkaar op en het ontwerp faalde.
De Fix: De auteur verminderde het ontwerp naar 9 deuren (8 voor data, 1 voor instructies). Dit paste perfect. Het paper benadrukt dat dit niet zomaar een "tweak" is; het is een harde regel. Als je probeert meer deuren toe te voegen, kan de fysieke chip de draden simpelweg niet correct routeren.

5. De Resultaten: Succes en een Glitch

De auteur testte deze machine door een "GHZ-toestand" (een specifiek quantumpatroon) te simuleren met een toenemend aantal qubits.

Het Succes: Voor systemen met 1 tot 15 qubits werkte de machine perfect. Hij produceerde de juiste resultaten met 100% nauwkeurigheid. De tijd die nodig was om de simulatie uit te voeren, groeide voorspelbaar (ongeveer 2,16 keer langzamer voor elke extra qubit toegevoegd), wat overeenkomt met de wiskunde.
De Glitch: Toen de auteur probeerde om 16 of meer qubits te simuleren, begon de machine foutieve antwoorden te geven.
- De Oorzaak: Het bleek dat wanneer het systeem te groot werd, twee "Swap Workers" tegelijkertijd probeerden te schrijven naar dezelfde geheugenkamer. Ze zaten elkaar in de weg, waardoor een van de schrijfacties verloren ging.
- De Fix: De auteur vond de exacte regel code die de verkeersopstopping veroorzaakte en voegde een eenvoudige "wait"-instructie toe om hen om de beurt te laten werken. Deze fix is gedocumenteerd, maar het paper merkt op dat de definitieve hardwaretest nog niet is uitgevoerd om te bevestigen dat de fix in de echte wereld werkt.

6. De Connectie met de Werkelijkheid

De machine is niet slechts een op zichzelf staand speeltje; hij maakt verbinding met Qiskit, een populaire softwaretool die door quantumonderzoekers wordt gebruikt.

De Brug: De auteur heeft een "vertaler" gebouwd die standaard quantumcode geschreven door mensen neemt, deze afbreekt in de 19 specifieke bewegingen die de machine begrijpt, en deze naar de chip stuurt.
De Belofte: Als je deze tool gebruikt, zal hij niet stilletjes terugvallen op een trage computer als de chip faalt; hij zal je onmiddellijk laten weten als er iets mis is.

Samenvatting

Dit paper presenteert een hoogwaardige, op maat gemaakte quantumsimulator die een gespecialiseerde chip met een enorme geheugenbandbreedte gebruikt om quantumcircuits met extreme precisie te simuleren.

Wat het heeft bereikt: Het heeft succesvol tot 15 qubits gesimuleerd met perfecte nauwkeurigheid en bewezen dat een specife "9-deuren" geheugenontwerp noodzakelijk is om de chip te laten functioneren.
Wat het heeft gevonden: Het liep tegen een muur aan bij 16 qubits door een verkeersopstopping in het geheugensysteem, identificeerde de exacte oorzaak en stelde een fix voor.
De Kern: Het is een bewijs van concept dat laat zien hoe het zorgvuldig ontwerpen van de "leidingen" (geheugentoegang) van een chip de simulatie van quantumfysica extreem veel sneller kan maken, mits men de fysieke limieten van de bedrading van de chip respecteert.

Technische Samenvatting: Een Native RTL Quantum Statevector Simulator in FP64 op een HBM-uitgeruste FPGA

Probleemstelling
Volledige statevector-kwantumcircuitsimulatie vereist het opslaan en bijwerken van $2^n$ complexe amplitudes. Bij dubbele precisie (FP64, 16 bytes per amplitude) legt dit een harde geheugencapaciteitsgrens op van ongeveer 29 qubits op een enkel apparaat met 8 GB geheugen. Hoewel de geheugencapaciteit de bovengrens bepaalt, wordt de prestatie van dergelijke simulators vaak beperkt door de geheugenbandbreedte in plaats van de rekenkracht. Single-qubit gates vereisen dat elke amplitude exact één keer wordt aangeraakt, terwijl two-qubit gates alle amplitudes moeten scannen om actieve paren te identificeren. Bestaande FPGA-simulators waren historisch gezien beperkt tot on-chip BRAM (wat circa 5–16 qubits beperkt) of off-chip DDR4, en de meeste opereren in single of mixed precision. Bovendien missen High-Level Synthesis (HLS) tools vaak de granulariteit die nodig is om geheugeninterleaving en AXI-masteraantallen te optimaliseren, wat leidt tot routing-fouten op complexe HBM-fabrics.

Methodologie
Het artikel presenteert qsim, een native Verilog RTL-implementatie van een double-precision statevector simulator gericht op de Xilinx Alveo U55C FPGA. Het ontwerp is een structurele vertaling van een gevalideerde HLS-kernel (v06) naar handgeschreven RTL om expliciete controle te verkrijgen over de pipeline-structuur, geheugengeometrie en timing.

Architectuur en Geheugentopologie: Het systeem maakt gebruik van de 16 GB HBM2-subsystemen van de U55C. Een kritieke architecturale invariant is de negen-AXI-master-beperking: het ontwerp gebruikt acht onafhankelijke AXI4-masterpoorten voor amplitude-banken en één gedeelde poort voor gate-instructies. Deze topologie is afgeleid van een routing-fout in de voorgaande HLS-poging (die probeerde 17 masters te gebruiken), waarbij de Vivado-router de 16-banken-architectuur afwees vanwege congestie in de HBM-switchregio. De acht-banken-topologie gebruikt een modulo-acht interleaving-schema (bank(k) = k mod 8) om amplitude-indices over de banken te verdelen, wat parallelle AXI4-transacties mogelijk maakt.
Gate Engines: De kernel implementeert 19 gate-opcodes via drie gespecialiseerde engines:
1. SG Engine (Single-Qubit): Voert willekeurige $2 \times 2$ unitaire matrices uit. Het maakt gebruik van een gepipelde FP64 complex vermenigvuldiger (cmul_fp64) met een latentie van 7 cycli, gebouwd van Xilinx Floating-Point Operator IP's.
2. CNOT Engine: Voert conditionele amplitude-swaps uit zonder floating-point rekenkunde. Het bevat een serialisatiepad voor "same-bank" swaps (waarbij de control- en target-qubits naar dezelfde HBM-bank mappen) om write-collisions te voorkomen.
3. CZ Engine: Negatieveert amplitudes door de IEEE 754 sign-bit om te keren, wat geen rekenunits vereist.
Parametrische Gates: Matrices voor parametrische gates (RX, RY, RZ, P, U2, U3) worden on-chip samengesteld met behulp van een 24-cyclus CORDIC-pipeline om $\cos(\theta)$ en $\sin(\theta)$ waarden te genereren. Fixed matrices worden opgeslagen in een combinatorische BRAM-vrije ROM.
Host Integratie: Het systeem wordt blootgesteld via een Qiskit 1.0.2 BackendV2. De Python host-laag transpileert circuits naar de native 17-gate basis, codeert gates in 256-bit pakketten en beheert DMA-transfers via de Xilinx Runtime (XRT). De backend geeft expliciet fouten als de hardware-executie faalt, om stille fallback naar software te voorkomen.

Belangrijkste Bijdragen

Native RTL Implementatie: Een volledige, synthetiseerbare Verilog RTL-kernel voor de Alveo U55C, die 19 gate-opcodes implementeert met FP64-precisie, ter vervanging van een eerdere HLS-ontwerp om routing-haalbaarheid en pipeline-controle te garanderen.
Routing-Gevalideerde Architectuur: De vaststelling van de negen-AXI-master (8 banken + 1 gate) topologie als een niet-onderhandelbare architecturale invariant, gedocumenteerd door de analyse van een eerdere routing-fout.
Gespecialiseerde Hardware Engines:
- Een 7-cyclus gepipelde FP64 complex vermenigvuldiger.
- Een CNOT engine met expliciete same-bank write serialisatie-logica.
- Een CZ engine die gebruikmaakt van sign-bit inversie.
Qiskit Backend: Een volledige BackendV2 integratie die transpileren, pakketcodering en statevector-terugwinning afhandelt, waardoor wordt gegarandeerd dat de hardware de enige executiepad is.
Verificatie en Karakterisering: Functionele verificatie van acht correctheidstests (inclus_ Bell en GHZ staten) en een qubit-sweep experiment (n=1 tot n=20) die de executie-scaling kwantificeert.

Resultaten

Functionele Correctheid: RTL-simulatie met Vivado xsim bevestigde alle acht functionele tests met amplitude-fouten onder $10^{-9}$ .
GHZ Sweep (n=1 tot 15): De simulator bereikte een perfecte fidelity ( $F=1.0$ ) voor GHZ-circuits van 1 tot 15 qubits. De executietijd schaalde met ongeveer 2.16× per qubit, wat iets boven de theoretische minimale $2\times$ ligt door de overhead van de CNOT engine (het scannen van alle $2^n$ indices, inclusief inactieve) en vaste FSM-transitie-kosten.
n ≥ 16 Falen: Voor $n \ge 16$ faalde de simulatie (fidelity daalde naar 0.5). Het document identificeert de oorzaak als een same-bank write serialisation defect in de CNOT engine. Wanneer de target-qubit index groter is dan 15, mappen alle actieve swap-paren naar dezelfde HBM-bank. Een raceconditie in de write FSM zorgde ervoor dat de tweede write van een paar werd gedropt als de arbiter te snel terugkeerde naar een idle-toestand. Het document beschrijft een minimale één-regel fix (het toevoegen van een wait-state voor het ready-signaal van de arbiter) om dit op te lossen.
Geprojecteerde Prestaties: Bij de beoogde klok van 258.5 MHz, wordt geprojecteerd dat een 15-qubit GHZ-circuit ongeveer 9.19 ms zal uitvoeren, terwijl een 20-qubit circuit 390 ms zou duren (exclusief het defect).

Betekenis
Dit artikel positioneert qsim als de eerste double-precision statevector FPGA simulator gebouwd rond HBM2 en blootgesteld via een moderne, transpiler-bewuste Qiskit backend. De betekenis ligt niet in het ontsnappen aan de exponentiële geheugenlimiet van statevector-simulatie, maar in het bieden van een geverifieerde, hardware-getrouwe implementatie van de methode op een platform met hoge bandbreedte. Door over te stappen van HLS naar native RTL, tonen de auteurs aan dat expliciete controle over geheugeninterleaving en AXI-masteraantallen essentieel is voor het bereiken van timing closure op HBM-uitgeruste FPGA's. Het werk biedt een eerlijke karakterisering van schaalingslimieten en specifieke hardware-foutmodi (zoals het same-bank write defect), en biedt een transparante baseline voor toekomstige hardware-versnelde kwantumsimulatie-inspanningen.