DM13-3. Obligatorisk opgave E.05 Håndoptimering af SPARC assembler-kode

Transkript

1 - 3. Obligatorisk opgave E.05 Håndoptimering af SPARC assembler-kode Jacob Aae Mikkelsen december

2 Indhold 1 Opgave beskrivelse 2 2 Muligheder for optimering efter branch Beregning af hukommelses adresse Unødvendig I/O Undlade at oprette nyt registervindue Analyse Quicksort metoden Partition Implementation 3 5 Afprøvning 5 6 Konklusion 6 7 bilag Den optimerede assemblerkode Den kommenterede ikke-optimerede partition Den oprindelige assemblerkode O2 optimeret assemblerkode

3 1 Opgave beskrivelse Det udleverede c-program for quicksort algoritmen skal først ved hjælp af gcc oversættes til SPARC assembler kode, hvorefter den del der har med metoden partition at gøre skal optimeres manuelt. Opgaven består i at analysere assemblerkoden, samt beskrive implementationen og afprøvningen. Analysen skal indeholde en beskrivelse af hvordan den oprindelige kode fungerer og dennes brug af registre. Implementations afsnittet skal indeholde overvejelser med hensyn til den optimerede kode, og dokumentation af denne. Koden ønskes endvidere udførligt dokumenteret. Afprøvningens resultater skal vedlægges som dokumentation for korrekthed. 2 Muligheder for optimering 2.1 efter branch Da SPARC maskinen benytter en pipelined opbygning, vil kommandoen lige efter en branch instruktion blive udført lige meget om der hoppes eller ej. Assembleren løser dette ved at indsætte en 1. Denne instruktion kan visse steder benyttes til at udføre kode, og derved spare en instruktion. Det kræver dog at der findes en instruktion der kan flyttes; ofte hoppes der jo på grund af en branch, og det må ikke være en linie, som branchen afhænger af. 2.2 Beregning af hukommelses adresse Det tager to instruktioner at lave en addresse til hukommelsen på en SPARC maskine, fordi en hukommelses adresse er på 32 bit, og en instruktion maksimalt kan holde 22 bit. Det er derfor en fordel at beregne en adresse én gang, og gemme denne i et register, som der så kan refereres relativt til, når det er fx et array der skal hentes oplysninger i. Assemblerens kode beregner denne adresse mange gange, uden at gemme den, så her er der mulighed for at optimere en del. 2.3 Unødvendig I/O Tilgang til hukommelsen er en af de tidsbekostelige instruktioner, specielt hvis ikke dataene findes i cachen. Det kan derfor betale sig at begrænse I/O aktiviteten, og i stedet gemme midlertidige værdier i et register. 2.4 Undlade at oprette nyt registervindue Hvis den metode der håndoptimeres er en leaf-procedure, en metode der ikke kalder andre metoder og kun bruger et begrænset antal variabler, kan 1 - no operation, udfører ingenting 2

4 det lade sig gøre ikke at oprette et nyt sæt registre, og på den måde spare for en del flytten rundt af pointere i stacken. 3 Analyse 3.1 Quicksort metoden Det første der bemærkes i quicksort, er at der her oprettes et nyt sæt registre, det vil altså sige at det kun er hertil vi behøver at koncentrere os om indholdet af registrene. Ved gennemgang af metoden ser vi at den kun benytter registrene %i0 og %i1 af ind-registrene, samt %o0 og %o1 af udregistrene, og det er disse registre den sender til partition som parametre. Vi ser også at den skal have resultatet leveret i %o Partition Den uoptimerede assemblerkode for partition er på 103 instruktioner. Der er 7 steder den sammensætter adressen på num-arrayets første element, ved sethi og or kombinationen. Dette er 14 liniers kode, hvor kun 2 er nødvendig, hvis blot man opbevarer adressen i et register. Der er ligeledes 7 gange at følgende kombination forekommer: ld [%fp+68], %o1 mov %o1, %o2 Her kunne lige så godt loades direkte ind i det rigtige register, og herved må der kunne spares alle mov linierne..ll7,.ll16 og.ll17 består kun af hop instruktioner, og der kunne der lige så godt være hoppet direkte til det rigtige sted, i stedet for denne omvej. Ellers følger assembler koden ret lineært c-koden, se i bilag 7.2, hvor partition metoden er vedlagt, kommenteret på hvad der sker. 4 Implementation Vi ønsker altså helt konkret at lave en implementeret udgave, hvor der kun benyttes de eksisterende ud registre, fra %o0 til %o5 2, idet %06 og %07 har en speciel funktion som bl.a. %sp[2] Da vi ved ikke at oprette et nyt sæt registre ved at p og r befinder sig i %o0 og %o1, er det første vi gør at finde adressen på num arrayet og gemme denne i %o2: 2 De globale registre %g0 til %g7 kunne også benyttes, men det er ikke nødvendigt 3

