QuPort: Topology-, Port-, and Congestion-Aware Compilation for Modular Multi-QPU Quantum Systems

Dit artikel introduceert QuPort, een compilatiekader voor modulaire multi-QPU-systemen dat een drie-niveau model en het TPCCAP-algoritme hanteert om qubit-toewijzing, poorttoewijzing en interconnectcongestie gezamenlijk te optimaliseren, waardoor cross-QPU-verkeer en communicatieknelpunten worden geminimaliseerd.

De kern

Stel je voor dat je een enorme, complexe feest wilt organiseren waar de gasten "quantumbits" (qubits) zijn en de ruimtes waar ze hangen kleine, aparte quantumcomputers zijn die QPUs worden genoemd.

In de oude tijden zaten alle gasten in één grote balzaal. De taak van de "feestplanner" (de compiler) was er gewoon voor zorgen dat gasten die met elkaar moesten praten, naast elkaar stonden. Als dat niet zo was, moest de planner mensen verplaatsen (een proces dat "routing" heet) totdat ze konden kletsen.

Maar nu bouwen we modulaire quantumcomputers. In plaats van één grote balzaal hebben we een gebouw met vele kleine, aparte ruimtes (QPUs). Sommige ruimtes zijn verbonden door gangen, maar de gangen zijn smal en duur om te gebruiken.

Dit artikel introduceert een nieuwe feestplanner genaamd QuPort. Hier is hoe het werkt, met behulp van eenvoudige analogieën:

1. De Drie Kaarten

Om het feest te plannen, kijkt QuPort tegelijkertijd naar drie verschillende kaarten:

• De Gastenlijst (Logische Grafiek): Wie moet met wie praten, en hoeveel? (Sommige gasten zijn beste vrienden en moeten constant praten; anderen zeggen slechts één keer "hallo").
• De Ruimtelijke Indeling (Fysieke Kaart): Binnen elke kleine ruimte, welke stoelen zitten naast elkaar?
• Het Gebouwplan (Interconnect-grafiek): Hoe zijn de ruimtes verbonden? Zijn er directe gangen, of moet je door drie andere ruimtes lopen om bij de volgende te komen?

2. Het Grote Probleem: De "Deuropening"-Bottleneck

Als je twee beste vrienden in verschillende ruimtes zet, moeten ze over de gang schreeuwen. Maar er zijn twee grote problemen:

1. Te veel schreeuwen: Als te veel paren vrienden in verschillende ruimtes zitten, raken de gangen verstopt.
2. Te weinig deuren: Elke ruimte heeft slechts een paar "communicatiedeuren" (poorten). Als je 100 gasten in een ruimte zet, maar slechts 5 van hen moeten naar buiten schreeuwen, kun je er maar 5 tegelijk laten gaan. De rest blijft vastzitten.

3. De Oplossing: De TPCCAP-Strategie

QuPort gebruikt een speciale strategie genaamd TPCCAP om te beslissen wie in welke ruimte gaat. Het probeert drie dingen in evenwicht te brengen:

• Afstand: Het probeert beste vrienden in dezelfde ruimte te houden. Als ze in verschillende ruimtes moeten zijn, plaatst het ze in ruimtes die directe buren zijn (korte gangen).
• Deurdruk: Het zorgt ervoor dat geen enkele ruimte gedwongen wordt meer "deuren" te gebruiken dan ze eigenlijk hebben. Het zal niet 10 schreeuwend gasten in een ruimte met slechts 5 deuren zetten.
• Gangverkeer: Het spreidt het schreeuwen uit zodat geen enkele gang verstopt raakt met te veel verkeer.

4. Hoe QuPort Het Feest Plant (De Algoritmen)

QuPort raadt niet zomaar; het gebruikt een paar slimme trucs om de beste indeling te vinden:

