Download presentation
Presentation is loading. Please wait.
1
מבנה מחשבים ספרתיים תרגול מס' 9: Out Of Order Execution
2
Execution of instructions with variable execution time
The longest operation in the machine fixes the frequency. First improvement: Break long instruction in many short operations Implement several pipelines in EXE Implementing pipeline in EXE is not possible for all the instructions Execution time of certain instructions is variable (load with cache miss…) Disadvantage: More pipe stages = bigger penalty on misprediction and more data hazards (CPI increase)
3
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider
4
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R2<-R3*R3 R1<-R1+4
5
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R1<-R1+4 R4<-R3+R4 R2<-R3*R3
6
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R1<-R1+4 R2<-R3*R3 R4<-R3+R4
7
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R1<-R1+4 R2<-R3*R3 R4<-R3+R4
8
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R2<-R3*R3 R4<-R3+R4
9
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R2<-R3*R3 R4<-R3+R4
10
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R4<-R3+R4 R2<-R3*R3
11
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R4<-R3+R4 R2<-R3*R3
12
Execution of instructions with variable execution time
Second improvement: Allow instructions of different pipelines to be executed Out of Order. Execute many independent instructions in parallel in different pipelines Execution must keep correctness of the code Improve CPI
13
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R2<-R3*R3 R1<-R1+4
14
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R1<-R1+4 R4<-R3+R4 R2<-R3*R3
15
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R1<-R1+4 R2<-R3*R3 R4<-R3+R4
16
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R4<-R3+R4 R1<-R1+4 R2<-R3*R3
17
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R4<-R3+R4 R2<-R3*R3
18
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R4<-R3+R4 R2<-R3*R3
19
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R2<-R3*R3
20
דוגמא R1<-R1+4 R2<-R3*R3 R4<-R3+R4 IF ID MEM WB DIV EX M1 M2
Integer unit Multiply divider R2<-R3*R3
21
CPI ענין נוסף: במכונות in order כמו שהכרנו עד היום ניתן (אם בכלל) להגיע ל-CPI מינימאלי של 1. גם עם OOOE חסם זה נשאר אם נאפשר ביצוע במקביל רק של שלב ה-EXE. אבל נוכל לשבור חסם זה אם נאפשר שיפור שלישי: ביצוע מספר הוראות במקביל גם בשאר השלבים. IF ID EXE MEM WB IF ID EXE MEM WB
22
OOO-Execution Processor
לרב מעבדים מודרניים מבצעים את שלבי ה-fetch-decode וה-commit בסדר התוכנית (in order), ואילו את שלב הביצוע מבצעים out of order. (out-of-order) Fetch & Decode EXE Retire (commit) In-order מקום להוראה הבאה הוראה הבאה שמבצעת commit
23
תלויות מידע - data hazards
להזכירכם אנו מכירים כבר תלות מידע מסוג RAW: ADD R1,R2,R3 ADD R5,R6,R1 OOOE יוצרת תלויות מידע חדשות: WAR – Write After Read DIV R1,R2,R3 // many cycles ADD R5,R6,R1 // depends on previous instruction ADD R6,R7,R8 // WAR issue הוראת החילוק הארוכה מעכבת את הוראת החיבור העוקבת שממתינה לערך של R1. מכיוון שאנו מאפשרים ביצוע out of order ההוראה השלישית שלא ממתינה לדבר תתבצע, ואז ההוראה השניה - לכשתתבצע - עלולה לקרוא את הערך של R6 כפי שנכתב ע"י ההוראה השלישית ולא כפי שהתכוון המשורר (או המתכנת).
24
WAW – Write After Write : DIV R1,R2,R3 // many cycles
ADD R5,R6,R1 // depends on previous instruction ADD R5,R7,R8 // WAW issue גם כאן ההוראה השניה מעוכבת ואילו השלישית לא. מה שעלול לקרות: ההוראה השלישית תכתוב ל-R5 לפני ההוראה השניה, ולבסוף כשהשניה תכתוב גם כן, היא תשנה ערך זה. בסופו של דבר יחזיק R5 בערך לא עדכני. תלויות אלו נקראות False Dependencies (כיוון שאם היה לרשות הקומפיילר מספר בלתי מוגבל של רגיסטרים, הוא היה יכול לבחור רגיסטרים שונים לכל פעולה ואז הפקודות לא היו תלויות אחת בשניה יותר). בעיה נוספת היא Structural Hazard - מצב בו הוראה כלשהי נאלצת להמתין כי אין יחידת חישוב פנויה עבורה. למשל רצף פעולות חילוק עלול לגרום לכך.
25
Register Renaming דרך לפתור את ה-False Dependencies החדשות היא Register Renaming. הרעיון: שמירת שתי מערכות רגיסטרים - רגיסטרים ארכיטקטוניים - גלויים למשתמש ונמצאים בשימוש המהדר (כלומר בשפת אסמבלי). מאגר (pool) של רגיסטרים פיזיים רבים. אנו מבצעים שני מיפויים בשלב ה-rename&allocate, אחרי ה-decode: מהרגיסטרים הפיזיים לארכיטקטוניים - רגיסטר פיזי ממופה לרגיסטר הארכיטקטוני אליו ייכתב ערכו בשלב ה-commit. מהרגיסטרים הארכיטקטוניים לפיזיים - רגיסטר ארכיטקטוני ממופה לרגיסטר הפיזי שהפנה אליו אחרון. כדי שהפקודות הבאות יידעו מאיפה לקרוא את האופרנדים שלהן. ROB RAT
26
דוגמא: DIV R1,R2,R3 ADD R2,R4,R1 ADD R2,R3,R3 ADD R4,R3,R2 WAW WAR
Arch reg.. Tempreg.. R1 R2 R3 R4 DIV R1,R2,R3 ADD R2,R4,R1 ADD R2,R3,R3 ADD R4,R3,R2 WAW WAR Renamer T0 T1 T2 T3 Tn buffer ציקלי
27
דוגמא: T0 DIV R1,R2,R3 ADD R2,R4,R1 ADD R2,R3,R3 ADD R4,R3,R2 Renamer
Arch reg.. Tempreg.. R1 R2 R3 R4 T0 DIV R1,R2,R3 ADD R2,R4,R1 ADD R2,R3,R3 ADD R4,R3,R2 Renamer T0 T1 T2 T3 Tn R2/R3
28
דוגמא: T0 DIV R1,R2,R3 T1 ADD R2,R4,R1 ADD R2,R3,R3 ADD R4,R3,R2
Arch reg.. Tempreg.. R1 R2 R3 R4 T0 DIV R1,R2,R3 ADD R2,R4,R1 ADD R2,R3,R3 ADD R4,R3,R2 T1 Renamer T0 T1 T2 T3 Tn R2/R3 R4+T0
29
דוגמא: T0 DIV R1,R2,R3 T2 ADD R2,R4,R1 ADD R2,R3,R3 ADD R4,R3,R2
Arch reg.. Tempreg.. R1 R2 R3 R4 T0 DIV R1,R2,R3 ADD R2,R4,R1 ADD R2,R3,R3 ADD R4,R3,R2 T2 Renamer T0 T1 T2 T3 Tn R2/R3 R4+T0 R3+R3
30
דוגמא: T0 DIV R1,R2,R3 T2 ADD R2,R4,R1 ADD R2,R3,R3 ADD R4,R3,R2 T3
Arch reg.. Tempreg.. R1 R2 R3 R4 T0 DIV R1,R2,R3 ADD R2,R4,R1 ADD R2,R3,R3 ADD R4,R3,R2 T2 T3 Renamer T0 T1 T2 T3 Tn R2/R3 R4+T0 שימו לב: כעת אין תלויות מסוג False Dependencies, אבל RAW עדיין קיים. R3+R3 R3+T2
31
ROB (Re-Order Buffer) דרך נפוצה למימוש הדבר היא ע"י ROB, שהוא חוצץ המקבל את ההוראות משלב ה-decode לפי הסדר. מספר הכניסה ב-ROB מהווה את מספר הרגיסטר הזמני. בשלב ה-EXE נכתבת התוצאה לכניסה המתאימה ב-ROB. ההוראות מבצעות את שלב ה-commit לפי הסדר שלהן ב-ROB – הוראה יכולה לבצע commit רק אם זו שלפניה עשתה זאת. ROB # Data Valid Data DST V I xxx ECX 1 12 EAX 2 x XXX 3
32
Structures IDQ RAT ROB RS RRF Dest. Arch Reg 4 wr. ports
(1 bit) #phys reg EAX RRF EBX ROB 19 ECX 23 ROB RS # Data Valid Data DST 19 V I xxx EBX 23 ECX 37 x XXX 38 v src1 src2 Pdst add 1 97H 12H 19 sub rob19 33H 23 Dest. Phys Reg 4 wr. Ports 1 per uop Arch reg: value from RRF Phys reg valid: value from ROB Phys ref not valid: wait for value RRF EAX 97H Source & dest values updated after EXE
33
P6 כדוגמא ל-OOO ניקח את מכונת ה-P6 שממומשת במעבדי Pentium2 ו-Pentium3.
במכונה זו ההוראות מסוג CISC נכנסות לשלב ה-decode לפי הסדר. שם הן מפורקות להוראות פנימיות הנקראות uops מסוג RISC. הוראות אלו מתבצעות בשלב ה-EXE out-of-order. לבסוף בשלב ה-commit (retire), ה-uops מחוברות בחזרה להוראות ה-CICS ע"פ הסדר המקורי של ההוראות. כמו כן המכונה משתמשת ב-register renaming הממומש ע"י ROB.
34
דוגמא DIV R2,R4,R3 LD R3,R4(50) DIV R1,R2,R3 ADD R2,R4,R3 SUB R3,R2,R3
נניח כי: Div: 4cc Add/Sub: 1cc Mem: 2cc
35
Instruction Q ROB Execute Retire RAT R3R2-R3 RF1 R2R4+R3 RF2
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RF1 Arch Reg. RF2 Instruction Q RF3 RF4 MOB RS ROB # Valid Data Valid Data DST I x xxx X RS example v src1 src2 Pdst add 1 97H 12H 37 sub rob37 33H 38 Phys. Reg. Execute Retire
36
Cycle 0 Instruction Q ROB Execute Retire RAT R3R2-R3 RF1 R2R4+R3 RF2
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RF1 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. RF2 Instruction Q RF3 RF4 MOB RS ROB # Valid Data Valid Data DST x xxx X Phys. Reg. Execute Retire
37
Cycle 1 Instruction Q ROB Execute Retire RAT R3R2-R3 RF1 R2R4+R3 RB0
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RF1 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. RB0 Instruction Q RF3 RF4 RS MOB ROB RB0R4/R3 Comment Valid Data Valid Data DST R2 R4/R3 1 xxx R2 Phys. Reg. Execute Retire
38
Cycle 2 Instruction Q ROB Execute Retire RAT R3R2-R3 RF1 R2R4+R3 RB0
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RF1 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. RB0 Instruction Q RB1 RF3 RF4 RS MOB ROB RB0R4/R3 RB1MEM(not rdy) MobR4+50 Comment Valid Data Valid Data DST R2 R4/R3 1 xxx R2 R3MEM(r4+50) R3 Execute RB0R4/R3 (1) Retire
39
Cycle 3 Instruction Q ROB Execute Retire RAT R3R2-R3 RB2 RF1 R2R4+R3
Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. R2R4+R3 RB0 Instruction Q R1R2/R3 RB1 R3MEM(R4+50) R2 R4/R3 RF4 RS MOB ROB RB1MEM(not Rdy) W MobR4+50 Comment Valid Data Valid Data DST R2 R4/R3 1 xxx R2 R3MEM(r4+50) R3 R1 R2 / R3 R1 RB2RB0/RB1 Execute RB0 R4/R3 (1) (2) Retire
40
Cycle 4 Instruction Q ROB Execute Retire RAT R3R2-R3 R2R4+R3
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RB2 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. RB3 Instruction Q RB0 RB1 RF4 RS MOB ROB RB1MEM(not rdy) RB1MEM(R4+50) (w) (1) RB3R4+RB1 Comment Valid Data Valid Data DST R2 R4/R3 1 xxx R2 R3MEM(r4+50) R3 R1 R2 / R3 R1 R2 R4 + R3 RB2RB0/RB1 W Mob R4+50 Execute RB0R4/R3 (2) (3) Retire
41
Cycle 6 Cycle 5 Instruction Q ROB Execute Retire RAT R3R2-R3 RB2
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RB2 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. RB3 Instruction Q RB4 RB1 RF4 RS MOB ROB RB1MEM(R4+50) (2) (1) RB3R4+RB1 W Comment Valid Data Valid Data DST R2 R4/R3 1 xxx R2 R3MEM(r4+50) R3 R1 R2 / R3 R1 R2 R4 + R3 R3 R2 – R3 RB2RB0/RB1 W 1 Value2 Value3 RB4RB3-RB1 Execute RB0 R4/R3 (3) (4) Retire
42
Cycle 6 Instruction Q ROB Execute Retire RAT R3R2-R3 RB2 R2R4+R3 RB3
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RB2 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. RB3 Instruction Q RB4 RF4 RS MOB ROB RB3R4+RB1 Comment Valid Data Valid Data DST R2 R4/R3 1 value2 R2 R3MEM(r4+50) value3 R3 R1 R2 / R3 xxx R1 R2 R4 + R3 R3 R2 – R3 RB2RB0/RB1 RB4RB3-RB1 W Execute Retire
43
Cycle 7 Instruction Q ROB Execute Retire RAT R3R2-R3 RB2 R2R4+R3 RB3
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RB2 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. RB3 Instruction Q RB4 RF4 RS MOB ROB Comment Valid Data Valid Data DST R2 R4/R3 1 Value2 R2 R3MEM(r4+50) Value3 R3 R1 R2 / R3 xxx R1 R2 R4 + R3 R3 R2 – R3 R2 RB0 R3 RB1 RB4RB3-RB1 RB3 R4+RB1 1 Value4 RB2 RB0/RB1 (1) (2) Execute RB4 RB3-RB1 Retire
44
Cycle 8 Instruction Q ROB Execute Retire RAT R3R2-R3 RB2 R2R4+R3 RB3
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RB2 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. RB3 Instruction Q RB4 RF4 RS MOB ROB Comment Valid Data Valid Data DST R2 R4/R3 R3MEM(r4+50) R1 R2 / R3 1 xxx R1 R2 R4 + R3 Value4 R2 R3 R2 – R3 Value5 R3 RB2 RB0/RB1 (3) Execute Retire
45
Cycle 9 Instruction Q ROB Execute Retire RAT R3R2-R3 RB2 R2R4+R3 RB3
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RB2 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. RB3 Instruction Q RB4 RF4 RS MOB ROB Comment Valid Data Valid Data DST R2 R4/R3 R3MEM(r4+50) R1 R2 / R3 1 xxx R1 R2 R4 + R3 Value4 R2 R3 R2 – R3 Value5 R3 RB2 RB0/RB1 (4) Execute Retire
46
Cycle 10 Instruction Q ROB Execute Retire RAT R3R2-R3 RB2 R2R4+R3
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RB2 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. RB3 Instruction Q RB4 RF4 RS MOB ROB Comment Valid Data Valid Data DST R2 R4/R3 R3MEM(r4+50) R1 R2 / R3 1 Value6 R1 R2 R4 + R3 Value4 R2 R3 R2 – R3 Value5 R3 Execute Retire
47
Cycle 11 Instruction Q ROB Execute Retire RAT R3R2-R3 R2R4+R3
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. Instruction Q RF4 RS MOB ROB Comment Valid Data Valid Data DST R2 R4/R3 R3MEM(r4+50) R1 R2 / R3 1 Value6 R1 R2 R4 + R3 Value4 R2 R3 R2 – R3 Value5 R3 Execute Retire R1RB2 R2RB3 R3RB4
48
Cycle 12 Instruction Q ROB Execute Retire RAT R3R2-R3 RF1 R2R4+R3
R3MEM(R4+50) R2 R4/R3 R1 R2 R3 R4 RF1 Div: 4cc Add/Sub: 1cc Mem: 2cc Arch Reg. RF2 Instruction Q RF3 RF4 RS MOB ROB Comment Valid Data Valid Data DST R2 R4/R3 R3MEM(r4+50) R1 R2 / R3 R2 R4 + R3 R3 R2 – R3 Execute Retire
49
Backup
50
כיצד ניתן לשפר את ביצועי המערכת
ב-pipeline של MIPS אותו למדנו זה מכבר, הייתה יחידת ALU בודדת שדאגה לביצוע כל הפעולות (שלב ה-EXE) הבעיה: ישנן פעולות כבדות יותר וכבדות פחות – למשל חיבור שלמים יהיה קל יותר מפעולת חילוק. מכיוון שמחזור השעון אמור להספיק לביצוע כל פעולה הרי שבעקבות הפעולות הכבדות נקבל מחזור שעון ארוך – פגיעה בביצועים.
51
פתרון 1 נאפשר רק ביצוע הוראות פשוטות שלוקחות זמן קצר, והוראות כבדות יפורקו למספר הוראות פשוטות (מעבדי ה-RISC הראשונים היו כאלה). חסרונות: ישנן פעולות כגון חישובי floating-point אשר קשה לפרק אותם לחלקים בעלי זמן ביצוע שווה. ישנן פעולות כגון גישה לזיכרון, עבורן זמן הביצוע (גישה) אינו קבוע (תלוי בעומס על ה-bus) או משתנה מדור לדור.
52
פתרון 2 נהפוך את שלב ה-EXE ל-pipeline (או ל-multicycle). כך הוראה כבדה תתבצע במספר שלבים ונוכל לשמור על מחזור שעון קטן. חסרונות: לא ברור שתמיד נוכל לפרק הוראה כבדה לשלבי pipeline. הוספת שלבים מגדילה את ה-penalty שאנו משלמים על חיזויים שגויים וכן יוצרת בעיות עם תלויות המידע (data hazards) – אמנם נקטין את מחזור השעון אבל אנו עלולים לפגוע ב-CPI.
53
פתרון 3 נבנה pipeline שונה לפקודות בעלות זמן ביצוע שונה.
קרי, כל עוד התכנית שומרת על נכונותה, נאפשר לפקודה שמופיעה בקוד מאוחר יותר להסתיים לפני שפקודה שקדמה לה מסתיימת. שיטה זו מאפשרת ביצוע של מספר הוראות במקביל: כל עוד שייכות ל-pipeline שונה. כל עוד אינן תלויות אחת בשניה. כך נוכל לשפר את ה-CPI של המכונה ובכך לשפר ביצועים.
54
OOOE – The P6 Example In-Order Front End Out-of-order Core
BIU: Bus Interface Unit IFU: Instruction Fetch Unit (includes IC) BTB: Branch Target Buffer ID: Instruction Decoder MIS: Micro-Instruction Sequencer RAT: Register Alias Table Out-of-order Core ROB: Reorder Buffer RRF: Real Register File RS: Reservation Stations IEU: Integer Execution Unit FEU: Floating-point Execution Unit AGU: Address Generation Unit MIU: Memory Interface Unit DCU: Data Cache Unit MOB: Memory Order Buffer L2: Level 2 cache In-Order Retire External Bus L2 MOB BIU DCU MIU IFU AGU R BTB S IEU I D FEU MIS ROB RAT
Similar presentations