5 partition: sethi %hi(num), %o2 or %o2, %lo(num), %o2 Når nu man ved at adresserne vi søger efter i arrayet ligger med spring på 4, kan vi lige så godt lave denne omregning én gang for alle, og dermed spare de sll kommandoer der er hver gang vi skal hente noget i arrayet. Blot skal der trækkes 4 fra eller lægges 4 til i stedet for 1. Vi venstreskifter derfor både r og p med 2, som er det samme som at gange med 4. sll %o0, 2, %o0 sll %o1, 2, %o1 Pivot elementet er det der ligger på plads p i arrayet, og det henter vi ud og gemmer i %o3: ld [%o2+%o0], %o3 I forhold til den udleverede C-kode, finder vi nu i og j. Da vi ikke skal bruge p og r til noget længere, kan vi placere i i register %o0 og j i %o1. add %o0, -4, %o0 add %o1, 4, %o1 Vi er nu nået til den første løkke, der jo kun stoppes, når den brydes for at returnere. Den startes med en j=j-1, og denne instruktion genbruges i den kommende løkke..ll9: add %o1, -4, %o1 Det næste vi møder er en ny start på en løkke, vi henter derfor num[j] ud af arrayet, gemmer i %o4 og sammenligner med pivot elementet i %o3. Hvis pivot er den mindste kører løkken endnu en iteration. Da der ikke er noget vi kan flytte til lige efter branch en bliver vi nødt til at indsætte en. 3 ld [%o2+%o1], %o4 cmp %o4, %o3 bg.ll9 Den næste blok er så starten på den tredje løkke, hvori = i+1 genbruges, og num[i] sammenlignes med pivot elementet. Her slipper vi dog for en instruktion efter branchen, da cmp ikke ændrer på noget hvis den skulle blive udført når der hoppes. 3 Kunne også syntaktisk indføre en br,a i stedet for br med en efter, men dette er af kosmetisk betydning, det har ingen indflydelse på kørslen af det oversatte program. 4

6 .LL11: add %o0, 4, %o0 ld [%o2+%o0], %o5 cmp %o5, %o3 bl.ll11 Sammenligningen i < j er enkel, da vi har begge i registrene %o0 og %o1, og hvis det ikke sandt, hoppes til slutningen, og alle løkkerne er færdige. Her er heller ikke nogen instruktioner der kan passe ind, så vi indsætter en. Hvis ikke udføres ombytningen af de to elementer, og der springes til den første af løkkerne. Efter dette branch kan vi gemme den sidste af værdierne i ombytningen, da denne skal udføres under alle omstændigheder. cmp %o0, %o1 bge.ll8 st %o5, [%o2+%o1] b.ll9 st %o4, [%o2+%o0] Slutteligt er der bare at placere j i register %o0, i stedet for register %o1, men da denne skal højreskiftes tilbage igen giver dette ingen ekstra kommanda, men kan derimod indsættes efter retl kommandoen, der jo er en hop kommando..ll8: retl srl %o1,2, %o0 Register Brug %o0 p og i %o1 r og j %o2 adressen på num-arrayet %o3 pivot elementet %o4 Arbejds register %o5 Arbejds register Tabel 1: Oversigt over de benyttede registre 5 Afprøvning For at afprøve programet skal den optimerede kode compileres, og udskriften vedlægges. Følgende er hvad resultatet blev: Input: 42, 10, 18, 19, 18, 12, 8, 3, 15, 20, 3, 17, 25, 11, 23, 12, 0, -8,-13, 9, 5