• Zware-Edge-Clustering: Het kijkt eerst naar de sterkste vriendschappen en vergrendelt die paren samen in dezelfde ruimte voordat het zich zorgen maakt over de rest.
• Gebalanceerd Gierig: Het vult de ruimtes één gast per keer, waarbij het altijd de ruimte kiest die het meest logisch is voor die gast zonder de ruimte te vol te maken.
• Gesimuleerde Temperen: Dit is als een fase van "twee keer nadenken". Na het initiële plan probeert het willekeurige kleine veranderingen (zoals het verwisselen van twee gasten) om te zien of het feest soepeler verloopt. Als een verandering de dingen beter maakt, behoudt het die. Als het de dingen slechter maakt, houdt het het misschien toch even vast om te voorkomen dat je vast komt te zitten in een "goed genoeg" maar niet "perfect" plan.

5. De Lijst met "Externe Evenementen"

Zodra de gasten aan ruimtes zijn toegewezen, maakt QuPort een speciale instructielijst.

• Lokale Instructies: "Gast A en Gast B zijn in Ruimte 1. Ze kunnen normaal praten."
• Externe Evenementen: "Gast A is in Ruimte 1 en Gast B is in Ruimte 2. Ze moeten praten."

QuPort bepaalt niet hoe ze over de gang praten (of ze lasers, draden of magie gebruiken). Het markeert simpelweg de plek waar dat gesprek moet plaatsvinden en vertelt de hardware-engineers: "Jullie moeten hier een protocol bouwen om deze specifieke schreeuw te behandelen."

6. Het Schema

Tot slot schat QuPort in hoe lang het feest zal duren. Het telt hoeveel "schreeuwen" tegelijkertijd kunnen plaatsvinden zonder de gangen te verstoppen of de deuren op te maken. Het geeft een ruwe schatting van de totale tijd (makespan) op basis van deze abstracte regels.

Wat QuPort NIET Is

Het artikel is zeer duidelijk over wat deze tool niet is:

• Het is geen fysieke machine.
• Het kent de specifieke fysica van je quantumcomputer niet (zoals hoe lang een batterij meegaat of hoeveel fouten een laser maakt).
• Het voert niet daadwerkelijk het "schreeuwen" over de ruimtes uit.

Samenvattend: QuPort is een slim verkeersregelaar voor een modulaire quantumcomputer. Het bedenkt de beste manier om het werk te verdelen over verschillende kleine computers, zodat ze niet vast komen te zitten terwijl ze op elkaar wachten, terwijl het ervoor zorgt dat ze niet proberen meer deuren of gangen te gebruiken dan er daadwerkelijk bestaan. Het bereidt de instructies voor zodat de daadwerkelijke hardware-engineers later de beste manier kunnen bedenken om de "schreeuw"-technologie te bouwen.

Technische samenvatting

Technische Samenvatting: QuPort - Topologie-, Poort- en Congestiebewuste Compilatie voor Modulaire Multi-QPU Kwantumsystemen

1. Probleemstelling

