Memóriakezelés feladatok. 2048 409639873518 61444200 8192 1024010070 122881109211093 14336 16384 1.Feladat: 12 bites címtartomány. 0 ~ 2047 legyen mindig.

Az előadások a következő témára: "Memóriakezelés feladatok. 2048 409639873518 61444200 8192 1024010070 122881109211093 14336 16384 1.Feladat: 12 bites címtartomány. 0 ~ 2047 legyen mindig."— Előadás másolata:

1 Memóriakezelés feladatok

2 2048 409639873518 61444200 8192 1024010070 122881109211093 14336 16384 1.Feladat: 12 bites címtartomány. 0 ~ 2047 legyen mindig elérhető. Hivatkozott címek: 3987,4200,3518,11092,11093,10070 ebben a sorrendben. Megoldás: tömbkapcsolás, 2 kB-os tömbök, 2 kB-os határon. Hány tömb kell, és hány kapcsolás, ha kezdetben a 0, 1 tömb aktív? Másik eljárás: címek osztása a tömbmérettel, hányados egész része megadja a tömb-indexet, ezek rendre 1,2,1,5,5,4. A szükséges tömbök: 0,1,2,4,5 azaz 5 darab. A hivatkozások során 4 kapcsolásra van szükség.

3 001023 110242047 235184541 31007011093 1. feladat, indexelt leképezéssel. Az ablak mérete 1 kB. A 4 kB-os címtérbe 4 darab ablak fér be, tehát az indexregiszter tömb 4 regisztert tartalmaz. Címek: 3987,4200,3518,11092,11093,10070 1 kB-os ablak: 10 bit 12 címbit-ből 2 marad az ablakok címzésére, vagyis 4 ablak/indexregiszter lesz Az első két ablakot a program futásához szükséges 2kB eléréséhez kell használni. A harmadikba 3518-at írva lefedhető a 3518, 3987 és a 4200-as hivatkozás, a negyedikbe 10070-et írba lefedhető a 10070, a 11092 és a 11093-as hivatkozás

4 Lapméret 4kB (12 bittel címezhető), egyszintes laptábla 8 bites bejegyzésekkel. Laptábla mérete: 4096 bejegyzés x 8 bit = 4096 bájt 1501112 fizikai cím (16 bit) 230 virtuális cím (24 bit) Fizikai tár mérete: 2 16, lapok száma = 2 16 / 2 12 = 2 4 =16 A00000 = 1010 0000 0000 0000 0000 0000, a 15-ös keretben A03FFF = 1010 0000 0011 1111 1111 1111 A00 A01 A02 A03 Vcím 1 1 0 0 0000 1111 0000 0011 xxxx TLB találat esetén 0, TLB hiba esetén 1 (címfordításhoz!!) 2. feladat (eltolás) (lapszám) szektorszám

5 012910fizikai cím (13 bit) 3 szintű hierarchikus laptábla, a méret azonos minden szinten, a bejegyzés 16 bites. Lapon belüli eltolás: 10 bit, mert a lapméret 1 kB. Mivel a laptáblák azonos méretűek, minden szintet 2 bit címez. 10+2+2+2=16 22210 b) Első szint 4 bejegyzés x 16 bit = 8 bájt. Mindegyik megcímez 4 darab második szintű táblát Második szint 4 x 4 = 16 bejegyzés x 16 bit = 32 bájt. Mindegyik megcímez 4 darab harmadik szintű táblát Harmadik szint 16 x 4 = 64 bejegyzés x 16 bit = 128 bájt. Összesen tehát 128 + 32 + 8 = 168 bájt c) Optimális esetben minden szinten egyetlen bejegyzés van a memóriában: 3 * 8 = 24byte. Egyszintű laptábla esetén: 2 6 =64 bejegyzés, 128 byte. d) Fizikai memória mérete 2 13 bájt, egy lap mérete 2 10 bájt, 2 13 / 2 10 = 2 3 vagyis 8 lap fér a fizikai memóriába 3. feladat 015virtuális cím (16 bit)

6 10010000000000001001111111111111 10 01 00 10 11 01 10 1 01 1 1 0 1 0 0x0007 0x0003 00 01 10 11 g) TLB találat esetén 0, TLB hiba esetén 3 (címfordításhoz!!)

7 09fizikai cím 015 Lapon belüli eltolás: 10 bit A hash tábla mérete 16 x 4 bit (3 bit cím, és a V bit) Laptábla mérete 8 bejegyzés x 16 bit = 16 bájt b) Fizikai memória mérete 2 13 bájt, egy lap mérete 2 10 bájt, 2 13 / 2 10 = 2 3 vagyis 8 lap fér a fizikai memóriába. c) Az inverz laptábla bejegyzéseinek száma megegyezik a keretek számával, vagyis mérete 8 * 16 bit = 16 byte. Egyszintű tábla esetén 2 6 azaz 64 * 16 bit = 128 byte kellene. 4. Feladat a) virtuális cím Lapméret 2 10 bájt. Inverz laptábla, a hash fv.értéke a virtuális cím 10~13 bitje. Laptábla bejegyzés mérete 16 bit. 1510 0 Lapon belüli eltolás 913 x 14 1012

8 TLB találat esetén 0, TLB hiba esetén legjobb esetben 2 (1 a hash mutató tábla, 1 a laptábla Legrosszabb esetben 5 (1 a hash mutató táblán, 4 a láncon) 1111 1110 0000 1 0001 0010 0011 0100 0101 0110 0111 7 3 0 0 1 x x Hash mutató tábla NULL 5 00 01 02 03 04 05 06 07 mutatóVlap sorszám 1 1 1 100100 010100 100110 Laptábla

9 5. feladat ValidLapszámKeretszám 18890 11399843 0?? 0?? 4 bejegyzéses TLB. Kezdetben az állapota: Virtuális laptábla, az alsó szint a 86. lapon kezdődik. A virtuális cím 42 bites, az eltolás 12 bites, a laptáblák minden szinten 1024 darab, 4 byte-os bejegyzést tartalmaznak. Lapméret 4 kB, a fizikai cím 32 bites. Hányszor kell a memóriához nyúlni az 1399, 2064, 4101 címek fordításakor? Melyik keret hányadik byte-ját kell kiolvasni és milyen sorrendben?

10 32228493 52 138 90 51319 x keretszám 86. lap a virtuális címtartományban 86 87 88 89 90 86 Lap száma a virtuális címtérben 0 1 234 0 Laptábla lap indexe

11 Virtuális cím 42 bit, laptábla bejegyzés mérete: 4 bájt Lap mérete 4 kB, egy lapon 1024 bejegyzés, fizikai cím 32 bit a)1399-as lap a TLB-ben van, címfordításhoz nem kell a memóriához nyúlni b)2064-es lap, nincs a TLB-ben, keresni kell A virtuális laptábla lineáris címzésű. A A 2064-es lap címe a legalsó szinten az INT(2064/1024) = 2-es indexű laptábla lapon van Lapon belüli helye 2064 – 2 * 1024 = 16-os bejegyzés, eltolása 16*4=64 Az ábra szerint a laptábla 2-es indexű lapja, a 86+2=88-as lap a 90-es keretben található, az pedig benne van a TLB-ben, így egy memória művelet kell a címfordításhoz, a 90-es keret 16 indexű bejegyzését kell olvasni, ez a 90 * 4096 + 64 = 368704 címen van. c)4101-es lap, nincs a TLB-ben, keresni kell INT(4101/1024) = 4, tehát a laptábla 4 indexű lapja (a 90-es lap), azon belül 4101 – 4 * 1024 = 5-ös bejegyzés, eltolása 5 * 4 = 20 –32. keret, 0~3 bájt, 32 * 4096 = 131072 (legfelső szint) -228. keret, 16~19. bájt, 228 * 4096 + 16 = 933904 (középső szint) -19. keret, 20~23. bájt, 19 * 4096 + 20 = 77844, vagyis három olvasás

