View
61
Download
0
Category
Preview:
DESCRIPTION
מבנה מחשבים ספרתיים 234267. זיכרון מטמון - המשך מבוסס על תרגול של מורן גביש, חלק מהשרטוטים עפ"י ליהוא רפפורט, רנדי כץ, פטרסון Updated by Franck Sala. - PowerPoint PPT Presentation
Citation preview
(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)
tag DataSet#00011011
כל שורה בזכרון יכולה להמצא בשורה אחת במטמון .waysבאחד משני ה-
.set מספיק ביט אחד לכל LRUע"מ לממש
מהווה k-waysיתרון / חסרון: השיטה של פשרה סבירה, אופטימלית בביצועים.
tag DataSet#00011011
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
Compulsoryפעם ראשונה בבלוק – Way 1 )M( 1 2 1
Conflict Way 0 )H( 1 1 2
Conflict Way 1 )H( 1 2 2
כנ"ל 1 3-4
Compulsoryפעם ראשונה בבלוק – Way 0 )M( 2 1 5
Compulsoryפעם ראשונה בבלוק – Way 1 )M( 2 2 5
Conflict 2-4 – בדיוק כמו בעמודות 2 6-8
Capacity -גם ב – fully associative היינו מקבלים החטאה
Way 0 )M( 1 1 1
Capacity -גם ב – fully associative היינו מקבלים החטאה
Way 1 )M( 1 2 1
Conflict 1 2-4
Capacity -גם ב – fully associative היינו מקבלים החטאה
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
סוג החטאה fullyב- associativ
e
ממופה ל- set #
שורה עמודה
Compulsoryפעם ראשונה בבלוק – Way 0 )M( 1 1 1
Compulsoryפעם ראשונה בבלוק – Way 1 )M( 1 2 1
Conflict Way 0 )H( 1 1 2
Conflict Way 1 )H( 1 2 2
כנ"ל 1 3-4
Compulsoryפעם ראשונה בבלוק – Way 0 )M( 2 1 5
Compulsoryפעם ראשונה בבלוק – Way 1 )M( 2 2 5
Conflict 2-4 – בדיוק כמו בעמודות 2 6-8
Capacity -גם ב – fully associative היינו מקבלים החטאה
Way 0 )M( 1 1 1
Capacity -גם ב – fully associative היינו מקבלים החטאה
Way 1 )M( 1 2 1
Conflict 1 2-4
Capacity -גם ב – fully associative היינו מקבלים החטאה
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
סוג החטאה fullyב- associativ
e
ממופה ל- set #
עמודה שורה
Compulsoryפעם ראשונה בבלוק – Way 0 1 1 1
HIT 1 2-4 1
Compulsoryפעם ראשונה בבלוק – Way 1 2 5 1
HIT 2 6-8 1
Compulsoryפעם ראשונה בבלוק – Way 0 1 1 2
HIT 1 2-4 2
Compulsoryפעם ראשונה בבלוק – Way 1 2 5 2
HIT 2 6-8 2
Capacity -גם ב – fully associative היינו מקבלים החטאה
Way 0 1 1 1
HIT 1 2-4 1
Capacity -גם ב – fully associative היינו מקבלים החטאה
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נוספת של התוכנית את קריאת הבלוקים שכבר נמצאים בשלושת ה-
ה"סטטיים".
int array[1024];for ) int i=0 ; i<1024 ; i+
+ (array[i] = 0;
- 16 sets / 4 ways = 1KB
26
How many(3שאלה ב' )misses :
int array[1024];for ) int i=0 ; i<1024 ; i+
+ (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
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 ? ? ? ? ?
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
Directory Data Directory Dataset LRU tag V M 3 2 1 0 Tag V M 3 2 1 0
0x00 1 0x0000 0 0 0x73 0x2D 0x10 0x8F
00010 1 0 0x15 0x4C 0x8A 0x33
Directory Dataset tag V M 3 2 1 0
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כלומר
:L1בקשת כתיבה ל-
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
Directory Data Directory Dataset LRU tag V M 3 2 1 0 Tag V M 3 2 1 0
0x00 1 0x0000 0 0 0x73 0x2D 0x10 0x8F
00010 1 0 0x15 0x4C 0x8A 0x33
Directory Dataset tag V M 3 2 1 0
0x00 0x0001 1 0 0x15 0x4C 0x8A 0x33
39
(5שאלה ג' – פתרון )
WAY 0 WAY1
Directory Data Directory Dataset 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 0x15 0x4C
0x8A
0x33
Directory Dataset tag V M 3 2 1 0
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
Directory Data Directory Dataset 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
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
.set = 0x00 tag = 0x10כלומר
:L1בקשת כתיבה ל-
רלוונטיות ויחידות לכל הבלוק. למרות שבמקרה זה היינו כותבים M ו- V : סיביות תשובה.write-backלראשונה לכתובת זו, מדיניות הכתיבה )לכל הבלוק( הייתה
?0x10003 במקום 0x10001 : מה היה קורה אם היינו רוצים לבצע כתיבה לכתובת שאלה
WAY 0 WAY1
Directory Data Directory Dataset 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
Directory Dataset tag V M 3 2 1 0
0x00 0x0001 1 0 0x15 0x4C 0x8A 0x33
42
(8שאלה ג' – פתרון )
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
Directory Dataset tag V M 3 2 1 0
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חיפוש ב-
.set = 0x01 tag = 0x10כלומר
: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
Directory Dataset tag V M 3 2 1 0
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
(10שאלה ג' – פתרון )
WAY 0 WAY1
Directory Data Directory Dataset LRU tag V M 3 2 1 0 Tag V M 3 2 1 0
0x00 0 0x0000 0 0 0x73 0x2D 0x10 0x8F 00010 1 1 0x99 0x4C
0x8A
0x33
Directory Dataset tag V M 3 2 1 0
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
Recommended