7 Output: -13, -8, 0, 3, 3, 8, 9, 10, 11, 12, 12, 15, 17, 18, 18, 19, 20, 23, 25, 42, Det ser ud til at være korrekt sorteret. Med et så lille datasæt kan det ikke vurderes om køretiden faktisk er forbedret, men eftersom den ikke optimerede assemblerkode fylder 103 instruktioner, og den optimerede fylder 24, er det ikke urealistisk at tro at det fakisk er tilfældet. For at se om sorteringsalgoritmen i virkeligheden får sorteret alle elementerne rigtigt, køres den optimerede kode derfor også med et datasæt fra -10 til 9, indsat i bagvendt rækkefølge. Alle tallene i arrayet skal hermed flyttes, og resultatet er her: Input: 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9,-10, Output: -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, Testen er lavet ved at udskifte værdierne i num: øverst i assemblerkoden. Da denne test også er bestået, konkluderes at korrektheden er i orden. Hvis der skal testes om det er tilfredsstillende optimeret, kan vi sammenligne med en optimeret version af assemblerkoden, ved at oversætte den med kommandoen: gcc -S -O2 quicksort.c. Denne er vedlagt i bilag 7.4, og som det ses, er partition på 44 linier. Vores håndoptimerede kode på 24 linier vurderes derfor som tilfredsstilende. Den maskin optimerede benytter endvidere g-registrene, det gøres ikke i den håndoptimerede. 6 Konklusion Quicksort algoritmen er oversat til assembler kode, og metoderne quicksort og partition er analyseret. Partition er håndoptimeret, og resultatet er testet og vurderet at være tilfredsstillende. Selve optimeringsprocessen er beskrevet. Alle delopgaver er derfor løst, og processen er dokumenteret her. Skulle man filosofere en anelse over optimeringen, kan man lægge mærke til at metoden quicksort kalder sig selv rekursivt 2 gange for hver gang den kalder partition. Derfor vil der blive oprettet mange registervinduer, selvom vi ikke gør det i partition. Dette kunne ændres ved at lave en iterativ udgave af quicksort i stedet for en rekursiv som vi har set på. Den iterative implementation er til gengæld mere kompliceret at programmere.[3] Hvor vidt det reelt vil ændre køretiden væsentligt skal være usagt, og det skal mere betragtes som en strøtanke i denne afsluttende del af denne opgave. 6

8 Litteratur [1] Tanenbaum, Andrew S., Structured Cmputer Organization, 5th ed. [2] Sun Microsystems, Inc., Assembly Languge Reference Manual for SPARC [3] 7

9 7 bilag 7.1 Den optimerede assemblerkode. f i l e " quicksort. c" gcc2_compiled. :. global num. section ". data". type num,# object. s i z e num,80 num:. uaword 42. uaword 10. uaword 18. uaword 19. uaword 18. uaword 12. uaword 8. uaword 3. uaword 15. uaword 20. uaword 3. uaword 17. uaword 25. uaword 11. uaword 23. uaword 12. uaword 0. uaword 8. uaword 13. uaword 9. section ". rodata". align 8.LLC0:. asciz "%3d,". section ". text ". global writearray. type writearray,#function. proc 020 writearray :!#PROLOGUE# 0 st %i0, [%fp +68] st %i1, [%fp +72] save %sp, 112, %sp!#prologue# 1 st %i0, [%fp +68] st %i1, [%fp +72]. LL3 : 8

10 . LL5 :. LL4 :. LL2 : ld [%fp +72], %o1 cmp %o0, %o1 ble. LL5 b. LL4 sethi %hi (num), %o0 or %o0, %lo (num), %o1 mov %o0, %o3 s l l %o3, 2, %o2 sethi %hi (.LLC0), %o3 or %o3, %lo (.LLC0), %o0 ld [%o1+%o2 ], %o1 c a l l printf, 0 add %o0, 1, %o1 st %o1, [%fp +68] b. LL3 ret restore. LLfe1 :. s i z e writearray,. LLfe1 writearray. global partition. type partition,#function. proc 04 partition : sethi %hi (num), %o2 or %o2, %lo (num), %o2 s l l %o0, 2, %o0 s l l %o1, 2, %o1 ld [%o2+%o0 ], %o3 add %o0, 4, %o0 add %o1, 4, %o1. LL9 : add %o1, 4, %o1 ld [%o2+%o1 ], %o4 cmp %o4, %o3 bg. LL9. LL11 : add %o0, 4, %o0 ld [%o2+%o0 ], %o5 cmp %o5, %o3 9

