Pipelining: Software Optimeringar Av: Gustaf Lagerblad

Transkript

1 1 Pipelining: Software Optimeringar Av: Gustaf Lagerblad Abstrakt Denna rapport är en sammanfattning av tre vetenskapliga artiklar som beskriver olika metoder för att optimera software pipelining momentet i pipelining processer. I A Simple, Verified Validator beskriver Jean-Baptiste Tristan och Xavier Leroy (2010) en algoritm som de har utvecklat som kan användas som en validator av kod för software pipelining. I An Automatic Parallel-Stage Decoupled Software Pipelining Parallelization Algorithm Based on OpenMP framför Xiaoxian Liu, Rongcai Zhao, Lin Han, och Peng Liu (2013) deras lösning på problemet är att de flesta processorerna idag har flera kärnor men många program är skrivna så att det ska köras på enkel kärnade processorer. De försöker lösa detta problemet genom att implementera en decoupler av koden för bättre anpassa den till att sätt in i en software pipeline. Det som presenteras i A Software Pipelining Algorithm in High-Level Synthesis for FPGA Architectures av Lei Gao, David Zaretsky, Gaurav Mittal, Dan Schonfeld och Prith Banerjee (2009) är hur man kan optimera FPGA arkitektur genom att implementera en software pipeline på hög nivå. De framställer denna optimeringen genom att modifiera modulo algoritm. Inledning I artikeln av Jean-Baptiste Tristan och Xavier Leroy (2010) beskriver de ett verktyg som är baserats på ett huvudkoncept. Detta koncept kan förenklas till att man ska gå från ett block av kod i en högre nivå till ett block av koden som ska in i processors pipeline. Från den slutsatsen skapade de algoritm. Denna algoritm anser Jean-Baptiste Tristan och Xavier Leroy (2010). vara så pass enkel att den kan bli implementerad i fler moment angående software pipelining. De menar att det kan användas för att optimera utvecklingsprocessen med att använda den i en debugger. Algoritmen anses av Jean-Baptiste Tristan och Xavier Leroy (2010). vara också tillräckligt kraftfull för att implementeras i kompilatorer. Xiaoxian Liu et al. (2013) presenterar i deras artikel An Automatic Parallel-Stage Decoupled Software Pipelining Parallelization Algorithm Based on OpenMP sätt att optimera program exekveringstid genom att översätt enkeltrådade applikationer till flertrådade. Deras givna anledning är på grund av att prevalensen av fler kärnade processorer och att mycket av dagens program är skrivna så att applikationen ska exekveras på en enkeltrådade processor. Att gå från enkel till flertrådade enligt Xiaoxian Liu et al. (2013) skapar problem med kontrollflödet, rekursiva datastrukturer och generella pekare. Deras lösning är att använda sig av en algoritm som frikopplar koden så at den kan struktureras om till att passa med ett parallellt pipelinesystem.

2 2 Det som presenterats i Lei Gao et al. artikel A Software Pipelining Algorithm in High-Level Synthesis for FPGA Architectures är deras modifiering av modulo schemaläggnings algoritm för högnivåsyntes för FPGA-arkitekturer. Lei Gao et al. variant på algoritmen är inriktad på att förbättra prestanda av FPGA genom att implementera en software pipeline. De problem som Lei et al. försöker lösa i deras modifiering av modulo algoritmen är pipeline får delar som blir beroende av varandra och så sätt uppkommer problem när en enhet vill ha information av en den enhet som fråga och skapar en paradox. Ytterligare ett problem enligt dem som uppkommer är att den klassiska implementationen av algoritmen inte använder livstids hål eller tillfälliga hål i minnesoperationer med hänsyn till att sänka intervallet mellan start och huvud blocket av kod. Bakgrund I början av 1980-talet började software pipelining som koncept enligt Monica S. Lam (1988) i hennes artikel Software Pipelining: An Effective Scheduling Technique for VLIW Machines men även i Jean-Baptiste Tristan och Xavier Leroy (2010) artikel A Simple, Verified Validator for Software Pipelining. Lam beskriver i sin artikel att historian av software pipelining börja med instruction-level parallelism (ILP) och Davidson och Patel studier i hardware pipelining. Davidson och Patel beskriver Monica S. Lam (1988) kom fram till insättning av rätt mängd förseningar och buffrar mellan resurser, till exempel ALU:n, kan öka genomströmningen och ta bort risker av resurskollisioner. De framförde även en algoritm som sätter in minimalt mäng fördröjningar i schemat för att göra så att varje operation exekverar på samma tidsintervall så kallad branch-and-bound algoritmen. Monica (1988) antyder att det är lätt att se paralleller mellan software pipelining och ILP. Hon anser detta på grund av licensen mellan varje operation i en pipeline och varje operation i en loop. Huvudbakgrund A Simple, Verified Validator Enligt Jean-Baptiste Tristan och Xavier Leroy (2010) i deras artikel A Simple, Verified Validator menar de att software pipelining kan delas upp i tre steg. Det första steg väljer man ut en inre loop från koden. Vid det här laget tar de fram några beteckningar av delar av loopen. N är en statisk variabel som dikterar antal gånger loopen körs. B är basic block alltså själva koden som exekveras vid varje genomgång av loopen. De specificerar att B inte får innehålla några funktioner, kallelser eller villkorliga hopp. Sist i som är indexet av hur många gånger loopen har genomförts. Sedan i steg två menar Jean-Baptiste Tristan och Xavier Leroy (2010) är själva omvandlingen av koden från vanlig kod till att vara anpassad för en pipeline. Denna process kallas software pipeliner. Här introduceras ytterligare några variabler S, P, E, μ och δ. Där S är en ny loopkropp kallad steady state. P är koden som utförs innan loopen, på så sätt fylls pipelinen innan loopen startar. Sedan E är koden som exekveras efter loopen så att den kan tömma pipelinen. μ är antal gånger minimalt loopen kan itereras och δ är antal unrolls av S. En genomgång av S är δ iterationer av original loopens B. Sista variabeln som beskrivs är θ som är alla variabler som finns inne i original loopen.