12 TLB és cache feladatok

13 TLB/cache 1. feladat ValidLapszámKeretszámKor 111121 1742 1363 0494 ValidKeretszám 15 0? 0? 16 19 111 0? 14 0? 0? 13 112 Fordítandó címek: 4095, 31272, 15789, 15000, 7193, 4096, 8912 Laphiba esetén az új lap az eddig előforduló legnagyobb keretszámnál eggyel nagyobb számú keretbe kerül. A TLB állapota Egyszintes laptábla 4 bejegyzéses TLB, teljesen asszociatív, ideális LRU algoritmussal

14 ValidLapszámKeretszámKor 1111111 11 1112 13 1 234411 11111117 7777774 4444442 312233 111111133333336 6666663 441122 0 11 1 1 1 1 4 00 0 0 0 0 9 55 5 5 5 5 4 12 3 3 4 4 4095: int(4095/4096)=0, a 0-s lap a laptáblában van, így H 31272:int(31272/4096)=7, a 7-es lap a TLB-ben van, így T 15789:int(15789/4096)=3, a 3. lap a TLB-ben van, így: T 15000:int(15000/4096)= 3, a 3. lap a TLB-ben van, így: T 7193:int(7192/4096)=1, az 1-es lap nincs a laptáblában,LH laptábla 1-es bejegyzése 1 13 4096:int(4096/4096)=1, az 1-es lap a TLB-ben van, ígyT 8912:int(8912/4096)=2, a 2-es lap nincs a laptáblában, ígyLH laptábla 2-es bejegyzése 1 14 ValidLapszámKeretszámKor 11132 1744 1363 12141 a) Mi lesz a TLB végső állapota 4 kB-os lapméret esetén?

15 ValidLapszámKeretszámKor 111 11 12 1 233 1117 774 442 344 1113316 6133 412 0 114 009 554 121 4095: int(4095/16384)=0, a 0-s lap a laptáblában van, így H 31272:int(31272/16384)=1, az 1-es lap nincs a laptáblában, így LH a laptábla 1-es bejegyzése 1 13 15789:int(15789/16384)=0, a 0-s lap a TLB-ben van, így: T 15000:int(15000/16384)= 0, a 0-s. lap a TLB-ben van, így: T 7193:int(7192/16384)=0, a 0-s lap a TLB-ben van, ígyT 4096:int(4096/16384)=0, a 0-s lap a TLB-ben van, ígyT 8912:int(8912/16384)=0, a 0-s lap a TLB-ban van, ígyT b) 16 kB-os lapokkal

16 TLB/cache 2. feladat 256 byte-os cache, 64 byte-os blokkméret  4 darab blokk, kezdetben mind érvénytelen. Olvasás a(z) 1, 3, 8, 4, 3, 6, 8, 1 blokkokról. a)Direkt leképezés (LRU nem számít) 1 38 (mod 4=0) 4 (mod 4=0) 3681 VTartalom 0? 11 0? 0? V 0? 11 0? 13 V 18 11 0? 13 V 18→4 11 0? 13 VTartalom 18→4 11 0? 13 VTartalom 18→4 11 16 13 VTartalom 18→4 →8 11 16 13 VTartalom 18→4 →8 11 16 13 6 hiba (pirossal jelöltek) és 2 találat

17 TLB/cache 2. feladat 256 byte-os cache, 64 byte-os blokkméret  4 darab blokk, kezdetben mind érvénytelen. b ) teljesen asszociatív szervezés (LRU számít) 1 384 3681 VTartalom 11 0? 0? 0? V 11 13 0? 0? V 11 13 18 0? V 11 13 18 14 V 11 13 18 14 V 11→6 13 18 14 VTartalom 11→6 13 18 14 VTartalom 11→6 13 18 14→1 6 hiba és 2 találat

18 TLB/cache 2. feladat 256 byte-os cache, 64 byte-os blokkméret  4 darab blokk, kezdetben mind érvénytelen. c) Két utas asszociatív szervezés (2 db 2 blokkos felépítés, LRU csak a soron belüli 2 blokkra vonatkozik). Első sor csak páros, második csak páratlan blokkot tartalmaz. 138 4 368 1 VT. 0? 11 6 hiba 2 találat VT. 0? 0? V 0? 11 V 0? 13 V 18 11 V 0? 13 V 18 11 V 14 13 V 18 11 V 14 13 V 18→6 11 VT. 14 13 V 18→6 11 VT. 14→8 13 VT. 18→6 11 VT. 14→8 13

19 TLB/cache 3. feladat 32 kB méretű cache, 64 byte-os blokkméret. Fizikai cím 32 bit, virtuális cím 48 bit. A 64 byte-os blokkméret 6 bites eltolást jelent, a szervezéstől függetlenül. 4 utas asszociatív szervezés mellett hány darab és hány bites komparátor kell, ha a)Fizikailag indexelt a cache, fizikai tag-ekkel A 32 kB-os cache-be 512 darab 64 byte-os blokk fér el (2 15 / 2 6 = 2 9 =512) A 4 utas szervezés miatt minden index értékhez 4 blokk tartozik, így az index max. értéke 128, ami 7 bitet kíván. A tag méretre 32 – 7 – 6 = 19 bit, tehát 4 darab 19 bites komparátor kell Tag:19 bit, index: 7 bit, eltolás: 6 bit b) Virtuálisan indexelt cache, virtuális tag-ekkel Ha virtuális tag-eket használunk, akkor a tag-ek mérete 48-7-6 = 35 bit. Minden egyes kereséskor 4 db 35 bites komparátor dolgozik Tag: 35 bit, index: 7 bit, eltolás: 6 bit

