Cache példák 2019 (IMSC).

Az előadások a következő témára: "Cache példák 2019 (IMSC)."— Előadás másolata:

1 Cache példák 2019 (IMSC)

2 Egy program az alábbi memóriablokkokról olvas (ebben a sorrendben):
1. Feladat Vegyünk egy 256 byte méretű cache-t 64 byte-os blokkmérettel. A cache kezdetben csupa érvénytelen blokkot tartalmaz. Egy program az alábbi memóriablokkokról olvas (ebben a sorrendben): • 1, 3, 8, 4, 3, 6, 8, 1 Adja meg a cache hibák számát és a cache végső tartalmát LRU algoritmus mellett (a) direkt leképzés esetén, (a) Direkt leképzés esetén az LRU-nak nincs szerepe. Azt, hogy egy blokk hova kerül a cache-be, a blokk számának 4-el való osztási maradéka határozza meg. Az egységes jelölés kedvéért az azonos indexű cache blokkokat egymás alá írjuk, így most a cache pillanatnyi állapota 4 egymás alá rajzolt blokkból áll. A cache tartalma az alábbiak szerint alakul. A 8 memóriaműveletből 6 cache hiba, és 2 cache találat volt.

3 1. Feladat Vegyünk egy 256 byte méretű cache-t 64 byte-os blokkmérettel. A cache kezdetben csupa érvénytelen blokkot tartalmaz. Egy program az alábbi memóriablokkokról olvas (ebben a sorrendben): • 1, 3, 8, 4, 3, 6, 8, 1 Adja meg a cache hibák számát és a cache végső tartalmát LRU algoritmus mellett (b) teljesen asszociatív szervezés esetén, (b) A teljesen asszociatív esetben már az LRU algoritmusnak is van szerepe, azt is nyomon kell követni, hogy melyik blokkot mikor hivatkoztuk utoljára. A ”tag”, vagyis a tárolt blokk száma mellett ezért a blokkok korát is tárolni és folyamatosan frissíteni kell. Új blokk érkezésekor, ha nincs szabad hely, a legöregebb helyére tesszük. Mivel a teljesen asszociatív szervezés esetén minden blokknak ugyanaz az indexe (nincs indexelés), a cache pillanatnyi állapotát egyetlen sorba, egymás mellé rajzolt 4 blokkal jelöljük. A memóriahivatkozások hatására a cache állapota a következőképpen alakul. Megint csak 2 cache találat volt.

4 Egy program az alábbi memóriablokkokról olvas (ebben a sorrendben):
1. Feladat Vegyünk egy 256 byte méretű cache-t 64 byte-os blokkmérettel. A cache kezdetben csupa érvénytelen blokkot tartalmaz. Egy program az alábbi memóriablokkokról olvas (ebben a sorrendben): • 1, 3, 8, 4, 3, 6, 8, 1 Adja meg a cache hibák számát és a cache végső tartalmát LRU algoritmus mellett (c) két utas asszociatív szervezés esetén. (c) A két utas asszociatív esetben az első sor (0-ás index) 2 blokkja páros, a második sor (1-es index) 2 blokkja páratlan blokkokat tud tárolni. Először ez alapján kell kiválasztani a megfelelő sort, az LRU algoritmust csak a soron belüli két blokk közül való választáskor kell alkalmazni.

5 2. Feladat Vegyünk egy 32 kB méretű cache-t 64 byte-os blokkmérettel. A CPU rendelkezzen 32 bites fizikai, 48 bites virtuális címekkel. 4-utas asszociatív szervezés mellett hány darab és hány bites összehasonlítást kell végezni egy keresés során, ha (a) Fizikailag indexelt cache-t használunk, fizikai tag-ekkel A cím alsó 6 bitje az eltolás (26 = 64). A cache-be 32 kB / 64 byte = 512 blokk fér el. Ha 4-utas a szervezés, akkor az index egy adott értékéhez 4 blokk tartozik, vagyis 512/4 = 128 féle indexünk lehet, ami 7 bittel írható le. (a) Ha a cache kizárólag fizikai címekre alapozott, akkor a tag-ek mérete = 19 bit. Minden egyes kereséskor a 4-utas cache-ben az index által kijelölt 4 blokk 19 bites tag-jeit kell összehasonlítanunk a cím megfelelő bitjeivel. Vagyis egyidejűleg 4 darab 19 bites összehasonlítást kell elvégezni.