3 3 Följande i steg tre byts original loopen ut med den nya software pipelined loopen enligt Jean- Baptiste Tristan och Xavier Leroy (2010). Jean-Baptiste Tristan och Xavier Leroy (2010) algoritmen som de framför i deras artikel ligger huvudsakligen i steg två. De använder tidigare använda variabler för att jämföra den nyskapade loopen med original loopen. Deras algoritm gör detta genom att han en funktion som tar fram run-time beteende och därefter jämföra mellan variabler. (1) α(b μ ) θ α(p) och α(e) (2) α(e) och α(b δ ) θ α(s) och α(e) (3) α(b) θ (4) α(b)(i) = Op(addi(1), i 0 ) (5) α(p)(i) = α(b μ )(i) (6) α(e)(i) = α(b δ )(i) (7) α(b)(n) = α(p)(n) = α(s)(n) = α(e)(n) = N 0 Det som kontrolleras i (1) och (2) är att de kodblocken som är observerbara är ekvivalenta. I kontrollen (3) checkar den om de observerbara variablerna θ är de samma i de två blocken. I (4) till (6) säkra att indexen i ökar som förväntat med alla variabler. I sista inspektionen (7) kontrolleras om variabeln N behåller sin statiska karakteristiska egenskap. Om alla av dessa kriterier möts menare Jean-Baptiste Tristan och Xavier Leroy (2010) att software pipeliner har utförts korrekt och att koden kommer utför samma uppgift. A Software Pipelining Algorithm in High-level Synthesis for FPGA Architectures Lei Gao et al. (2009) presenterar i deras artikel A Software Pipelining Algorithm in High- Level Synthesis for FPGA Architectures en software pipelining algoritm för högnivåspråk för FPGA:er. Deras algoritm kan brytas ner till två moment som sätts ihop i själva konstruktionen av software pipelineade koden. De två stegen som beskrivs är analysen av cirkulära beroenden, alltså om variabler är beroende av andra variabler i loopen, och minnes hål under hela loopens livstid samt insättningar av förseningar. Vid Lei Gao et al. (2009) algoritmens analys av cirkulära beroenden börjar med som förra artikeln av Jean-Baptiste Tristan et al. definieras kanterna av loopen och själva huvuddelen av loopen. Sedan är begränsade upprepande MII (minimum initiation interval) uträknat av original loopen. Därefter är loopen unrolled med en faktor av två. Sist så använder deras algoritm sliding window metoden för att gå igenom den förändrade loopen och räknar om den begränsade upprepande MII. Efter dessa moment har utförts så skapar algoritmen en prolog, epilog och en ny loopkropp. Lei Gao et al. skriver att detta ger algoritmen en tidkomplexitet av O(m n) där m är antal tid steg och n antal instruktioner. I värsta fallet är enligt Lei Gao et al när m = n då får funktionen komplexiteten O(n 2 ).

