Out Of Order Execution (Part 1) Updated by Franck Sala

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


Renamer

Arch reg..

Tempreg..

27

דוגמא:

T0

T1

T2

T3

Tn

R1

R2

R3

R4


T0

R2/R3R4+T0

T1

Renamer

Arch reg..

Tempreg..

28

דוגמא:

T0

T1

T2

T3

Tn

R1

R2

R3

R4


T0

R2/R3R4+T0

T2

R3+R3

Renamer

Arch reg..

Tempreg..

29

דוגמא:

T0

T1

T2

T3

Tn

R1

R2

R3

R4


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


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


R3MEM(R4+50)

R2 R4/R3


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


R3MEM(R4+50)

R2 R4/R3


Valid Data DST


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


R3MEM(R4+50)

R2 R4/R3


Valid Data DST


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


R3MEM(R4+50)

R2 R4/R3


Valid Data DST


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


R3MEM(R4+50)

R2 R4/R3


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


R3MEM(R4+50)

R2 R4/R3

Execute

Retire


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


R3MEM(R4+50)

R2 R4/R3

Execute

Retire


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


R3MEM(R4+50)

R2 R4/R3

Execute

Retire


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


R3MEM(R4+50)

R2 R4/R3

Execute

Retire


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


R3MEM(R4+50)

R2 R4/R3

Execute

Retire


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


R3MEM(R4+50)

R2 R4/R3

Execute

Retire


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

Documents

Out Of Order Execution (Part 1) Updated by Franck Sala