מבנה מחשבים ספרתיים 234267 זיכרון מטמון - המשך זיכרון מטמון - המשך מבוסס על תרגול של מורן גביש, חלק מהשרטוטים עפ"י ליהוא רפפורט, רנדי כץ, פטרסון Updated by Franck Sala Last update: Nov 27th 2005 (C) Yohai Devir 234267 - November 2005

תזכורת הרעיון מאחורי זיכרון מטמון: החזקת עותק חלקי של הזיכרון "קרוב" למעבד כך שזמן הגישה אליו יהיה קצר בהרבה. היות ושכיחות השימוש בנתונים אינה אחידה והיות והבאת נתונים מהזיכרון הראשי אורכת זמן רב, ניתן לשפר בכך את הביצועים במידה ניכרת. מקומיות בזמן – אם ניגשנו לאובייקט מסוים, סביר להניח שניגש אליו שוב בקרוב. מקומיות במקום – אם ניגשנו לאובייקט מסוים סביר להניח שניגש לאובייקטים סמוכים אליו. פגיעה (Hit) – הנתון מופיע ברמת הזיכרון. החטאה (Miss) – הנתון לא מופיע ברמת הזיכרון ולכן צריך להביאו מרמה נמוכה יותר. יחס פגיעה (hit rate) - אחוז הפגיעות מתוך סה"כ הגישות לזיכרון. Miss rate = 1 – hit rate בלוק – הזיכרון המרכזי מחולק לבלוקים של מספר בתים. בכל פעם שנצטרך להעתיק בית למטמון נעתיק את כל הבלוק בו הוא נמצא. "קרוב" – קרבה פיזית מאיצה אמנם את זמן הגישה, אך עיקר השיפור נובע מאיכות הזיכרון

Fully associative Organization Address Fields 31 4 Tag = Block# Line Offset Tag Array Data array Tag = Line = = 31 Hit\Miss data

Fully associative Organization Block 1 Block 2 כל בלוק בזכרון יכול להתמפות לכל שורה במטמון. Tag Array Data array Block m Tag Line : Block n יתרון: Hit Rate גבוה. חסרון: מימוש ההשוואה המקבילית קשה ויקר.

Direct Mapping Organization 3. מציאת הנתון: א. נמצא את השורה המתאימה עפ"י ה- set כאינדקס במערך. ב. נשווה את ה- tag של הכתובת עם ה- tag של השורה במטמון אליה הצביע ה- set. במידה ויש התאמה הבלוק המבוקש נמצא במטמון. אחרת יש החטאה וצריך להביא את הבלוק. ג. במידה והנתון נמצא במטמון, ניגש ל- byte המתאים בשורה עפ"י שדה ה- disp. Block number 31 13 5 4 Tag Set Line Offset Tag Line 29 =512 sets Set# Tag Array 31 Cache storage

Direct Mapping Organization כל שורה בזכרון יכולה להמצא בשורה אחת במטמון. שימו לב שאין צורך במדיניות פינוי! block 2 (set = 10) block 0 (set = 00) Cache Size block 6 (set = 10) block 4 (set = 00) Cache Size tag Data Set# 00 01 10 11 . יתרון: קל למימוש וזול חסרון: miss rate גבוה שנובע משיטת המיפוי המאפשרת מיפוי של מספר כתובות (בעלות סיביות set זהות) לאותה שורה במטמון. block 4n+2 (set = 10) block 4n (set = 00) Cache Size

2 way set associative Organization 3. מציאת הנתון: א. נמצא את השורה המתאימה עפ"י ה- set כאינדקס במערך. ב. נשווה את ה- tag של הכתובת הדרושה עם ה- tag של השורה במטמון אליה הצביע ה- set בכל אחד מה- ways. במידה ויש התאמה הבלוק המבוקש נמצא במטמון. אחרת יש החטאה וצריך להביא את הבלוק. ג. במידה והנתון נמצא במטמון, ניגש ל- byte המתאים בשורה עפ"י שדה ה- disp. 31 6 5 4 Tag Set Line Offset Way 1 Way 0 Tag Data Tag Data Set# Set# MUX = Hit/Miss Data Out

