Date post: | 14-Dec-2015 |
Category: |
Documents |
Upload: | alfredo-buckey |
View: | 217 times |
Download: | 2 times |
Out Of Order Execution(Part 1)
Updated by Franck Sala
2
Execution of instructions with variable execution time
• The longest operation in the machine fixes the frequency
• Break long instruction in many short operations– Implement a pipeline in EXE– Not possible for all the instructions– Execution time of certain instruction is variable (load with cache miss…)– More pipe stages = bigger penalty on misprediction and more data
hazards (CPI increase)
3
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
4
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R1<-R1+4R2<-R3*R3
5
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R1<-R1+4
R2<-R3*R3R4<-R3+R4
6
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
7
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
8
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R2<-R3*R3
R4<-R3+R4
9
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R2<-R3*R3
R4<-R3+R4
10
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R2<-R3*R3
R4<-R3+R4
11
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R2<-R3*R3R4<-R3+R4
12
Execution of instructions with variable execution time
• 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
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R1<-R1+4R2<-R3*R3
14
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R1<-R1+4
R2<-R3*R3R4<-R3+R4
15
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
16
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
17
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R2<-R3*R3
R4<-R3+R4
18
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R2<-R3*R3
R4<-R3+R4
19
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R2<-R3*R3
20
דוגמא
IF ID
EX
M1 M2 M3 M4 MEM WB
DIV
Integer unit
Multiply
divider
R1<-R1+4
R2<-R3*R3
R4<-R3+R4
R2<-R3*R3
21
CPIכמו שהכרנו עד היום ניתן in orderעניין נוסף: במכונות •
1 מינימאלי של CPI-(אם בכלל) להגיע ל יש את חסם זה אם נאפשר OOOEגם בביצוע של •
.EXEביצוע מקביל רק של שלב ה-
אבל נאפשר גם בשאר השלבים ביצוע מספר הוראות •במקביל אזי שנוכל לשבור את חסם זה.
IF ID EXE MEM WB
IF ID EXE MEM WB
22
)data hazardתלויות מידע (
: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
הוראת החילוק הארוכה מעכבת את הוראת החיבור העוקבת • out of, מכיוון שאנו מאפשרים ביצוע R1שממתינה לערך של
order ההוראה השלישית שלא מחכה לכלום תתבצע, ואז R6ההוראה השנייה לכשתתבצע עלולה לקרוא את הערך של
כפי שנכתב ע"י ההוראה השלישית ולא כפי שהתכוון המשורר (או המתכנת).
23
WAW – Write After Write :DIV R1,R2,R3 // many cycles ADD R5,R6,R1 // depends on previous instructionADD R5,R7,R8 // WAW issue
גם כאן ההוראה השנייה מעוכבת ואילו השלישית לא, מה שעלול • לפני ההוראה R5להתבצע הוא שההוראה השלישית תכתוב ל-
השנייה, ולבסוף כשהשנייה תכתוב גם כן, היא תשנה את ערך זה.
בערך לא עדכני.R5בסופו של דבר, יחזיק
תלויות אלו נקראותFalse Dependencies כיוון שאם היה) לרשות המהדר (קומפילר) מספר בלתי מוגבל של רגיסטרים היה
יכול לבחור רגיסטרים שונים לכל פעולה ואז לא היו הפקודות תלויות אחת בשניה יותר)
בעיה נוספת שעוד לא הכרנו היאStructural Hazard זהו מצב ,בו הוראה כלשהי נאלצת להמתין כי אין יחידת חישוב פנויה
עבורה. למשל רצף פעולות חילוק עלול לגרום לכך.
24
Register Renaming
Registerדרך לפתור את בעיית התלויות החדשות היא ע"י •Renaming.
שמירת שתי מערכות רגיסטרים זאת אשר גלויה למשתמש הרעיון: •) ואשר בשימוש המהדר (שפת הסף), רגיסטרים ארכיטקטונים(
)poolמתוך מאגר (רגיסטרים פיזיים ומספר גדול של
אנו מבצעים שני מיפויים: •האחד מהרגיסטרים הארכיטקטוניים לרגיסטרים הפיזיים לצורך פתירת –
לשלב decodeבעיות תלויות מדומות .המיפוי הזה מבוצע במעבר בין שלב ה-הביצוע
והשני מהרגיסטרים הפיזיים לארכיטקטוניים לצורך שמירת "תמונת –המיפוי הזה מבוצע כחלק מפעולת . המכונה" כפי שהקומפילר בנה אותה
commit ומעבירים את הערך שלהם לרגיסטרים המקוריים
וה- commitע"פ רוב, מעבדים מודרניים מבצעים את שלבי ה-•fetch-decode ) בסדר התוכניתin order ואילו את שלב הביצוע (
.out of orderמבצעים
25
דוגמא:
T0
T1
T2
T3
Tn
R1
R2
R3
R4 WARWAW
bufferציקלי
DIV R1,R2,R3ADD R2,R4,R1ADD R2,R3,R3ADD R4,R3,R2
Renamer
Arch reg..
Tempreg..
26
דוגמא:
T0
T1
T2
T3
Tn
R1
R2
R3
R4
T0
R2/R3
DIV R1,R2,R3ADD R2,R4,R1ADD R2,R3,R3ADD R4,R3,R2
Renamer
Arch reg..
Tempreg..
27
דוגמא:
T0
T1
T2
T3
Tn
R1
R2
R3
R4
DIV R1,R2,R3ADD R2,R4,R1ADD R2,R3,R3ADD R4,R3,R2
T0
R2/R3R4+T0
T1
Renamer
Arch reg..
Tempreg..
28
דוגמא:
T0
T1
T2
T3
Tn
R1
R2
R3
R4
DIV R1,R2,R3ADD R2,R4,R1ADD R2,R3,R3ADD R4,R3,R2
T0
R2/R3R4+T0
T2
R3+R3
Renamer
Arch reg..
Tempreg..
29
דוגמא:
T0
T1
T2
T3
Tn
R1
R2
R3
R4
DIV R1,R2,R3ADD R2,R4,R1ADD R2,R3,R3ADD R4,R3,R2
T0
R2/R3R4+T0
T2
R3+R3R3+T2
T3
שים לב:
תלויות מסוג כעת איןFalse Dependencies
עדיין קייםRAWאבל
Renamer
Arch reg..
Tempreg..
30
ROB (reorder Buffer)
, שהוא חוצץ המקבל ROBדרך נפוצה למימוש הדבר היא ע"י • ע"פ הסדר, הכניסה התאימה decodeאת ההוראות משלב ה-
מהווה את מספר הרגיסטר הזמניROBב-
ROB נכתבת התוצאה לכניסה המתאימה ב-EXEבשלב ה-• ע"פ הסדר שלהן commitוההוראות מבצעות את שלב ה-
רק אם זו שלפניה עשתה commit – הוראה יכולה לבצע ROBב-זאת.
Structures
RS
RAT / Alloc
IDQ
#phys reg (1 bit)
EAX 37 RRF
EBX 19 ROB
ECX 23 ROB
ROBv src1 v src2 Pdst
add 1 97H 1 12H 37
sub 0 rob37 1 33H 38
RRF:0 EAX 97H
# Data Valid Data DST
19 V V 12H EBX
23 V V 33H ECX
37 V I xxx EAX
38 I x xxx EAX
Dest. Arch Reg4 wr. ports
Dest. Phys Reg4 wr. Ports1 per uop
Arch reg: value from RRFPhys reg valid: value from ROBPhys ref not valid: wait for value
Source & dest values updated after EXE
32
P6 שממומשת במעבדי P6 ניקח את מכונת ה-OOOכדוגמא ל-•
Pentium2-ו Pentium3
ע"פ הסדרdecode נכנסות לשלב ה-CISCבמכונה זו ההוראות מסוג •
RISC מסוג uopsשם הן מפורקות להוראות פנימיות הנקראות •EXE out-of-order הוראות אלו מתבצעות בשלב ה-•
מחוברים בחזרה להוראות uops ה-commit (retire)לבסוף בשלב ה-• ע"פ הסדר המקורי של ההוראותCICSה-
ROB הממומש ע"י register renamingהמכונה גם משתמשת ב-•
33
דוגמא
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
34
RS example
Instruction Q
MOB
RS
Execute
Retire
RATR1
R2
R3
R4
R3<-R2-R3R2<-R4+R3R1<-R2/R3
R3<-MEM(R4+50)
R2<-R4/R3
ArchReg.
RF1
RF2
RF2
RF3
ROB
Phys.Reg.
# Valid
Data Valid Data DST
I x xxx X
I x xxx X
I x xxx X
I x xxx X
I x xxx X
I x xxx X
I x xxx X
I x xxx X
v src1 v src2 Pdst
add 1 97H 1 12H 37
sub 0 rob37 1 33H 38
35
Instruction Q
MOBRSROB
Execute
Retire
RATR1
R2
R3
R4
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
ArchReg.
Phys.Reg.
RF1
RF2
RF2
RF3
# Valid
Data Valid Data DST
0 x xxx X
0
0
0
0
0
0
0
36
Instruction Q
MOBRS
Execute
Retire
RATR1
R2
R3
R4
RB0
RB0R4/R3
ArchReg.
RF1
RF2
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
ROBComment Valid Data
Valid Data DST
R2 R4/R3 1 0 xxx R2
0
0
0
0
0
0
0
37
Instruction Q
MOBRS
Execute
Retire
RATR1
R2
R3
R4
RB0
RB0R4/R3
RB0R4/R3 (1)
RB1
MobR4+50RB1MEM(not rdy)
ArchReg.
RF1
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
ROBComment Valid Data
Valid Data DST
R2 R4/R3 1 0 xxx R2R3MEM(r4+50) 1 0 xxx R3
0
0
0
0
0
0
38
Instruction Q
MOBRS
Execute
Retire
RATR1
R2
R3
R4
RB0
RB0R4/R3
RB0 R4/R3 (2)
RB1
MobR4+50RB1MEM(not Rdy)
RB2
Mob R4+50
W
RB2RB0/RB1
ArchReg.
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
ROBComment Valid Data
Valid Data DST
R2 R4/R3 1 0 xxx R2R3MEM(r4+50) 1 0 xxx R3
R1 R2 / R3 1 0 xxx R1
0
0
0
0
0
39
Instruction Q
MOBRS
Execute
Retire
RATR1
R2
R3
R4
RB3
RB0R4/R3
RB0R4/R3 (3)
RB1
RB3R4+RB1RB1MEM(R4+50)
RB2
)1(
RB2RB0/RB1 W
ArchReg.
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
ROBComment Valid Data
Valid Data DST
R2 R4/R3 1 0 xxx R2R3MEM(r4+50) 1 0 xxx R3
R1 R2 / R3 1 0 xxx R1R2 R4 + R3 1 0 xxx R2
0
0
0
0
40
Instruction Q
MOBRS
Execute
Retire
RATR1
R2
R3
R4
RB3
RB0 R4/R3
RB0 R4/R3 (4)
RB4
RB3R4+RB1RB1MEM(R4+50)
RB2
)2(
RB2RB0/RB1 WRB4RB3-RB1
W
ArchReg.
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
ROBComment Valid Data
Valid Data DST
R2 R4/R3 1 0 xxx R2R3MEM(r4+50) 1 0 xxx R3
R1 R2 / R3 1 0 xxx R1R2 R4 + R3 1 0 xxx R2R3 R2 – R3 1 0 xxx R3
0
0
0
41
Instruction Q
MOBRS
Execute
Retire
RATR1
R2
R3
R4
RB3
RB4
RB2
RB2RB0/RB1
RB4RB3-RB1
RB2RB0/RB1 (1)RB3 R4+RB1
RB3R4+RB1
W
ArchReg.
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
ROBComment Valid Data
Valid Data DST
R2 R4/R3 1 1 Value2 R2R3MEM(r4+50) 1 1 Value3 R3
R1 R2 / R3 1 0 xxx R1R2 R4 + R3 1 0 xxx R2R3 R2 – R3 1 0 xxx R3
0
0
0
42
Instruction Q
MOBRS
RATR1
R2
R3
R4
RB3
RB4
RB2RB0/RB1
RB2 RB0/RB1 (2)
R2 RB0
R3 RB1
RB2
RB4 RB3-RB1
RB4RB3-RB1
ArchReg.
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
Execute
Retire
ROBComment Valid Data
Valid Data DST
R2 R4/R3 1 1 Value2 R2R3MEM(r4+50) 1 1 Value3 R3
R1 R2 / R3 1 0 xxx R1R2 R4 + R3 1 1 Value4 R2R3 R2 – R3 1 0 xxx R3
0
0
0
43
Instruction Q
MOBRS
RATR1
R2
R3
R4
RB3
RB4
RB2RB0/RB1
RB2 RB0/RB1 (3)
RB2ArchReg.
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
Execute
Retire
ROBComment Valid Data
Valid Data DST
R2 R4/R3 0R3MEM(r4+50) 1 1 Value3 R3
R1 R2 / R3 1 0 xxx R1R2 R4 + R3 1 1 Value4 R2R3 R2 – R3 1 1 Value5 R3
0
0
0
44
Instruction Q
MOBRS
RATR1
R2
R3
R4
RB3
RB4
RB2RB0/RB1
RB2 RB0/RB1 (4)
RB2ArchReg.
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
Execute
Retire
ROBComment Valid Data
Valid Data DST
R2 R4/R3 0R3MEM(r4+50) 0
R1 R2 / R3 1 0 xxx R1R2 R4 + R3 1 1 Value4 R2R3 R2 – R3 1 1 Value5 R3
0
0
0
45
Instruction Q
MOBRS
RATR1
R2
R3
R4
RB3
RB4
RB2ArchReg.
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
Execute
Retire
ROBComment Valid Data
Valid Data DST
R2 R4/R3 0R3MEM(r4+50) 0
R1 R2 / R3 1 1 Value6 R1R2 R4 + R3 1 1 Value4 R2R3 R2 – R3 1 1 Value5 R3
0
0
0
46
Instruction Q
MOBRS
RATR1
R2
R3
R4
R1RB2 R2RB3 R3RB4
ArchReg.
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
Execute
Retire
ROBComment Valid Data
Valid Data DST
R2 R4/R3 0R3MEM(r4+50) 0
R1 R2 / R3 1 1 Value6 R1R2 R4 + R3 1 1 Value4 R2R3 R2 – R3 1 1 Value5 R3
0
0
0
47
Instruction Q
MOBRS
RATR1
R2
R3
R4
ArchReg.
RF3
R3R2-R3R2R4+R3R1R2/R3
R3MEM(R4+50)
R2 R4/R3
Execute
Retire
ROBComment Valid Data
Valid Data DST
R2 R4/R3 0R3MEM(r4+50) 0
R1 R2 / R3 0R2 R4 + R3 0R3 R2 – R3 0
0
0
0
RF1
RF2
RF2
48
Backup
49
כיצד ניתן לשפר את ביצועי המערכת
אותו למדנו זה מכבר, MIPSשל pipelineב-• בודדת שדאגה לביצוע כל ALUהייתה יחידת
)EXEהפעולות (שלב ה-
ישנן פעולות כבדות יותר וכבדות פחות – הבעיה:•למשל חיבור שלמים יהיה קל יותר מפעולת
חילוק.מכיוון שמחזור השעון אמור להספיק לביצוע כל פעולה הרי שבעקבות הפעולות הכבדות נקבל
מחזור שעון ארוך – פגיעה בביצועים.
50
1פתרון נאפשר רק ביצוע הוראות פשוטות שלוקחות זמן קצר, •
והוראות כבדות יפורקו למספר הוראות פשוטות (מעבדי הראשונים היו כאלה) RISCה-
חסרונות: ישנן פעולות כגון חישוביfloating-point אשר קשה
לפרק אותם לחלקים בעלי זמן ביצוע שווה
(גישה) ישנן פעולות כגון גישה לזיכרון שזמן הביצוע) או משתנה מדור busאינו קבוע (תלוי בעומס על ה-
לדור
51
2 פתרון
(או pipeline ל - EXEנהפוך את שלב ה-•) כך הוראה כבדה תתבצע במספר שלבים multicycleל-
ונוכל לשמור על מחזור שעון קטן
:חסרונות לא ברור שתמיד נוכל לפרק הוראה כבדה לשלבי
pipeline
-הוספת שלבים מגדילה את הpenalty שאנו משלמים על חיזויים שגויים וכן יוצרת בעיות עם תלויות המידע
) data hazard אמנם נקטין את מחזור השעון אבל – (.CPIאנו עלולים לפגוע ב-
52
3פתרון שונה לפקודות בעלות זמן ביצוע שונהpipelineנבנה •
שונה להסתיים שלא ע"פ pipelineנאפשר להוראות מ-•סדר הופעתן בקוד
קרי, כל עוד התוכנית שומרת על נכונותה, נאפשר לפקודה –שמופיעה בקוד מאוחר יותר להסתיים לפני שפקודה שקדמה
לה מסתיימת
שיטה זאת מאפשרת ביצוע של מספר הוראות במקביל:• שונה pipeline כל עוד שייכות ל-– CPIכל עוד אינן תלויות אחת בשניה. כך נוכל לשפר את ה-–
של המכונה ובכך לשפר ביצועים.
53
Fetch &Decode
EXE Retire(commit)
In-order In-order
(out-of-order)
מקום להוראה
הבאה
הוראה הבאה
שמבצעת commit
54
• In-Order Front End– 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
MIS
AGU
MOB
External Bus
IEU
MIU
FEU
BTB
BIU
IFU
ID
RAT
RS
L2
DCU
ROB
OOOE – The P6 Example