Parallel processing

CPU Timeהמטרה היא להקטין את ה-

CPU Time=clock cycle*CPI*IC

CPU Time.כמה זמן לקח למעבד כלשהו לבצע תוכנית – CPI (cycles per instruction)שעון המעבד צריך כדי לבצע- מדד שאומר כמה מחזורי

פקודה כלשהי.IC-Instruction Count.מספר הפקודות בתוכנית –

עד כה למדנו:

Minimize clock cycle Þmore GHZ (add more pipe stages)

Minimize CPI Þ µArch (more execution unit)

)AVXTM( Minimize IC Þ architecture

ILP - Instruction level parallel processingמקבילות ברמת המעבד, הוא מטפל במספר – פקודות

-בpipelineסרט נע, פקודה בכל תחנה, צריך להרחיב לכל האורך – כל התחנות inצריכות להיות באותו רוחב אחרת יהיה לנו צוואר בקבוק בתחנה הצרה ביותר.

order execution, CPI>=1(Cycle Per Instruction) הוספת pipe stage מפחית clock cycle .CPIאבל מעלה

Dual pipeliningאלו מעבדים שיש– העובדיםpipelinesבהם מספר

במקביל, ניתן ליצור צינור בו כל שלב יכול לטפל בשתי פקודות עוקבות

בתוכנית – זה יפה אך מה עם רוצים צינור רחב יותר? הבעיה בשיטה – אם יש תלות בין שתי הפקודות, הן

לא יכולות להישלח בו זמנית.

אבל עם פוטנציאלI-מומש בפנטיום מוגבל.

Very Large Instruction Word- VLIW עוד לפני שהתוכנית מוזנת למעבד, המהדר מנתח את הקוד ומבצע את אותם סוגים של החלטות אשר

על השבב עצמו. ברגע שהוא החליט איזה נתיבים לבחור, הוא אוסף את כל היו מתבצעות בזמן ריצה בצורה כזו בתוכנית העברתאוגד אותם להוראה גדולה יותרהפקודות שהוא יודע שניתן להריץ במקביל,

משימה זו מהמעבד למהדר היא בעלת מספר יתרונות. ראשית, המהדר יכול להשקיע יותר זמן בניתוח הקוד, יתרון שלמעבד אין כיוון שהוא חייב לסיים את המשימה כמה שיותר מהר. לכן גרסת המהדר

יכולה להיות מדויקת באופן מהותי יותר מאשר אותו קוד אשר רץ דרך האלגוריתמים של המעבד. שנית, הניבוי של תוכנית המעגל החשמלי של המעבד היא מסובכת למדי, והעברת הניבוי למהדר מורידה את הסיבוכיות מהמעבד בצורה רבה. המעבד לא צריך יותר לנתח שום דבר; הוא פשוט מפרק את ההוראה

לחלקים ומזין את חלקיה לליבות השונות. שלישית, ביצוע הניבוי על ידי המהדר היא "הוצאה" חדפעמים, לעומת הניבוי במעבד שמתרחש כל פעם שהתוכנית רצה.

החסרון בכך הוא שהתנהגות תוכנית שרצה לא תמיד מובנת מאליו ולא נובעת ישירות מהקוד שאיתו נוצרה, ויכולה להשתנות מאוד כתלות במידע שמעובד. מעבד ממוצע יכול מעשית לבצע החלטות עיבוד

לפי המידע אשר מועבר, לעומת המהדר שיכול רק לנחש זאת. מכך, זה אפשרי מאוד שהמהדר יטעה VLIWבניבוי שלו אפילו באופן יותר תדיר מאשר לוגיקה מקבילה הנמצאת על המעבד. לכן, תכנון ה-

מסתמך רבות על הביצועים של המהדרים, פשרה המאפשרת להפחית את מורכבות החומרה של – הוא מעבד מסוג זה itaniumהאיטניום המעבד על חשבון הגדלת המורכבות של תוכנת המהדר.

נכל כישלון.

Superscalar

השיפור - צריך לנהל את הפקודות שאפשר לשלוח יחד- החיפוש אחר פקודות לביצוע על ידי ניתוח התלויות בין הפקודות ושליחה במקביל פקודות שאינן תלויות בפקודות

שקודמות להן.

scheduling השפעת שינוי הסדר בקוד- א.

for(i=1000;i>0;i--)X[i]=x[i]+50

MIPS איברים של מספרים שלמים, כתוב לולאה בשפת אסמבלי של ה-1000נתון מערך בעל כפי שמסורטט בעמודMips לכל איברי המערך. מבנה ה50המבצעת הוספה של הערך

הקודם (למטה), תאר מבחינת מחזורי מכונה, את תהליך ביצוע הפקודות בתוך המערכת (לאכולל הבאה ופיענוח).

R2מצביע לתחילת המערך R1מצביע לסוף המערך

intMem0)R1(חישוב הכתובת) (1

LD R7,0(R1)2*3

DADDI R4,R7,504*5*6

0)R1(חישוב הכתובת) (7DADDIU R1,R1,#-8SD R4,0(R1)8**9*10BNE R1,R2,LOOP11*12*13

cycle13הלולאה בוצעה ב- CPI=13/5=2.6

ב. ביצוע שינוי במיקום הפקודה הרביעית

LD R7,0(R1)DADDI R4,R7,50SD R4,0(R1)DADDIU R1,R1, -8BNE R1,R2,LOOP

Loop:

LD R7,0(R1)DADDIU R1,R1, -8

DADDI R4,R7,50SD R4,8(R1)BNE R1,R2,LOOP

Loop:

intMem0)R1(חישוב הכתובת) (1

DADDIU R1,R1, -8LD R7,0(R1)2**3DADDI R4,R7,50*4

*5*6

8)R1((חישוב הכתובת) 7BNE R1,R2,LOOPSD R4,8(R1)8**9*

cycle10 CPI=10/5=2הפעם הלולאה בוצעה ב-

Loop unrolling בזיכרון.1000 תאים המתחיל מכתובת 40 בעל Floating Pointנתון מערך של

המבצעת:MIPS כתוב תוכנית ב א.

A[ i ]={A [ i ]×2+5 , i even

A [ i ]×3+4 , else עותקים .2 של Loop Unrollingב. בצע

, כך שירוץ מהר ככל האפשר, לאת הלולאה בלבדג. הזן את הקוד שקיבלת בסעיפים א' ו ב' Super scalar:הבא

Pipe. לגישה לזיכרון 2 Pipes לפעולות Mult-FP. 1Pipe ל Branch Integer/ 2 Pipes לפעולות Add-FP.

הנח שהפקודות הובאו ופוענחו, עליך לתאר את תזמון יחידות הביצוע.

: edumips64השהיות הפקודות על פי הנתון ב-

וזמן ריצה עבור התוצאות מסעיף ג' .CPI , Cycles Per Iterationד. חשב בקובץ כך שירוץ מהר ככל האפשר2 שבעמוד Super scalarה. הזן את הקוד של סעיף א' ל

.CPIוחשב R1מצביע על תחילת המערך –

F3=3,f4=4,f5=5R2מצביע על סוף המערך –

DADDI R1,R1,-32LOOP: LDC1 F11,40(R1)

LDC1 F13,56(R1) LDC1 F10,32(R1) LDC1 F12,48(R1)

MUL.D F11,F11,F3 MUL.D F13,F13,F3 ADD.D F10,F10,F10 ADD.D F12,F12,F12

DADDI R1,R1,32 ADD.D F10,F10,F5

ADD.D F11,F11,F4 ADD.D F12,F12,F5 ADD.D F13,F13,F4

SDC1 F10,0(R1) SDC1 F11,8(R1) SDC1 F12,16(R1) SDC1 F13,24(R1) BNEZ R1,R2,LOOP

DADDI R1,R1,-16

1 LOOP: LDC1 F0,16(R1) 2 LDC1 F1,24(R1) 3 ADD.D F0,F0,F0

4 MULTD F1,F1,F3 5 DADDI R1,R1,16

6 ADD.D F0,F0,F5 7 ADD.D F1,F1,F4

8 SDC1 F0,0(R1) 9 SDC1 F1, 8(R1)

10 BNEZ R1,R2,LOOP

השהיהסוג הפקודהMULTDc7

ADDD/SUBD4c

:unrollingלפני INTADDD2ADDD1MULTD2MULTD1MEM1CYCLES

16)R1(124)R1(LDC1 F0,16(R1)2

*LDC1 F1,24(R1)

3

ADD.D F0*42MUL.DI F15

DADDI R1,R1,16326*437**48

*59ADD.D F0610

27113*124*13* ADD.D F114*15

0)R1(3164SD F0,0(R1)17**18*19

8)R1(20BNEZ R2SD F1,-8(R1)21

**22*23

Cycles−Per−Iteration=23

CPI=¿of cyclesic

=2310

=2 .3

ExecutionTimeloop=(23×20)×2ns=920nsלפני:

:LOOP Unrolling אחרי ה

INTADDD2ADDD1MULTD1MEM1CYCLES

40)R1(156)R1(LDC1 F112

32)R1(LDC1 F13* 348)R1(LDC1 F10* 4

MUL.D F11LDC1 F125MUL.D F13*6

ADD.D F103*7ADD.D F12248

DADDI R1,R1,322359346104*711***12*ADD.D F10*13

ADD.D F12ADD.D F11*14ADD.D F1315

16*17

**180)R1(**198)R1(*SD F10,0(R1)20) R1 (16SD F11, 8(R1)21

24)R1(SD F12,16(R1)

22

BNEZ R2SD F13,24(R1)

23

**24**25

Cycles−Per−Iteration=25

2=12 . 5

CPI=2518

=1 .4

ExecutionTimeLOOP=(25×10)×2ns=500ns אחרי:

, אנו רואים שהרבה יותר יעיל לעשות זאתloop unrollingכלומר התוכנה היא זו שמבצעת מבחינת ביצועים.

1 3 4

2 5

6

Data Flow Graph

r1 r5 r6

r4r8

Fetch DecodeInstruction Pool

Commit

Execute

In order In order

Out Of order

OOOE Out Of Order Execution -

(1) r1 ¬ r4 / r7 (2 )r8 ¬ r1 + r2

(3 )r5 ¬ r5 + 1(4 )r6 ¬ r6 - r3 (5 )r4 ¬ r5 + r6 (6 )r7 ¬ r8 * r4

134

5 2 6

Out-of-order execution

134

52

6

In-order execution

-שלבי הFetch -וה Decode -ממלאים את ה Instruction Pool, בצורת in-orderזהו אותו ),execution"חלון פקודות" בו מחפשים פקודות בלתי תלויות שאפשר לשלוח לביצוע (

כלומר שלא על פי סדר הופעתן בתכנית.Out Of Orderהפקודות נישלחות הפקודות שבוצעו חוזרות חזרה ומסיימיםin order Retirementכלומר פקודות למעשה

משנות את מצב המכונה, עפ"י סדר הופעתן בתוכנית, -כתוצאה מOOOE תלויות מדומות נוצרות ,WAR(Write After Read), RAW (read after

write) -ו WAW (Write After Write):

Data Hazard

RAWתלות מידע מסוג -

WARתלות מידע מסוג

הוראת החילוק הארוכה מעכבת את פעולת החיבור שאחריה, פעולת החיבור ממתינה לערךR1 מכיוון שמאפשרים ,OOOההוראה השלישית, שלא תלויה תתבצע, ואז ההוראה השנייה

כפי שנכתב על ידי ההוראה השלישית ולא כפיR6לכשתתבצע עלולה לקרוא את הערך של שהתכוון המתכנת.

WAWתלות מידע מסוג DIV R5,R2,R3

ADD R5,R6,R1ADD R9,R5,R5ADD R5,R7,R8 ההוראה השנייה והשלישית מעוכבות, ואילו הרביעית עלולה להתבצע, הוא ההוראה הרביעית

יישאר עם הערך הלא נכון מבין השניים.R5 לפני ההוראה השנייה, בסוף ערך R5תשנה את

(1 )r1¬R9/17

(2 )r2¬r2+r1

(3 )r1¬23

(4 )r3¬r3+r1

(5 )jc L3

תתבצע לפני3אם פקודה מס' 1פקודה מס'

R1יקבל ערך סופי שגוי WAWבעיה מסוג

(6 )r1¬35

(7 )L3: r4¬r3+r1

(8 )r3¬2

Control Hazard.הוראה התלויה בהוראות סיעוף – אין לקדמה למקום לפני הוראת סיעוף.הוראה שאינה תלויה בהוראות סיעוף – אין להעבירה למקום לאחר הוראת הסיעוף

כאשר נשלח לביצוע פקודות שנמצאות אחרי קפיצה – כלומר יתכן שבפועל עד שהיינו מגיעים התכנית תקפוץ והן כלל לא יבוצעו. in orderאליהן בביצוע

Registerגם את פתרון התלויות המדומות וגם את בעיית הביצוע הספקולטיבי פתרו בעזרת Renamingשבעצם אומר שבמקום שפקודה תכתוב לרגיסטר הארכיטקטוני של המכונה היא

תכתוב לרגיסטר זמני, פיסיקלי.

נעשה לפי סדר הופעת הפקודות בתכנית: renamingביצוע דוגמא:

False Dependencies ( WAW,WAR) גורמת שלא יהיו תלויות מסוג renamingפעולת ה-

עדיין קיים RAW מסוג data hazardאבל

מקצים את הפקודות בשני מבנים.Renaming ואז Fetch, Decodeאחרי שלבי ה-

) ROB (Re-order Buffer -ו RS (Reservation Stations) הקצאת פקודות אליהן נעשית .in order -ומתרחשת במקביל. ההוצאה מ ROB היא in order -אך ההוצאה מה RS היא out of order.

תתבצע לפני8אם פקודה WAR בעיה מסוג 7פקודה

R1#0R2#1R2#2R4#3

#4#5

WAW

WAR

RAW

Fetch &

Decod

renam

Commit

In order

In order

RS

ROB

הפקודות נכנסות ליחידתRS-ו ROB בצורת in orderכאשר המערכת מזהה פקודה , שהאופרנדים שלה מוכנים, ויחידת הביצוע שלה מוכנה, הפקודה מועברת אל יחידת

הביצוע, לא לפי סדר הופעת הפקודה בתכנית.בגלל העובדה שמוציאים את הפקודות לא לפי הסדר, סדר הפקודות משתנה (לא כפי שמופיע

בתוכנית). -יחידת הROB משמשת לסידור חזרה, הפקודות נרשמו בצורת in –orderוהן חוזרות אחרי ,

. in order יבוא commit, ה- out of orderביצוע בצורה -לכל פקודה בROB -נוצר אוגר פיזי, מספרו הוא כמספר הכניסה ב ROBבו הפקודה מוקצת . .אל האוגר הפיזי תירשם התשובה המוחזרת מיחידת הביצועRS -יכול לשלוח פקודה לביצוע ואחר כך להעביר את הערך שהיא חישבה לפקודה אחרת ב RS

ברגע שהוא יהיה מוכן. -בשלב הretire/commitנעשית כתיבה בפועל מהרגיסטרים הפיזיים אל ה-זכרון או

לרגיסטרים הארכיטקטונים.

Reservation station-RS - לכל אופרדפקודות שעדיין לא בוצעוביחידה זו קיים תור של , ') וכן יחידת הביצוע אותה צריך.1סיבית המסמנת האם ערך האופרד זמין ('

בכל מחזור שעון נבדקות הפקודות ומועברות על פי זמינותם וזמינות יחידות הביצוע הפנויות.

, נוצר "בלגן"- מי ששומר עלout of order אבל מוציאים RS in orderמכיוון שממלאים את . in order ויוצאות out-of-order אליו פקודות נכנסות FIFO שהוא ROBהסדר, זה ה-

אז אפשר להתחייב על שינוי מצב המכונהretire (commite) ל- ROBכאשר פקודה יוצאת מה- בעקבותיה ולכן שם נעשית כתיבה בפועל לזכרון או העתקת רגיסטרים פיזיים לארכיטקטונים.

- ROB- Re-order Bufferכותבים ליחידה זוin-orderומסמנים בו מתי באיור כל הפקודות שהסתיימו לפקודה, commitאפשר לעשות

, ורק ברגע שנוצר רצף של פקודות או מספיקמסומנות באדום אפשר לעשותROB ה- מתחילתפקודה אחת ראשונה, שסיימו

commit.

לכמה פקודות במקביל, תלוי ברוחב היחידה,commitניתן לבצע פקודות במקביל.8 ,4 ל- commitישנן מערכות יכולות לבצע

Out Of order

Execute

vsrc1vsrc2Pdst

add197H112H37

מסמנים את הפקודה עםexecution, בשלב ה- 0חריגה, לדוגמא: חלוקה ב- במקרה של אבל עדיין לא מטפלים בשגיאה. faultהסימון

לאחר בדיקה שהפקודה אכן צריכה להתבצע. (יתכן שביצענו את הפקודהcommitבשלב ה- ), רקflushבעקבות חיזוי קפיצה שגוי ולא היינו אמורים להגיע אליה כלל, במקרה כזה יתבצע

תתקבל הפסיקה, כאשר היא תגיע לראשcommitבמקרה של אימות והגעת הפקודה ל- התור.

RRF – Real Register File

architecture register fileשומר את

האוגרים ממוספריםEax- 0,EBX- 1..... והנתונים שבאוגרים

OOO) במכונת pipelineשלבי הצינור (

FETCH – 1שלב

-in. ומביאים בבת אחת מספר פקודות – זה קורה cache instזהו השלב הראשון, פונים ל- order -הפקודות נשמרות ב .instruction queue) כולל את חיזוי פקודת הקפיצה .branch