6 2. Feladat Vegyünk egy 32 kB méretű cache-t 64 byte-os blokkmérettel. A CPU rendelkezzen 32 bites fizikai, 48 bites virtuális címekkel. 4-utas asszociatív szervezés mellett hány darab és hány bites összehasonlítást kell végezni egy keresés során, ha (b) Virtuálisan indexelt cache-t használunk, virtuális tag-ekkel (b) Ha virtuális tag-eket használunk, akkor a tag-ek mérete = 35 bit. Minden egyes kereséskor 4 db 35 bites összehasonlításra van szükség.

7 3. Feladat Vegyünk egy 512 byte méretű cache-t 64 byte-os blokkmérettel. A cache fizikai címeket használ mind az indexeléshez, mind a tag-ekhez. A fizikai címek 16 bit szélesek. Egy program az alábbi memóriacímekről olvas (ebben a sorrendben): • 13, 136, 490, 541, 670, 74, 581, 980 (a) Adja meg a fenti címekhez tartozó ”tag”, ”index” és ”eltolás” mezőket • teljesen asszociatív szervezés • direkt leképzés • két utas asszociatív szervezés esetén. (a) Az 512 byte-os méret 512/64 = 8 blokk tárolását teszi lehetővé. Mivel a blokkok mérete 64 byte, mindhárom esetben 6 bites lesz az eltolás mező. A további mezők mérete a cache szervezéstől függ: • Teljesen asszociatív szervezés esetén nincs indexelés, minden blokk bárhova kerülhet. Index: 0 bit, tag: 16 − 6 = 10 bit. • Direkt leképzés esetén a cache-nek mind a 8 blokkja ”direktben” az index mezővel kerül kiválasztásra, tehát az index mező 3 bites. A maradék 16 − 3 − 6 = 7 bit lesz a cache tag-ek mérete. • Két utas asszociatív szervezés esetén minden blokk két helyre kerülhet a cache-ben. Tehát a cím indexe alapján a 4 darab 2 utas tároló egyikét kell kijelölni. A 4 féle indexhez 2 bit szükséges, a tag-ek tehát 16 − 6 − 2 = 8 bit szélesek lesznek.

8 Egy program az alábbi memóriacímekről olvas (ebben a sorrendben):
3. Feladat Vegyünk egy 512 byte méretű cache-t 64 byte-os blokkmérettel. A cache fizikai címeket használ mind az indexeléshez, mind a tag-ekhez. A fizikai címek 16 bit szélesek. Egy program az alábbi memóriacímekről olvas (ebben a sorrendben): • 13, 136, 490, 541, 670, 74, 581, 980 (a) Adja meg a fenti címekhez tartozó ”tag”, ”index” és ”eltolás” mezőket • teljesen asszociatív szervezés • direkt leképzés • két utas asszociatív szervezés esetén. (a) A memóriacímek felbontása ennek megfelelően történik. A blokk szám és az eltolás szétválasztásához a címet el kell osztani 64-el, az eredmény egész része a blokk száma, a maradék a blokkon belüli eltolás. A blokk számból direkt leképzés esetén 8-al, a 2 utas asszociatív esetben pedig 4-el való osztás maradékaként kapjuk az indexet, egész részeként pedig a cache tag-et. 13 (0/13) 136 (2/8) 490 (7/42) 541 (8/29) 670 (10/30) 74 (1/10) 581 (9/5) 980 (15/20) Eltolás 13 8 42 29 30 10 5 20 Tag teljesen asszoc. Tag direkt leképez. Index direkt leképez. Tag két utas asszoc. Index két utas assz.

9 Egy program az alábbi memóriacímekről olvas (ebben a sorrendben):
3. Feladat Vegyünk egy 512 byte méretű cache-t 64 byte-os blokkmérettel. A cache fizikai címeket használ mind az indexeléshez, mind a tag-ekhez. A fizikai címek 16 bit szélesek. Egy program az alábbi memóriacímekről olvas (ebben a sorrendben): • 13, 136, 490, 541, 670, 74, 581, 980 (a) Adja meg a fenti címekhez tartozó ”tag”, ”index” és ”eltolás” mezőket • teljesen asszociatív szervezés • direkt leképzés • két utas asszociatív szervezés esetén. (a) A memóriacímek felbontása ennek megfelelően történik. A blokk szám és az eltolás szétválasztásához a címet el kell osztani 64-el, az eredmény egész része a blokk száma, a maradék a blokkon belüli eltolás. A blokk számból direkt leképzés esetén 8-al, a 2 utas asszociatív esetben pedig 4-el való osztás maradékaként kapjuk az indexet, egész részeként pedig a cache tag-et. 13 (0/13) 136 (2/8) 490 (7/42) 541 (8/29) 670 (10/30) 74 (1/10) 581 (9/5) 980 (15/20) Eltolás 13 8 42 29 30 10 5 20 Tag teljesen asszoc. 2 7 1 9 15 Tag direkt leképez. Index direkt leképez. Tag két utas asszoc. Index két utas assz.

