Learning to Parallelize with OpenMP by Augmented Heterogeneous AST Representation
Dit artikel stelt Graph2Par voor, een nieuwe graafgebaseerde leerbenadering die gebruikmaakt van een uitgebreide heterogene AST-representatie en een nieuw gecreëerde OMP_Serial-dataset om een nauwkeurigheid van 85% te bereiken bij het detecteren van OpenMP-paralleliseerbare lussen, waarmee het de huidige state-of-the-art op basis van tokens overtreft.
Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer
Moderne computers zijn de laatste tijd veranderd in enorme steden van kleine werkers, die elk in een fractie van een seconde een taak kunnen uitvoeren. Om deze machines snel te laten draaien, moeten programmeurs hen leren om veel werkers tegelijkertijd naar buiten te sturen om taken uit te voeren, in plaats van hen één voor één in een rij te laten werken. Deze praktijk, bekend als parallellisatie, is essentieel om het meeste uit de huidige krachtige hardware te halen. Het is echter moeilijk om een computer te vertellen hoe hij zijn werk moet verdelen. Het vereist een diep begrip van hoe verschillende onderdelen van een programma met elkaar afhankelijk zijn. Als een programmeur een fout maakt, kan het programma crashen of een foutief antwoord produceren. Al decennia lang bouwen experts hulpmiddelen om automatisch deze kansen voor teamwork te vinden, maar deze hulpmiddelen spelen vaak te veilig, waardoor ze veel kansen om te versnellen missen, of ze raken in de war door complexe codestructuren.
In een recente studie hebben onderzoekers geprobeerd computers te leren om deze kansen zelfstandig te herkennen, met behulp van een methode die geïnspireerd is op hoe machines taal begrijpen. Het team, geleid door Le Chen en collega's van Iowa State University en Intel Labs, richtte zich op een specifiek type instructie die wordt gebruikt in de programmeertaal C, genaamd OpenMP. Deze instructies fungeren als wegwijzers die de computer vertellen waar het veilig is om tegelijkertijd meerdere werkers te starten. De uitdaging was dat bestaande hulpmiddelen, die vertrouwen op rigide wiskundige regels, vaak het bos niet meer door de bomen zien. Ze kunnen een perfect paralleliseerbare lus missen simpelweg omdat deze een functieaanroep of een geneste structuur bevat die er voor een traditionele analyzer ingewikkeld uitziet. De onderzoekers realiseerden zich dat ze om dit op te lossen een nieuwe manier nodig hadden om de computer te laten zien hoe de code er werkelijk uitziet, niet alleen als een reeks woorden, maar als een kaart van de structuur en betekenis.
Om dit aan te pakken, moest het team eerst een enorme bibliotheek met voorbeelden opbouwen, een dataset die zij OMP Serial noemden. Ze verzamelden bijna 18.600 voorbeelden van lussen die al als parallel waren gemarkeerd en ongeveer 14.000 lussen die dat niet waren. Ze haalden deze uit duizenden echte softwareprojecten die op het internet te vinden zijn, evenals uit zorgvuldig ontworde synthetische voorbeelden die specifieke patronen testen. Deze collectie bood hen een rijke grondwaarheid om van te leren. Maar het hebben van de data was slechts de helft van de strijd; ze hadden een manier nodig om de data in een machine learning-model te voeden dat de code echt zou kunnen begrijpen. In plaats van de code te behandelen als een zin in een boek, waarbij de volgorde van woorden het belangrijkst is, besloten ze de code te behandelen als een complexe kaart. Ze creëerden een representatie genaamd een augmented heterogeneous abstract syntax tree. In eenvoudige termen is dit een gedetailleerde grafiek die elk deel van de code met elkaar verbindt. Het toont niet alleen de hiërarchie van het programma — zoals een bovenliggende opdracht en de onderliggende opdrachten — maar ook hoe de code van de ene stap naar de volgende stroomt en hoe de woorden in de code naast elkaar staan in de tekst. Deze kaart legt het structurele skelet van het programma vast, terwijl ook de subtiele relaties tussen verschillende onderdelen worden bewaard die een simpele lijst van woorden zou missen.
Met deze nieuwe kaart in de hand trainden de onderzoekers een geavanceerd leermodel dat bekend staat als een heterogeneous graph transformer. Stel je dit model voor als een student die duizenden van deze kaarten te zien krijgt, samen met het juiste antwoord voor elk exemplaar: of de lus veilig is om te paralleliseren of niet. Het model leert de verborgen patronen te herkennen die op veiligheid wijzen. Het let op de verschillende soorten verbindingen in de kaart, waarbij het begrijpt dat een link tussen een functieaanroep en een variabele iets anders kan betekenen dan een link tussen twee wiskundige operaties. Eenmaal getraind, werd het model getest op zijn vermogen om te voorspellen welke lussen geparalleliseerd konden worden en, cruciaal, welk specif kind type instructie gebruikt moest worden om dat te doen. De resultaten waren opmerkelijk. Het model behaalde een nauwkeurigheid van 85 procent in het detecteren van paralleliseerbare regio's, waarmee het de beste bestaande hulpmiddelen die vertrouwen op traditionele statische analyse aanzienlijk overtrof.
De studie onthulde ook precies waar de oude hulpmiddelen faalden. De onderzoekers ontdekten dat de meest voorkomende fouten gemaakt door traditionele software te maken hadden met lussen die functieaanroepen bevatten, lussen die een grote hoeveelheid gegevens reduceren tot een enkele waarde, en lussen die genest zijn binnen andere lussen. Dit zijn de lastige gevallen waarbij de code er rommelig uitziet voor een rigide analyzer, maar eigenlijk veilig is voor parallel werk. De nieuwe machine learning-benadering kon deze complexe structuren daarente daarentegen met veel meer succes aan. Het gokte niet alleen; het leerde de onderliggende logica van de vorm van de code. De onderzoekers toonden aan dat door een rijke, structurele kijk op de code te combineren met krachtige leeralgoritmen, het mogelijk is om een taak te automatiseren die lang menselijke intuïtie heeft vereist. Dit werk suggereert dat de toekomst van het schrijven van snelle software niet ligt in betere regelboeken voor computers, maar in het leren aan computers om de code te zien zoals een ervaren menselijke programmeur dat doet: als een levend, onderling verbonden systeem in plaats van een statische opeenvolging van commando's.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.