predictor.( יחידה זוCISC הפקודות באורך זהה, והן מועברות לפיענוח. במערכות מסוג RISCבמערכות

כוללת את שלב ההחלטה איפה פקודה מתחילה ואיפה היא מסתיימת (ישנן פקודות בגודלbyte 16 ועד bytes -ב .instruction queue .הפקודות יוכנסו לכל כניסה פקודה בנפרד

Decode – 2שלב

– הוא שלב בו מתורגמות הפקודות2 אל שלב instruction queueפקודות מועברות מה- לאותות חשמליים, בעזרתם הפקודות ינותבו ליחידות המתאימות לביצוע הפקודה. לדוגמא

פקודה מסוג חילוק של מספרים ממשיים ינותבו ליחידה המתאימה, חיבור של מספריםשלמים וען הלאה.

בסיסיים, ומרגע זה ואילךµopcodes פקודות מורכבות יחולקו למספר CISCבמערכות מסוג במובן זה שהיא מבצעת רק פקודות פשוטות יחסית.RISCהמכונה מתנהגת כמכונת

המפוענחות.µops – הוא מכיל את הIDQאחרי שלב הפענוח יש תור נוסף שנקרא

FetchIQ

DecodeIDQ

AllocRS

ExecutionROB

Commit

FetchIQ

DecodeIDQ

AllocRS

ExecutionROB

Commit

renaming = שלב ה- Alloc – 3שלב

) על פי הקצאת מיקום הפקודה)Renameing: הקצאת שמות לאוגרים פיזיים Allocateשלב ה-

