לדלג לתוכן

8.1 - צינור ההוראות - תרגול

תרגול - צינור ההוראות

תרגיל 1 - ציור דיאגרמת pipeline

נתונות 4 הוראות הבאות שרצות על pipeline קלאסי בן 5 שלבים (IF, ID, EX, MEM, WB):

mov eax, 10
mov ebx, 20
add ecx, eax
sub edx, ebx
  1. ציירו דיאגרמת pipeline (טבלה של הוראות מול מחזורי שעון) בהנחה שאין שום hazards. בכמה מחזורים מסתיימות כל 4 ההוראות?
  2. עכשיו שימו לב - הוראה 3 (add ecx, eax) תלויה בהוראה 1 (mov eax, 10). זהו data hazard. בהנחה שהמעבד תומך ב-forwarding מפלט EX לכניסת EX, ציירו שוב את הדיאגרמה. האם נדרש עיכוב?
  3. שנו את הוראה 1 ל-mov eax, [mem] (load מזכרון). עכשיו התוצאה מוכנה רק אחרי שלב MEM. ציירו שוב את הדיאגרמה עם forwarding מפלט MEM לכניסת EX. כמה בועות (stalls) נדרשות?

תרגיל 2 - זיהוי סכנות

נתון קטע האסמבלי הבא:

mov eax, [ebx]       ; (1) read from memory
add eax, ecx         ; (2) addition
mov [edx], eax       ; (3) write to memory
sub ecx, 5           ; (4) subtraction
cmp ecx, 0           ; (5) comparison
jz done              ; (6) conditional jump
  1. זהו את כל סכנות הנתונים (data hazards) בקטע הזה. לכל סכנה, ציינו בין איזה שתי הוראות היא קורית ובאיזה אוגר.
  2. איזה מהסכנות ניתן לפתור באמצעות forwarding בלבד? איזה דורש stall?
  3. זהו את סכנת הבקרה (control hazard). איזה הוראות כבר נכנסו לpipeline כשהjz מתחיל להתבצע?
  4. אם הjz כן קופץ, כמה מחזורים הולכים לאיבוד בpipeline flush (בpipeline 5 שלבים)?

תרגיל 3 - חישוב תפוקה

  1. הpipeline בן 5 שלבים מריץ 100 הוראות. בהנחה שאין hazards כלל:
  2. כמה מחזורי שעון לוקח להריץ את כל 100 ההוראות?
  3. מהי התפוקה (הוראות למחזור - IPC)?

  4. מהי התפוקה אם לא היה pipeline כלל (כל הוראה 5 מחזורים)?

  5. עכשיו נניח שכל 5 הוראות יש branch שגורם ל-pipeline flush מלא (5 מחזורים מבוזבזים). חשבו מחדש:

  6. כמה מחזורים לוקח להריץ 100 הוראות?

  7. מהי התפוקה בפועל?

  8. חזרו על סעיף 2, אבל הפעם עם pipeline בן 20 שלבים (כמו Pentium 4). כמה מחזורים מבוזבזים על כל branch? מה התפוקה?

תרגיל 4 - CISC לעומת RISC ומיקרו-פעולות

נתונה ההוראה הבאה בx86:

add [ebx+ecx*4], eax

הוראה זו מבצעת: קריאה מכתובת ebx+ecx*4 בזכרון, חיבור הערך עם eax, וכתיבה חזרה לאותה כתובת.

  1. פרקו את ההוראה הזו למיקרו-פעולות (uops) פשוטות - כל uop מבצע פעולה אחת בלבד (חישוב כתובת, load, פעולה אריתמטית, store). כמה uops קיבלתם?
  2. ציירו את דיאגרמת הpipeline עבור ה-uops (בpipeline 5 שלבים). כמה מחזורים לוקח לבצע את כל ה-uops?
  3. ההוראה המקבילה ב-RISC (ARM) תיראה כך:
    ldr r4, [r1, r2, lsl #2]   ; load from address r1+r2*4 into r4
add r4, r4, r0              ; r4 = r4 + r0
str r4, [r1, r2, lsl #2]   ; store back to memory

    כמה מחזורים לוקחות 3 ההוראות האלה בpipeline (עם forwarding)? השוו לתוצאה מסעיף 2.
  4. אם הpipeline הפנימי של מעבד x86 עובד על uops, מה היתרון בכך שהמתכנת (או הקומפיילר) כותב הוראות CISC ולא RISC?