Számítógép Architektúrák

Átírás

1 Számítógép Architektúrák Utasításkészlet architektúrák április 11. Budapest Horváth Gábor docens BME Hálózati Rendszerek és Szolgáltatások Tsz.

2 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 2 Hol tartunk? Vezérlésáramlásos CPU Perifériák Adatáramlásos Igényvezérelt Memória

3 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 3 Utasításkészletek Processzorok jellemzője: Programozási felület / Utasításkészlet architektúra Részei: Utasítások Támogatott adattípusok Regiszterek Címzési módok Jelzőbitek Perifériakezelési mód Megszakítás- és kivételkezelés

4 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 4 Utasításkészletek Mit tanulunk erről? Miből áll egy utasítás? Milyen fajta utasítások vannak? És az operandusok hol vannak? Hogy kezelhető a feltételes ugrás és végrehajtás? Milyen formában tároljuk az utasításokat? Mi az a little-endian és big-endian? RISC vs. CISC

5 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 5 Utasítások jellemzői Utasítások felépítése: Utasítás kódja / művelet típusa Operandusok címei / értékei Eredmény címe Következő utasítás címe Takarékosság: Köv. utasítás címe elhagyható + R1 42 R2 Operadusok száma: 3 operandusú műveletek: R1 R2 + R3 2 operandusú műveletek: R1 R1 + R2 1 operandusú műveletek: ADD R1 / 5 R2 R3

6 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 6 Utasítások jellemzői Utasítások fajtái: Adatmozgatás R1 R2, R1 MEM[100], R1 42, MEM[100] R1, MEM[100] 42 Aritmetikai és logikai R1 R2+R3, R1 MEM[100]*42, MEM[100] R1 & R2 Vezérlésátadó: JUMP 42, JUMP +28 IF R1==R2, CALL proc, RETURN Veremkezelő PUSH R1, PUSH 42, R2 I/O műveletek IO[42] R1, R1 IO[42] Transzcendens függvények POP R2 SIN R1, R2 SQRT 42 Egyebek

7 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 7 Címzési módok Címzési mód megadja, hogy hol az operandus Ahol lehet: Magában az utasításkódban Regiszterben Memóriában Címzési mód Példa Regiszter R1 R2 + R3 Közvetlen konstans R1 R Direkt R1 R2 + MEM[42] Regiszter indirekt R1 R2 + MEM[R3] Eltolt indirekt R1 R2 + MEM[R3+42] Memória indirekt R1 R2 + MEM[MEM[R3]] Indexelt R1 R2 + MEM[R3+R4]

8 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 8 Vezérlésátadó utasítások Célszerűen relatív címzés, pl. JUMP -28 Feltételes ugrás 3 jellemző megvalósítása: Feltétel kódokkal: COMPARE R1, R2 JUMP label IF GREATER Feltétel regiszterekkel: R0 R1 > R2 JUMP label IF R0 Összehasonlít és ugrik : JUMP label IF R1 > R2

9 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 9 Predikátumok Predikátumok: feltételhez kötött utasítások R1 R IF P2 Predikátumregiszter: végrehajtási feltételt tárol Állítása: összehasonlító műveletekkel P2 R3 R5

10 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 10 Utasítások jellemzői Utasításokat binárisan kódolva tároljuk Binárisan kódolt utasítások hossza szerint: Fix hosszú kódolás: Változó hosszú kódolás:

11 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 11 Assembly programozás Alacsony szintű programozás: Utasítások kézi kódolása kényelmetlen A binárisan kódolt utasítássorozat emberi fogyasztásra alkalmatlan Eszköz: assembly programozás Assembly A legalacsonyabb szintű programozási nyelv A gépi utasítások szöveges megfelelője 1 assembly utasítás -ból 1 gépi utasítás lesz Assembler: az assembly leírásból gépi kódot készít Minden utasításkészlet architektúrára más és más!

12 Utasításkódolás Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 12

13 Utasításkódolás Assembly kód A Terminátor processzora: MOS-6502 (akár az Apple II-é) (1975 és 1980 között messze a legolcsóbb CPU: a vele azonos képességű Intel és Motorola processzorok árának hatodába került) A Terminátor a Nibble magazin egyik példaprogramját futtatja Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 13