10 Egy program az alábbi memóriacímekről olvas (ebben a sorrendben):
3. Feladat Vegyünk egy 512 byte méretű cache-t 64 byte-os blokkmérettel. A cache fizikai címeket használ mind az indexeléshez, mind a tag-ekhez. A fizikai címek 16 bit szélesek. Egy program az alábbi memóriacímekről olvas (ebben a sorrendben): • 13, 136, 490, 541, 670, 74, 581, 980 (a) Adja meg a fenti címekhez tartozó ”tag”, ”index” és ”eltolás” mezőket • teljesen asszociatív szervezés • direkt leképzés • két utas asszociatív szervezés esetén. (a) A memóriacímek felbontása ennek megfelelően történik. A blokk szám és az eltolás szétválasztásához a címet el kell osztani 64-el, az eredmény egész része a blokk száma, a maradék a blokkon belüli eltolás. A blokk számból direkt leképzés esetén 8-al, a 2 utas asszociatív esetben pedig 4-el való osztás maradékaként kapjuk az indexet, egész részeként pedig a cache tag-et. 13 (0/13) 136 (2/8) 490 (7/42) 541 (8/29) 670 (10/30) 74 (1/10) 581 (9/5) 980 (15/20) Eltolás 13 8 42 29 30 10 5 20 Tag teljesen asszoc. 2 7 1 9 15 Tag direkt leképez. Index direkt leképez. Tag két utas asszoc. Index két utas assz.

11 Egy program az alábbi memóriacímekről olvas (ebben a sorrendben):
3. Feladat Vegyünk egy 512 byte méretű cache-t 64 byte-os blokkmérettel. A cache fizikai címeket használ mind az indexeléshez, mind a tag-ekhez. A fizikai címek 16 bit szélesek. Egy program az alábbi memóriacímekről olvas (ebben a sorrendben): • 13, 136, 490, 541, 670, 74, 581, 980 (a) Adja meg a fenti címekhez tartozó ”tag”, ”index” és ”eltolás” mezőket • teljesen asszociatív szervezés • direkt leképzés • két utas asszociatív szervezés esetén. (a) A memóriacímek felbontása ennek megfelelően történik. A blokk szám és az eltolás szétválasztásához a címet el kell osztani 64-el, az eredmény egész része a blokk száma, a maradék a blokkon belüli eltolás. A blokk számból direkt leképzés esetén 8-al, a 2 utas asszociatív esetben pedig 4-el való osztás maradékaként kapjuk az indexet, egész részeként pedig a cache tag-et. 13 (0/13) 136 (2/8) 490 (7/42) 541 (8/29) 670 (10/30) 74 (1/10) 581 (9/5) 980 (15/20) Eltolás 13 8 42 29 30 10 5 20 Tag teljesen asszoc. 2 7 1 9 15 Tag direkt leképez. Index direkt leképez. Tag két utas asszoc. Index két utas assz.

12 Egy program az alábbi memóriacímekről olvas (ebben a sorrendben):
3. Feladat Vegyünk egy 512 byte méretű cache-t 64 byte-os blokkmérettel. A cache fizikai címeket használ mind az indexeléshez, mind a tag-ekhez. A fizikai címek 16 bit szélesek. Egy program az alábbi memóriacímekről olvas (ebben a sorrendben): • 13, 136, 490, 541, 670, 74, 581, 980 (a) Adja meg a fenti címekhez tartozó ”tag”, ”index” és ”eltolás” mezőket • teljesen asszociatív szervezés • direkt leképzés • két utas asszociatív szervezés esetén. (a) A memóriacímek felbontása ennek megfelelően történik. A blokk szám és az eltolás szétválasztásához a címet el kell osztani 64-el, az eredmény egész része a blokk száma, a maradék a blokkon belüli eltolás. A blokk számból direkt leképzés esetén 8-al, a 2 utas asszociatív esetben pedig 4-el való osztás maradékaként kapjuk az indexet, egész részeként pedig a cache tag-et. 13 (0/13) 136 (2/8) 490 (7/42) 541 (8/29) 670 (10/30) 74 (1/10) 581 (9/5) 980 (15/20) Eltolás 13 8 42 29 30 10 5 20 Tag teljesen asszoc. 2 7 1 9 15 Tag direkt leképez. Index direkt leképez. Tag két utas asszoc. 3 Index két utas assz.