20 TLB/cache 4. feladat 512 byte-os cache, 64 byte-os blokkméret  8 darab blokk, kezdetben mind érvénytelen. A fizikai cím 16 bites. Mivel a blokkméret 64 byte, ezért az eltolás mindig 6 bites. a)Direkt leképezés: a 8 blokk címzésére 3 bites index kell, így a tag 7 bites lesz Számítás: offset/eltolás=cím mod 64, blokkszám=INT(cím / 64) index=blokkszám mod 8, tag=INT(blokkszám/8) T.I.O. 0013 028 0742 1029 1230 0110 115 1720 Offset (6 bit)tag(7 bit) index(3 bit) 13 (bsz: INT(13/ 64)=0, offs:13mod64=13, index:0mod8=0, tag: INT(0/8)=0 ) 136 (bsz: INT(136/64)=2, offs: 136mod64=8, index:2mod8=2, tag: INT(2/8)=0) 490 (bsz: INT(490/64)=7, offs: 490mod64=42, index:7mod8=7, tag: INT(7/8)=0) 541 (bsz: INT(541/64)=8, offs: 541mod64=29, index: 8mod8=0, tag: INT(8/8)=1) 670 (bsz: INT(670/64)=10, offs: 670mod64=30, index:10mod8=2, tag: INT(10/8)=1) 74 (bsz: INT(74/64)=1, offs: 74mod64=10, index:1mod8=1, tag: INT(1/8)=0) 581 (bsz: INT(581/64)=9, offs:581mod64=5, index: 9mod8=1, tag: INT(9/8)=1) 980 (bsz: INT(980/64)=15, offs: 980mod64=20, index: 15mod8=7, tag: INT(15/8)=1)

21 TLB/cache 4. feladat b. kérdés Cache tartalma teljesen asszociatív leképezés esetén: a cache mind a nyolc blokkot tartalmazza, a sorrend tetszőleges

22 TLB/cache 4. feladat 512 byte-os cache, 64 byte-os blokkméret  8 darab blokk, kezdetben mind érvénytelen. b)Teljesen asszociatív szervezés (nincs index, csak tag) Számítás: offset=cím mod 64, tag = INT(cím / 64) T0 013 28 742 829 1030 110 95 1520 Offset (6 bit)tag(10 bit) 13 136 490 541 670 74 581 980

23 c)Két utas asszociatív leképezésnél minden blokk két helyre kerülhet a gyorsítótárba. Mivel a cache memória és a blokk mérete változatlan, ezért 2 darab, egyenként 4 bejegyzést tartalmazó tárunk van. 4 bejegyzés címzéséhez két bit kell, így a tag 8 bites lesz. 0567815 tagindexoffset TagIndexOffset 0013 028 1342 2029 2230 0110 215 3320 13int(13/64)=0 mod 4 =0int(0/4)=013-0*64=13 136int(136/64)=2 mod 4 = 2int(2/4)=0132-2*64=8 490int(490/64)=7 mod 4 = 3int(7/4)=1490-7*64=42 541int(541/64)=8 mod 4 = 0int(8/4)=2541-8*64=29 670int(670/64)=10 mod 4 = 2int(10/4)=2670-10*64=30 74int(74/64)= 1 mod 4 = 1int(1/4)=074-1*64=10 581int(581/64)=9 mod 4 = 1int(9/4)=2581-9*94=5 980int(980/64)=15 mod 4 = 3int(15/4)=3980-15*64=20

24 B kérdés. T.I.O. 0013 028 0742 1029 1230 0110 115 1720 13 136 490 541 670 74 581 980 VTagBlokk tartalom 10 11 11 0? 0? 0? 0? 11 Cache tartalma direkt vezérlés esetén: az index egyértelműen meghatározza.

25 TLB/cache 4. feladat b. kérdés Cache tartalma két utas asszociatív leképezés esetén: minden index értékhez két különböző tag-et tudunk tárolni VTBlokk 12 12 12 13 VT 10 10 10 11 Index 0 Index 1 Index 2 Index 3 TagIndexOffset 0013 028 1342 2029 2230 0110 215 3320

26 TLB/cache 5. feladat Legyen egy 1 kB-os cache, 64 byte-os blokkmérettel. Kezdetben minden blokk érvénytelen. A következő program fut le: short int t[32][32]; int sum = 0; for (int i=0; i<32; i++) for (int j=0; j<32; j++) sum += t[i][j]; a. kérdés: hány cache hibát vált ki a program? Mennyi a hiba-arány? A cache-ben egy blokk 64 byte, ami éppen megegyezik a 32 rövid egész méretével, így egy blokkban egy sort tudunk tárolni. A cache 16 blokkból áll, így egyidejűleg 16 sor lehet benne. A 32-szer ismétlődő külső ciklus minden iterációjában be kell tölteni egy sort, tehát 32 hiba lesz, a hiba-arány 32/1024 b. kérdés: mi lesz a hiba-arány, he felcseréljük a két ciklust? A ciklusok felcserélése esetén a belső ciklus soronként, azaz 64 byte-onkét hivatkozik a tömbre, így minden lefutása egy cache hibát, egy sor betöltését okozza. A 16-os indexűtől kezdve a 31-esig a sorok felülírják a már betöltötteket, azaz a belső ciklus minden iterációja cache hibát okoz. A hibák száma tehát 32*32=1024, a hiba-arány 100%. c. kérdés: ha a cache mérete 32 * 64 byte = 2 kB, akkor a hiba-arány mindig annyi, mint az a. esetben

27 Pipeline feladatok 1.

28 Pipe 1. feladat Adott a következő utasítás sorozat i1: R0 MEM [R1+8] i2: R2 R0 * 3 i3: R3 MEM [R1+12] i4: R4 R3 * 5 i5: R0 R2 + R4 A pipeline 5 fokozatú IF: utasítás lehívás, ID: utasítás dekódolás, EX: végrehajtás MEM: memória hozzáférés, WB: regiszter visszaírás IFIDEXMEMWB

29 Pipe 1. feladat a. kérdés Adat-egymásrahatások. Megadás formája: függő: függés típusa( amitől függ) Típusok: –RAW: read after write –WAR: write after read –WAW: write after write i1: R0  MEM [R1+8] i2: R2  R0 * 3 i3: R3  MEM [R1+12] i4: R4  R3 * 5 i5: R0  R2 + R4 i1: - i2: RAW(i1) i3: - i4: RAW(i3) i5: RAW(i4), RAW(i2),WAW(i1)

30 Pipe 1. feladat b. kérdés Ütemezés 1234567891011 i1IFIDEXMEMWB i2IFIDA*EXMEMWBi3IFF*IDEXMEMWBi4IFA*IDEXMEMWB i5IFF*IDEXMEMWB i2-A*: i2-nek kell i1 eredménye, az csak MEM végén van meg, adatfüggés i3-F*:ID-t i2 foglalja, feldolgozási függés i4-A*:i4-nek kell i3 eredménye, MEM végén van meg, adatfüggés i5-F*:ID-t foglalja i4, feldolgozási függés