14 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 14 Utasításkódolás Assembly kód Binárisan kódolt (gépi) utasítások

15 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 15 Példa utasításkódolásra (x86) ADD ECX, EAX = 01 C1 (ASCII: ) ADD EDI, [EBX] = 03 3B (ASCII: ;)

16 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 16 Példa utasításkódolásra (x86) ADD EBX, = 81 C3 15 6B (ASCII: Qü ke )

17 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 17 Utasításkészletek további jellemzői Bájtsorrend: Little endian: legkisebb helyiértékkel kezdi Big endian: legnagyobb helyiértékkel kezdi Példa: (=1656B15) Little endian: 15 6B Big endian: B 15 Perifériakezelő utasítások: Külön I/O utasítások (IN/OUT) Memóriára leképzett Ortogonalitás ill. közel ortogonalitás

18 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 18 RISC vs. CISC Trend a 70-es években: sok, összetett utasítás Motiváció: Lassú memória Drága memória Egyszerűbb fordítóprogram Ez a CISC (Complex Instruction Set Computer) Jellemzői: Kényelmes, összetett műveletek Regiszter-memória utasítások (pl. R1 Redundancia Sokféle címzési mód Változatos utasításhossz Változatos utasítás-végrehajtási idő R2 + MEM[42] )

19 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 19 RISC vs. CISC Trend a 80-as/90-es években: egyszerű utasítások Motiváció: Egyszerűbb processzor Átláthatóbb mikroarchitektúra hatékonyabb implementáció Ez a RISC (Reduced Instruction Set Computing) Jellemzői: Elemi utasítások, redundancia kerülése Load-Store és regiszter-regiszter műveletek R1 R2+MEM[42] helyett R3 MEM[42]; R1 R2+R3. Kevés címzési mód Fix utasításhossz Egyforma utasítás-végrehajtási idők

20 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 20 RISC vs. CISC Összehasonlítás: CISC: tömör RISC: egyszerű Kevesebb tervezési hiba Huzalozott vezérlés (vs. Mikroprogramozás) Kisebb IC Alacsonyabb fogyasztás Jobb gyártási kihozatal Járulékos eszközökkel integrálható CISC: kevés regiszter vs. RISC: több regiszter

21 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 21 Néhány érdekes utasításkészlet MISC: Minimal Istruction Set Computer pl. verem alapú OISC: One Istruction Set Computer pl. kivonás és ugrás, ha az eredmény negatív NISC: No Instruction Set Computer Nanokódot használ: közvetlenül a programozó vezérli a CPU funkcionális egységeit

22 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 22 x86 Történelemóra Első tag: 1971, Intel : Az Intel 8088-as lesz az IBM PC processzora Eredetileg 16 bites volt, később 32 és 64 bites kiterjesztések Nagy teljesítményű szerverektől a mobil eszközök piacáig 40 éves kompatibilitási kényszer Félvezetőipari beruházások hatalmas gyártástechnológiai előny

23 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 23 Történelemóra ARM Első megvalósítás: 1987 A legelterjedtebb utasításkészlet architektúra Kezdetektől 32 bites, 2011 óta 64 bites Elsődleges szempont: egyszerűség és a fogyasztás Az ARM nem gyárt processzort, de licenszel Utasításkészletet Saját tervezésű processzort (pl. ARM Cortex processzorcsalád) Licenszelők: Qualcomm: csak utasításkészletet vett, a processzor saját tervezésű Apple: vett processzor licenszet, de továbbfejlesztette Nvidia Tegra, Samsung Exynos, Texas OMAP, Marvell, Rockchip, Allwinner, Amlogic, Nufront, Broadcom, stb.: ARM Cortex magokat licenszelnek, gyártanak Fejlődés: 2008: A legerősebb ARM processzor: 680MHz (850 DMIPS, Apple iphone 1: 412 MHz) 2013: Qualcomm Snapdragon 800: 2.3 GHz, 4 mag, out-of-order utasításvégrehajtás (31188 DMIPS)