Modulaire kwantumarchitecturen, die meerdere Quantum Processing Units (QPU's) via interconnects verbinden, vormen een unieke compilatie-uitdaging die verschilt van monolithische apparaten. Bij compilatie voor één apparaat is de lokale koppelingskaart de primaire beperking; niet-lokale interacties worden opgelost via het invoegen van SWAP-gates. In modulaire systemen zijn interacties tussen qubits op verschillende QPU's echter niet slechts "langere" lokale gates, maar afhankelijk van schaarse communicatiemiddelen: de topologie van de interconnect, communicatiepoorten en linkcapaciteit.

Bestaande compilers behandelen communicatie tussen QPU's vaak als een secundaire zorg of verbergen deze binnen standaard routing. Deze aanpak is ontoereikend voor modulaire systemen omdat een toewijzing die acceptabel is op een enkele koppelingsgrafiek, kan falen in een modulaire setting als deze:

1. Excessief verkeer tussen QPU's creëert.
2. Verkeer concentreert op een klein aantal interconnect-links (wat congestie veroorzaakt).
3. Te veel grens-qubits (qubits die interageren met andere QPU's) toewijst aan een QPU met onvoldoende communicatiepoorten.

Het artikel adresseert de behoefte aan een compilerframework dat expliciet tegelijkertijd redeneert over lokale apparaatconnectiviteit en communicatie tussen QPU's, voordat een specifiek fysiek protocol voor externe gates wordt geselecteerd (bijvoorbeeld fotonische links, entanglement-generatie).

2. Methodologie

QuPort is een op Python gebaseerd compilatieframework dat is gebouwd op Qiskit. Het introduceert een systeemmodel op drie niveaus en een specifiek partitioneringsalgoritme om het gebruik van middelen te optimaliseren.

2.1 Systeemmodel

Het framework abstracteert het compilatieprobleem naar drie distincte grafieken:

1. Logische Interactiegrafiek ($G_L$): Een gewogen ongerichte grafiek waarbij knopen logische qubits zijn en de gewichten van de randen de frequentie of temporale belangrijkheid van twee-qubit interacties vertegenwoordigen.
2. Fysische Koppelingskaart: Een gerichte grafiek die de connectiviteit binnen elke individuele QPU weergeeft (bijvoorbeeld grid, ring, clique).
3. QPU Interconnectgrafiek ($G_Q$): Een ongerichte grafiek die de topologie weergeeft die de QPU's verbindt (bijvoorbeeld mesh, ring, Clos, fat-tree). Deze grafiek wordt gebruikt om hop-afstanden en linkbelastingen te berekenen.

Het systeem neemt $N$ QPU's aan, elk met $C$ reken-qubits en $P$ communicatie-qubits. Een logische-to-QPU-partitie ($\pi$) moet de capaciteitsbeperking ($C+P$) per QPU respecteren.

2.2 Het TPCCAP-doel

De kern van QuPort is de TPCCAP-doelfunctie (Topology-, Port-, and Congestion-Aware Partitioning), $J(\pi)$, die een gewogen som van drie kostentermen minimaliseert:

1. Gewogen Snijafstand: $\sum w_{ij} \cdot d(\pi(i), \pi(j))$. Dit straft interacties tussen qubits die zijn toegewezen aan QPU's die ver uit elkaar liggen in de interconnectgrafiek, waarbij $d$ de kortste-padsafstand is.
2. Communicatie-poort Overloop: $\sum \max(0, b_q - P)^2$. Dit straft QPU's waar het aantal grens-qubits ($b_q$) de beschikbare communicatiepoorten ($P$) overschrijdt.
3. Gerouteerde Link-belasting Congestie: $\sum L_e^2$. Dit straft de gekwadrateerde belasting op interconnect-randen ($e$), en ontmoedigt verkeerconcentratie op specifieke links.

2.3 Algoritmen

QuPort implementeert een pijplijn van heuristieken om het partitionerings- en lay-outprobleem op te lossen:

• Zware-rand Clustering: Voegt zwaar gewogen logische paren samen tot clusters, zolang de clustergrootte de QPU-capaciteit niet overschrijdt.
• Gebalanceerde Greedy Partitionering: Wijs logische qubits één voor één toe op basis van gewogen graad, waarbij de belasting over QPU's in evenwicht wordt gebracht terwijl plaatsing in de buurt van reeds toegewezen buren wordt beloond.
• TPCCAP Lokale Zoek: Verfijnt de initiële partitie door qubits te verplaatsen om de $J(\pi)$-doel te verminderen, terwijl capaciteitsbeperkingen worden gehandhaafd.
• TPCCAP-SA (Gesimuleerde Temperen): Voegt een stochastische verfijningsfase toe om lokale minima te ontsnappen door af en toe verplaatsingen te accepteren die de doelfunctie verhogen.
• Communicatie-poort-bewuste Lay-out: Na partitionering worden specifieke logische qubits geselecteerd om communicatiepoorten te bezetten op basis van hun "externe score" (totale gewicht van interacties met andere QPU's).
• Gedistribueerde Programmaconstructie: In gedistribueerde modus extrahert het framework twee-qubit operaties tussen QPU's als expliciete externe gebeurtenissen en voegt synchronisatiebarrières in, terwijl lokale operaties alleen worden gerouteerd binnen hun respectieve QPU-koppelingskaarten.

2.4 Planning en Kostenschatting

QuPort bevat een topologie-bewuste schatter die de uitvoeringstijd (makespan) benadert met behulp van abstracte kostparameters:

• Lokale Kosten: Uitvoeringstijden voor gates op één qubit, twee qubits en SWAP-operaties.
• Externe Kosten: Een model dat de kosten voor entanglement-generatie ($\tau_E$), klassieke round-trip kosten ($\tau_C$) en externe overhead ($\tau_R$) combineert.
• Planning: Externe operaties worden ingepakt in "rondes" op basis van beschikbare communicatiepoorten en linkcapaciteiten, met inachtneming van de interconnect-topologie.

3. Belangrijkste Bijdragen

1. Expliciete Abstractie op Drie Niveaus: Het artikel stelt een abstractie op compilatieniveau voor die de logische interactiegrafiek, de fysische koppelingskaart en de QPU-interconnectgrafiek scheidt. Deze scheiding maakt optimalisatie mogelijk van kosten die specifiek zijn voor modulaire systemen (afstand, poorten, congestie) en die onzichtbaar zijn voor standaard monolithische compilers.
2. De TPCCAP-doelfunctie: Een nieuwe doelfunctie die gezamenlijk optimaliseert voor QPU-afstand, schaarste aan communicatiepoorten en linkcongestie, in plaats van deze als aparte of secundaire zorgen te behandelen.
3. Gedistribueerd Compilatiepad: Een mechanisme dat een intermediaire representatie produceert waarbij lokale circuits en externe gebeurtenissen expliciet zijn gescheiden. Dit stelt de compiler in staat modulaire bewuste planningen te genereren zonder zich te committeren aan een specifieke hardware-implementatie van externe gates.
4. Open-source Framework: De implementatie van deze algoritmen in Python/Qiskit, waardoor een reproduceerbare omgeving wordt geboden voor het bestuderen van modulaire compilatiestrategieën.

4. Resultaten en Validatie

Het artikel focust op de algoritmische structuur en correctheid van het framework in plaats van gekalibreerde hardware-runtime-resultaten te rapporteren.

• Correctheid: De auteurs leveren formele bewijzen (Proposities 1 en 2) die aantonen dat hun partitioneringsalgoritmen (Zware-rand, Greedy, TPCCAP, TPCCAP-SA) strikt voldoen aan capaciteitsbeperkingen per QPU en dat hun multi-pad routingroutines het verkeersgewicht behouden.
• Validatie: Het framework dwingt validatiecontroles af op partitie-invoer, lay-outconstructie en verkeersmatrices om te zorgen voor eindige, niet-negatieve en symmetrische waarden.
• Reikwijdte van Resultaten: Het artikel claimt niet om specifieke hardware-protocollen te overtreffen of gekalibreerde foutpercentages te leveren. In plaats daarvan wordt aangetoond dat het framework succesvol geldige partities en gedistribueerde programma's genereert die voldoen aan de gedefinieerde abstracte beperkingen.

5. Betekenis en Claims

Het artikel positioneert QuPort als een abstractie op compilatieniveau in plaats van een hardware-implementatie. De betekenis hiervan ligt in:

• Ontkoppeling van Compilatie en Hardware-protocollen: Door de logische partitionering en extractie van externe gebeurtenissen te scheiden van de fysieke realisatie van externe gates, stelt QuPort onderzoekers in staat de algoritmische structuur van modulaire compilatie te bestuderen voordat een specifieke interconnect-technologie (bijvoorbeeld fotonisch versus microgolf) wordt vastgesteld.
• Middelen-bewuste Mapping: Het benadrukt dat modulaire compilatie een verschuiving vereist van het minimaliseren van SWAP's naar het minimaliseren van "snijafstand", "poortoverloop" en "linkcongestie".
• Bescheidenheid in Claims: De auteurs stellen expliciet dat het framework geen gekalibreerde hardware-runtime claimt, noch een fysiek protocol voor externe gates implementeert. De "externe gebeurtenissen" zijn intermediaire representaties die aangeven waar een backend een protocol moet leveren. De planningschatter wordt beschreven als een "laag-gebaseerd greedy model", niet als een geverifieerde netwerkbesturingsplanner.

Kortom, QuPort biedt een gestructureerde, heuristiek-gedreven aanpak voor het complexe probleem van middelenallocatie dat inherent is aan modulaire kwantumcomputing, en biedt een tool om de trade-offs tussen topologie, poortbeschikbaarheid en congestie op een platform-onafhankelijke manier te verkennen.