.in-order, כל התהליך עד כה מבוצעROBב-

Execution – 4שלב

בשלב זה עוברים לביצוע הפקודות שלא על פי סדר כתיבתם בתוכנית, אלא פקודות נבחרות

ומועברות לביצוע בכל מחזור מכונה על פי מוכנות האופרנדים וזמינות יחידת הביצוע המתאימה לפקודה. ישנן מערכות שיבדקו כמה פקודות אחרות תלויות בפקודה זו ויעבירו את

הפקודה, שיש בה יותר פקודות תלויות.

Commit – 5שלב

השלב האחרון בצינור, "מוציאים" את הפקודות בראש התור אלו הפקודות הישנות ביותר מה-

ROB ,exception/fault) וכן לא מסומנות ב- executed" bit=1וזאת בתנאי שהן בוצעו (מסומנות "

.fault וטיפול ב- pipline ב- flush מתבצע faultבמקרה שיש

מעתיקים את המידע מהרגיסטר הפיסי לרגיסטר הארכיטקטוני או לזיכרון ובכך הביצוע נעשה באותוcommit פקודות שניתן לבצע עליהן 8, 6, 4רשמי וסופי. ישנן מערכות בעלות כמות של

מחזור מכונה.

(ללא חיזוי) בעלת: Super-Scalar OOOE נתונה מערכת : 1 שאלה שניPipes . עבור גישה לזיכרון שניPipes עבור FP ADDD/SUBD. שתי יחידות עבורInt/Branch. Pipe אחד עבור MULTD FP. פקודות 4ניתן לבצע עד memory -ו WBבמקביל