24 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 24 Történelemóra PowerPC 1991-ben, az IBM, Apple és Motorola összefogásában Felülmúlják az x86 processzorok teljesítményét (2010: 4.25 GHz, 8 magos, magonként 4 szál) A PC-kben nem terjedt el, munkaállomásokban és szerverekben igen Modern játékkonzolok mindegyike PowerPC-re épül (Kivéve a PS4 és az Xbox One: ezek 64 bites, x86 architektúrájú AMD processzorokat tartalmaznak)

25 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 25 Történelemóra SPARC 1987, SUN Kezdetektől 64 bites Nyílt platform A UltraSPARC T1 és T2 VeriLog szinten elérhető!!! 2011: a világ legerősebb számítógépe SPARC alapú (2013: a negyedik legerősebb) 2013: SPARC T5: 3.6 GHz, 8 mag, 16 szál/mag

26 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 26 m68k Történelemóra 1979, Motorola Kezdetektől 32 bites Az x86 legnagyobb vetélytársa volt Apple Macintosh, Commodore Amiga, Atari ST, SEGA MegaDrive, korai HP és SUN szerverek, lézernyomtatók,... Utolsó tag: 1994, Motorola 68060, kb. Pentium sebesség Halála: Motorola belépett a PowerPC szövetségbe

27 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 27 Alpha Történelemóra 1992, DEC Alpha Kezdetektől 64 bites Rendkívül innovatív: 21164: első CPU nagy, a CPU-val egy szilíciumon elhelyezett cache-el 21264: első CPU magas órajellel ÉS sorrenden kívüli végrehajtással 21364: első CPU integrált memóriavezérlővel 21464: első többszálúságot támogató CPU (lett volna, ha forgalomba kerül) Nagyon erős lebegőpontos egység 833 MHz > 3x Pentium 1 GHz! Kézi tervezés Halála: Compaq felvásárolja és leállítja a fejlesztést

28 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 28 Történelemóra PA-RISC 1986, HP PA-RISC Eleinte 32, majd 64 bites A korosodó m86k szerverek kiváltására Nem használ másodszintű cache-t, de elsőszintűt annyit, amennyit azóta sem használ senki Nagyon erős lebegőpontos egység 552 MHz > 2x Pentium 1 GHz! Halála: HP az Intel Itanium mellett teszi le a voksát

29 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 29 Történelemóra IA-64 (Itanium) 1994-ben indul a HP & Intel közös fejlesztés Hatalmas sajtófigyelem, költséges fejlesztés Első tag: 2001, kiábrándító teljesítménnyel, pár ezret adtak el Hardveres kompatibilitás az x86-tal: a 100MHz Pentium sebességén... Gond: spéci compiler kell, nem gondolták, hogy ez ilyen nehéz Azóta is fejlesztik, között db-ot adtak el Egyre több cég hagy fel a platform támogatásával 2008: Microsoft 2011 március: Oracle

30 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 30 Összehasonlítás x86 ARM PowerPC SPARC Hány bites 64 32/ Megjelenés éve Operandusok Műveletek Reg-mem Reg-reg Reg-reg Reg-reg CISC vs. RISC CISC RISC RISC RISC Regiszterek sz. 8/16 16/ Utasításkódolás Vált. (1-17) Fix (4) Fix (4 töm.) Fix (4) Felt. utasítások Feltétel kód Feltétel kód Feltétel kód Feltétel kód Bájtsorrend Little Big Big/Bi Bi Címzési módok Perifériakezelés I/O utasítások Mem. lekép. Mem. lekép. Mem. lekép. Predikátumok Nincs Van Nincs Nincs

31 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 31 Összehasonlítás m68k Alpha PA-RISC Itanium Hány bites Megjelenés éve Operandusok Műveletek Reg-mem Reg-reg Reg-reg Reg-reg CISC vs. RISC CISC RISC RISC EPIC Regiszterek sz Utasításkódolás Vált. (2-22) Fix (4) Fix (4) Fix (16) Felt. utasítások Feltétel kód Feltétel reg. Összeh. & ugr.? Bájtsorrend Big Bi Big Bi Címzési módok 9 1 5? Perifériakezelés Mem. lekép. Mem. lekép. Mem. lekép. Mem. lekép. Predikátumok Nincs Nincs Nincs Van

32 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 32 Esettanulmány: Fibonacci sorozat #include <stdio.h> int main () { int i, n, a, b, f; scanf("%d", &n); a = 0; b = 1; for (i=0; i<n; i++) { f = a + b; a = b; b = f; } } printf ("%d\n", f);

