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

1. מבנה מחשבים ספרתיים234267 זיכרון מטמון- המשך מבוסס על תרגול של מורן גביש, חלק מהשרטוטים עפ"י ליהוא רפפורט, רנדי כץ, פטרסון Updated by Franck Sala 234267 - November 2005

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

22. שאלה ב' • לפניך קטע הקוד הבא, המשמש לאתחול מערך: • intarray[1024]; • for ( inti=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

23. שאלה ב'Tag directory size : א. כמה סיביות בסה"כ מכיל ה-tag directory של מטמון הנתונים? … WAY 0 WAY 3 • 16 byte blocks : 4 bits , 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 הוא: Tag Line Tag Line Tag Array Cache storage Tag Array Cache storage

24. int array[1024]; for ( inti=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.

25. int array[1024]; for ( inti=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 ה"סטטיים".

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

27. שאלה ב' (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

28. שאלה ב' (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. אם המידע שבמטמון לא רלוונטי, מספר ההחטאות לא ישתנה. אם המידע שבמטמון רלוונטי (המטמון מכיל חלק מנתוני המערך), המידע שאנו מחפשים כבר נמצא במטמון ולכן יקטן מספר ההחטאות.

29. שאלה ב' (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 הוא לא יימחק כי הגישה סדרתית.

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

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

33. שאלה ג' • נתון מעבד דמוי פנטיום, הזהה לפנטיום פרט לכך שרוחב בלוק ב- 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

34. שאלה ג' (2) • סדר הגישות לזיכרון: • טעינת בית בודד מכתובת 0x00010002 • כתיבת בית בודד 0xFF לכתובת 0x00010003 • קריאת DW מכתובת 0x00010000 – 0x00010003 • כתיבת בית בודד 0x99 לכתובת 0x00010003 • כתיבת בית בודד 0xA5 לכתובת 0x00010004 L1, L2 והזיכרון הראשי מאותחלים למצב הבא (שאר הכניסות במצב I): L1: WAY 0 L2: Main Memory: כתובת 000100000x

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

36. שאלה ג' – פתרון (2) • שלב 1 – טעינת בית בודד מכתובת 0x10002( = 0010 0000 0000 0000 0001) חיפוש ב- L1: כלומר set = 0x00tag = 0x10 ב- Way 0: Valid = 1 אבל tag = 0x0000. ב- Way 1: Valid = 0. L1 Miss ! חיפוש ב- L2: כלומר set = 0x00tag = 0x01. Valid = 1 אבל tag = 0x0000 ולכן גם L2 miss

37. שאלה ג' – פתרון (3) • כדי להביא את השורה מהמטמון, L2 צריך לפנות את השורה מ- set = 0. • כדי לשמור על עקרון ההכלה, L2 מבצע Snoop & Invalidate ל- L1 עבור כתובת 0. • L1 בודק עבור tag=0 set=0. הנתון נמצא ב- way #0 לשורה עם M=0, כלומר אין צורך לכתוב אותה לזיכרון, אלא רק למן כפנויה: V:=0 • L2 יכול עכשיו לקרוא מהזיכרון את השורה ולעדכן את הנתון. • L1 קורא את השורה מ- L2 אל Way #1. MISS 0 0 snoop MISS Main Memory: כתובת 000100000x

38. שאלה ג' – פתרון (4) • שלב 2 – כתיבת בית בודד0xFF לכתובת 0x10003( = 0011 0000 0000 0000 0001) בקשת כתיבה ל- L1: כלומר set = 0x00tag = 0x10. L1 מבצע חיפוש ב- set = 0 בשני ה-way, מוצא hit ב- Way #1 וכותב את הנתון לבית מספר 3. מכיוון שהכתיבה הראשונה היא write-through, לא מעדכנים את סיבית Modified, וכותבים את הנתון גם ל-L2 בקשת כתיבה ל-L2: כלומר set = 0x00tag = 0x01. מדיניות הכתיבה ב- L2 היא write backולכן הוא לא מבצע כתיבה החוצה לזיכרון אלא רק משנה את סיבית Modified ל- 1

39. שאלה ג' – פתרון (5) • שלב 2 – כתיבת בית בודד0xFF לכתובת 0x10003( = 0011 0000 0000 0000 0001) 0xFF 1 0xFF הזיכרון הראשי לא מעודכן ! Main Memory: כתובת 000100000x

40. שאלה ג' – פתרון (6) • שלב 3 – קריאת בלוק שלם מכתובת 0x10003- 00x1000 ( = XX00 0000 0000 0000 0001) קריאת בלוק מ- L1: כלומר set = 0x00, tag = 0x10, disp לא רלוונטי בקריאת בלוק. L1 מבצע חיפוש ב- set = 0 בשני ה- way, מוצא hit ב- Way #1וקורא את כל הנתונים משם.

41. שאלה ג' – פתרון (7) • שלב 4 – כתיבת בית בודד, 0x99 לכתובת 0x10003( = 0011 0000 0000 0000 0001) בקשת כתיבה ל- L1: כלומר set = 0x00tag = 0x10. L1 מבצע חיפוש ב- set = 0 בשני ה- way, מוצא hit ב- Way #1 וכותב את הנתון לבית מספר 3. מכיוון שהכתיבה השנייה היא write-back, מעדכנים את סיבית Modified, ולא כותבים את הנתון ל- L2. שאלה : מההיהקורהאםהיינורוציםלבצעכתיבהלכתובת0x10001 במקום 0x10003? תשובה : סיביות V ו- M רלוונטיות ויחידות לכל הבלוק. למרות שבמקרה זה היינו כותבים לראשונה לכתובת זו, מדיניות הכתיבה (לכל הבלוק) הייתה write-back.

42. שאלה ג' – פתרון (8) • שלב 4 – כתיבת בית בודד, 0x99 לכתובת 0x10003( = 0011 0000 0000 0000 0001) 1 0x99 לא מעודכן !L2 הזיכרון הראשי לא מעודכן ! Main Memory: כתובת 000100000x

43. שאלה ג' – פתרון (9) • שלב 5 – כתיבת בית בודד 0xA5 לכתובת 0x10004( = 0100 0000 0000 0000 0001) כתובת 000100000x חיפוש ב- L1: כלומר set = 0x01tag = 0x10. בשני ה- waysV=0 ולכן L1 Miss ! המדיניות של L1 היא no-write-allocate, ולכן L1 מעביר את בקשת הכתיבה ל- L2. חיפוש ב- L2: כלומר set = 0x01tag = 0x01. בכל השורות ב- L2 למעט set=00 מתקיים V=0 לכן גם L2 Miss ! המדיניות של L2 היא no-write-allocate, ולכן L2 מעביר את בקשת הכתיבה לזיכרון הראשי.

44. שאלה ג' – פתרון (10) Main Memory: כתובת 000100000x 0x99