31 Pipe 1. feladat c. kérdés Forwarding 1234567891011 i1IFIDEXMEMWB i2IFIDA*EXMEMWBi3IFF*IDEXMEMWBi4IFA*IDEXMEMWB i5IFF*IDEXMEMWB i2 az i1 eredményét (R0 értéke) a MEM/WB regiszterből veszi i4 az i3 eredményét (R3 értéke) a MEM/WB regiszterből veszi i5 az i4 eredményét (R4 értéke) az EX/MEM regiszterből veszi (nincs memória hivatkozás)

32 Pipe 1. feladat d. kérdés Végrehajtás pipeline-nal és anélkül –Pipeline: 11 egységnyi idő (feltöltéssel/kiürüléssel együtt) –Nélküle: – Összesen 22 egységnyi idő i15 i24 i35 i44 i54

33 Pipe 1. feladat e. kérdés Gyorsítás átrendezéssel Eredeti sorrend: i1: R0  MEM [R1+8] i2: R2  R0 * 3 i3: R3  MEM [R1+12] i4: R4  R3 * 5 i5: R0  R2 + R4 Átrendezve i1: R0  MEM [R1+8] i2: R3  MEM [R1+12] i3: R2  R0 * 3 i4: R4  R3 * 5 i5: R0  R2 + R4 Ezzel felszámoltuk az –eredeti jelöléssel- i2: RAW(i1) és az i4: RAW(i3) függőségek miatti várakozásokat Mivel a feldolgozási függéseket az adat függések okozták, azok is megszűnnek, így várakozás nélkül 9 egységnyi idő alatt végrehajtható a program

34 Pipe 2. feladat Adott a következő utasítás sorozat i1: R5  MEM [R3+24] i2: R6  MEM [R4+16] i3: R7  R6 + R5 i4: R8  R6 – R5 i5: R5  R7 * R8 I6: R4  R4 + 4 A pipeline 5 fokozatú IF: utasítás lehívás, ID: utasítás dekódolás, EX: végrehajtás MEM: memória hozzáférés, WB: regiszter visszaírás IFIDEXMEMWB

35 Pipe 2. feladat a. kérdés Adat-egymásrahatások. Megadás formája: függő: függés típusa(amitől függ) Típusok: –RAW: read after write –WAR: write after read –WAW: write after write i1: R5  MEM [R3+24] i2: R6  MEM [R4+16] i3: R7  R6 + R5 i4: R8  R6 – R5 i5: R5  R7 * R8 i6: R4  R4 + 4 i1: - i2:- i3: RAW(i1), RAW(i2) i4: RAW(i1).RAW(i2) i5: RAW(i3), RAW(i4),WAW(i1), WAR(i3), WAR(I4) i6: WAR(i2)

36 Pipe 2. feladat b. kérdés Ütemezés 18 i1 IFIDEXMEMWB 23456791011 A*i3IFIDEXMEMWB i2IFIDEXMEMWBi5IFIDEXMEMWBi4IFIDEXMEMWBF* i6IFIDEXMEMWB

37 Pipe 2. feladat c. kérdés Forwarding 18 i1 IFIDEXMEMWB 23456791011 A*i3IFIDEXMEMWB i2IFIDEXMEMWBi5IFIDEXMEMWBi4IFIDEXMEMWBF* i6IFIDEXMEMWB

38 Pipe 2. feladat d. kérdés Végrehajtás pipeline-nal és anélkül –Pipeline: 11 egységnyi idő (feltöltéssel/kiürüléssel együtt) –Nélküle: –Összesen 26 egységnyi idő i15 i25 i34 i44 i54 i64

39 Pipe 2. feladat e. kérdés Gyorsítás átrendezéssel Eredeti sorrend: i1: R5  MEM [R3+24] i2: R6  MEM [R4+16] i3: R7  R6 + R5 i4: R8  R6 – R5 i5: R5  R7 * R8 i6: R4  R4 + 4 Átrendezve i1: R5  MEM [R3+24] i2: R6  MEM [R4+16] i3: R4  R4 + 4 i4: R7  R6 + R5 i5: R8  R6 – R5 i6: R5  R7 * R8 Ezzel felszámoltuk az –eredeti jelöléssel- i3: RAW(i1), RAW(i2) és az i4: RAW(i1),RAW(i2) függés miatti várakozást Mivel a feldolgozási várakozást az adat függés miatti okozta, az is megszűnik, így várakozás nélkül 10 egységnyi idő alatt végrehajtható a program

40 Pipe 2. feladat e. kérdés Az ütemezés, forwardinggal 18 i1 IFIDEXMEMWB 23456791011 i3IFID EXMEM WB i2IFIDEXMEMWB i5 IFIDEXMEMWB i4IFIDEXMEMWB i6IFIDEXMEMWB

41 Pipe 3. feladat Adott a következő utasítás sorozat i1: D0  D1 * D2 i2: D3  D0 + D5 i3: MEM [R0 + 4]  D3 i4: MEM [R0 +12]  D0 D0~D5 regiszterek lebegőpontos számot, R0 egész számot tárol A lebegőpontos összeadás 4 időegységet, a szorzás 7 egységet, a többi művelet 1 időegységet késleltet. Az iterációs idő mindig 1 egység

42 Pipe 3. feladat A pipeline szerkezete IF ID EX MEMWB S0S1S2S3 M0M1M2M3M4M5M6 M0~M6: lebegőpontos szorzás S0~S3: lebegőpontos összeadás

43 Pipe 3. feladat a. kérdés Adat egymásra hatások. Megadás formája: függő: függés típusa(amitől függ) Típusok: –RAW: read after write –WAR: write after read –WAW: write after write i1: D0  D1 * D2 i2: D3  D0 + D5 i3: MEM [R0 + 4]  D3 i4: MEM [R0 +12]  D0 i1: - i2: RAW(i1) i3: RAW(i2) i4: RAW(i1)

44 Pipe 3. feladat b. kérdés Ütemezés 1234567891011121314151617 i1IFIDM0 MEM WBM1M2M3M4M5M6A*i2IFIDA* S0S1S2S3 MEM WBF*i3IFIDF* A* F*EX MEM WBF* i4 IFID F* EX MEM WBF* Az EX helyett az ID-ben is lehet várakoztatni!

45 Pipe 3. feladat c. kérdés Gyorsítás átrendezéssel Eredeti sorrend: i1: D0  D1 * D2 i2: D3  D0 + D5 i3: MEM [R0 + 4]  D3 i4: MEM [R0 +12]  D0 Átrendezve i1: D0  D1 * D2 i2: D3  D0 + D5 i3: MEM [R0 +12]  D0 i4: MEM [R0 + 4]  D3 Távolabbra került a D3 miatti adatfüggésben érintett i2 és i3