33 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 33 Esettanulmány Megvalósítás x86-ban (=IA-32) Csak a ciklus: ESP+20: f ESP+24: b ESP+28: a ESP+32: n ESP+36: i mov DWORD PTR [ESP + 36], 0 jmp.lbb0_1.lbb0_2: mov EAX, DWORD PTR [ESP + 28] add EAX, DWORD PTR [ESP + 24] mov DWORD PTR [ESP + 20], EAX mov EAX, DWORD PTR [ESP + 24] mov DWORD PTR [ESP + 28], EAX mov EAX, DWORD PTR [ESP + 20] mov DWORD PTR [ESP + 24], EAX inc DWORD PTR [ESP + 36].LBB0_1: mov EAX, DWORD PTR [ESP + 36] cmp EAX, DWORD PTR [ESP + 32] jl.lbb0_2 i = 0 f = a + b a = b b = f i ++ i és n összehasonlítása ugrás (még egy kör), ha kisebb

34 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 34 Esettanulmány Megvalósítás x86-ban (=IA-32) Csak a ciklus: ESP+20: f ESP+24: b ESP+28: a ESP+32: n ESP+36: i mov DWORD PTR [ESP + 36], 0 jmp.lbb0_1.lbb0_2: mov EAX, DWORD PTR [ESP + 28] add EAX, DWORD PTR [ESP + 24] mov DWORD PTR [ESP + 20], EAX mov EAX, DWORD PTR [ESP + 24] mov DWORD PTR [ESP + 28], EAX mov EAX, DWORD PTR [ESP + 20] mov DWORD PTR [ESP + 24], EAX inc DWORD PTR [ESP + 36].LBB0_1: mov EAX, DWORD PTR [ESP + 36] cmp EAX, DWORD PTR [ESP + 32] jl.lbb0_2 Memóriareferens műveletek: CISC! i = 0 f = a + b a = b b = f i ++ i és n összehasonlítása ugrás (még egy kör), ha kisebb

35 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 35 Esettanulmány Megvalósítás x86-ban (=IA-32) Csak a ciklus: ESP+20: f ESP+24: b ESP+28: a ESP+32: n ESP+36: i mov DWORD PTR [ESP + 36], 0 jmp.lbb0_1.lbb0_2: mov EAX, 1 DWORD 2 PTR [ESP + 28] add EAX, DWORD PTR [ESP + 24] mov DWORD PTR [ESP + 20], EAX mov EAX, DWORD PTR [ESP + 24] mov DWORD PTR [ESP + 28], EAX mov EAX, DWORD PTR [ESP + 20] mov DWORD PTR [ESP + 24], EAX inc DWORD PTR [ESP + 36].LBB0_1: mov EAX, DWORD PTR [ESP + 36] cmp EAX, DWORD PTR [ESP + 32] jl.lbb0_2 Kétoperandusú műveletek: CISC! i = 0 f = a + b a = b b = f i ++ i és n összehasonlítása ugrás (még egy kör), ha kisebb

36 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 36 Esettanulmány Megvalósítás x86-ban (=IA-32) Csak a ciklus: ESP+20: f ESP+24: b ESP+28: a ESP+32: n ESP+36: i mov DWORD PTR [ESP + 36], 0 jmp.lbb0_1.lbb0_2: mov EAX, DWORD PTR [ESP + 28] add EAX, DWORD PTR [ESP + 24] mov DWORD PTR [ESP + 20], EAX mov EAX, DWORD PTR [ESP + 24] mov DWORD PTR [ESP + 28], EAX mov EAX, DWORD PTR [ESP + 20] vezérlésátadás mov DWORD PTR [ESP + 24], EAX inc DWORD PTR [ESP + 36].LBB0_1: mov EAX, DWORD PTR [ESP + 36] cmp EAX, DWORD PTR [ESP + 32] jl.lbb0_2 Feltétel kódokra alapozott i = 0 f = a + b a = b b = f i ++ i és n összehasonlítása ugrás (még egy kör), ha kisebb