11 bl. LL11 cmp %o0, %o1 bge. LL8 st %o5, [%o2+%o1 ] b. LL9 st %o4, [%o2+%o0 ]. LL8 : r e t l s r l %o1,2, %o0. LLfe2 :. s i z e partition,. LLfe2 partition. global quicksort. type quicksort,#function. proc 020 quicksort :!#PROLOGUE# 0 save %sp, 120, %sp!#prologue# 1 st %i0, [%fp +68] st %i1, [%fp +72] ld [%fp +72], %o1 cmp %o0, %o1 bge. LL19 ld [%fp +72], %o1 c a l l partition, 0 st %o0, [%fp 20] ld [%fp 20], %o1 c a l l quicksort, 0 ld [%fp 20], %o0 add %o0, 1, %o1 mov %o1, %o0 ld [%fp +72], %o1 c a l l quicksort, 0. LL19 :. LL18 : ret restore. LLfe3 :. s i z e quicksort,. LLfe3 quicksort. section ". rodata" 10

12 .LLC1:.LLC2:. align 8. asciz "Input : ". align 8. asciz "\noutput : ". align 8.LLC3:. asciz "\n". section ". text ". global main. type main,#function. proc 04 main :!#PROLOGUE# 0 save %sp, 112, %sp!#prologue# 1 sethi %hi (.LLC1), %o1 or %o1, %lo (.LLC1), %o0 c a l l printf, 0 mov 0, %o0 mov 19, %o1 c a l l writearray, 0 mov 0, %o0 mov 19, %o1 c a l l quicksort, 0 sethi %hi (.LLC2), %o1 or %o1, %lo (.LLC2), %o0 c a l l printf, 0 mov 0, %o0 mov 19, %o1 c a l l writearray, 0 sethi %hi (.LLC3), %o1 or %o1, %lo (.LLC3), %o0 c a l l printf, 0. LL20 :. LLfe4 : ret restore. s i z e main,. LLfe4 main. ident "GCC: (GNU) ( release )" 11

13 7.2 Den kommenterede ikke-optimerede partition partition :!#PROLOGUE# 0 save %sp, 128, %sp!#prologue# 1 st %i0, [%fp +68] p gemmes st %i1, [%fp +72] r gemmes sethi %hi (num), %o1 or %o1, %lo (num), %o0 Adressen på num ld [%fp +68], %o1 hent p mov %o1, %o2 f l y t p s l l %o2, 2, %o1 p 4 ld [%o0+%o1 ], %o0 pivot elementet st %o0, [%fp 28] gem pivot hent p add %o0, 1, %o1 i = r 1 st %o1, [%fp 20] gem i ld [%fp +72], %o0 hent r add %o0, 1, %o1 j = r + 1 st %o1, [%fp 24] gem j. LL7 : b. LL9 hop t i l. LL09 b. LL8 Her kommer vi ikke t i l. LL9 : ld [%fp 24], %o0 hent j add %o0, 1, %o1 j = j 1 st %o1, [%fp 24] gem j. LL10 : sethi %hi (num), %o1 or %o1, %lo (num), %o0 Adressen på num ld [%fp 24], %o1 hent j mov %o1, %o2 f l y t j s l l %o2, 2, %o1 j 4 ld [%o0+%o1 ], %o0 hent num[ j ] ld [%fp 28], %o1 hent pivot cmp %o0, %o1 Sammenlign bg. LL12 hop hvis større b. LL11 hop. LL12 : ld [%fp 24], %o0 hent j add %o0, 1, %o1 j = j 1 st %o1, [%fp 24] gem j b. LL10 hop 12

