מבנה מחשבים ספרתיים 234267

(C )Yohai Devir 234267 - November 2005 1

מבנה מחשבים ספרתיים234267

זיכרון מטמון - המשךמבוסס על תרגול של מורן גביש, חלק מהשרטוטים עפ"י ליהוא רפפורט, רנדי כץ,

פטרסוןUpdated by Franck Sala

2

תזכורתשל הזיכרון "קרוב" למעבד עותק חלקי החזקת הרעיון מאחורי זיכרון מטמון:

כך שזמן הגישה אליו יהיה קצר בהרבה. היות ושכיחות השימוש בנתונים אינה אחידה והיות והבאת נתונים מהזיכרון הראשי אורכת זמן רב, ניתן לשפר בכך

את הביצועים במידה ניכרת.

– אם ניגשנו לאובייקט מסוים, סביר להניח שניגש אליו שוב מקומיות בזמןבקרוב.

– אם ניגשנו לאובייקט מסוים סביר להניח שניגש לאובייקטים מקומיות במקוםסמוכים אליו.

– הנתון מופיע ברמת הזיכרון.(Hitפגיעה )– הנתון לא מופיע ברמת הזיכרון ולכן צריך להביאו מרמה (Missהחטאה )

נמוכה יותר.- אחוז הפגיעות מתוך סה"כ הגישות לזיכרון. (hit rateיחס פגיעה )

Miss rate = 1 – hit rate– הזיכרון המרכזי מחולק לבלוקים של מספר בתים. בכל פעם שנצטרך בלוק

להעתיק בית למטמון נעתיק את כל הבלוק בו הוא נמצא.

3

Fully associative Organization

Tag Line

Tag Array

Tag = Block# Line Offset

Address Fields0431

Data array

031

==

=

Hit\Miss data

4

Fully associative Organization

גבוה.Hit Rate יתרון:•

חסרון: מימוש ההשוואה המקבילית קשה •ויקר.

Tag Line

Tag Array Data array

Block 1

Block n

::

Block 2

Block m

כל בלוק בזכרון יכול להתמפות לכל שורה במטמון.

5

Direct Mapping Organization. מציאת הנתון:3

כאינדקס במערך.setא. נמצא את השורה המתאימה עפ"י ה- של השורה במטמון אליה הצביע ה- tag של הכתובת עם ה- tagב. נשווה את ה-

set במידה ויש התאמה הבלוק המבוקש נמצא במטמון. אחרת יש החטאה .וצריך להביא את הבלוק.

. disp המתאים בשורה עפ"י שדה ה- byteג. במידה והנתון נמצא במטמון, ניגש ל-

Line

Tag Array

Tag

Set#

Cache storage 031

Tag Set Line Offset

041331 5Block number

29 =

512 sets

6

Direct Mapping Organization

CacheSize

.

.

.

.

CacheSize

CacheSize

block 2 (set = 10)

block 0 (set = 00)

block 6 (set = 10)

block 4 (set = 00)

block 4n+2 (set = 10)

block 4n (set = 00)

tag DataSet#00011011

כל שורה בזכרון יכולה להמצא בשורה אחת במטמון.

שימו לב שאין צורך במדיניות פינוי!

קל למימוש וזוליתרון: גבוה שנובע משיטת miss rate חסרון:

המיפוי המאפשרת מיפוי של מספר כתובות זהות) לאותה שורה set(בעלות סיביות

במטמון.

7

2 way set associative Organization. מציאת הנתון:3

כאינדקס במערך.setא. נמצא את השורה המתאימה עפ"י ה- של השורה במטמון אליה הצביע ה- tag של הכתובת הדרושה עם ה- tagב. נשווה את ה-

set -בכל אחד מהways במידה ויש התאמה הבלוק המבוקש נמצא במטמון. אחרת .יש החטאה וצריך להביא את הבלוק.

. disp המתאים בשורה עפ"י שדה ה- byteג. במידה והנתון נמצא במטמון, ניגש ל-

Tag Set Line Offset04531

Way 0Tag

Set#

Data

Data Out

Way 1

=

Hit/Miss

=

Tag

Set#

Data

MUX

6

8

CacheSize

.

.

.

.

CacheSize

CacheSize

2 (set = 10)

0 (set = 00)

6 (set = 10)

4 (set = 00)

4n+2 (set = 10)

4n (set = 00)


כל שורה בזכרון יכולה להמצא בשורה אחת במטמון .waysבאחד משני ה-

.set מספיק ביט אחד לכל LRUע"מ לממש

מהווה k-waysיתרון / חסרון: השיטה של פשרה סבירה, אופטימלית בביצועים.


WAY 0 WAY 1

2 way set associative Organization

9

מדיניות פינוי

במטמון יהיו הרבה פחות שורות מאשר בלוקים בזכרון הראשי

כאשר יש צורך להביא בלוק נוסף למטמון יהיה צורך לזרוק את אחד הבלוקים הקודמים.

יש מספר אפשרויות לבחור מי יהיה הבלוק שייזרק:

.1LRU - least recently used

הבלוק שזמן רב ביותר לא השתמשנו בו )לקריאה או לכתיבה(.•

.2LRM - least recently modified

הבלוק שזמן רב ביותר לא כתבנו אליו.•

.3Random

בחירה אקראית לחלוטין.•

10

עקרון ההכלה

במטמון ההיררכי שעובד לפי עקרון ההכלה כל רמה של הזיכרון ההיררכי מכילה את כל הנתונים

שנמצאים ברמה שמעליה. הדבר נועד ע"מ לפשט את הפרוטוקולים של התקשורת בין רמה

לרמה. העיקרון לא מתקיים בכל המעבדים.

CPU Registers

L1 Cache

L2 Cache

L3 Cache

Disk

Backup

Main Memory

Multi level

Cache

11

מדיניות עדכון למטמוןWrite back בזמן כתיבה נרשום רק לרמה הדרושה. העדכון לשאר הרמות יבוצע –

כאשר הנתון ייזרק מהמטמון.

DDכתיבה

D D

פינוי מקום L1לנתון אחר

L2

.write back מילים בבלוק( בעל שתי רמות שפועלות במדיניות כתיבה fully associative, 2הציור – עבור מטמון )

Write through בזמן כתיבה נרשום את הערך החדש של הנתון גם לרמה – שמתחתיו. כאשר הנתון ייזרק מהמטמון, אין צורך לעדכן את הרמה שמתחתיו.

. write through מילים בבלוק( בעל שתי רמות שפועלות במדיניות כתיבה fully associative, 2הציור – עבור מטמון )

כתיבה פינוי מקום L1לנתון אחר

L2

12

Write Miss: מדיניות כתיבה

Write allocate במקרה של החטאה מורידים לרמה שמתחת בקשה להבאת –הבלוק. טרם הבאת הבלוק מהרמה התחתונה מפנים את המקום המתאים )מבחינת

set.)ומדיניות החלפה

I I

בקשת כתיבה, החטאה ופינוי מקום

Dהבאת הבלוק

L1וכתיבה

L2

No Write allocate במקרה של החטאה מורידים לרמה שמתחת את בקשת –הכתיבה עצמה. אין הבאה של הבלוק לרמה הנדרשת.

בקשת כתיבה לרמה , החטאה1

D

L1

L2

write back מילים בבלוק( בעל שתי רמות שפועלות במדיניות כתיבה fully associative, 2הציור – עבור מטמון )

בקשת כתיבה מרמה , פגיעה2 לרמה 1

13

סיביות סטאטוס