46 Pipe 3. feladat d. kérdés Ütemezés átrendezés után 1234567891011121314151617 i1IFIDM0 MEM WBM1M2M3M4M5M6A*i2IFIDA* S0S1S2S3 MEM WBF*i3IFIDF* EX MEM WBF* A*F*i4 IFID EX MEM WB i2: szüksége van i1 eredményére (D0 értéke), adat függés miatt várakozik i3: i2 foglalja az ID egységet, feldolgozási függés miatt várakozik i4: szüksége van i2 eredményére ( D3 értéke), adat függés miatt, azután i2 foglalja a MEM egységet, feldolgozási függés miatt

47 Pipe 4. feladat Adott a következő utasítás sorozat i1: D2  D0 * D1 i2: MEM [R0 + 0]  D2 i3: D2  D0 + D1 i4: MEM [R0 +8]  D2 D0~D2 regiszterek lebegőpontos számot, R0 egész számot tárol A lebegőpontos összeadás 4 időegységet, a szorzás 7 egységet, a többi művelet 1 időegységet késleltet. Az iterációs idő mindig 1 egység

48 Pipe 4. feladat a. kérdés Adat egymásra hatások. Megadás formája: függő: függés típusa(amitől függ) Típusok: –RAW: read after write –WAR: write after read –WAW: write after write i1: D2  D0 * D1 i2: MEM [R0 + 0]  D2 i3: D2  D0 + D1 i4: MEM [R0 +8]  D2 i1: - i2: RAW(i1) i3: WAW(i1),WAR(i2) i4: RAW(i3)

49 Pipe 4. feladat b. kérdés Ütemezés: i3 WB állapota nem előzheti meg i1 WB állapotát, mert ez hibás értéket adna D2-ben. Ezért 1234567891011121314151617 i1IFIDM0 MEM WBM1M2M3M4M5M6 EX i2IFIDA* F* MEM WB A STORE műveleteket EX helyett az ID-ben is lehet várakoztatni! S0i3IFIDS1S2 MEM WBS3 A*/F* F*F*F*F*EX i4 IFID MEM WBF*F*F*F*F*F*F*F*

50 Pipeline feladatok 2

51 Pipe-2 1.1. Feladat Legyen adott az alábbi utasítás sorozat: i1: D1  MEM [R0+0] i2: D1  D0 * D1 i3: D4  D2 / D1 i4: D2  MEM [R1+0] i5: D3  D0 + D2 i6: D4  D4 – D3 i7: MEM [R1]  D4 a) Azonosítsuk a WAW és WAR adat függőségeket! i2: WAW(i1) i4: WAR(i3) i6: WAW(i3), RAW(i3),RAW(i5) i3: RAW(i1) i5: RAW(i4)

52 Pipe-2 1.1. Feladat Legyen adott az alábbi utasítás sorozat: i1: D1  MEM [R0+0] i2: D1  D0 * D1 i3: D4  D2 / D1 i4: D2  MEM [R1+0] i5: D3  D0 + D2 i6: D4  D4 – D3 i7: MEM [R1]  D4 b) Szüntesse meg a WAW és WAR adat-egymásrahatásokat regiszter átnevezés segítségével! A regiszter átnevezést végezze el minden utasításra szisztematikusan! A lebegőpontos fizikai regisztereket jelölje T0, T1, T2,..., az egész típusú fizikai regisztereket U0, U1, U2,.... A regiszterleképző tábla tartalma kezdetben: i2: WAW(i1) i4: WAR(i3) i6: WAW(i3), RAW(i3),RAW(i5) i3: RAW(i1) i5: RAW(i4) LogikaiFizikai R0U7 R1U3 D0T6 D1T2 D2T8 D3T1 D4T11

53 Pipe-2 1.1. Feladat Legyen adott az alábbi utasítás sorozat: i1: D1  MEM [R0+0] i2: D1  D0 * D1 i3: D4  D2 / D1 i4: D2  MEM [R1+0] i5: D3  D0 + D2 i6: D4  D4 – D3 i7: MEM [R1]  D4 i2: WAW(i1) i4: WAR(i3) i6: WAW(i3), RAW(i3),RAW(i5) i3: RAW(i1) i5: RAW(i4) LogikaiFizikai R0U7 R1U3 D0T6 D1T2 D2T8 D3T1 D4T11 D1T12 D1T13 D4T14 D2T15 D3T16 D4T17 T12 U7 T13 T6 T14 T8 T13 T15 U3 T16T6 T15 T17 T14 T16 U3 T17 Log.Kezd.i1i2i3i4i5i6i7 R0U7 R1U3 D0T6 D1T2T12T13 D2T8T15 D3T1T16 D4T11T14T17

54 Pipe-2 1.1. Feladat Legyen adott az alábbi utasítás sorozat: D2  MEM [R0+0] D2  D0 * D2 D8  D4 / D2 D4  MEM [R1+0] D6  D0 + D4 D8  D8 – D6 i7: MEM [R1]  D8 Regiszter átnevezéssel szüntessük meg a WAW és WAR függőségeket! Használjuk a T0,T1…Tn jelölést, és minden utasítás esetén nevezzünk át! T0 D2T0 T1 D8T2 D4T3 T4 D6 T4 T5 T2 T5

55 Pipe-2 1.2. Feladat Legyen adott az alábbi utasítás sorozat: i1: D1  D2 – D3 i2: D4  D1 + D2 i3: D5  D4 + D1 i4: D0  D2 / D5 i5: D1  MEM [R0 + 0] i6: D4  D1 + D2 i7: D5  D4 + D1 Azonosítsuk a WAW és WAR adat függőségeket! i5: WAW(i1),WAR(i3),WAR(i2) i6: WAW(i2), WAR(i3) i7: WAW(i3),WAR(i4)

56 Pipe-2 1.2. Feladat Legyen adott az alábbi utasítás sorozat: D1  D2 – D3 D4  D1 + D2 D5  D4 + D1 D0  D2 / D5 D1  MEM [R0 + 0] D4  D1 + D2 D5  D4 + D1 Regiszter átnevezéssel szüntessük meg a WAW és WAR függőségeket! Használjuk a T0,T1…Tn jelölést, és minden utasítás esetén nevezzünk át! T11 T12 T13 T14 T15 T16 T13 T17 T15 T11 LogikaiFizikai R0U4 D0T6 D1T2 D2T8 D3T1 D4T9 D5T10 T1T1T8T8 T8T8 T8T8 U4 T8T8 D1T11 D4T12 D5T13 D0T14 D1T15 D4T16 D5T17 Log.Kezd.i1i2i3i4i5i6i7 R0U4 D0T6T14 D1T2T11T15 D2T8 D3T1T15 D4T9T12T16 D5T10T13T17