14 . LL11 :. LL13 :. LL15 :. LL14 : ld [%fp 20], %o0 hent i add %o0, 1, %o1 i = i + 1 st %o1, [%fp 20] gem i sethi %hi (num), %o1 Adressen på num or %o1, %lo (num), %o0 ld [%fp 20], %o1 hent i mov %o1, %o2 f l y t i s l l %o2, 2, %o1 i 4 ld [%o0+%o1 ], %o0 hent num[ i ] ld [%fp 28], %o1 hent pivot cmp %o0, %o1 sammenlign bl. LL15 hop hvis mindre end b. LL14 hop ld [%fp 20], %o0 hent i add %o0, 1, %o1 i = i+1 st %o1, [%fp 20] gem i b. LL13 hop ld [%fp 20], %o0 hent i ld [%fp 24], %o1 hent j cmp %o0, %o1 sammenlign bge. LL16 hop større end e l l e r l i g med sethi %hi (num), %o1 or %o1, %lo (num), %o0 adressen på num ld [%fp 20], %o1 hent i mov %o1, %o2 f l y t i s l l %o2, 2, %o1 i 4 ld [%o0+%o1 ], %o0 hent num[ i ] st %o0, [%fp 32] gem num[ i ] sethi %hi (num), %o1 or %o1, %lo (num), %o0 adressen på num ld [%fp 20], %o1 hent i mov %o1, %o2 f l y t i s l l %o2, 2, %o1 i 4 sethi %hi (num), %o3 or %o3, %lo (num), %o2 adressen på num ld [%fp 24], %o3 hent j mov %o3, %o4 f l y t j s l l %o4, 2, %o3 j 4 ld [%o2+%o3 ], %o2 hent num[ j ] 13

15 . LL16 :. LL17 :. LL8 :. LL6 : st %o2, [%o0+%o1 ] gem [ j ] sethi %hi (num), %o1 adressen på num or %o1, %lo (num), %o0 ld [%fp 24], %o1 hent j mov %o1, %o2 f l y t j s l l %o2, 2, %o1 j 4 ld [%fp 32], %o2 hent num[ i ] st %o2, [%o0+%o1 ] gem num[ i ] b. LL17 hop b. LL8 hop b. LL7 hop ld [%fp 24], %o0 hent j mov %o0, %i0 f l y t j b. LL6 hop ret restore tilbage 7.3 Den oprindelige assemblerkode. f i l e " quicksort. c" gcc2_compiled. :. global num. section ". data". type num,# object. s i z e num,80 num:. uaword 42. uaword 10. uaword 18. uaword 19. uaword 18. uaword 12. uaword 8. uaword 3. uaword 15. uaword 20. uaword 3. uaword 17. uaword 25. uaword 11 returner f l y t r e g i s t r e 14

16 . uaword 23. uaword 12. uaword 0. uaword 8. uaword 13. uaword 9. section ". rodata". align 8.LLC0:. asciz "%3d,". section ". text ". global writearray. type writearray,#function. proc 020 writearray :!#PROLOGUE# 0 save %sp, 112, %sp!#prologue# 1 st %i0, [%fp +68] st %i1, [%fp +72]. LL3 :. LL5 :. LL4 :. LL2 : ld [%fp +72], %o1 cmp %o0, %o1 ble. LL5 b. LL4 sethi %hi (num), %o0 or %o0, %lo (num), %o1 mov %o0, %o3 s l l %o3, 2, %o2 sethi %hi (.LLC0), %o3 or %o3, %lo (.LLC0), %o0 ld [%o1+%o2 ], %o1 c a l l printf, 0 add %o0, 1, %o1 st %o1, [%fp +68] b. LL3 ret restore 15

17 . LLfe1 :. s i z e writearray,. LLfe1 writearray. global partition. type partition,#function. proc 04 partition :!#PROLOGUE# 0 save %sp, 128, %sp!#prologue# 1 st %i0, [%fp +68] st %i1, [%fp +72] sethi %hi (num), %o1 or %o1, %lo (num), %o0 ld [%fp +68], %o1 mov %o1, %o2 s l l %o2, 2, %o1 ld [%o0+%o1 ], %o0 st %o0, [%fp 28] add %o0, 1, %o1 st %o1, [%fp 20] ld [%fp +72], %o0 add %o0, 1, %o1 st %o1, [%fp 24]. LL7 : b. LL9 b. LL8. LL9 : ld [%fp 24], %o0 add %o0, 1, %o1 st %o1, [%fp 24]. LL10 : sethi %hi (num), %o1 or %o1, %lo (num), %o0 ld [%fp 24], %o1 mov %o1, %o2 s l l %o2, 2, %o1 ld [%o0+%o1 ], %o0 ld [%fp 28], %o1 cmp %o0, %o1 bg. LL12 b. LL11. LL12 : ld [%fp 24], %o0 16