13 Egy program az alábbi memóriacímekről olvas (ebben a sorrendben):
3. Feladat Vegyünk egy 512 byte méretű cache-t 64 byte-os blokkmérettel. A cache fizikai címeket használ mind az indexeléshez, mind a tag-ekhez. A fizikai címek 16 bit szélesek. Egy program az alábbi memóriacímekről olvas (ebben a sorrendben): • 13, 136, 490, 541, 670, 74, 581, 980 (a) Adja meg a fenti címekhez tartozó ”tag”, ”index” és ”eltolás” mezőket • teljesen asszociatív szervezés • direkt leképzés • két utas asszociatív szervezés esetén. (a) A memóriacímek felbontása ennek megfelelően történik. A blokk szám és az eltolás szétválasztásához a címet el kell osztani 64-el, az eredmény egész része a blokk száma, a maradék a blokkon belüli eltolás. A blokk számból direkt leképzés esetén 8-al, a 2 utas asszociatív esetben pedig 4-el való osztás maradékaként kapjuk az indexet, egész részeként pedig a cache tag-et. 13 (0/13) 136 (2/8) 490 (7/42) 541 (8/29) 670 (10/30) 74 (1/10) 581 (9/5) 980 (15/20) Eltolás 13 8 42 29 30 10 5 20 Tag teljesen asszoc. 2 7 1 9 15 Tag direkt leképez. Index direkt leképez. Tag két utas asszoc. 3 Index két utas assz.

14 3. Feladat Vegyünk egy 512 byte méretű cache-t 64 byte-os blokkmérettel. A cache fizikai címeket használ mind az indexeléshez, mind a tag-ekhez. A fizikai címek 16 bit szélesek. Egy program az alábbi memóriacímekről olvas (ebben a sorrendben): • 13, 136, 490, 541, 670, 74, 581, 980 (b) Adja meg a cache végső tartalmát mind a 3 esetben, LRU algoritmus mellett! (A cache kezdetben csupa érvénytelen blokkot tartalmaz) 8 blokknyi hely van a cache-ben, és mi pont 8 adatot akarunk elhelyezni, a teljesen asszociatív szervezés pedig semmilyen megkötést nem ír elő a blokkok elhelyezésére. Teljesen asszociatív szervezés mellett a cache a végső állapotában az összes blokkot tartalmazza, tetszőleges sorrendben.

15 Egy program az alábbi memóriacímekről olvas (ebben a sorrendben):
3. Feladat Vegyünk egy 512 byte méretű cache-t 64 byte-os blokkmérettel. A cache fizikai címeket használ mind az indexeléshez, mind a tag-ekhez. A fizikai címek 16 bit szélesek. Egy program az alábbi memóriacímekről olvas (ebben a sorrendben): • 13, 136, 490, 541, 670, 74, 581, 980 (b) Adja meg a cache végső tartalmát mind a 3 esetben, LRU algoritmus mellett! (A cache kezdetben csupa érvénytelen blokkot tartalmaz) Direkt leképzés esetén a blokkok elhelyezése egyértelmű, az index meghatározza. Összesen 4-szer fordul elő, hogy korábban már szereplő blokkot felül kell írni, tehát csak 4 blokk lesz a végén a cache-ben. 13 (0/13) 136 (2/8) 490 (7/42) 541 (8/29) 670 (10/30) 74 (1/10) 581 (9/5) 980 (15/20) Tag direkt leképez. 1 Index direkt leképez. 2 7