הבאה:RAW Hazardכמו כן נתונה טבלת ההשהיות במקרה של Stall Cyclesהפקודה

MULTD FP5ADD/SUB FP3

- המבצעת:MIPS כתבו תוכנית בא.

FetchIQ

DecodeIDQ

AllocRS

ROB

ExecutionROB

Commit

FetchIQ

DecodeIDQ

AllocRS

ROB

ExecutionROB

Commit

FetchIQ

DecodeIDQ

AllocRS

ROB

ExecutionROB

Commit

בזיכרון.1000 תאים המתחיל מכתובת 20 בן FP הוא מערך של A כאשר מערך

והם גדולים ואינםRS וב-ROBהניחו שהפקודות נמצאות ב- , Super-Scalarהזינו את הקוד ל ב. .Cycles Per Iteration ו CPI חשבו מתמלאים.

עותקים ביחס למה שעשית ב א'!), הזינו את הקוד 2 עותקים (2 של Loop Unrollingבצעו ג. .Cycles Per Iteration ו CPI הנתון, וחשבו Super-Scalar ל

.tc=1ns ואחריה אם ידוע ש Unrollingחשבו זמן ריצה כולל של התוכנית לפני גרסת ה ד. (כלומר עבור הקוד של א' ועבור הקוד של ג' .)