18 . LL11 :. LL13 :. LL15 :. LL14 : add %o0, 1, %o1 st %o1, [%fp 24] b. LL10 ld [%fp 20], %o0 add %o0, 1, %o1 st %o1, [%fp 20] sethi %hi (num), %o1 or %o1, %lo (num), %o0 ld [%fp 20], %o1 mov %o1, %o2 s l l %o2, 2, %o1 ld [%o0+%o1 ], %o0 ld [%fp 28], %o1 cmp %o0, %o1 bl. LL15 b. LL14 ld [%fp 20], %o0 add %o0, 1, %o1 st %o1, [%fp 20] b. LL13 ld [%fp 20], %o0 ld [%fp 24], %o1 cmp %o0, %o1 bge. LL16 sethi %hi (num), %o1 or %o1, %lo (num), %o0 ld [%fp 20], %o1 mov %o1, %o2 s l l %o2, 2, %o1 ld [%o0+%o1 ], %o0 st %o0, [%fp 32] sethi %hi (num), %o1 or %o1, %lo (num), %o0 ld [%fp 20], %o1 mov %o1, %o2 s l l %o2, 2, %o1 sethi %hi (num), %o3 or %o3, %lo (num), %o2 ld [%fp 24], %o3 mov %o3, %o4 17

19 . LL16 :. LL17 :. LL8 :. LL6 : s l l %o4, 2, %o3 ld [%o2+%o3 ], %o2 st %o2, [%o0+%o1 ] sethi %hi (num), %o1 or %o1, %lo (num), %o0 ld [%fp 24], %o1 mov %o1, %o2 s l l %o2, 2, %o1 ld [%fp 32], %o2 st %o2, [%o0+%o1 ] b. LL17 b b. LL8. LL7 ld [%fp 24], %o0 mov %o0, %i0 b. LL6 ret restore. LLfe2 :. s i z e partition,. LLfe2 partition. global quicksort. type quicksort,#function. proc 020 quicksort :!#PROLOGUE# 0 save %sp, 120, %sp!#prologue# 1 st %i0, [%fp +68] st %i1, [%fp +72] ld [%fp +72], %o1 cmp %o0, %o1 bge. LL19 ld [%fp +72], %o1 c a l l partition, 0 st %o0, [%fp 20] 18

20 . LL19 :. LL18 : ld [%fp 20], %o1 c a l l quicksort, 0 ld [%fp 20], %o0 add %o0, 1, %o1 mov %o1, %o0 ld [%fp +72], %o1 c a l l quicksort, 0 ret restore. LLfe3 :. s i z e quicksort,. LLfe3 quicksort. section ". rodata". align 8.LLC1:. asciz "Input : ". align 8.LLC2:. asciz "\noutput : ". align 8.LLC3:. asciz "\n". section ". text ". global main. type main,#function. proc 04 main :!#PROLOGUE# 0 save %sp, 112, %sp!#prologue# 1 sethi %hi (.LLC1), %o1 or %o1, %lo (.LLC1), %o0 c a l l printf, 0 mov 0, %o0 mov 19, %o1 c a l l writearray, 0 mov 0, %o0 mov 19, %o1 c a l l quicksort, 0 sethi %hi (.LLC2), %o1 or %o1, %lo (.LLC2), %o0 c a l l printf, 0 19

21 . LL20 :. LLfe4 : mov 0, %o0 mov 19, %o1 c a l l writearray, 0 sethi %hi (.LLC3), %o1 or %o1, %lo (.LLC3), %o0 c a l l printf, 0 ret restore. s i z e main,. LLfe4 main. ident "GCC: (GNU) ( release )" 7.4 -O2 optimeret assemblerkode. f i l e " quicksort. c" gcc2_compiled. :. global num. section ". data". type num,# object. s i z e num,80 num:. uaword 42. uaword 10. uaword 18. uaword 19. uaword 18. uaword 12. uaword 8. uaword 3. uaword 15. uaword 20. uaword 3. uaword 17. uaword 25. uaword 11. uaword 23. uaword 12. uaword 0. uaword 8. uaword 13. uaword 9. section ". rodata". align 8.LLC0:. asciz "%3d," 20