16 Egy program az alábbi memóriacímekről olvas (ebben a sorrendben):
3. Feladat Vegyünk egy 512 byte méretű cache-t 64 byte-os blokkmérettel. A cache fizikai címeket használ mind az indexeléshez, mind a tag-ekhez. A fizikai címek 16 bit szélesek. Egy program az alábbi memóriacímekről olvas (ebben a sorrendben): • 13, 136, 490, 541, 670, 74, 581, 980 (b) Adja meg a cache végső tartalmát mind a 3 esetben, LRU algoritmus mellett! (A cache kezdetben csupa érvénytelen blokkot tartalmaz) 2-utas asszociatív esetben 2 azonos indexű blokkot is tárolni tudunk. Ebben a példában egyszer sem fordul elő, hogy felül kell írni egy korábbi blokkot, tehát a végén 8 blokk lesz a cache-ben. 13 (0/13) 136 (2/8) 490 (7/42) 541 (8/29) 670 (10/30) 74 (1/10) 581 (9/5) 980 (15/20) Tag két utas asszoc. 1 2 3 Index két utas assz.

17 4. Feladat Vegyünk egy 1 kB méretű cache-t 64 byte-os blokkmérettel
4. Feladat Vegyünk egy 1 kB méretű cache-t 64 byte-os blokkmérettel. A cache kezdetben csupa érvénytelen blokkot tartalmaz. Lefuttatjuk az alábbi programot: 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]; Feltételezések: a short int 2 byte-os, a t tömb blokkhatáron kezdődik, a két dimenziós tömb a memóriában sor-folytonosan helyezkedik el, a cache direkt leképzést használ. Az i,j változó regiszterekben van tárolva, a cache-t nem terhelik. (a) Hány cache hibát vált ki a fenti algoritmus? Számolja ki a cache hiba-arányt! (a) A blokkméret 64 byte, így pontosan 32 rövid egész fér el egy blokkban. A blokkok száma 16. Az első 16 sor-hivatkozás mindegyike betölt egy blokkot, ez 16 cache-hiba. A második 16 sor is hibát okoz, hiszen a cache már tele van, ez újabb 16 hiba, összesen tehát 32 cache hibánk lesz. A hiba arány 32/1024=3.125%

18 4. Feladat Vegyünk egy 1 kB méretű cache-t 64 byte-os blokkmérettel
4. Feladat Vegyünk egy 1 kB méretű cache-t 64 byte-os blokkmérettel. A cache kezdetben csupa érvénytelen blokkot tartalmaz. Lefuttatjuk az alábbi programot: short int t[32][32]; int sum = 0; for (int j=0; j<32; j++) for (int i=0; i<32; i++) sum += t[i][j]; Feltételezések: a short int 2 byte-os, a t tömb blokkhatáron kezdődik, a két dimenziós tömb a memóriában sor-folytonosan helyezkedik el, a cache direkt leképzést használ. Az i,j változó regiszterekben van tárolva, a cache-t nem terhelik. (b) Hány cache hibát vált ki a fenti algoritmus, ha megcseréljük a két ciklust? Számolja ki a cache hiba-arányt! (b) Megcserélt ciklus esetén az első oszlopra történő hivatkozás először betölti a 0~15 sort, ezzel megtelik a cache, ezután a 16~31. sor betöltése ismét 16 cache hibát okoz, azaz egyetlen oszlop kezelése 32 hibát okoz. Ez ugyanígy történik az összes oszlop esetén, vagyis 32x32= 1024 cache hiba lesz, a hiba-arány 100%

19 4. Feladat Vegyünk egy 1 kB méretű cache-t 64 byte-os blokkmérettel
4. Feladat Vegyünk egy 1 kB méretű cache-t 64 byte-os blokkmérettel. A cache kezdetben csupa érvénytelen blokkot tartalmaz. Lefuttatjuk az alábbi programot: 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]; Feltételezések: a short int 2 byte-os, a t tömb blokkhatáron kezdődik, a két dimenziós tömb a memóriában sor-folytonosan helyezkedik el, a cache direkt leképzést használ. Az i,j változó regiszterekben van tárolva, a cache-t nem terhelik. (c) Mekkora cache-re lenne szükség, hogy a megcserélt for ciklusokkal is ugyanolyan hibaarányt kapjunk, mint az eredeti algoritmussal? (c) Ha el tudjuk érni, hogy a 16~31. sor ne írja felül a már benn lévő sorokat, akkor minden sort csak egyszer kell betölteni. Ez akkor lehetséges, ha a cache mind a 32 sort képes tárolni, azaz 32x64=2048 bájt méretű gyorsítótár kell.