2 way set associative Organization ע"מ לממש LRU מספיק ביט אחד לכל set. 2 (set = 10) 0 (set = 00) Cache Size 6 (set = 10) 4 (set = 00) Cache Size WAY 0 WAY 1 tag Data tag Data Set# 00 01 10 11 Set# 00 01 10 11 . יתרון / חסרון: השיטה של k-ways מהווה פשרה סבירה, אופטימלית בביצועים. 4n+2 (set = 10) 4n (set = 00) Cache Size 8

מדיניות פינוי במטמון יהיו הרבה פחות שורות מאשר בלוקים בזכרון הראשי כאשר יש צורך להביא בלוק נוסף למטמון יהיה צורך לזרוק את אחד הבלוקים הקודמים. יש מספר אפשרויות לבחור מי יהיה הבלוק שייזרק: LRU - least recently used הבלוק שזמן רב ביותר לא השתמשנו בו (לקריאה או לכתיבה). LRM - least recently modified הבלוק שזמן רב ביותר לא כתבנו אליו. Random בחירה אקראית לחלוטין.

עקרון ההכלה במטמון ההיררכי שעובד לפי עקרון ההכלה כל רמה של הזיכרון ההיררכי מכילה את כל הנתונים שנמצאים ברמה שמעליה. הדבר נועד ע"מ לפשט את הפרוטוקולים של התקשורת בין רמה לרמה. העיקרון לא מתקיים בכל המעבדים. CPU Registers L1 Cache Multi level Cache L2 Cache L3 Cache Main Memory Disk Backup

מדיניות עדכון למטמון Write back – בזמן כתיבה נרשום רק לרמה הדרושה. העדכון לשאר הרמות יבוצע כאשר הנתון ייזרק מהמטמון. כתיבה פינוי מקום לנתון אחר L1 D L2 D הציור – עבור מטמון (fully associative, 2 מילים בבלוק) בעל שתי רמות שפועלות במדיניות כתיבה write back. Write through – בזמן כתיבה נרשום את הערך החדש של הנתון גם לרמה שמתחתיו. כאשר הנתון ייזרק מהמטמון, אין צורך לעדכן את הרמה שמתחתיו. כתיבה פינוי מקום לנתון אחר L1 L2 הציור – עבור מטמון (fully associative, 2 מילים בבלוק) בעל שתי רמות שפועלות במדיניות כתיבה write through.

מדיניות כתיבה: Write Miss Write allocate – במקרה של החטאה מורידים לרמה שמתחת בקשה להבאת הבלוק. טרם הבאת הבלוק מהרמה התחתונה מפנים את המקום המתאים (מבחינת set ומדיניות החלפה). בקשת כתיבה, החטאה ופינוי מקום הבאת הבלוק וכתיבה L1 I D L2 No Write allocate – במקרה של החטאה מורידים לרמה שמתחת את בקשת הכתיבה עצמה. אין הבאה של הבלוק לרמה הנדרשת. בקשת כתיבה מרמה 1 לרמה 2, פגיעה בקשת כתיבה לרמה 1, החטאה L1 L2 D הציור – עבור מטמון (fully associative, 2 מילים בבלוק) בעל שתי רמות שפועלות במדיניות כתיבה write back

סיביות סטאטוס Dirty (modified) - על מנת לבצע מדיניות write back לכל בלוק תשמר סיבית מיוחדת dirty שתהווה אינדיקציה האם הבלוק עודכן וטרם נכתב לרמת זיכרון נמוכה יותר. Valid - בלוק שנמצא במצב I (Invalid) הוא בלוק שבו המידע שנמצא בשורת ה- data אינו משקף את המידע שנמצא בבלוק בעל tag מתאים ברמות נמוכות יותר.

סוגי החטאות Compulsory – הבלוק לא היה מעולם בשימוש עד עכשיו, בהכרח הוא לא יימצא במטמו(cold miss) Conflict – הבלוק כבר היה בשימוש אך היות והמטמון אינו fully associative בלוק אחר תפס את מקומו. LRU policy and mapping affects conflict misses Capacity – הבלוק כבר היה בשימוש אך היות ומאז נקראו יותר בלוקים ממה שהמטמון היה יכול להכיל, בלוק אחר תפס את מקומו. גם אם המטמון היה fully-associative הייתה נוצרת כאן החטאה. - Associativity can’t help