(נמקו) האם יכול להיות שהאיטרציה הראשונה תארך זמן שונה מהאיטרציות שאחריה?ה. תנו דוגמא למקרה שבו האיטרציה הראשונה ארוכה מהאיטרציות שאחריה.תנו דוגמא למקרה שבו האיטרציה הראשונה קצרה מהאיטרציות שאחריה.

פתרוןDADDI R1, R0, 1000 /R1 ->Start of A1DADDI R2, R0, 1160 /R2 ->End of A2SUB.D F6, F6, F6 / F6=0 for even index3DADDI R3,R0,24DMTC1 R3,F25CVT.D.L F2,F2 ;F2=26ADD.D F4,F2,F2 ;F4=47MOV.D F5,F2 ;F5=28LOOP: LDC1 F0, 0(R1) / F0=A[i] (even)9LDC1 F1, 8(R1) ; F1=A[i+1] (odd)10MUL.D F0, F0, F6 ; F0=A[i] * i11ADD.D F1, F1, F5 ; F1=A[i+1] + 2(i+1)12SDC1 F0, 0(R1) ;A[i]=A[i] * i13SDC1 F1, 8(R1) ; A[i+1]=A[i+1] + 2(i+1)14DADDI R1, R1, 16 ; R1->A[i+2]15ADD.D F6, F6, F2 ; Update even index16ADD.D F5, F5, F4 ; Update odd index17BNE R1, R2, LOOP18