20 5. Feladat Vegyünk egy 2 kB méretű cache-t 64 byte-os blokkmérettel
5. Feladat Vegyünk egy 2 kB méretű cache-t 64 byte-os blokkmérettel. A cache kezdetben csupa érvénytelen blokkot tartalmaz. Lefuttatjuk az alábbi programot: double a[32][64]; double b[32][32]; for (int i=0; i<32; i++) for (int j=0; j<32; j++) a[i][2*j] += b[i][16+j/2]; Feltételezések: a double 8 byte-os, a t tömb blokkhatáron kezdődik, a két dimenziós tömb a memóriában sor-folytonosan helyezkedik el, a cache direkt leképezést használ. Az i,j változó regiszterekben van tárolva, a cache-t nem terhelik. (a) Hány cache hibát vált ki a fenti algoritmus? Számolja ki a cache hiba-arányt! a) A külső ciklus minden iterációjában a belső ciklusban a „b” tömb 16 elemére hivatkozunk (bi,16~bi,31), ez 16*8=128 byte, azaz 2 blokk. Ugyan az „a” tömbből csak 32 elemre hivatkozunk, (ezek a páros indexűek: ai,0~ai,62) de a teljes tömböt be kell hozni, ez 64*8=512 bájt, azaz 8 blokk. Így a cache hibák száma: 2+8=10. Ezalatt összesen 3*32 memóriaművelet történik (2 olvasás, 1 írás). A külső ciklust is figyelembe véve 32*10=320 hiba adódik 3*32*32=3072 műveletre, azaz a cache hiba arány 10,4%.

21 5. Feladat Vegyünk egy 2 kB méretű cache-t 64 byte-os blokkmérettel
5. Feladat Vegyünk egy 2 kB méretű cache-t 64 byte-os blokkmérettel. A cache kezdetben csupa érvénytelen blokkot tartalmaz. Lefuttatjuk az alábbi programot: double a[32][64]; double b[32][32]; for (int j=0; j<32; j++) for (int i=0; i<32; i++) a[i][2*j] += b[i][16+j/2]; Feltételezések: a short double 8 byte-os, a t tömb blokkhatáron kezdődik, a két dimenziós tömb a memóriában sor-folytonosan helyezkedik el, a cache direkt leképzést használ. Az i,j változó regiszterekben van tárolva, a cache-t nem terhelik. (b) Hány cache hibát vált ki a fenti algoritmus, ha megcseréljük a két ciklust? Számolja ki a cache hiba-arányt! b) Nézzük az első ciklust: j=0, 0=i<32 . a[0][0]=a[0][0]+b[0][16] a[1][0]=a[1][0]+b[1][16] …..a[31][0]=a[31][0]+b[31][16] Minden „i” értékhez be kell hozni „a”-ból és „b”-ből is egy blokknyit. A belső ciklus 16. végrehajtása teljesen megtölti a cache-t, minden esetben cache hibát okozva. Ugyanez történik a 16=i<32 esetben is és j minden értékére. Megcserélt ciklusok esetén minden egyes oszlophoz teljesen újra kell tölteni a cache memóriát, ezért a ciklusok megcserélésével 100% lesz a cache hiba arány.

22 5. Feladat Vegyünk egy 2 kB méretű cache-t 64 byte-os blokkmérettel
5. Feladat Vegyünk egy 2 kB méretű cache-t 64 byte-os blokkmérettel. A cache kezdetben csupa érvénytelen blokkot tartalmaz. Lefuttatjuk az alábbi programot: double a[32][64]; double b[32][32]; for (int i=0; i<32; i++) for (int j=0; j<32; j++) a[i][2*j] += b[i][16+j/2]; Feltételezések: a double 8 byte-os, a t tömb blokkhatáron kezdődik, a két dimenziós tömb a memóriában sor-folytonosan helyezkedik el, a cache direkt leképzést használ. Az i,j változó regiszterekben van tárolva, a cache-t nem terhelik. (c) Mekkora cache-re lenne szükség, hogy a megcserélt for ciklusokkal is ugyanolyan hibaarányt kapjunk, mint az eredeti algoritmussal? c) 64 blokknak (32 az „a” tömbnek, 32 a „b”-nek) kell elférnie a cache-ben, hogy a másik ciklusszervezés is jó legyen, tehát 4kB-os cache szükséges.