ParEVO: Synthesizing Code for Irregular Data: High-Performance Parallelism through Agentic Evolution

ParEVO is een framework dat gebruikmaakt van een evolutionair agent en gespecialiseerde LLM's om hoogpresterende parallelle algoritmen voor onregelmatige datastructuren te synthetiseren, waardoor het aanzienlijke snelheidswinsten boekt ten opzichte van bestaande modellen en menselijke experts.

De kern

Stel je voor dat je een enorme, chaotische bibliotheek hebt. De boeken (data) liggen niet netjes op rij, maar zijn verspreid over de hele vloer, in verschillende talen, en sommige zijn zwaar, andere licht. Je wilt nu een team van 100 mensen (de computercores) inzetten om deze bibliotheek te ordenen.

Het probleem? Als je gewoon zegt: "Iedereen, pak een boek en leg het op de juiste plek", dan raken ze elkaar in de weg, duwen ze elkaars handen weg, en raken ze de boeken kwijt. Dit is wat informatici irreguliere data noemen: data die niet in een strak patroon past, zoals sociale netwerken, weersvoorspellingen of verkeersstromen.

ParEVO is de slimme oplossing die dit probleem oplost. Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het Probleem: De "Slome" Robot

Vroeger konden computers alleen maar één taak tegelijk doen (zoals één persoon die één boek leest). Nu hebben we supercomputers met duizenden "hersenen" die tegelijk kunnen werken. Maar programmeer die computers is heel lastig.

De beste AI-modellen van vandaag (zoals de slimste chatbots) zijn getraind op gewone code. Ze zijn gewend aan lineaire instructies: "Doe dit, dan dat." Als je ze vraagt om die bibliotheek te sorteren met 100 mensen, proberen ze vaak iets doms: ze laten iedereen tegelijk naar hetzelfde boek rennen. Het resultaat? Een enorme ruzie (in de computerwereld: een race condition), en de bibliotheek staat nog steeds in de war.

2. De Oplossing: ParEVO (De Slimme Architect)

ParEVO is een nieuw systeem dat AI gebruikt om snel en veilig parallelle code te schrijven. Het doet dit in drie stappen, alsof het een meester-bouwkundige is die een team van vakmensen opleidt.

Stap 1: De "Critic-Refine" Oefenboeken (De Parlay-Instruct Corpus)

Stel je voor dat je een student wilt leren zwemmen. Je kunt hem niet zomaar in het diepe gooien. Je moet hem eerst laten oefenen in een zwembad met een instructeur.

• ParEVO heeft een speciale bibliotheek van 13.820 oefenopgaven gemaakt.
• Een "Docent" (een AI) bedacht een probleem.
• Een "Student" (een andere AI) probeerde het op te lossen.
• Een "Critic" (een strenge examinator) keek of het werkde. Als de code crashte of te langzaam was, werd het weggegooid.
• Alleen de perfecte, snelle oplossingen kwamen in het leerboek. Zo leerde de AI precies hoe je die chaotische bibliotheek moet sorteren zonder ruzie te maken.

Stap 2: De Gespecialiseerde Vakmensen (Fine-Tuning)

Nu de AI het concept begrijpt, krijgen ze een specialisatie.

• In plaats van te leren hoe je "gewone" code schrijft, leren deze modellen een speciale taal: ParlayLib.
• Denk aan ParlayLib als een set van magische gereedschappen. In plaats van zelf te zeggen "pak dit boek en leg het daar", zeg je tegen de AI: "Gebruik de Filter-machine om alle rode boeken te halen, en de Sorteer-machine om ze op te rijgen."
• Deze gereedschappen zijn zo ontworpen dat ze nooit in de war raken, zelfs niet als 100 mensen tegelijk werken. De AI leert om altijd deze veilige, krachtige tools te gebruiken.

Stap 3: De Evolutionaire Agent (De Test- en Verbeter-Lus)

Dit is het meest creatieve deel. Stel je voor dat je een auto bouwt die zo snel mogelijk moet racen.

1. De AI bouwt een eerste versie van de auto.
2. De auto rijdt een rondje op de baan (de computer voert de code uit).
3. De AI kijkt naar de tijd: "Oeps, deze versie is te traag op de bochten."
4. De AI zegt: "Oké, ik ga de motor iets anders instellen."
5. Dit proces herhaalt zich honderden keren. De AI evolueert de code, net zoals natuur de beste dieren selecteert.
6. Als de code een fout maakt (bijvoorbeeld: twee mensen duwen tegelijk tegen een deur), wordt de auto direct gestopt en moet de AI opnieuw beginnen.