22 . section ". text ". global writearray. type writearray,#function. proc 020 writearray :!#PROLOGUE# 0 save %sp, 112, %sp!#prologue# 1 cmp %i0, %i1 bg. LL4 sethi %hi (num), %o0 or %o0, %lo (num), %l1 sethi %hi (.LLC0), %l0 s l l %i0, 2, %o0. LL7 :. LL4 : ld [% l1+%o0 ], %o1 c a l l printf, 0 or %l0, %lo (.LLC0), %o0 add %i0, 1, %i0 cmp %i0, %i1 ble. LL7 s l l %i0, 2, %o0 ret restore. LLfe1 :. s i z e writearray,. LLfe1 writearray. global partition. type partition,#function. proc 04 partition :!#PROLOGUE# 0!#PROLOGUE# 1 sethi %hi (num), %g2 mov %g2, %g1 or %g2, %lo (num), %g2 s l l %o0, 2, %g3 add %o1, 1, %o1 ld [%g2+%g3 ], %o4 mov %g2, %o5 add %o0, 1, %o2 s l l %o1, 2, %o3. LL11 : add %o3, 4, %o3 ld [%o3+%o5 ], %g2 add %o2, 1, %o0 cmp %g2, %o4 21

23 . LL14 :. LL13 :. LL24 :. LL23 :. LL10 : ble. LL13 add %o1, 1, %o1 or %g1, %lo (num), %g3 add %o3, 4, %o3 ld [%g3+%o3 ], %g2 cmp %g2, %o4 bg. LL14 add %o1, 1, %o1 mov %o0, %o2 s l l %o2, 2, %g2 ld [%o5+%g2 ], %g3 cmp %g3, %o4 bge. LL23 cmp %o2, %o1 or %g1, %lo (num), %o0 add %o2, 1, %o2 s l l %o2, 2, %g2 ld [%o0+%g2 ], %g3 cmp %g3, %o4 bl, a. LL24 add %o2, 1, %o2 cmp %o2, %o1 bge. LL10 s l l %o2, 2, %g2 ld [%o5+%g2 ], %o0 ld [%o3+%o5 ], %g3 st %g3, [%o5+%g2 ] b. LL11 st %o0, [%o3+%o5 ] r e t l mov %o1, %o0. LLfe2 :. s i z e partition,. LLfe2 partition. global quicksort. type quicksort,#function. proc 020 quicksort :!#PROLOGUE# 0 save %sp, 112, %sp!#prologue# 1 cmp %i0, %i1 bge. LL26 mov %i1, %o1 22

24 . LL26 : c a l l partition, 0 mov %i0, %o0 mov %o0, %l0 mov %i0, %o0 c a l l quicksort, 0 mov %l0, %o1 add %l0, 1, %o0 c a l l quicksort, 0 mov %i1, %o1 ret restore. LLfe3 :. s i z e quicksort,. LLfe3 quicksort. section ". rodata". align 8.LLC1:. asciz "Input : ". align 8.LLC2:. asciz "\noutput : ". align 8.LLC3:. asciz "\n". section ". text ". global main. type main,#function. proc 04 main :!#PROLOGUE# 0 save %sp, 112, %sp!#prologue# 1 sethi %hi (.LLC1), %o0 c a l l printf, 0 or %o0, %lo (.LLC1), %o0 mov 0, %o0 c a l l writearray, 0 mov 19, %o1 mov 19, %o1 c a l l quicksort, 0 mov 0, %o0 sethi %hi (.LLC2), %o0 c a l l printf, 0 or %o0, %lo (.LLC2), %o0 mov 0, %o0 c a l l writearray, 0 mov 19, %o1 sethi %hi (.LLC3), %o0 23

25 . LLfe4 : c a l l printf, 0 or %o0, %lo (.LLC3), %o0 ret restore. s i z e main,. LLfe4 main. ident "GCC: (GNU) ( release )" 24