דוגמא כמה החטאות ייווצרו במהלך התכנית ומאילו סוגים? הנח: נתון מערך של 2 שורות של 2 בלוקים. כל בלוק 4 בתים. התכנית עוברת על המערך פעמיים, בית – בית, לאורך הטורים. המטמון הינו מטמון direct mapped של שני בלוקים. Tag Data כמה החטאות ייווצרו במהלך התכנית ומאילו סוגים? הנח: טרם הרצת התכנית אין במטמון שום מידע שקשור אליה. המערך מיושר בזיכרון לפי השורות. עדכון כל תא לא תלוי בשאר התאים.

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

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 סוג החטאה ב- fully associative ממופה ל- set# שורה עמודה Compulsory – פעם ראשונה בבלוק Way 0 (M) 1 Way 1 (M) 2 Conflict Way 0 (H) Way 1 (H) כנ"ל 3-4 5 Conflict – בדיוק כמו בעמודות 2-4 6-8 Capacity – גם ב- fully associative היינו מקבלים החטאה 2-4 … סה"כ 32 החטאות מתוכן 4 מסוג Compulsory, 4 מסוג Capacity ו- 24 מסוג 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 סוג החטאה ב- fully associative ממופה ל- set# שורה עמודה Compulsory – פעם ראשונה בבלוק Way 0 (M) 1 Way 1 (M) 2 Conflict Way 0 (H) Way 1 (H) כנ"ל 3-4 5 Conflict – בדיוק כמו בעמודות 2-4 6-8 Capacity – גם ב- fully associative היינו מקבלים החטאה 2-4 … סה"כ 32 החטאות מתוכן 4 מסוג Compulsory, 4 מסוג Capacity ו- 24 מסוג Conflict

דוגמא (3)Compiler: מוצע לשפר את ביצועי התכנית באמצעות מהדר (קומפיילר). אילו שינויים ניתן לבצע בתכנית (תוך ידיעת נתוני המעבד)? 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

סה"כ 8 החטאות מתוכן 4 מסוג Compulsory, 4 מסוג Capacity 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 סוג החטאה ב- fully associative ממופה ל- set# עמודה שורה Compulsory – פעם ראשונה בבלוק Way 0 1 HIT 2-4 Way 1 2 5 6-8 Capacity – גם ב- fully associative היינו מקבלים החטאה ... סה"כ 8 החטאות מתוכן 4 מסוג Compulsory, 4 מסוג Capacity

שאלה א' נתונה מערכת פנטיום עם L2 cache שתי רמות המטמון באותו גודל. זמן הגישה לשתי רמות המטמון זהה, L2 גדול מ- L1. זמן הגישה ל- L2 ולזיכרון הראשי זהה. 1. לא מועיל. אין תועלת ב- L2, כי לפי עקרון ההכלה התוכן של L1 מוכל ב- L2. ולכן כל מה שנמצא ב- L2 נמצא גם ב- L1 (ולכן לא נצטרך לקרוא או לכתוב כלום מ- L2) וכל מה שלא נמצא ב- L1 גם לא נמצא ב- L2, (ולכן לא נצטרך לחפש כלום ב- L2) 2. מועיל. יש תועלת ב- L2 כי הוא גדול יותר. היות וזמן הגישה זהה, נעדיף לקרוא ישר מ- L2 ולכן דווקא L1 אינו מועיל לביצועי המערכת. 3. לא מועיל. L2 מיותר כי ניתן לגשת לזיכרון הראשי באותה מהירות וללא חשש להחטאה.

שאלה ב' לפניך קטע הקוד הבא, המשמש לאתחול מערך: int array[1024]; for ( int i=0 ; i<1024 ; i++ ) array[i] = 0; הנחות: 1. המשתנה i והמצביע array מאוחסנים ברגיסטרים. 2. משתנה מסוג int תופס 4 בתים בזיכרון – לא בהכרח aligned. 3. למערכת זיכרון מטמון נפרד לקוד, לנתונים וכן TLB 4. גודל מטמון הנתונים 1KB (עבור data) והוא מאורגן בשיטת way-set-associative 4, גודל כל בלוק 16 בתים, מדיניות כתיבה write through, מדיניות write-allocate ומדיניות פינוי random. 5. ניתן להניח כי לא מתבצעת החלפת תהליכים במהלך ריצת התוכנית. 6. גודל כתובת 32 ביט. 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

