CrossTL: Hub-Based Translation of GPU Programs and the Preservation of Source Rules
Dit artikel introduceert CrossTL, een open-source hub-gebaseerde vertaler die tien GPU-talen naar elf doelwitten routeert via een regeldragende tussenliggende taal (CrossGL), waarbij wordt aangetoond dat het expliciet behouden van bronspecifieke semantische regels de vertaalafwijkingen aanzienlijk vermindert in vergelijking met syntaxis-alleen benaderingen, hoewel het niet volledig de correctheid kan garanderen vanwege onderliggende implementatie-onconformiteiten en slechts marginale bruikbaarheidswinsten biedt op grootschalige code van derden.
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 door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer
Moderne videogames, wetenschappelijke simulaties en kunstmatige intelligentie vertrouwen allemaal op een speciaal soort computerprogramma dat draait op grafische processoren. Deze chips zijn ongelooflijk snel in het tegelijkertijd uitvoeren van veel berekeningen, maar ze zijn kieskeurig over hoe ze met getallen omgaan. Verschillende bedrijven die deze chips maken — zoals Apple, NVIDIA en AMD — gebruiken verschillende talen om deze programma's te schrijven. Hoewel de talen aan de oppervlakte op elkaar lijken, verschillen ze vaak in de meest fundamentele regels van de rekenkunde. Bijvoorbeeld: de ene taal kan zeggen dat het optellen van een getal bij zichzelf, wanneer het resultaat te groot is, moet terugkeren naar een klein negatief getal, terwijl een andere taal zegt dat diezelfde handeling ongedefinieerd is en tot alles kan leiden. Als een ontwikkelaar een programma voor het ene type chip schrijft en probeert over te zetten naar een ander type, moeten de vertaalhulpmiddelen beslissen welke regel ze volgen. Als ze dit fout doen, kan het programma wel compileren en draaien, maar produceert het het verkeerde antwoord, wat een game kan laten crashen of wetenschappelijke gegevens kan corrumperen.
Een team onderzoekers zette zich schrap om dit probleem op te lossen door een universele vertaler voor deze grafische programma's te bouwen. Ze creëerden een systeem genaamd CrossTL, dat fungeert als een centraal knooppunt. In plaats van voor elk mogelijk paar talen een aparte vertaler te bouwen, neemt hun systeem code van tien verschillende brontalen en zet deze om naar één enkele, neutrale vorm voordat het wordt verzonden naar elf verschillende doeltaalvormen. De kernuitdaging waar zij voor stonden, was dat deze neutrale vorm op zichzelf niet onthoudt welke specifieke regel voor een bepaat stuk code van toepassing zou moeten zijn. Het ziet een simpel plusteken, maar kan niet zien of dat teken staat voor "terugkeren naar een klein getal" of "stoppen en een foutmelding geven". Zonder dit geheugen zou de vertaler per ongeluk de betekenis van het programma kunnen veranderen, wat leidt tot stille fouten waarbij de code wel draait, maar het verkeerde resultaat berekent.
Om dit op te lossen, ontwikkelden de onderzoekers een methode genaamd "rule carrying" (regel-dragen). Ze pasten hun vertaler aan door een specifieke notitie bij elke wiskundige operatie te voegen die ze tegenkomen. Deze notitie legt precies vast welke regel de oorspronkelijke taal voor die operatie gebruikte. Wanneer de code door het knooppunt beweegt en richting een nieuwe doeltaal gaat, controleert de vertaler deze notitie. Als de doeltaal dezelfde regel volgt, laat de vertaler de operatie ongewijzigd door. Als de doeltaal een andere regel volgt, vervangt de vertaler de operatie door een op maat gemaakte code die de doeltaal dwingt zich exact gedragen als de brontaal. Dit zorgt ervoor dat het programma hetzelfde resultaat berekent op de nieuwe hardware als op de oude, ongeacht de verschillen in de onderliggende talen.
Het team testte dit systeem grondig met een reeks van zesent zestig zorgvuldig ontworpen testprogramma's, bekend als hazard kernels. Deze tests waren ontworpen om de specifieke regels te triggeren waar talen van mening verschillen, zoals wat er gebeurt bij een deling door nul of het optellen van getallen die te groot zijn. Ze draalden deze tests op een verscheidenheid aan echte hardware en softwareomgevingen, waaronder de grafische processoren van Apple en diverse open-source drivers. De resultaten toonden aan dat zonder hun nieuwe methode, bestaande vertaalhulpmiddelen in veel gevallen de juiste regels kwijtraakten, wat leidde tot onjuiste outputs. Wanneer de onderzoekers de "rule-carrying" functie inschakelden, behield het systeem de correcte werking in bijna alle gevallen. Van honderden testruns daalde het aantal fouten drastisch; de overgebleven enkele fouten werden herleid tot specifieke eigenaardigheden in de manier waarop bepaalde drivers de code afhandelden, in plaats van gebreken in de vertalingslogica zelf.
De studie onderzocht ook hoe deze nieuwe methode presteerde op duizenden echte programma's geschreven door derden, variërend van machine learning-bibliotheken tot graphics engines. De onderzoekers ontdekten dat hoewel het nieuwe systeem iets minder waarschijnlijk was om code te produceren die door een compiler werd geaccepteerd vergeleken met sommige gevestigde tools, het veel betrouwbaarder was in het garanderen dat de code die wel compileerde, ook daadwerkelijk werkte. Sterker nog, de nieuwe methode veranderde het succespercentage van de code met minder dan één procentpunt, wat bewees dat het kan worden toegepast zonder bestaande workflows te verstoren. De onderzoekers concludeerden dat voor een vertaler om werkelijk getrouw te zijn, hij niet alleen syntaxis van de ene taal naar de andere moet verplaatsen, maar ook de semantische regels van de brontaal met zich mee moet dragen, zodat de betekenis van het programma de reis ongeschonden overleeft.
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.