הנתון:Super-Scalarנזין את הקוד ל ב.

Cycles MEM1 MEM2 ADDD FP1 ADDD FP2 MULTD FP INTEGER INTEGER1 SUB.D

#3, F6, F6DADDI #1, R0, 1000

DADDI #2, R0, 1160

2 2 DADDI #4,R0,23 3 *4 * חישוב ( (#1)8*

כתובתחישוב (#1)0כתובת

5 LDC1 #9, 0(#1)

LDC1 #10, 8(#1)

* DMTC1 #4,#5 DADDI #15, #1, 16

6 * * *7 MUL.D #11,

#9, F6*

8 2 CVT.D.L #5,#69 3 *10 4 *11 ADD.D

#7,#6,#6ADD.D #16, #3, #6

5 MOV.D #8,#6

12 2 * *13 3 * *14 * ADD.D #12,

#10, #8חישוב (#1)0כתובת

15 SDC1 #11, 0(#1)

* 2

16 ADD.D #17, #8, #7

3

17 *18 *19 8(#1 BNE R1, R2,

LOOP20 SDC1 F1,

8(#1)*

21 * *

F6F5F4F2F1F0R3R2R1#3#87#5##10#94#2##1register mapping#16#17#6#12#11#15

CPI=21

18=1 .16

, כיוון14נשים לב שמהאיטרציה השנייה ואילך מס' המחזורים לאיטרציה יהיה הערה:שהתלות של

הפקודות שבלולאה בפקודות האתחול כבר לא קיימת:

Cycles MEM1 MEM2 ADDD FP1 ADDD FP2 MULTD FP INTEGER INTEGER1 ADD.D#27,#17,f4 ADD.D#26,#16,f2 0(#15) 8(#15)2 LDC1 #19,

add(0+#15)LDC1 #20, add(8+#15)

DADDI #25, #15, 16

3 * *4 ADD.D#22,#20,

#17MUL.D #21,#19,#16

5 2 26 3 37 * 48 * 59 * 8(#15)10 SDC1#18,

add(8+#13)*

11 * 0(#15) BNE #25,#2,LO12 SDC1#21,

add(0+#15)*

13 * *

F7F6F5F1F0R1#20#19register mapping

72##2627##22#21#25register mapping

Cycles−Per−Iteration=131

=13

CPI=1310

=1 .3

cpu time=(21+13∗9 )1ns=138ns

עותקים :2 של Loop Unrollingנבצע ג.

DADDI R1, R0, 1000 /R1 ->Start of A1DADDI R2, R0, 1160 /R2 ->End of A2SUB.D F6, F6, F6 / F6=03DADDI R3,R0,24DMTC1 R3,F55CVT.D.L F5,F5 ;F5=26MOV.D F7, F5 ;F7=27MOV.D F8,F7 ;F8=28ADD.D F10,F5,F5 ;F10=49ADD.D F9,F10,F5 ;F9=4+2=610ADD.D F11,F10,F10 ;F11=811LDC1 F0, 0(R1) / F0=A[i] (even)LOOP:12LDC1 F1, 8(R1) / F1=A[i+1] (odd)13LDC1 F2, 16(R1) / F2=A[i+2] (even)14LDC1 F3, 24(R1) / F3=A[i+3] (odd)15MUL.D F0, F0, F6 / F0=A[i] * i16ADD.D F1, F1, F7 / F1=A[i+1] + 2(i+1)17MUL.D F2, F2, F8 / F2=A[i+2] * (i+2)18ADD.D F3, F3, F9 / F3=A[i+3] + 2(i+3)19SD F0, 0(R1) / A[i]=A[i] * i20SDC1 F1, 8(R1) / A[i+1]=A[i+1] + 2(i+1)21SDC1 F2, 16(R1) / A[i+2]=A[i+2] *( i+2)22SDC1 F3, 24(R1) / A[i+3]=A[i+3] + 2(i+3)23ADD.D F6, F6, F1024ADD.D F7, F7, F1125ADD.D F8, F8, F1026ADD.D F9, F9, F1127ADDI R1, R1, 32 / R1->A[i+4]28BNE R1, R2, LOOP29

הנתון:Super-Scalarנזין הקוד ל

Cycles MEM1 MEM2 ADDD FP1 ADDD FP2 MULTD FP INTEGER INTEGER1 SUB.D #3,F6,F6 DADDI #1,R0,1000 DADDI#2,R0,11602 2 * DADDI #4,R0,23 3 * DADDI #28, #1, 324 * 0(#1) 8(#1)5 LD #12,

(0+#1)LD #13, (8+#1)

16(#1) DMTC1 #4,#5

6 * LD #14, (16+#1)

*24(#1)

7 LD #15, (24+#1)

MUL.D#16,#12,#3 *

8 2 CVT.D.L #6,#59 3 *10 4 *11 ADD.D

#9,#6,#65 MOV.D #7, #5

12 2 * *13 ADD.D #17,

#13, #73 * *

14 2 * 0(#1) MOV.D #8,#7 ;F8=2

15 SDC1#16, (0+#1)

3 * *

16 *ADD.D #11,#9,#9

ADD.D #10,#9,#6

*

17 ADD.D #24, #3, #9

2 ADD.D #26, #8, #9

MUL.D #18, #14, #8

18 3 2 8(#1)19 SDC1 #17,

(8+#1)* * 3

20 * * 421 ADD.D #25,

#7, #11ADD.D #19, #15, #10

5

22 ADD.D #27, #10, #11

2 *

23 3 *24 * 16(#1)25 SDC1 #18,

(16+#1)*

26 24(#1) BNE#23,#2,LOOP27 SDC1 #19

add(24+#1)*

28 * *

F10

F9F8F7F6F5F3F2F1F0R3R2R1

#9#10#87##35##15#14#13#12#42##1register mapping#27#2

6#25#246##19#18#17#16#28register mapping

:Cycles Per Iteration ו CPIנחשב

CPI=28

29=0.9655

Cycles−Per−Iteration=28

2=14

Cycles MEM1 MEM2 ADDD FP1 ADDD FP2 MULTD FP INTEGER INTEGER1 ADD.D#42,#24

,#9ADDDI#43,#25,#11

0(#28) 8(#28)

2 LD#30, (0+#28)

LDC1 31#, (8+#28)

ADDDI#44,#26,#9

ADDDI#45,#27,#11

16(#28) 24(#28)

3 LDC1 #32, add(16+#28)

LDC1#33, *(24+#28)

DADDI #46, #28, 32

4 * * ADD.D #35, #31, #25

MUL.D#34,#30,#24

5 ADD.D#37,#33,#27

MUL.D#36,#32,#26

6 3 37 * 48 * 59 * * 8(#28)10 SD #35,

add(8+#28)* 24(#28)

11 SD #32, (24+#23)

* 0(#28)

12 SD #34, add(0+#28)

16(#28) BNE#41,#2,LOOP

13 SD #40, add(16+#23)

*

14 * *

:Cycles Per Iteration ו CPIנחשב

CPI=14

18=0 .77

Cycles−Per−Iteration=14

2=7

:tc=1ns ואחריה כאשר ידוע ש Unrollingנחשב זמן ריצה כולל של התוכנית לפני גרסת ה ד.

cpu time=(21+13∗9 )1ns=138ns

ExecutionTime=(28+14×4 אחרי: )×1ns=84ns