שאלה ב'Tag directory size : Line Tag Array Tag Cache storage WAY 0 WAY 3 … 16 byte blocks : 4 bits , 2 4 sets : 4 bits  tag = 32 – 8 = 24 bits ה- tag directory מכיל את 24 סיביות ה- tag וסיבית valid (אין סיבית modified כי המדיניות היא write-through ואין סיבית LRU כי מדיניות הפינוי היא Random). מכיוון שמדובר ב- 4way cache כשבכל way יש 16 sets, גודל ה- tag directory הוא:

שאלה ב' (2)how many misses: int array[1024]; for ( int i=0 ; i<1024 ; i++ ) array[i] = 0; - 16 sets / 4 ways = 1KB שאלה ב' (2)how many misses: ב. נתון כי בתחילת הרצת קטע הקוד מטמון הנתונים ריק. מהו מספר ה- cache misses המקסימאלי שאירעו במטמון הנתונים במהלך ריצת קטע הקוד? כל int תופס בזיכרון 4 בתים, לכן יש צורך לעבור על 4*1024 = 4096 בתים באופן רציף. אם המערך היה יושב מיושר (aligned) בזיכרון, ומתחיל בתחילת בלוק, אז מספר ה- misses יהיה כמספר הבלוקים שתופס המערך במטמון. אם המערך לא היה מיושר, אז הוא היה מוסט קדימה או אחורה במספר בתים, ואז מספר הבלוקים שהמערך תופס וההחטאות הוא 256+1=257.

שאלה ב' (3)How many misses: int array[1024]; for ( int i=0 ; i<1024 ; i++ ) array[i] = 0; - 16 sets / 4 ways = 1KB שאלה ב' (3)How many misses: - Best hit rate in D-cache if we run the code 10 times ? מה יהיה ה- hit rate המקסימאלי במטמון הנתונים עבור הרצה של קטע הקוד 10 פעמים ברציפות כאשר בתחילת ההרצה הראשונה מטמון הנתונים ריק? (לצורך החישוב יש להניח כי קריאת משתנה מסוג int מצריכה גישה בודדת למטמון, במקרה שהמשתנה הוא aligned) כדי למצוא HR מקסימאלי נחפש MR מינימאלי – המערך יהיה מיושר. נשתמש בשלושה ways באופן סטטי, ואת ההחלפות ב- cache נבצע רק ב-way הנותר. כלומר משהוכנסו בלוקים לשלושת ה- ways ה"סטטיים", לא נפנה אותם עד לסיום התוכנית (אפשרי כי מדיניות הפינוי היא random). כשנצטרך לפנות מקום במטמון נפנה מה- way הרביעי. בצורה זו נחסוך בכל הרצה נוספת של התוכנית את קריאת הבלוקים שכבר נמצאים בשלושת ה- ways ה"סטטיים".

שאלה ב' (3)How many misses: int array[1024]; for ( int i=0 ; i<1024 ; i++ ) array[i] = 0; - 16 sets / 4 ways = 1 KB שאלה ב' (3)How many misses: 3 ways static

שאלה ב' (3)how many misses: אם נפעל בצורה כזו, מספר ה- cache misses יהיה: בהרצה ראשונה של התכנית יהיו 256 החטאות כי צריך להביא את כל הבלוקים למטמון (בהנחה שהמערך מיושר) בתשע ההרצות הבאות נחסוך את הבאת הבלוקים שנמצאים בשלושת ה- ways ה"סטטיים" ובמונחי החטאות: נחסוך 3*16 = 48 החטאות First pass: 256 misses 9 next passes: misses saved: 3 ways * 16 set  208 misses

שאלה ב' (4) ד. מהו מספר הבלוקים המקסימאלי שיועברו מהזיכרון הראשי למטמון הנתונים (עבור הרצה יחידה של קטע הקוד) אם נתון כעת, כי משתנה i יושב בכתובת פיזית 0x0001 0000 בזיכרון (ולא ברגיסטר) וכן מדיניות no write allocate ? - Number of blocks copied from memory to cache? בביצוע לולאת for אנו ניגשים לכל אחד מהמשתנים במערך לצורך כתיבה בלבד. המשתנה היחידי שנקרא הוא i (בבדיקת תנאי היציאה). המטמון עובד במדיניות NO-write allocate ולכן בכל בקשות הכתיבה נעדכן רק את הזיכרון הראשי, והבלוק היחיד שיטען למטמון יהיה של משתנה i. הכתובת x000010000 יושבת מיושרת בזיכרון ולכן נטען בלוק אחד למטמון. ה. אם בתחילת הרצת קטע הקוד, מטמון הנתונים היה מלא, כיצד היה משתנה מספר ההחטאות (שחושב בסעיף ב') How many misses if the cache was full before the run? בסעיף ב' מצאנו כי מספר ההחטאות המקסימאלי הוא 257. אם המידע שבמטמון לא רלוונטי, מספר ההחטאות לא ישתנה. אם המידע שבמטמון רלוונטי (המטמון מכיל חלק מנתוני המערך), המידע שאנו מחפשים כבר נמצא במטמון ולכן יקטן מספר ההחטאות.

