Memóriakezelés feladatok

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.

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, 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 et írba lefedhető a 10070, a és a as hivatkozás

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 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 = , a 15-ös keretben A03FFF = A00 A01 A02 A03 Vcím xxxx TLB találat esetén 0, TLB hiba esetén 1 (címfordításhoz!!) 2. feladat (eltolás) (lapszám) szektorszám

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 = 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 = 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)

x0007 0x g) TLB találat esetén 0, TLB hiba esetén 3 (címfordításhoz!!)

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 Lapon belüli eltolás 913 x

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) x x Hash mutató tábla NULL mutatóVlap sorszám Laptábla

5. feladat ValidLapszámKeretszám ?? 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?

x keretszám 86. lap a virtuális címtartományban Lap száma a virtuális címtérben Laptábla lap indexe

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 * = 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 = (legfelső szint) keret, 16~19. bájt, 228 * = (középső szint) -19. keret, 20~23. bájt, 19 * = 77844, vagyis három olvasás

TLB és cache feladatok

TLB/cache 1. feladat ValidLapszámKeretszámKor ValidKeretszám 15 0? 0? ? 14 0? 0? 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

ValidLapszámKeretszámKor : 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 :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 a) Mi lesz a TLB végső állapota 4 kB-os lapméret esetén?

ValidLapszámKeretszámKor : 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 :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

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 ? 13 V 18→4 11 0? 13 VTartalom 18→4 11 0? 13 VTartalom 18→ VTartalom 18→4 → VTartalom 18→4 → hiba (pirossal jelöltek) és 2 találat

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) VTartalom 11 0? 0? 0? V ? 0? V ? V V V 11→ VTartalom 11→ VTartalom 11→ →1 6 hiba és 2 találat

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 VT. 0? 11 6 hiba 2 találat VT. 0? 0? V 0? 11 V 0? 13 V V 0? 13 V V V V V 18→6 11 VT V 18→6 11 VT. 14→8 13 VT. 18→6 11 VT. 14→8 13

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 = 35 bit. Minden egyes kereséskor 4 db 35 bites komparátor dolgozik Tag: 35 bit, index: 7 bit, eltolás: 6 bit

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 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)

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

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) T Offset (6 bit)tag(10 bit)

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 tagindexoffset TagIndexOffset int(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)= *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)= *64=20

B kérdés. T.I.O VTagBlokk tartalom ? 0? 0? 0? 11 Cache tartalma direkt vezérlés esetén: az index egyértelműen meghatározza.

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 VT Index 0 Index 1 Index 2 Index 3 TagIndexOffset

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

Pipeline feladatok 1.

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

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)

Pipe 1. feladat b. kérdés Ütemezés 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

Pipe 1. feladat c. kérdés Forwarding 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)

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

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

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

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)

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

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

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

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

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

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

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

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)

Pipe 3. feladat b. kérdés Ütemezés 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!

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

Pipe 3. feladat d. kérdés Ütemezés átrendezés után 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

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

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)

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 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*

Pipeline feladatok 2

Pipe 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)

Pipe 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

Pipe 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

Pipe 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

Pipe 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)

Pipe 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

Elágazásbecslés

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) % M01 M11 M21 M31 S/H ugrott nem ugrott Ugrik Nem ugrik

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) % M012 M11 M2M21 M31 S/H1H

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) % M012 M11 M2M21 M310 S/H1HS

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) % M012 M110 M21 M310 S/H1HSS

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) % M012 M110 M21 M3100 S/H1HSSS

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) % M012 M1100 M21 M3100 S/H1HSSSS

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) % M0123 M1100 M21 M3100 S/H1HSSSSS

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) % M0123 M11000 M21 M3100 S/H1HSSSSSS

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) % M01233 M11000 M21 M3100 S/H1HSSSSSSS

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) % M01233 M11000 M21 M31001 S/H1HSSSSSSSH

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

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

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

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 BHR

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 BHR

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 BHR

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 BHR

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 BHR

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 BHR

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.

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

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: = 1.3 ciklus/utasítás, vagyis lassabb, mint BTB-vel.

VLIV/EPIC feladatok

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

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

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

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 * * 3 = 3.2 ciklus Ha a < 0 80%-ban teljesül, akkor 0.8 * * 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

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)

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)

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 1i1i i2i5 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

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.

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.

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)

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

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.

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.

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;

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

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!

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

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 ;

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.

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!

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

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

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.

(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  D i5: R0  R0 + 8

Utasítás 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  D i5: R0  R0 + 8

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  D D2, 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  D i9: R1  R1 + 8 i10: D7  D6 * D1 i11: D1  D i12: R2  R2 + 8 i13: D0  D0 + D3 i14: D0  D0 + D5 i15: D0  D0 + D7

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?

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  D i4: R0  R0 + 8 i7: D5  D4 * D1 i8: D1  D i9: D0  D0 + D3 i10: D0  D0 + D5 Utasítás 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