57 Elágazásbecslés

58 Branch 1. Feladat a) 4 ugrást követ, 2 bites az állapotgép tehát a PHT 8 bites. b) Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) %4031310103 M01 M11 M21 M31 S/H 00 01 10 11 ugrott nem ugrott Ugrik Nem ugrik

59 Branch 1. Feladat Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) %4031310103 M012 M11 M2M21 M31 S/H1H

60 Branch 1. Feladat Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) %4031310103 M012 M11 M2M21 M310 S/H1HS

61 Branch 1. Feladat Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) %4031310103 M012 M110 M21 M310 S/H1HSS

62 Branch 1. Feladat Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) %4031310103 M012 M110 M21 M3100 S/H1HSSS

63 Branch 1. Feladat Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) %4031310103 M012 M1100 M21 M3100 S/H1HSSSS

64 Branch 1. Feladat Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) %4031310103 M0123 M1100 M21 M3100 S/H1HSSSSS

65 Branch 1. Feladat Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) %4031310103 M0123 M11000 M21 M3100 S/H1HSSSSSS

66 Branch 1. Feladat Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) %4031310103 M01233 M11000 M21 M3100 S/H1HSSSSSSS

67 Branch 1. Feladat Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) %4031310103 M01233 M11000 M21 M31001 S/H1HSSSSSSSH

68 Branch 2. Feladat Globális PHT, globális BHR, 2 bites, utolsó két ugrás eredményét tárolja, léptető regiszter, tartalma indexeli a PHT-ket Ugrás esetén a BHR-be a 1 lép be, nem ugrásnál 0 a)BHR 2 bit, 4 értéket tud tárolni, mindegyikhez tartozik egy 2 bites állapotgép, vagyis a PHT 4*2=8 bites b) Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) M01 M11 M21 M31 S/H1 BHR11

69 Branch 2. Feladat Globális PHT, globális BHR, 2 bites, utolsó két ugrás eredményét tárolja, léptető regiszter, tartalma indexeli a PHT-ket Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) M01 M11 M21 M312 S/H1H BHR11

70 Branch 2. Feladat Globális PHT, globális BHR, 2 bites, utolsó két ugrás eredményét tárolja, léptető regiszter, tartalma indexeli a PHT-ket Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) M01 M11 M21 M3121 S/H1HH BHR11 10

71 Branch 2. Feladat Globális PHT, globális BHR, 2 bites, utolsó két ugrás eredményét tárolja, léptető regiszter, tartalma indexeli a PHT-ket Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) M01 M11 M210 M3121 S/H1HHS BHR11 1000

72 Branch 2. Feladat Globális PHT, globális BHR, 2 bites, utolsó két ugrás eredményét tárolja, léptető regiszter, tartalma indexeli a PHT-ket Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) M010 M11 M210 M3121 S/H1HHSS BHR11 1000

73 Branch 2. Feladat Globális PHT, globális BHR, 2 bites, utolsó két ugrás eredményét tárolja, léptető regiszter, tartalma indexeli a PHT-ket Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) M0100 M11 M210 M3121 S/H1HHSSS BHR11 1000

74 Branch 2. Feladat Globális PHT, globális BHR, 2 bites, utolsó két ugrás eredményét tárolja, léptető regiszter, tartalma indexeli a PHT-ket Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) M01001 M11 M210 M3121 S/H1HHSSSH BHR11 1000 01

75 Branch 2. Feladat Globális PHT, globális BHR, 2 bites, utolsó két ugrás eredményét tárolja, léptető regiszter, tartalma indexeli a PHT-ket Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) M01001 M110 M2101 M3121 S/H1HHSSSHSH BHR11 1000 011001

76 Branch 2. Feladat Globális PHT, globális BHR, 2 bites, utolsó két ugrás eredményét tárolja, léptető regiszter, tartalma indexeli a PHT-ket Feltételes ugrások címei, (T) ha teljesült, (N) ha nem 464(T)543(N)777(N)543(N)777(N)464(T)777(N)464(T)543(T) M01001 M1101 M2101 M3121 S/H1HHSSSHSHH BHR11 1000 01100111

77 Branch 3. Feladat Egy processzorban az ugrási címek becslésére BTB-t használnak. A BTB találati arány (vagyis hogy egy ugrási utasításra egyáltalán tartalmaz becslést) 90%. BTB találat esetén a becslés pontossága 90%. Ha az ugró utasítás nincs a BTB-ben, 4 ciklus, ha benne van, de rossz a becslés, 3 ciklusnyi késleltetést szenved a futó program végrehajtása. A programban a feltételes elágazások aránya 15%. Most feltesszük, hogy semmi más (semmilyen más egymásrahatás) nem lassítja a program futását, és ha nincs ugrás, a pipeline minden ciklusban végezni tud egy utasítás végrehajtásával.

78 Branch 3. Feladat a) Átlagosan hány ciklusonként végez a pipeline egy utasítás végrehajtásával? Utasítás Nem ugró Ugró 0,85 0,15 0,9 0,1 Nincs benne 4 Benne van Találat Nem Találat 3 0,9 Késl=0,85*0+0,15*0,1*4+0,15*0,9*0,9*0+ 0,15*0,9*0,1*3=0,1005 Átlagosan 1,1005 ciklusonként végez

79 Branch 3. Feladat b) Hogy viszonyul az eredmény a BTB nélküli esethez, amikor minden ugró utasítás egységesen 2 szünet beiktatását vonja maga után? Ebben az esetben az eredmény: 0.85 1+0.15 3 = 1.3 ciklus/utasítás, vagyis lassabb, mint BTB-vel.

80 VLIV/EPIC feladatok

81 VLIW 1. feladat Adott az alábbi C kód: if (a < 0) { b = 1; c = 2; } else { d = 3; e = 4; }

82 VLIW 1. a. Írja át a fenti C kódot a tárgyban használt pszeudo- assembly nyelvre! Hány utasításra van szükség? JUMP label IF R0≥0 R1  1 R2  2 JUMP end label: R3  3 R4  4 end: a ~ R0, b ~ R1, c ~ R2, d ~ R3, e ~ R4

83 VLIW 1. b. Predikátumokkal P1,P2  R0 < 0 R1  1 IF P1 R2  2 IF P1 R3  3 IF P2 R4  4 IF P2

84 VLIW 1. c. Hány utasítást kell végrehajtani a predikátumokkal és az anélkül megvalósított kódban, ha – az a < 0 az esetek 20%-ában teljesül? – az a < 0 az esetek 80%-ában teljesül? Predikátumokkal mindig 5 óraciklus, ha teljesül a feltétel, ha nem Predikátumok nélkül: Ha a < 0 20%-ban teljesül akkor: 0.2 * 4 + 0.8 * 3 = 3.2 ciklus Ha a < 0 80%-ban teljesül, akkor 0.8 * 4 + 0.2 * 3 = 3.8 ciklus Megjegyzés: A predikátumok kifejezetten hátrányosnak tűnnek, DE – Nem kell elágazásbecslés – Hibás becslés esetén kieső ciklusok is vannak