Wat levert dit op?

Het resultaat is verbluffend:

• Snelheid: ParEVO is gemiddeld 106 keer sneller dan de beste commerciële AI-modellen die we nu hebben. Op sommige moeilijke taken is het zelfs 1100 keer sneller.
• Betrouwbaarheid: De code die ParEVO schrijft, crasht bijna nooit. Het leert de AI om veilig te werken, zelfs in het grootste chaos.
• Vergelijking met Mensen: In sommige gevallen is de code die ParEVO schrijft zelfs sneller dan wat de beste menselijke programmeurs kunnen bedenken.

De Grootte Les

ParEVO laat zien dat AI niet alleen maar tekst kan schrijven of plaatjes kan maken. Als je AI de juiste gereedschappen geeft (zoals ParlayLib) en je laat het oefenen met een strenge "Critic" en een evolutionaire test, kan het complexe, chaotische problemen oplossen die tot nu toe onmogelijk leken voor computers.

Het is alsof je een team van honderd mensen niet meer laat rennen in het rond, maar hen een perfect georganiseerd systeem geeft om samen te werken. En dat systeem wordt nu ontworpen door een AI die zelf leert hoe het werkt.

Technische samenvatting

Titel: ParEVO: Synthese van Code voor Irreguliere Data: Hoge Prestaties door Parallelisme via Agente Evolutie

Auteurs: Liu Yang, Zeyu Nie, Andrew Liu, Felix Zou, Deniz Altınbükün, Amir Yazdanbakhsh, Quanquan C. Liu (Yale University & Google DeepMind).

---

1. Het Probleem

De overgang van sequentiële naar parallelle computing is essentieel voor moderne high-performance toepassingen, maar wordt gehinderd door de steile leercurve van concurrent programmeren. Dit probleem wordt verergerd bij irreguliere datastructuren (zoals sparse grafen, onbalansbomen en niet-uniforme meshes).

• Uitdagingen: Bij irreguliere data zijn toegangspatronen tot het geheugen onvoorspelbaar en zijn werkverdelingen dynamisch. Statische planning faalt hier vaak.
• Fouten in huidige LLM's: Bestaande Large Language Models (LLM's) zijn getraind op sequentiële code en vertonen een sterke "sequentiële bias". Wanneer ze worden gevraagd om parallelle code te genereren, introduceren ze vaak subtiele race-conditions, deadlocks of inefficiënte, grofkorrelige vergrendelingen die de uitvoering zelfs langzamer maken dan sequentiële code.
• Gebrek aan abstractie: Het leren van lage-niveau threading-primitieven (zoals pthreads) is foutgevoelig. Er is behoefte aan een benadering die gebruikmaakt van hoog-niveau algoritmische primitieven.

2. Methodologie: Het ParEVO Systeem

ParEVO is een end-to-end systeem dat drie fasen doorloopt om hoogwaardige parallelle code te synthetiseren, specifiek gericht op de ParlayLib-bibliotheek (voor C++) en RPB (voor Rust).

Fase 1: Data Synthese (Parlay-Instruct Corpus)

Omdat hoogwaardige parallelle code schaars is op GitHub, creëerden de auteurs een synthetische dataset van 13.820 taken via een "Teacher-Student-Critic" pipeline:

• Seed Generatie: Handmatig geschreven "gouden" voorbeelden van ParlayLib-primitieven en problemen van het DMOJ (online judge platform).
• Mutatie: Een "Teacher"-LLM (Gemini-3-Pro) mutte deze seeds via type-, constraint- en algoritmische mutaties.
• Critic Loop (Rejection Sampling): Alleen code die compileert én alle unit-tests passeert, wordt geaccepteerd. Dit garandeert een corpus van empirisch performante algoritmen.
• Performance Dataset: Specifieke trajecten van "langzaam vs. snel" code werden gegenereerd om het model te leren om optimalisaties te herkennen (bijv. het gebruik van map-scan-write patronen in plaats van sequentiële push_back).

Fase 2: Supervised Fine-Tuning (SFT)

De auteurs fine-tunen meerdere modellen om hun generatie te aligneren met de semantiek van ParlayLib:

• Modellen: DeepSeek-6.7B, Qwen3-30B (voor C++ en Rust) en Gemini-2.5-Pro.
• Techniek: Low-Rank Adaptation (LoRA) en Direct Preference Optimization (DPO) om foutpatronen te onderdrukken en veilige, hoog-niveau primitieven te bevorderen.
• Doel: Het model leren om intenties te vertalen naar composabele primitieven (zoals filter, pack, scan, reduce) in plaats van handmatig thread-beheer.

Fase 3: Evolutionary Coding Agent (ECA)

Om de "laatste mijl" van correctheid en performance te verbeteren, wordt een evolutionaire zoekstrategie gebruikt:

• Populatie: De agent genereert een populatie van kandidaat-oplossingen.
• Fitness Functie: De kwaliteit wordt niet bepaald door de LLM zelf, maar door deterministische externe tools:
  • Compilers (voor syntactische correctheid).
  • Dynamische race-detectoren (voor thread-safety).
  • Performance profilers (voor runtime snelheid).
• Selectie: Op basis van MAP-Elites worden diverse en performante oplossingen geselecteerd om de context voor de volgende iteratie te vullen. Dit proces herhaalt zich totdat de beste oplossing wordt gevonden.

3. Belangrijkste Bijdragen

1. Parlay-Instruct Corpus: Een uniek, verifieerd dataset van 13.820 parallelle coderingstaken, gefilterd op empirische performance en correctheid.
2. Gespecialiseerde Modellen: De release van fine-tuned modellen (DeepSeek-Parlay, Qwen-Parlay, Qwen-Rust, Gemini-2.5-Parlay) die de semantiek van ParlayLib en veilige Rust-patronen hebben geïnternaliseerd.
3. Evolutionary Coding Agent (ECA): Een framework dat compilatie-logs en runtime-profielen gebruikt als "fitness functies" om code iteratief te verbeteren, waardoor hallucinaties van race-conditions worden geëlimineerd.
4. Inzicht in Trade-offs: Het paper identificeert een "alignment tax": fine-tuning verhoogt de correctheid aanzienlijk (Pass@1 van 0,42 naar 0,76) maar kan de piekperformance iets verlagen (van 21,7x naar 13,6x versnelling) omdat het model veilige, hoog-niveau primitieven prefereert boven risicovolle, lage-niveau atomaire operaties.

4. Resultaten

De evaluatie vond plaats op de ParEval-benchmark en tegenover expert-menselijke baselines (PBBS en RPB):

• Prestaties op ParEval: ParEVO bereikte een gemiddelde 106x versnelling (met een maximum van 1103x) ten opzichte van de baseline. Op complexe irreguliere grafenproblemen werd een robuuste 13,6x versnelling behaald.
• Vergelijking met SOTA: Het systeem presteerde beter dan geavanceerde commerciële modellen zoals GPT-5-Thinking en Gemini-3-Pro.
• Menselijke Baselines: Op specifieke, zeer irreguliere kernels (zoals Maximal Independent Set) overtrof de gegenereerde Rust-code menselijke experts met een 4,1x versnelling.
• Correctheid: De fine-tuned modellen tonen een bijna perfecte compilatiekans (Build@1) en vermijden race-conditions die bij basismodellen veelvuldig voorkomen.

5. Betekenis en Conclusie

ParEVO demonstreert dat AI-agenten effectief kunnen navigeren in de complexe landschappen van High-Performance Computing (HPC), mits ze worden getraind op de juiste abstractieniveaus.

• Abstractie is cruciaal: Door te focussen op composabele primitieven (ParlayLib) in plaats van lage-niveau threads, worden de problemen van synchronisatie en race-conditions grotendeels opgelost door de bibliotheek zelf.
• Evolutie vs. Statistische Generatie: Het paper benadrukt dat statische generatie niet genoeg is voor HPC; een iteratieve, feedback-gedreven cyclus met deterministische verifiers (compilers/sanitizers) is noodzakelijk om zowel correctheid als performance te garanderen.
• Toekomst: Dit werk zet een precedent voor "AI-gedreven Performance Engineering", waarbij systemen actief redeneren over schaalbaarheid en de interactie tussen algoritmen en hardware, in plaats van alleen code te completeren.

De broncode en datasets zijn beschikbaar via de GitHub-repository van het project.