שאלה ב' (5) ו. אם בתחילת הרצת קטע הקוד, מטמון הנתונים היה מלא, כיצד היה משתנה זמן ריצת התכנית? Runtime if the cache was full before the run? בדומה לסעיף הקודם, ובהסתמך על כך שהחטאות מאריכות את זמן הריצה - אם המידע שבמטמון לא רלוונטי, מספר ההחטאות (וזמן הריצה) לא ישתנה. אם המידע שבמטמון רלוונטי (המטמון מכיל חלק מנתוני המערך), המידע שאנו מחפשים כבר נמצא במטמון ולכן יקטן מספר ההחטאות (וזמן הריצה) . ז. כיצד ישפיע שינוי מדיניות הפינוי ל-LRU על מספר ההחטאות (בהנחה שמטמון הנתונים מלא לפני תחילת ההרצה) לעומת מדיניות פינוי Random, עבור קטע הקוד הנתון? - Impact of LRU vs. Random on miss rate ? לא ניתן לחזות מה תהיה השפעת שינוי זה. נניח שהמטמון מכיל נתונים רלוונטיים בתחילת הרצת הקוד. במדיניות LRU אנו רצים באופן סידרתי על ארבעת ה-ways ולכן אנו עלולים לדרוס מידע שיהיה רלוונטי בהמשך הלולאה. בעוד שבמדיניות random ייתכן ולא נדרוס מידע זה. מצד שני, במדיניות random ייתכן ונדרוס בלוק עוד לפני שנזדקק לו, בעוד שבמדיניות LRU הוא לא יימחק כי הגישה סדרתית.

שאלה ב' (6) ח. איזה עיקרון (בהקשר של זיכרון מטמון) בא לידי ביטוי בקטע הקוד? 1. עיקרון אי הוודאות. 2. עיקרון הלוקאליות במקום. 3. עיקרון הלוקאליות בזמן. 4. עיקרון הלוקאליות במקום ועיקרון הלוקאליות בזמן. 5. אף אחת מתשובות 4-1 עיקרון הלוקאליות במקום בא לידי ביטוי בקטע קוד זה, כיוון שהמערך יושב בזיכרון בצורה רציפה ולכן בכל פעם שניגשנו לבלוק מסוים חסכנו החטאה ל- int-ים באותו בלוק. עיקרון הלוקאליות בזמן לא בא לידי ביטוי מכיוון שניגשנו לכל נתון פעם אחת בלבד. What about i when it comes from the memory ? - locality in time for i…

Line Tag Array Tag Cache storage WAY 0 WAY 3 … שאלה ב' (7)LRU : ט. תאר (בקצרה) שיטה למימוש מדיניות פינוי LRU במטמון הנתונים, על המימוש להיות חסכוני בזיכרון ככל הניתן (גם על חשבון יעילותו). כמה סיביות יש להוסיף למטמון עבור המימוש שהצעת. - Implement an LRU – how many bits ? נבצע LRU ברמת ה-set אבל עכשיו כבר לא מספיקה סיבית בודדת. נממש שיטה זו ע"י שמירת רשימה מקושרת ובה ארבעה צמתים (אחד לכל way) הרשימה תשמור את סדר עדכון ה- ways. בכל גישה ל-way נעדכן את הסדר ברשימה כך שה-way בו השתמשנו לאחרונה יהיה האחרון ברשימה. כדי לשמור את מספור ה-way נשתמש בשתי סיביות עבור כלway (כי יש ארבעה ways) ולכן בסה"כ נוסיף למטמון 2*4=8 סיביות לכל set. A B C D Hit way 0: A B C D MRU Way LRU B A C D Hit way 1: C A B D Hit way 2: D A B C Hit way 3:

שאלה ב' (7)LRU : ניתן לשפר את השיטה הקודמת באופן הבא: נשמור ברשימה רק שלושה צמתים: נשמיט את הצומת הממופה ל- way בו השתמשנו לאחרונה. בכל גישה ל- way הנמצא ברשימה, נוסיף לרשימה את ה way שהושמט ונוציא מהרשימה את ה-way אליו ניגשנו (הוא כרגע ה way בו השתמשנו לאחרונה). בדרך זאת נוסיף למטמון 2*3=6 סיביות לכל set. A B C D Hit way 0: Hit way 1: Hit way 2: Hit way 3: השיטה האופטימאלית (מבחינת חסכון במקום): בכל רגע יש לנו תור ובו ארבעה ways. מספר האפשרויות בו יכול התור להימצא הוא 24 = !4 מספיקות 5 סיביות (לכל set) כדי לקודד את כל המצבים.

שאלה ג' נתון מעבד דמוי פנטיום, הזהה לפנטיום פרט לכך שרוחב בלוק ב- data cache במעבד החדש הוא 4 בתים (גודל ה- data cache נשאר 8Kb) ביטי הסטטוס הם Valid , Modified נתונה מערכת עם המעבד החדש ועם זיכרון L2 cache בגודל 64KB , 4 בתים בבלוק וארגון 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

שאלה ג' (2) סדר הגישות לזיכרון: טעינת בית בודד מכתובת 0x00010002 כתיבת בית בודד 0xFF לכתובת 0x00010003 קריאת DW מכתובת 0x00010000 – 0x00010003 כתיבת בית בודד 0x99 לכתובת 0x00010003 כתיבת בית בודד 0xA5 לכתובת 0x00010004 L1, L2 והזיכרון הראשי מאותחלים למצב הבא (שאר הכניסות במצב I): Directory0 Data0 set Tag V M 3 2 1 0x00 0x0000 0x73 0x2D 0x10 0x8F L1: WAY 0 Directory Data set Tag V M 3 2 1 0x00 0x0000 0x73 0x2D 0x10 0x8F L2: Main Memory: 8 7 6 5 4 3 2 1 0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33 כתובת 000100000x

שאלה ג' – פתרון L1 עובד לפי פרוטוקול MESI, ומכיל 2 מטמונים נפרדים אחד ל-DATA ואחד ל-Code. מדיניות הכתיבה היא שילוב של שיטת write-through ושיטת write-back: כתיבה ראשונה לבלוק – בשיטת write-through ומכתיבה שנייה בשיטת write-back רוחב כל בלוק במטמון הוא 4 בתים, כלומר Offset = 2bit גודלו של L1 הוא 8KB : 213 בתים 4 בתים בבלוק : 211 בלוקים במטמון 2-way : 210 בלוקים בכל way – יש צורך ב-10 ביטים לשדה ה-set גודל הכתובת – 32 bit – נחסר את ביטי ה- set וה- disp ונקבל שיש 20 ביטים ל-tag Tag Set Offset 20bit 10bit 2bit L2 עובד במדיניות כתיבה write-back עם סיביות סטאטוס Valid ו-modified. רוחב כל בלוק במטמון הוא 4 בתים, כלומר offset = 2bit גודל המטמון 64KB : 216 בתים 4 בתים בבלוק : 214 בלוקים במטמון L2 עובד בשיטת direct-mapping ולכן מספר הבלוקים הוא כמספר ה-sets גודל הכתובת – 32 סיביות. לאחר חיסור סיביות set ו-disp נשארות 16 סיביות עבור tag tag set disp 16bit 14bit 2bit

שאלה ג' – פתרון (2) שלב 1 – טעינת בית בודד מכתובת 0x10002( = 0010 0000 0000 0000 0001) Tag (20) Set (10) Disp (2) 0000 0000 0000 0001 0000 0000 0000 00 10 חיפוש ב- L1: כלומר set = 0x00 tag = 0x10 WAY 0 WAY1 Directory Data set LRU tag V M 3 2 1 Tag 0x00 0x0000 0x73 0x2D 0x10 0x8F ?? ? ב- Way 0: Valid = 1 אבל tag = 0x0000. ב- Way 1: Valid = 0.  L1 Miss ! Tag (16) Set (14) Disp (2) 0000 0000 0000 0001 0000 0000 0000 00 10 חיפוש ב- L2: Directory Data set tag V M 3 2 1 0x00 0x0000 0x73 0x2D 0x10 0x8F כלומר set = 0x00 tag = 0x01. Valid = 1 אבל tag = 0x0000 ולכן גם L2 miss