85 VLIW 1.d. Ideális esetben hány lépésben hajtható végre a fenti kód 4 végrehajtó egységgel rendelkező VLIW processzorral predikátumokkal és anélkül? Predikátummal: 1 ciklus a predikátum kiértékelése, 1 ciklus a 4 egymástól független utasítás, összesen 2 ciklus Predikátumok nélkül: ha a C kódban adott feltétel teljesül 2 ciklus (első JUMP, a két értékadás és a második JUMP), ha nem teljesül akkor is két ciklus (első JUMP, a két értékadás)

86 Statikus ütemezés 2. feladat Legyen adott az alábbi utasítássorozat: i1: R2  MEM [R0+0] i2: R3  R0 * R2 i3: R8  R4 / R3 i4: R5  MEM [R1+8] i5: R6  R2 + R5 i6: R9  R5 / R6 i7: R10  R6 * R9 Az utasítássorozatot lefordítjuk egy olyan VLIW processzorra, melyben az alábbi utasítások helyezhetők el egy utasításcsoportban: 2 db memóriaművelet (végrehajtási idő: 3 órajel) 2 db egész aritmetikai művelet, vagy ugró utasítás (végrehajtási idő: 1 órajel)

87 Statikus ütemezés a) Ütemezze a megadott utasítássorozatot a megadott VLIW processzoron! Határozza meg az utasításcsoportok tartalmát, és a csoportok végrehajtásának idejét! i1 i2 i3 i4 i5 i6 i7 Mem1Mem2Int1Int2 1i1i4 2 3 4i2i5 5i3i6 6i7 A ki nem töltött helyekre NOP értendő! Függőségi gráf i1: R2  MEM [R0+0] i2: R3  R0 * R2 i3: R8  R4 / R3 i4: R5  MEM [R1+8] i5: R6  R2 + R5 i6: R9  R5 / R6 i7: R10  R6 * R9

88 Statikus ütemezés b) Mennyivel gyorsabb az így kapott program, mintha hagyományos 1-utas processzoron futtatnánk (pipeline nélkül)? Ha egyszerűen összeadjuk minden utasítás végrehajtási idejét, 11 jön ki, szemben az előző pontban, a VLIW megoldásra kiszámolt 6 órajellel.

89 Statikus ütemezés c) Hány utasításcsoportot állít elő a fordító klasszikus, és hányat dinamikus VLIW architektúra esetén? Klasszikus nem képes egymásrahatásokat kezelni, tehát a fordítónak kell a NOP sorokat is generálni, vagyis 6 csoport lesz, dinamikusnál az egymásra hatásokat a processzor kezeli, nem kell a NOP sorokat generálni, tehát 4 utasításcsoport lesz.

90 Statikus ütemezés 3. feladat Legyen adott az alábbi utasítássorozat: i1: R1  R2 - R3 i2: R4  MEM [R1] i3: R6  R4 + R1 i4: R0  R2 / R6 i5: R7  MEM [R9] i6: R8  R7 + R2 i7: R7  R7 + R6 Az utasítássorozatot lefordítjuk egy olyan VLIW processzorra, melyben az alábbi utasítások helyezhetők el egy utasításcsoportban: 2 db memóriaművelet (végrehajtási idő: 3 órajel) 2 db egész aritmetikai művelet, vagy ugró utasítás (végrehajtási idő: 1 órajel)

91 Statikus ütemezés a) Ütemezze a megadott utasítássorozatot a megadott VLIW processzoron! Határozza meg az utasításcsoportok tartalmát, és a csoportok végrehajtásának idejét! i1 i2 i3 i5 i7 i6 i4 Mem1Mem2Int1Int2 1i5i1 2i2 3 4i6 5i3 6i4i7 i1: R1  R2 - R3 i2: R4  MEM [R1] i3: R6  R4 + R1 i4: R0  R2 / R6 i5: R7  MEM [R9] i6: R8  R7 + R2 i7: R7  R7 + R6

92 Statikus ütemezés b) Mennyivel gyorsabb az így kapott program, mintha hagyományos 1-utas processzoron futtatnánk (pipeline nélkül)? Ha egyszerűen összeadjuk minden utasítás végrehajtási idejét, 11 jön ki, szemben az előző pontban, a VLIW megoldásra kiszámolt 6 órajellel.

93 Statikus ütemezés c) Hány utasításcsoportot állít elő a fordító klasszikus, és hányat dinamikus VLIW architektúra esetén? Klasszikus nem képes egymásra hatásokat kezelni, tehát a fordítónak kell a NOP sorokat is generálni, vagyis 6 csoport lesz, dinamikusnál az egymásra hatásokat a processzor kezeli, nem kell a NOP sort generálni, tehát 5 utasításcsoport lesz.

94 Ciklus optimalizálás 4. Feladat Az alábbi C kód kiszámolja egy lebegőpontos számokat tartalmazó tömb elemeinek átlagát: avg = 0; for (int i = 0; i < N; i++) avg += x[i]; avg /= N;

95 Ciklus optimalizálás a)Írja át a fenti C kód ciklusát a tárgyban használt pszeudo- assembly nyelvre! A C kód ciklusa az alábbi utasítássorozattal írható le (R0 kezdetben az x tömb elejére, R1 a tömb végére mutat, D0-ba olvassuk be a memóriából a következő elemet, D1 tárolja az avg változó értékét): i1: label: D0  MEM [R0] i2: D1  D1 + D0 i3: R0  R0 + 8 i4: JUMP label IF R0  R1

96 Ciklus optimalizálás b) A naív implementációhoz hány utasításcsoport szükséges a ciklus végrehajtásához egy olyan VLIW processzoron, melyben az alábbi utasítások helyezhetők el egy utasításcsoportban: 2 db memóriaművelet, 2 db lebegőpontos művelet, 2 db egész aritmetikai művelet, vagy ugró utasítás? (Most feltételezzük, hogy minden művelet 1 órajel alatt végrehajtható) Adja meg az utasítások ütemezését is!

97 Ciklus optimalizálás Mem1Mem2Int1Int2FP1FP2 1i1i3 2i4i2 2 utasítás, N-szer fut le, így 2N óraciklus kell A program ütemezése i1: label: D0  MEM [R0] i2: D1  D1 + D0 i3: R0  R0 + 8 i4: JUMP label IF R0  R1