4 4 I steg två när evalueringen om cirkulära beroenden har utförts går enligt Lei Gao et al. (2009) algoritmen vidare. Detta görs genom att analysera loopen efter minnens hål som existerar över hela loopens gång och skapar en delay på dessa platser i koden för att lösa dem. Denna process börjar med att ta fram alla minnes operationer i loopen och lägger dem i en tabell för att upptäcka minnes hazards. Efter detta så kontrolleras denna tabell och där hazards uppkommer så sätts en delay för att lösa problemet. Detta steg har en tid komplexitet på O(n 2 ) där n är mängden av operationer av loopen. När dessa två steg har exekverats genereras den nya loopen redo att användas i pipelinen. Lei Gao et al. (2009) beskriver i artikeln att om deras software pipeline algoritm generellt ökar prestandan med 35% på icke-pipelined implementationer och med 15% bättre generellt än traditionella modulu schemalagda algoritmer. An Automatic Parallel-Stage Decoupled Software Pipelining Parallelization Algorithm Based on OpenMP I artikeln av Xiaoxian Liu et al. (2013) presenterar de en algoritm som är baserad på OpenMP. Deras version av algoritmen har fokus på att implementera den nya tekniken av Decoupled Software Pipelining (DSWP) men även lägga in Parallel-Stage (PS). Detta medför att Xiaoxian Liu et al. vid utveckling fokuserade på att skapa en två stegs PS-DSWP. Dessa två steg kan ha tre kombinationer S-S, S-P och P-S. Där S är ett sekventiellt steg och P är ett parallellt steg. Algoritmen har två trådar som namnges mästar- och assistanstråd. Första kombinationen S-S exekveras koden enbart sekventiellt och detta medför att koden bara kör på en tråd. Sedan är programmets loopar uppdelade i två delare, en del till mästartråden och en del till assistanstråden. Det som hamnar i mästertråden är alla operationer och uppgifter som ska utföras och assistanstråden utför dem. Därefter delas de två trådarna in i grupper baserat på deras typ av uppgifter. Efter loopen har blivit omvandlad i S-S kan den gå vidare till S-P för att ytterligare öka parallellismen. Detta göras genom att ge assistanstråden uppgiften med att rotera mellan trådarna varje gång loopen gås igenom. Antalet av trådar är inte statiskt och kan vara flera stycken samtidigt. Om kombinationen blir P-S uppkommer problemet av att det inte längre går att använda tidigare metod som förra kombinationerna. Det som utförts först är att dela upp första steget i olika trådar. Sedan är en variabel skapad för att hålla reda på vilken tråd som används. Efter det har utförts så får det andra steget uppgiften att kontrollera operationer och uppgifter. Sist är allt synkroniserat. Efter parallelliseringen av loopen har genomförts så måste koden analyseras för att förhindra och fixa beroenden mellan trådarna. Dessa beroenden är kontroll, data inuti loopen, data utifrån som används inne och data inne som används utifrån. Kontroll beroendet uppkommer när en instruktion behöver data som finns i en annan tråd, alltså när en braching instruktion användas. Xiaoxian Liu et al. (2013) beskriver att detta beroende hanteras av två-stegs processen genom att dela upp utförandet av uppgifterna och instruktionerna i två grupper av trådar. Nästa beroende är när data är beroende av annan data inom samma loop. Detta är lös genom att skapa en ny uppgift som underlätta detta problem genom att använda metoden datadelnings firstprivate clause från OpenMP. Det löser problemet genom att spara den mängden

5 5 av variabler och håller de uppdaterade mellan trådarna. På samma sätt löses beroendet med data som finns utanför loopen som används inuti. Beroende-problemet med variabler som finns inuti loopen och ska användas utanför hanteras på ett liknade sätt som data inne i loopen. Istället för firstprivate clause används lastprivate clause som skickar tillbaka den till huvud tråden. Sedan när OpenMP PS-DSWP transformationen ska implementeras skapas en Program Dependence Graph (PDG) av loopen, där basic blocket är en egen node jämförelsevis med andra implementationer enligt Xiaoxian Liu et al. (2013) Därefter är basic blocken indelat baserad på vilken komponent de använd mest. Om det finns fler än en komponent som används huvudsakligen samlas alla i en nod. Om det finns bara en komponent som används huvudsakligen så stoppas implementationen på grund av att den inte kan bli uppdelad i flera trådar. Efter detta så valideras den nya loopen genom att lösa ett heuristiskt problem. Med Xiaoxian Liu et al. (2013) version av algoritmen beskriver de att de fick en maximal förbättring på exekveringstiden på 2,07 gånger snabbare och generellt fick de 1,39 gånger snabbare. Slutsatser I denna rapport gås igenom tre vetenskapliga artiklar som kan användas för att förbättra prestandan av software pipelinig steget. Denna rapport kan förbättras genom att göra en djupare analys av dessa artiklar och ämnet i helhet. Även kan det noteras att det finns en stor mängd av andra sätt att optimera software pipeling steget. Referenser Tristan, J. B. & Leroy, X. (2010). A Simple, Verified Validator. POPL '10 Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming language,45(1), ss doi: / Liu, X., Zhao, R.,Han, L. & Liu, P. (2013). An Automatic Parallel-Stage Decoupled Software Pipelining Parallelization Algorithm Based on OpenMP th IEEE International Conference on, Trust, Security and Privacy in Computing and Communications, IEEE International Conference, ss doi: /TrustCom Lei Gao, Zaretsky, D., Mittal, G., Schonfeld, D., Banerjee, P. (2009). A software pipelining algorithm in high-level synthesis for FPGA architectures th International Symposium on Quality Electronic Design, Quality of Electronic Design, ISQED Quality Electronic Design, ss doi: /ISQED Lam, M. (1988). Software pipelining: an effective scheduling technique for VLIW machines. ACM / SIGPLAN Notices, ss , 23(7). doi: /