שאלה ג' – פתרון (3) Main Memory: כדי להביא את השורה מהמטמון, L2 צריך לפנות את השורה מ- set = 0. כדי לשמור על עקרון ההכלה, L2 מבצע Snoop & Invalidate ל- L1 עבור כתובת 0. L1 בודק עבור tag=0 set=0. הנתון נמצא ב- way #0 לשורה עם M=0, כלומר אין צורך לכתוב אותה לזיכרון, אלא רק למן כפנויה: V:=0 L2 יכול עכשיו לקרוא מהזיכרון את השורה ולעדכן את הנתון. L1 קורא את השורה מ- L2 אל Way #1. WAY 0 WAY1 Directory Data set LRU tag V M 3 2 1 Tag 0x00 0x0000 0x73 0x2D 0x10 0x8F ?? ? WAY 0 WAY1 Directory Data set LRU tag V M 3 2 1 Tag 0x00 0x0000 0x73 0x2D 0x10 0x8F 00010 0x15 0x4C 0x8A 0x33 MISS snoop Directory Data set tag V M 3 2 1 0x00 0x0001 0x15 0x4C 0x8A 0x33 Directory Data set tag V M 3 2 1 0x00 0x0000 0x73 0x2D 0x10 0x8F MISS Main Memory: 8 7 6 5 4 3 2 1 0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33 כתובת 000100000x

שאלה ג' – פתרון (4) שלב 2 – כתיבת בית בודד0xFF לכתובת 0x10003( = 0011 0000 0000 0000 0001) WAY 0 WAY1 Directory Data set LRU tag V M 3 2 1 Tag 0x00 0x0000 0x73 0x2D 0x10 0x8F 00010 0x15 0x4C 0x8A 0x33 Directory Data set tag V M 3 2 1 0x00 0x0001 0x15 0x4C 0x8A 0x33 Tag (20) Set (10) Disp (2) 0000 0000 0000 0001 0000 0000 0000 00 11 כלומר set = 0x00 tag = 0x10. בקשת כתיבה ל- L1: L1 מבצע חיפוש ב- set = 0 בשני ה-way, מוצא hit ב- Way #1 וכותב את הנתון לבית מספר 3. מכיוון שהכתיבה הראשונה היא write-through, לא מעדכנים את סיבית Modified, וכותבים את הנתון גם ל-L2 Tag (16) Set (14) Disp (2) 0000 0000 0000 0001 0000 0000 0000 00 11 בקשת כתיבה ל-L2: כלומר set = 0x00 tag = 0x01. מדיניות הכתיבה ב- L2 היא write back ולכן הוא לא מבצע כתיבה החוצה לזיכרון אלא רק משנה את סיבית Modified ל- 1

הזיכרון הראשי לא מעודכן ! שאלה ג' – פתרון (5) שלב 2 – כתיבת בית בודד0xFF לכתובת 0x10003( = 0011 0000 0000 0000 0001) WAY 0 WAY1 Directory Data set LRU tag V M 3 2 1 Tag 0x00 0x0000 0x73 0x2D 0x10 0x8F 00010 0x15 0x4C 0x8A 0x33 0xFF Directory Data set tag V M 3 2 1 0x00 0x0001 0x15 0x4C 0x8A 0x33 1 0xFF הזיכרון הראשי לא מעודכן ! Main Memory: 8 7 6 5 4 3 2 1 0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33 כתובת 000100000x

כלומר set = 0x00, tag = 0x10, disp לא רלוונטי בקריאת בלוק. שאלה ג' – פתרון (6) שלב 3 – קריאת בלוק שלם מכתובת 0x10003- 00x1000 ( = XX00 0000 0000 0000 0001) Tag (20) Set (10) Disp (2) 0000 0000 0000 0001 0000 0000 0000 00 XX קריאת בלוק מ- L1: כלומר set = 0x00, tag = 0x10, disp לא רלוונטי בקריאת בלוק. WAY 0 WAY1 Directory Data set LRU tag V M 3 2 1 Tag 0x00 0x0000 0x73 0x2D 0x10 0x8F 00010 0xFF 0x4C 0x8A 0x33 L1 מבצע חיפוש ב- set = 0 בשני ה- way, מוצא hit ב- Way #1 וקורא את כל הנתונים משם.