98 Ciklus optimalizálás c) Alakítsa át a ciklust úgy, hogy a műveletek szoftver pipeline szerint végrehajthatók legyenek! Adja meg az utasítások ütemezését a szoftver pipeline kihasználásával! Hány utasításcsoportra van szükség? Ötlet: amíg az i. elem betöltését végezzük, azzal együtt végezhetjük az i-1. iteráció műveletét (avg növelése), hiszen addigra az i-1. elem már be lesz töltve. tmp 0  Load x[0]; for(int i = 1; i < N; i++) { tmp i  Load x[i]; avg += tmp i-1 ; } avg += tmp N-1 ;

99 Ciklus optimalizálás Figyeljük meg, hogy tmp i helyett elegendő egyetlen változót használni (tmp), hiszen a ciklusmag mindkét utasítása egyszerre, egymással párhuzamosan hajtódik végre, így a tmp régi értékét használja az összeadás, és a tmp új értéke a tömbből beolvasott új elem lesz. Most D0 legyen a memóriából beolvasott elem (tehát a tmp), és D1 az eredmény értéke. Vegyük észre továbbá, hogy a tömb aktuális elemére mutató pointer (R0) növelése, és az ugrási feltétel kiértékelése is párhuzamosan történhet, de ehhez az kell, hogy az ugrás ne "R0=tömb vége" esetén teljesüljön, hiszen ennek kiértékelésével párhuzamosan nő R0 értéke, azaz még az R0 régi értékével számol a feltétel. A helyes ugrási feltétel tehát: "R0=tömb vége-8" lesz. A "tömb vége - 8"-at most R1 fogja tárolni.

100 Ciklus optimalizálás Az utasítássorozat a következő lesz ( a {} zárójelek az egy csoportba szánt utasításokat jelölik). i1: D0  MEM [R0 - 8] label: { i2: D0  MEM [R0], i3: D1  D1 + D0, i4: R0  R0 + 8, i5: JUMP label IF R0<R1 } i6: D1  D1 + D0 Az i1 az előbbi, elemi műveleteket tartalmazó kód for ciklus előtti utasításához, i6 a for ciklus utáni utasításához tartozik. Lényegében ezek a szoftver pipeline feltöltését és kiürítését szolgálják. R0-ba az x[ 1 ] címét kell betölteni!

101 Ciklus optimalizálás Mem1Mem2Int1Int2FP1FP2 1i1 2i2i4i5i3 3i6 3 csoport, a 2. a ciklus magja, ez N-1szer fut le, i1 és i6 egy-egy ciklust igényelnek, így összesen N+1 ciklus kell

102 5. feladat Az alábbi C kód kiszámolja egy diszkrét valószínűségi változó várható értékét: ex = 0; for (int k = 0; k < N; k++) ex += k * p[k]; A műveletek végrehajtási ideje a következő: - egész aritmetikai műveletek: 1 órajel - load/store: 3 órajel - lebegőpontos szorzás: 4 órajel - lebegőpontos összeadás: 2 órajel

103 A pipeline felépítését az alábbi ábra mutatja: IF ID FP EX Add WB FpM * WB Mem WB Az utasítások sorrenden kívüli befejezése megengedett, amennyiben a program értelmén nem változtat. Több WB is végbemehet egyszerre, feltéve, hogy nem ugyanazt a regisztert írják.

104 (a) Írja át a ciklus magját a tárgyban használt pszeudo- assembly nyelvre! Feltéve, hogy R0 tartalmazza a mutatót a p tömb aktuális elemére, D0 tárolja ex-et, és D1 a ciklusváltozó értékét lebegőpontosan, a ciklusmag a következőképpen alakul: i1: D2  MEM [R0] i2: D3  D2 * D1 i3: D0  D0 + D3 i4: D1  D1 + 1.0 i5: R0  R0 + 8

105 Utasítás 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. i1 IF ID MEM0 MEM1 MEM2 WB i2 IF ID A* A* M0 M1 M2 M3 WB i3 IF F* F* ID A* A* A* A0 A1 WB i4 IF ID A0 A1 WB i5 IF ID EX WB Tehát 12 órajelre van szükség. Mivel a 8. órajelben már a ciklus következő körének az utasítása is elkezdhető, ezért most inkább vegyük úgy, hogy 7 órajelre van szükség a ciklus egy körének végrehajtásához. b) Hány órajel szükséges a ciklusmag egyszeri végrehajtásához? i1: D2  MEM [R0] i2: D3  D2 * D1 i3: D0  D0 + D3 i4: D1  D1 + 1.0 i5: R0  R0 + 8

106 c) Optimalizálja a ciklust ciklus-kifejtéssel! Hányszoros ciklus-kifejtésre van szükség? Adja meg a kifejtett ciklus magját pszeudo-assembly nyelven! Hány órajel szükséges az eredeti ciklusmag egyszeri végrehajtásához? A ciklusmag háromszoros kifejtésével: i1: D2  MEM [R0]D1 a ciklusváltozó i2: D4  MEM [R1]D0 az ex érték helye i3: D6  MEM [R2]R0, R1 és R2 a tömb három i4: D3  D2 * D1egymás utáni elemének a címe i5: D1  D1 + 1.0D2, D4 és D6 a három elem i6: R0  R0 + 8értéke i7: D5  D4 * D1D3, D5 és D7 a szorzatok helye i8: D1  D1 + 1.0 i9: R1  R1 + 8 i10: D7  D6 * D1 i11: D1  D1 + 1.0 i12: R2  R2 + 8 i13: D0  D0 + D3 i14: D0  D0 + D5 i15: D0  D0 + D7

107 A RAW függő utasítások távolsága most nagyobb, mint az operandus előállításának ideje, így egyetlen várakozás sem lesz szükséges. A 15 utasítás tehát 15 órajelciklus alatt fog végrehajtódni, azaz egy iterációhoz 15 /3 = 5 órajelciklus kell csak. (Ellenőrzés:az ütemezési diagram felrajzolásával) Kérdés: kétszeres ciklus-kifejtéssel hány órajelciklus kell?

108 i1: D2  MEM [R0]Az utasítások megfelelő i2: R0  R0 + 8átrendezésével az 5 órajel i3: D4  MEM [R0]per ciklus a mag kétszeres i5: D3  D2 * D1kifejtésével is elérhető i6: D1  D1 + 1.0 i4: R0  R0 + 8 i7: D5  D4 * D1 i8: D1  D1 + 1.0 i9: D0  D0 + D3 i10: D0  D0 + D5 Utasítás 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. i1 IF ID MEM0 MEM1 MEM2 WB i2 IF ID EX WB i3 IF ID MEM0 MEM1 MEM2 WB i5 IF ID M0 M1 M2 M3 WB i6 IF ID A0 A1 WB i4 IF ID EX WB i7 IF ID M0 M1 M2 M3 WB i8 IF ID A0 A1 WB i9 IF ID A0 A1 WB i10 IF ID A* A0 A1 WB