Dirty )modified( על מנת לבצע מדיניות -write back בלוק לכל שתהווה אינדיקציה האם הבלוק עודכן וטרם dirtyתשמר סיבית מיוחדת

נכתב לרמת זיכרון נמוכה יותר.

Valid בלוק שנמצא במצב - I )Invalid( הוא בלוק שבו המידע שנמצא מתאים tag אינו משקף את המידע שנמצא בבלוק בעל dataבשורת ה-

ברמות נמוכות יותר.

14

סוגי החטאות

Compulsory הבלוק לא היה מעולם בשימוש עד עכשיו, בהכרח הוא לא – ( cold missיימצא במטמו)

Conflict הבלוק כבר היה בשימוש אך היות והמטמון אינו – fully associative.בלוק אחר תפס את מקומו

- LRU policy and mapping affects conflict misses

Capacity הבלוק כבר היה בשימוש אך היות ומאז נקראו יותר בלוקים – ממה שהמטמון היה יכול להכיל, בלוק אחר תפס את מקומו. גם אם המטמון

הייתה נוצרת כאן החטאה.fully-associativeהיה

-Associativity can’t help

15

דוגמא בתים.4 בלוקים. כל בלוק 2 שורות של 2נתון מערך של

התכנית עוברת על המערך פעמיים, בית – בית, לאורך הטורים.

של שני בלוקים.direct mappedהמטמון הינו מטמון

כמה החטאות ייווצרו במהלך התכנית ומאילו סוגים?הנח:

טרם הרצת התכנית אין במטמון שום מידע שקשור אליה.1.

המערך מיושר בזיכרון לפי השורות.2.

עדכון כל תא לא תלוי בשאר התאים.3.

Tag Data

16

(2דוגמא )

ראשית, נבדוק לאן ממופים הבלוקים שבמערך:

אין הכרח שהבלוק הראשון ימופה לתא הראשון במטמון, אולם היות והמיפוי מחזורי, ימופו לאותה שורה במטמון.1מובטח כי כל הבלוקים במערך שמסומנים כ-

1 2

1 2

17

סוג החטאה fullyב- associativ

e

ממופה ל- set #

שורה עמודה

Compulsoryפעם ראשונה בבלוק – Way 0 )M( 1 1 1


Conflict Way 0 )H( 1 1 2


כנ"ל 1 3-4



Conflict 2-4 – בדיוק כמו בעמודות 2 6-8

Capacity -גם ב – fully associative היינו מקבלים החטאה

Way 0 )M( 1 1 1


Way 1 )M( 1 2 1

Conflict 1 2-4


Way 0 )M( 2 1 5

… … … … … מסוג 24 ו- Capacity מסוג Compulsory, 4 מסוג 4 החטאות מתוכן 32סה"כ

Conflict

1,1 1,2 1,3 1,4 1,5 1,6 1,7 1,8

2,1 2,2 2,3 2,4 2,5 2,6 2,7 2,8

1set Set 2

set 1 Set 2

18


e


שורה עמודה





כנ"ל 1 3-4



Conflict 2-4 – בדיוק כמו בעמודות 2 6-8


Way 0 )M( 1 1 1


Way 1 )M( 1 2 1

Conflict 1 2-4


Way 0 )M( 2 1 5

… … … … … מסוג 24 ו- Capacity מסוג Compulsory, 4 מסוג 4 החטאות מתוכן 32סה"כ

Conflict

1,1 1,2 1,3 1,4 1,5 1,6 1,7 1,8

2,1 2,2 2,3 2,4 2,5 2,6 2,7 2,8

1set Set 2

set 1 Set 2

19

: Compiler(3דוגמא )

.מוצע לשפר את ביצועי התכנית באמצעות מהדר )קומפיילר(

?אילו שינויים ניתן לבצע בתכנית )תוך ידיעת נתוני המעבד(

. עדכון המערך ברזולוציה של בלוקים.1

. עדכון המערך בשורות.2

. ביצוע שני העדכונים לתא, אחד אחרי השני.3

נניח שהמהדר משנה את אופן ריצת התכנית כך שהמערך מעודכן שורה אחר שורה. כמה החטאות ייוצרו ומאילו סוגים?

1,1 1,2 1,3 1,4 1,5 1,6 1,7 1,8

2,1 2,2 2,3 2,4 2,5 2,6 2,7 2,8

20


e


עמודה שורה

Compulsoryפעם ראשונה בבלוק – Way 0 1 1 1

HIT 1 2-4 1


HIT 2 6-8 1


HIT 1 2-4 2


HIT 2 6-8 2


Way 0 1 1 1

HIT 1 2-4 1


Way 1 2 5 1

HIT 2 6-8 1

... ... ... ... Capacity מסוג Compulsory, 4 מסוג 4 החטאות מתוכן 8סה"כ ...

1,1 1,2 1,3 1,4 1,5 1,6 1,7 1,8

2,1 2,2 2,3 2,4 2,5 2,6 2,7 2,8

1set Set 2

set 1 Set 2

21

שאלה א'

L2 cache נתונה מערכת פנטיום עם

.ונמק מועיל או לא, L2 האם בכל אחד מהמקרים הבאים סמן

שתי רמות המטמון באותו גודל.1.

.L1 גדול מ- L2זמן הגישה לשתי רמות המטמון זהה, 2.

ולזיכרון הראשי זהה. L2זמן הגישה ל- 3.

. L2 מוכל ב- L1 התוכן של עקרון ההכלה, כי לפי L2 אין תועלת ב- לא מועיל.. 1 )ולכן לא נצטרך לקרוא או לכתוב L1 נמצא גם ב- L2ולכן כל מה שנמצא ב-