שאלה ג' – פתרון (7) שלב 4 – כתיבת בית בודד, 0x99 לכתובת 0x10003( = 0011 0000 0000 0000 0001) WAY 0 WAY1 Directory Data set LRU tag V M 3 2 1 Tag 0x00 0x0000 0x73 0x2D 0x10 0x8F 00010 0xFF 0x4C 0x8A 0x33 Directory Data set tag V M 3 2 1 0x00 0x0001 0x15 0x4C 0x8A 0x33 Tag (20) Set (10) Disp (2) 0000 0000 0000 0001 0000 0000 0000 00 11 בקשת כתיבה ל- L1: כלומר set = 0x00 tag = 0x10. L1 מבצע חיפוש ב- set = 0 בשני ה- way, מוצא hit ב- Way #1 וכותב את הנתון לבית מספר 3. מכיוון שהכתיבה השנייה היא write-back, מעדכנים את סיבית Modified, ולא כותבים את הנתון ל- L2. שאלה : מה היה קורה אם היינו רוצים לבצע כתיבה לכתובת 0x10001 במקום 0x10003? תשובה : סיביות V ו- M רלוונטיות ויחידות לכל הבלוק. למרות שבמקרה זה היינו כותבים לראשונה לכתובת זו, מדיניות הכתיבה (לכל הבלוק) הייתה write-back.

הזיכרון הראשי לא מעודכן ! שאלה ג' – פתרון (8) שלב 4 – כתיבת בית בודד, 0x99 לכתובת 0x10003( = 0011 0000 0000 0000 0001) WAY 0 WAY1 Directory Data set LRU tag V M 3 2 1 Tag 0x00 0x0000 0x73 0x2D 0x10 0x8F 00010 0xFF 0x4C 0x8A 0x33 1 0x99 Directory Data set tag V M 3 2 1 0x00 0x0001 0x15 0x4C 0x8A 0x33 לא מעודכן !L2 הזיכרון הראשי לא מעודכן ! Main Memory: 8 7 6 5 4 3 2 1 0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33 כתובת 000100000x

שאלה ג' – פתרון (9) שלב 5 – כתיבת בית בודד 0xA5 לכתובת 0x10004( = 0100 0000 0000 0000 0001) WAY 0 WAY1 Directory Data set LRU tag V M 3 2 1 Tag 0x00 0x0000 0x73 0x2D 0x10 0x8F 00010 0x99 0x4C 0x8A 0x33 Directory Data set tag V M 3 2 1 0x00 0x0001 0x15 0x4C 0x8A 0x33 8 7 6 5 4 3 2 1 0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33 כתובת 000100000x Tag (20) Set (10) Disp (2) 0000 0000 0000 0001 0000 0000 0000 01 00 כלומר set = 0x01 tag = 0x10. חיפוש ב- L1: בשני ה- ways V=0 ולכן L1 Miss ! המדיניות של L1 היא no-write-allocate, ולכן L1 מעביר את בקשת הכתיבה ל- L2. Tag (16) Set (14) Disp (2) 0000 0000 0000 0001 0000 0000 0000 01 00 חיפוש ב- L2: כלומר set = 0x01 tag = 0x01. בכל השורות ב- L2 למעט set=00 מתקיים V=0 לכן גם L2 Miss ! המדיניות של L2 היא no-write-allocate, ולכן L2 מעביר את בקשת הכתיבה לזיכרון הראשי.

שאלה ג' – פתרון (10) Main Memory: 8 7 6 5 4 3 2 1 WAY 0 WAY1 Directory Data set LRU tag V M 3 2 1 Tag 0x00 0x0000 0x73 0x2D 0x10 0x8F 00010 0x99 0x4C 0x8A 0x33 Directory Data set tag V M 3 2 1 0x00 0x0001 0xFF 0x4C 0x8A 0x33 Main Memory: 8 7 6 5 4 3 2 1 0xA3 0x12 0x9B 0x00 0x17 0x15 0x4C 0x8A 0x33 כתובת 000100000x 0x99