37 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 37 Esettanulmány Megvalósítás x86-ban (=IA-32) Optimalizálás után: ESI: f ECX: b EDI: a EAX: n EDX: i xor.lbb0_2: mov add inc mov mov cmp jl EDX, EDX ESI, EDI ESI, ECX EDX EDI, ECX ECX, ESI EDX, EAX.LBB0_2 i = 0 f = a + b i ++ a = b b = f i és n összehasonlítása ugrás (még egy kör), ha kisebb A változók regiszterekbe kerültek a ciklusban nincs CPU-Memória adatmozgatás!

38 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 38 Esettanulmány Megvalósítás ARM-ban Optimalizálás nélkül (csak a ciklus): [sp]: f [sp #4]: b [sp #8]: a [sp #12]: n [sp #16]: i mov r4, #0 str r4, [sp, #16] b.lbb0_2.lbb0_1: ldmib sp, {r0, r1} add r0, r1, r0 str r0, [sp] ldr r1, [sp, #4] str r1, [sp, #8] ldr r2, [sp] str r2, [sp, #4] ldr r1, [sp, #16] add r0, r1, #1 str r0, [sp, #16].LBB0_2: ldr r0, [sp, #12] ldr r1, [sp, #16] cmp r1, r0 blt.lbb0_1 i = 0 Ugrás a ciklusfeltétel ellenőrzésére f = a + b a = b b = f i ++ i és n összehasonlítása ugrás (még egy kör), ha kisebb

39 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 39 Esettanulmány Megvalósítás ARM-ban Optimalizálás nélkül (csak a ciklus): mov r4, #0 str r4, [sp, #16] b.lbb0_2.lbb0_1: ldmib sp, 1 {r0, 2 3r1} add r0, r1, r0 str r0, [sp] ldr r1, [sp, #4] str r1, [sp, #8] ldr r2, [sp] str r2, [sp, #4] ldr r1, [sp, #16] add r0, r1, #1 str r0, [sp, #16].LBB0_2: ldr r0, [sp, #12] ldr r1, [sp, #16] cmp r1, r0 blt.lbb0_1 i = 0 f = a + b a = b Háromoperandusú műveletek: RISC! b = f i ++ i és n összehasonlítása [sp]: f [sp #4]: b [sp #8]: a [sp #12]: n [sp #16]: i Ugrás a ciklusfeltétel ellenőrzésére ugrás (még egy kör), ha kisebb

40 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 40 Esettanulmány Megvalósítás ARM-ban Optimalizálás nélkül (csak a ciklus): mov r4, #0 str r4, [sp, #16] b.lbb0_2.lbb0_1: ldmib sp, {r0, r1} add r0, r1, r0 str r0, [sp] ldr r1, [sp, #4] str r1, [sp, #8] ldr r2, [sp] str r2, [sp, #4] ldr r1, [sp, #16] add r0, r1, #1 str r0, [sp, #16].LBB0_2: ldr r0, [sp, #12] ldr r1, [sp, #16] cmp r1, r0 blt.lbb0_1 i = 0 f = a + b a = b Nincsenek regiszter-memória műveletek: RISC! b = f i ++ i és n összehasonlítása [sp]: f [sp #4]: b [sp #8]: a [sp #12]: n [sp #16]: i Ugrás a ciklusfeltétel ellenőrzésére ugrás (még egy kör), ha kisebb

41 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 41 Esettanulmány Megvalósítás ARM-ban Optimalizálás nélkül (csak a ciklus): mov r4, #0 str r4, [sp, #16] b.lbb0_2.lbb0_1: ldmib sp, {r0, r1} add r0, r1, r0 str r0, [sp] ldr r1, [sp, #4] str r1, [sp, #8] ldr r2, [sp] str r2, [sp, #4] ldr r1, [sp, #16] add r0, r1, #1 str r0, [sp, #16].LBB0_2: ldr r0, [sp, #12] ldr r1, [sp, #16] cmp r1, r0 blt.lbb0_1 i = 0 f = a + b Nincs redundancia, az az inkrementálásra nincs külön utasítás: RISC! b = f inkrementálásra nincs külön a = b i ++ i és n összehasonlítása [sp]: f [sp #4]: b [sp #8]: a [sp #12]: n [sp #16]: i Ugrás a ciklusfeltétel ellenőrzésére ugrás (még egy kör), ha kisebb

42 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 42 Esettanulmány Megvalósítás ARM-ban Optimalizálás nélkül (csak a ciklus): mov r4, #0 str r4, [sp, #16] b.lbb0_2.lbb0_1: ldmib sp, {r0, r1} add r0, r1, r0 str r0, [sp] ldr r1, [sp, #4] str r1, [sp, #8] ldr r2, [sp] str r2, [sp, #4] ldr r1, [sp, #16] add r0, r1, #1 str r0, [sp, #16].LBB0_2: ldr r0, [sp, #12] ldr r1, [sp, #16] cmp r1, r0 blt.lbb0_1 i = 0 f = a + b a = b Több regiszter feltöltése egymás utáni memóriacímekről b = f i ++ i és n összehasonlítása [sp]: f [sp #4]: b [sp #8]: a [sp #12]: n [sp #16]: i Ugrás a ciklusfeltétel ellenőrzésére ugrás (még egy kör), ha kisebb

43 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 43 Esettanulmány Megvalósítás ARM-ban Optimalizálás után: r0: a r1: f r2: b r3: i r12: n mov r3, #0.LBB0_2: add r1, r0, r2 add r3, r3, #1 mov r0, r2 mov r2, r1 cmp r3, r12 blt.lbb0_2 i = 0 f = a + b i ++ a = b b = f i és n összehasonlítása ugrás (még egy kör), ha kisebb A változók regiszterekbe kerültek a ciklusban nincs CPU-Memória adatmozgatás! Itt is feltételkódokra alapozott elágazáskezelés

44 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 44 Esettanulmány Megvalósítás PowerPC 32-ben (PPC32) Optimalizálás után: 7: a 6: b 5: i 4: f 3: n li 5, 0.LBB0_2: add 4, 7, 6 addi 5, 5, 1 mr 7, 6 mr 6, 4 cmpw 0, 5, 3 blt 0,.LBB0_2 i = 0 f = a + b i ++ a = b b = f i és n összehasonlítása (eredmény: 0. reg) ugrás (még egy kör), ha kisebb Rendes RISC processzor: 3 operandusú műveletek Nincsenek memóriareferens műveletek (a load/store-tól eltekintve) Nincs redundancia: az inkrementálás az addi (add integer) utasítással oldható meg

45 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 45 Esettanulmány Megvalósítás PowerPC 32-ben (PPC32) Optimalizálás után: li 5, 0.LBB0_2: i = 0 7: a 6: b 5: i 4: f 3: n add 4, 7, 6 addi 5, 5, 1 mr 7, 6 mr 6, 4 cmpw 0, 5, 3 blt 0,.LBB0_2 f = a + b i ++ a = b b = f i és n összehasonlítása (eredmény: 0. reg) ugrás (még egy kör), ha kisebb Feltételkódokra alapozott elágazáskezelés, DE: Van 8 speciális feltétel regiszter (condition register) Az összehasonlítás művelet eredményét bármelyikbe irányíthatjuk A feltételes elágazásnál megadhatjuk, hogy melyik feltétel regisztertől függjön az ugrás Ez már majdnem feltétel regiszterre alapozott elágazáskezelés! Teljesen az akkor lenne, ha nem lenne külön feltétel regiszter, hanem bármelyik általános regisztert használhatnánk erre a célra

46 Számítógép Architektúrák Horváth Gábor, BME Hálózati Rendszerek és Szolgáltatások Tsz. 46 Esettanulmány Megvalósítás Alpha-ban Optimalizálás után: $3: a $1: b $2: i $4: f $0: n $BB0_2: mov $31,$2 addq $3,$1,$4 addl $2,1,$2 mov $1,$3 mov $4,$1 cmplt $2,$0,$5 bne $5,$BB0_2 i = 0 (a $31 mindig konstans 0) f = a + b i ++ a = b b = f i és n összehasonlítása (eredmény: $5-be) ugrás (még egy kör), ha kisebb Mint az eddig látott RISC architektúrák De: feltétel regiszterre alapozott elágazásbecslése van Az összehasonlítás művelet eredményét tetszőleges általános regiszterbe irányíthatjuk A feltételes elágazásnál megadhatjuk, hogy melyik regisztertől függjön az ugrás