, )ולכן לא נצטרך L2 גם לא נמצא ב- L1( וכל מה שלא נמצא ב- L2כלום מ- (L2לחפש כלום ב-

כי הוא גדול יותר. היות וזמן הגישה זהה, נעדיף לקרוא L2. יש תועלת ב- מועיל. 2 אינו מועיל לביצועי המערכת.L1 ולכן דווקא L2ישר מ-

מיותר כי ניתן לגשת לזיכרון הראשי באותה מהירות וללא חשש L2. לא מועיל. 3להחטאה.

22

שאלה ב'

לפניך קטע הקוד הבא, המשמש לאתחול מערך:int array[1024];for ) int i=0 ; i<1024 ; i++ (

array[i] = 0;

הנחות: מאוחסנים ברגיסטרים.array והמצביע i. המשתנה 1.alignedלא בהכרח בתים בזיכרון – 4 תופס int. משתנה מסוג 2TLB. למערכת זיכרון מטמון נפרד לקוד, לנתונים וכן 3, way-set-associative 4( והוא מאורגן בשיטת data )עבור 1KB. גודל מטמון הנתונים 4

write-allocate, מדיניות write through בתים, מדיניות כתיבה 16גודל כל בלוק .randomומדיניות פינוי

. ניתן להניח כי לא מתבצעת החלפת תהליכים במהלך ריצת התוכנית.5 ביט.32. גודל כתובת 6

- I, array in register- int is 4 bytes )not aligned(- iCache: - dCache: 1KB – 4 way set associative – 16B block

- write through – write allocate - Random- TLB- 32 Bit address

23

: Tag directory sizeשאלה ב'

106

4

64

2

cache size 2# 2

block size 2

# 2# 2

# 2

blocks blocks

blockssets sets

ways

של מטמון הנתונים?tag directoryא. כמה סיביות בסה"כ מכיל ה-

- 16 byte blocks : 4 bits , sets : 4 bits tag = 32 – 8 = 24 bits

כי modified )אין סיבית valid וסיבית tag סיביות ה- 24 מכיל את tag directoryה- (.Random כי מדיניות הפינוי היא LRU ואין סיבית write-throughהמדיניות היא הוא:tag directory, גודל ה- sets 16 יש way כשבכל 4way cacheמכיוון שמדובר ב-

160016*4*124sizedirectory T##

setswaysVtag

ag

Line

Tag Array

Tag

Cache storage

LineTag

Tag Array Cache storage

WAY 0 WAY 3

…

24

how many(2שאלה ב' )misses :

missesblocks 25622

2

sizeblock

sizearray 84

12

ב. נתון כי בתחילת הרצת קטע הקוד מטמון הנתונים ריק. המקסימאלי שאירעו cache missesמהו מספר ה-

במטמון הנתונים במהלך ריצת קטע הקוד?

= 1024*4 בתים, לכן יש צורך לעבור על 4 תופס בזיכרון intכל ( aligned בתים באופן רציף. אם המערך היה יושב מיושר )4096

יהיה כמספר missesבזיכרון, ומתחיל בתחילת בלוק, אז מספר ה- הבלוקים שתופס המערך במטמון.

אם המערך לא היה מיושר, אז הוא היה מוסט קדימה או אחורה במספר בתים, ואז מספר הבלוקים שהמערך תופס וההחטאות הוא

256+1=257.

int array[1024];for ) int i=0 ; i<1024 ; i+

+ (array[i] = 0;

- 16 sets / 4 ways = 1KB

25

How many(3שאלה ב' )misses :

rate miss -1 ratehit

accessesmemory of #

misses cache of #rate miss

accessesmemory of #

hits cache of #ratehit

- Best hit rate in D-cache if we run the code 10 times ? 10 המקסימאלי במטמון הנתונים עבור הרצה של קטע הקוד hit rateמה יהיה ה-

פעמים ברציפות כאשר בתחילת ההרצה הראשונה מטמון הנתונים ריק? מצריכה גישה בודדת למטמון, int)לצורך החישוב יש להניח כי קריאת משתנה מסוג

(alignedבמקרה שהמשתנה הוא

מינימאלי – המערך יהיה מיושר.MR מקסימאלי נחפש HRכדי למצוא

way נבצע רק ב-cache באופן סטטי, ואת ההחלפות ב- waysנשתמש בשלושה ה"סטטיים", לא נפנה אותם עד waysהנותר. כלומר משהוכנסו בלוקים לשלושת ה- (. randomלסיום התוכנית )אפשרי כי מדיניות הפינוי היא

הרביעי. בצורה זו נחסוך בכל הרצה wayכשנצטרך לפנות מקום במטמון נפנה מה- waysנוספת של התוכנית את קריאת הבלוקים שכבר נמצאים בשלושת ה-

ה"סטטיים".


+ (array[i] = 0;

- 16 sets / 4 ways = 1KB

26

How many(3שאלה ב' )misses :


+ (array[i] = 0;

- 16 sets / 4 ways = 1 KB

3 ways static

27

: how many misses(3שאלה ב' )

יהיה:cache missesאם נפעל בצורה כזו, מספר ה- החטאות כי צריך להביא את כל 256בהרצה ראשונה של התכנית יהיו

הבלוקים למטמון )בהנחה שהמערך מיושר(בתשע ההרצות הבאות נחסוך את הבאת הבלוקים שנמצאים בשלושת ה-

ways החטאות 48 = 16*3 ה"סטטיים" ובמונחי החטאות: נחסוך - First pass: 256 misses- 9 next passes: misses saved: 3 ways * 16 set 208 misses

misses saved per iterationFirst run Other Runs

Total accesses # ofper iteration Iterations

256 9 *(256- 16*3 )min MR 0.21

1024 * 10

max HR 1- min MR 0.79

28

(4שאלה ב' )ד. מהו מספר הבלוקים המקסימאלי שיועברו מהזיכרון הראשי למטמון הנתונים

יושב בכתובת i)עבור הרצה יחידה של קטע הקוד( אם נתון כעת, כי משתנה ?no write allocate בזיכרון )ולא ברגיסטר( וכן מדיניות 0x0001 0000פיזית

- Number of blocks copied from memory to cache?

אנו ניגשים לכל אחד מהמשתנים במערך לצורך כתיבה בלבד. forבביצוע לולאת )בבדיקת תנאי היציאה(.i הוא נקראהמשתנה היחידי ש

ולכן בכל בקשות הכתיבה נעדכן רק את NO-write allocateהמטמון עובד במדיניות .iהזיכרון הראשי, והבלוק היחיד שיטען למטמון יהיה של משתנה

למטמון. בלוק אחד יושבת מיושרת בזיכרון ולכן נטען x000010000הכתובת

.257בסעיף ב' מצאנו כי מספר ההחטאות המקסימאלי הוא אם המידע שבמטמון לא רלוונטי, מספר ההחטאות לא ישתנה.

אם המידע שבמטמון רלוונטי )המטמון מכיל חלק מנתוני המערך(, המידע שאנו מחפשים .יקטן מספר ההחטאותכבר נמצא במטמון ולכן

ה. אם בתחילת הרצת קטע הקוד, מטמון הנתונים היה מלא, כיצד היה משתנה מספר ההחטאות )שחושב בסעיף ב'(

How many misses if the cache was full before the run?

29

(5שאלה ב' )

על מספר ההחטאות )בהנחה שמטמון הנתונים LRUז. כיצד ישפיע שינוי מדיניות הפינוי ל-, עבור קטע הקוד הנתון? Randomמלא לפני תחילת ההרצה( לעומת מדיניות פינוי

- Impact of LRU vs. Random on miss rate ?

לא ניתן לחזות מה תהיה השפעת שינוי זה. אנו רצים LRUנניח שהמטמון מכיל נתונים רלוונטיים בתחילת הרצת הקוד. במדיניות

ולכן אנו עלולים לדרוס מידע שיהיה רלוונטי בהמשך waysבאופן סידרתי על ארבעת ה- ייתכן ולא נדרוס מידע זה.randomהלולאה. בעוד שבמדיניות

ייתכן ונדרוס בלוק עוד לפני שנזדקק לו, בעוד שבמדיניות randomמצד שני, במדיניות LRU .הוא לא יימחק כי הגישה סדרתית

בדומה לסעיף הקודם, ובהסתמך על כך שהחטאות מאריכות את זמן הריצה - אם המידע שבמטמון לא רלוונטי, מספר ההחטאות )וזמן הריצה( לא ישתנה.

אם המידע שבמטמון רלוונטי )המטמון מכיל חלק מנתוני המערך(, המידע שאנו מחפשים . )וזמן הריצה(ולכן יקטן מספר ההחטאות כבר נמצא במטמון

ו. אם בתחילת הרצת קטע הקוד, מטמון הנתונים היה מלא, כיצד היה משתנה זמן ריצת התכנית?

Runtime if the cache was full before the run?

30

ח. איזה עיקרון )בהקשר של זיכרון מטמון( בא לידי ביטוי בקטע הקוד?

. עיקרון אי הוודאות.1. עיקרון הלוקאליות במקום.2. עיקרון הלוקאליות בזמן.3. עיקרון הלוקאליות במקום ועיקרון הלוקאליות בזמן.44-1. אף אחת מתשובות 5

(6שאלה ב' )

בא לידי ביטוי בקטע קוד זה, כיוון שהמערך הלוקאליות במקום עיקרון יושב בזיכרון בצורה רציפה ולכן בכל פעם שניגשנו לבלוק מסוים

-ים באותו בלוק.intחסכנו החטאה ל-

עיקרון הלוקאליות בזמן לא בא לידי ביטוי מכיוון שניגשנו לכל נתון פעם אחת בלבד.

What about i when it comes from the memory ?- locality in time for i…

31

שאלה ב' (7)LRU :

במטמון הנתונים, על המימוש להיות חסכוני LRUט. תאר )בקצרה( שיטה למימוש מדיניות פינוי בזיכרון ככל הניתן )גם על חשבון יעילותו(.

כמה סיביות יש להוסיף למטמון עבור המימוש שהצעת.- Implement an LRU – how many bits ?

אבל עכשיו כבר לא מספיקה סיבית בודדת.set ברמת ה-LRUנבצע ( הרשימה תשמור wayנממש שיטה זו ע"י שמירת רשימה מקושרת ובה ארבעה צמתים )אחד לכל

בו השתמשנו way נעדכן את הסדר ברשימה כך שה-way. בכל גישה ל-waysאת סדר עדכון ה- לאחרונה יהיה האחרון ברשימה.

( ולכן ways )כי יש ארבעה way נשתמש בשתי סיביות עבור כלwayכדי לשמור את מספור ה-.set סיביות לכל 8=4*2בסה"כ נוסיף למטמון

Line

Tag Array

Tag

Cache storage

LineTag

Tag Array Cache storage

WAY 0 WAY 3

…

A B C D

MRUWay

LRUWay

A B C DHit way 0:

B A C DHit way 1:

C A B DHit way 2:

D A B CHit way 3:

32

: LRU(7שאלה ב' )

ניתן לשפר את השיטה הקודמת באופן הבא: בו השתמשנו לאחרונה. wayנשמור ברשימה רק שלושה צמתים: נשמיט את הצומת הממופה ל-

שהושמט ונוציא מהרשימה את way הנמצא ברשימה, נוסיף לרשימה את ה wayבכל גישה ל- בו השתמשנו לאחרונה(.way אליו ניגשנו )הוא כרגע ה wayה-

.set סיביות לכל 6=3*2בדרך זאת נוסיף למטמון

השיטה האופטימאלית )מבחינת חסכון במקום(:. waysבכל רגע יש לנו תור ובו ארבעה

4 = !24מספר האפשרויות בו יכול התור להימצא הוא ( כדי לקודד את כל המצבים.set סיביות )לכל 5מספיקות

A B C DHit way 0:

B A C DHit way 1:

C A B DHit way 2:

D A B CHit way 3:

A B C DHit way 0:

B A C DHit way 1:

C A B DHit way 2:

D A B CHit way 3:

33

שאלה ג' במעבד החדש data cache, הזהה לפנטיום פרט לכך שרוחב בלוק ב- נתון מעבד דמוי פנטיום

(8Kb נשאר data cache בתים )גודל ה- 4הוא Valid , Modifiedביטי הסטטוס הם

בתים בבלוק וארגון 64KB , 4 בגודל L2 cacheנתונה מערכת עם המעבד החדש ועם זיכרון direct mapping

לאחר כל אחד מהשלבים הבאים.L1\L2תאר את מצב השורות והכניסות שיש בהן שינוי ב- כתוצאה מגישות לזיכרון עבור קוד. L2הוסף הסבר קצר, התעלם משינויים ב-

הנחותעקרון ההכלה L1 עובד לפי פרוטוקול MESI

L2 / -עובד ב write back No-write allocate- 32 bits address- L1 Data Cache:

- 8KB / 4 Bytes blocks / 2 ways- Modified + Valid- MESI

- L2 Cache 64KB- Block 4B / direct mapping- Inclusive- Write Back- No Write allocate

34

(2שאלה ג' ):סדר הגישות לזיכרון

0x00010002 טעינת בית בודד מכתובת 1.

0x00010003 לכתובת0xFF כתיבת בית בודד 2.

0x00010000 – 0x00010003 מכתובתDW קריאת 3.

0x00010003 לכתובת0x99 כתיבת בית בודד 4.

0x00010004 לכתובת0xA5 כתיבת בית בודד 5.

L1:

Directory Data

set Tag V M 3 2 1 0

0x00 0x0000 1 1 0x73 0x2D 0x10 0x8F

L2:

8 7 6 5 4 3 2 1 0

0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33

Main Memory:כתובת

000100000x

Directory0 Data0

set Tag V M 3 2 1 0

0x00 0x0000 1 0 0x73 0x2D 0x10 0x8FWAY 0

L1, L2 שאר הכניסות במצב( והזיכרון הראשי מאותחלים למצב הבאI:)

35

שאלה ג' – פתרוןL1 עובד לפי פרוטוקול MESI מטמונים נפרדים אחד ל-2, ומכיל DATA-ואחד ל Code .

: כתיבה ראשונה לבלוק – write-back ושיטת write-throughמדיניות הכתיבה היא שילוב של שיטת write-back ומכתיבה שנייה בשיטת write-throughבשיטת

Offset = 2bit בתים, כלומר 4 רוחב כל בלוק במטמון הוא • בתים8KB : 213 הוא L1 גודלו של • בלוקים במטמון211 בתים בבלוק :4 ••2-way : 210 בלוקים בכל way ביטים לשדה ה-10ב- – יש צורך set

tag ביטים ל-20 ונקבל שיש disp וה- set – נחסר את ביטי ה- bit 32גודל הכתובת – •

Tag Set Offset

20bit 10bit 2bit

L2 עובד במדיניות כתיבה write-back עם סיביות סטאטוס Valid-ו modified.offset = 2bit בתים, כלומר 4 רוחב כל בלוק במטמון הוא •בתים 64KB : 216 גודל המטמון • בלוקים במטמון 214 בתים בבלוק :4 •• L2 עובד בשיטת direct-mapping-ולכן מספר הבלוקים הוא כמספר ה setstag סיביות עבור 16 נשארות disp ו-set סיביות. לאחר חיסור סיביות 32 גודל הכתובת – •

tag set disp

16bit 14bit 2bit

36

(2שאלה ג' – פתרון )

)0x10002) = 0010 0000 0000 0000 0001 – טעינת בית בודד מכתובת 1שלב

WAY 0 WAY1

Directory Data Directory Dataset LRU tag V M 3 2 1 0 Tag V M 3 2 1 0

0x00 1 0x0000 1 0 0x73 0x2D 0x10 0x8F ?? 0 ? ? ? ? ?

.tag = 0x0000 אבל Way 0: Valid = 1ב- .Way 1: Valid = 0ב-

L1 Miss!

Tag (20) Set (10) Disp (2)

0000 0000 0000 0001 0000 0000 0000 00

10

set = 0x00 tag = 0x10כלומר

:L2חיפוש ב-

:L1חיפוש ב-

Tag (16) Set (14) Disp (2)

0000 0000 0000 0001 0000 0000 0000 00

10

.set = 0x00 tag = 0x01כלומר Directory Data

set tag V M 3 2 1 00x00 0x0000 1 1 0x73 0x2D 0x10 0x8F

Valid = 1 אבל tag = 0x0000 ולכן גם L2 miss

37

WAY 0 WAY1


0x00 1 0x0000 1 0 0x73 0x2D 0x10 0x8F ?? 0 ? ? ? ? ?

Directory Dataset tag V M 3 2 1 0

0x00 0x0000 1 1 0x73 0x2D 0x10 0x8F

(3שאלה ג' – פתרון ).set = 0 צריך לפנות את השורה מ- L2כדי להביא את השורה מהמטמון,

.0 עבור כתובת L1 ל- Snoop & Invalidate מבצע L2כדי לשמור על עקרון ההכלה,

L1 בודק עבור tag=0 set=0 -הנתון נמצא ב .way #0 לשורה עם M=0 כלומר אין צורך ,V:=0לכתוב אותה לזיכרון, אלא רק למן כפנויה:

L2.יכול עכשיו לקרוא מהזיכרון את השורה ולעדכן את הנתון L1 -קורא את השורה מ L2 אל Way #1.

WAY 0 WAY1


0x00 1 0x0000 0 0 0x73 0x2D 0x10 0x8F

00010 1 0 0x15 0x4C 0x8A 0x33


0x00 0x0001 1 0 0x15 0x4C 0x8A 0x33

8 7 6 5 4 3 2 1 0

0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33

Main Memory:

כתובת 000100000

x

MISS

MISS

snoop

00

38

(4שאלה ג' – פתרון ))0x10003) = 0011 0000 0000 0000 0001 לכתובת 0xFF – כתיבת בית בודד2שלב

L1 -מבצע חיפוש ב set = 0-בשני ה way מוצא ,hit -ב Way #1 3 וכותב את הנתון לבית מספר ., וכותבים את Modified, לא מעדכנים את סיבית write-throughמכיוון שהכתיבה הראשונה היא

L2הנתון גם ל-

Tag (20) Set (10) Disp (2)

0000 0000 0000 0001 0000 0000 0000 00

11

:L2בקשת כתיבה ל-

.set = 0x00 tag = 0x10כלומר


Tag (16) Set (14) Disp (2)

0000 0000 0000 0001 0000 0000 0000 00

11

. set = 0x00 tag = 0x01כלומר

ולכן הוא לא מבצע כתיבה החוצה לזיכרון אלא רק משנה write back היא L2מדיניות הכתיבה ב- 1 ל- Modifiedאת סיבית

WAY 0 WAY1


0x00 1 0x0000 0 0 0x73 0x2D 0x10 0x8F

00010 1 0 0x15 0x4C 0x8A 0x33


0x00 0x0001 1 0 0x15 0x4C 0x8A 0x33

39


WAY 0 WAY1


0x00 0 0x0000 0 1 0x73 0x2D 0x10 0x8F 00010 1 0 0x15 0x4C

0x8A

0x33


0x00 0x0001 1 0 0x15 0x4C 0x8A 0x33

8 7 6 5 4 3 2 1 0

0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33

Main Memory: כתובת 000100000x

0xFF

0xFF1

הזיכרון הראשי לא ! מעודכן

)0x10003) = 0011 0000 0000 0000 0001 לכתובת 0xFF – כתיבת בית בודד2שלב

40

(6שאלה ג' – פתרון ) 0x10003- 00x1000 ) = XX00 0000 0000 0000 – קריאת בלוק שלם מכתובת 3שלב

0001(

L1 -מבצע חיפוש ב set = 0 -בשני ה way מוצא ,hit -ב Way #1 וקורא את כל הנתונים משם.

Tag (20) Set (10) Disp (2)

0000 0000 0000 0001 0000 0000 0000 00

XX

לא רלוונטי בקריאת בלוק.set = 0x00, tag = 0x10, dispכלומר

:L1קריאת בלוק מ-

WAY 0 WAY1


0x00 0 0x0000 0 1 0x73 0x2D 0x10 0x8F 00010 1 0 0xFF 0x4C

0x8A

0x33

41

(7שאלה ג' – פתרון ))0x10003) = 0011 0000 0000 0000 0001 לכתובת 0x99 – כתיבת בית בודד, 4שלב

L1 -מבצע חיפוש ב set = 0 -בשני ה way מוצא ,hit -ב Way #1 וכותב את הנתון לבית מספר , ולא כותבים את Modified, מעדכנים את סיבית write-back. מכיוון שהכתיבה השנייה היא 3

.L2הנתון ל-

Tag (20) Set (10) Disp (2)

0000 0000 0000 0001 0000 0000 0000 00

11



רלוונטיות ויחידות לכל הבלוק. למרות שבמקרה זה היינו כותבים M ו- V : סיביות תשובה.write-backלראשונה לכתובת זו, מדיניות הכתיבה )לכל הבלוק( הייתה

?0x10003 במקום 0x10001 : מה היה קורה אם היינו רוצים לבצע כתיבה לכתובת שאלה

WAY 0 WAY1


0x00 0 0x0000 0 1 0x73 0x2D 0x10 0x8F 00010 1 0 0xFF 0x4C

0x8A

0x33


0x00 0x0001 1 0 0x15 0x4C 0x8A 0x33

42


WAY 0 WAY1

Directory Data Directory Data

set LRU tag V M 3 2 1 0 Tag V M 3 2 1 0

0x00 0 0x0000 0 1 0x73 0x2D 0x10 0x8F 00010 1 0 0xFF 0x4C

0x8A

0x33


0x00 0x0001 1 0 0x15 0x4C 0x8A 0x33

8 7 6 5 4 3 2 1 0

0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33

Main Memory:כתובת

000100000x

0x991

הזיכרון הראשי לא ! מעודכן

L2! לא מעודכן

)0x10003) = 0011 0000 0000 0000 0001 לכתובת 0x99 – כתיבת בית בודד, 4שלב

43

(9שאלה ג' – פתרון ))0x10004) = 0100 0000 0000 0000 0001 לכתובת 0xA5 – כתיבת בית בודד 5שלב

!L1 Miss ולכן ways V=0בשני ה- .L2 מעביר את בקשת הכתיבה ל- L1, ולכן no-write-allocate היא L1המדיניות של

Tag (20) Set (10) Disp (2)

0000 0000 0000 0001 0000 0000 0000 01

00

:L2חיפוש ב-


:L1חיפוש ב-

Tag (16) Set (14) Disp (2)

0000 0000 0000 0001 0000 0000 0000 01

00.set = 0x01 tag = 0x01כלומר

!L2 Miss לכן גם V=0 מתקיים set=00 למעט L2בכל השורות ב- מעביר את בקשת הכתיבה לזיכרון הראשי.L2, ולכן no-write-allocate היא L2המדיניות של

WAY 0 WAY1

Directory Data Directory Data

set LRU tag V M 3 2 1 0 Tag V M 3 2 1 0

0x00 0 0x0000 0 1 0x73 0x2D 0x10 0x8F 00010 1 1 0x99 0x4C

0x8A

0x33


0x00 0x0001 1 0 0x15 0x4C 0x8A 0x33

8 7 6 5 4 3 2 1 0

0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33כתובת

000100000x

44


WAY 0 WAY1


0x00 0 0x0000 0 0 0x73 0x2D 0x10 0x8F 00010 1 1 0x99 0x4C

0x8A

0x33


0x00 0x0001 1 0 0xFF 0x4C 0x8A 0x33

8 7 6 5 4 3 2 1 0

0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33

Main Memory: כתובת 000100000x

0x99

Documents

מבנה מחשבים ספרתיים 234267