עיבוד מקבילי ברמת החומרה

pipeline מעבד מצונר –

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

יצטברו לינארית.

ILP – Instruction Level Parallelismזה נקרא

יש מבחר טכניקות לרעיון הזה:

-Dual pipelining פקודות עוקבות במקביל בתנאי שהן בלתי תלויות:2 ביצוע למשל:

ADD EAX,EBXADD ESI,EDI

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

-

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

push %rbpmovq %rsp,%rbp

-Superscalerטכניקת ביצוע מקבילי של פקודות עוקבות בתוכנית עם מספר לא – מבוטל של וריאציות.

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

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

ןתלות בין הפקודות.

פקודות ארתמטיות, כתיבה וקריאה2לדוגמא, המעבד הבא מכיל יכולת לבצע לזיכרון, ופעולת מספר ממשי במקביל:

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

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

שייקח הוא המקסימום של זמני הפקודות ולא סכומם.

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

הבא:MIPSלדוגמא, נניח קטע הקוד ה-

ld r10,0(r2)

dadd r4,r5,r3

add.d f6,f7,f8

sd r8,8(r9)

dsub r15,r16,r17

dadd r18,r19,r20

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

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

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

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

למשל בקטעי הקוד הבא:

1)

ld r10,0(r2)

dadd r4,r5,r3

add.d f6,f7,f8

sd f6,0(r4)

sd r8,8(r9)

dsub r15,r16,r17

dadd r18,r19,r20

(2ו-

ld r10,0(r2)

dadd r4,r5,r3

add.d f6,f7,f8

add.d f3,f2,f1sd r8,8(r9)

dsub r15,r16,r17

dadd r18,r19,r20

(3ו-

ld r10,0(r2)

dadd r4,r5,r3

add.d f6,f7,f8

beqz r9,r0,label1

sd r8,8(r9)

label1:

dsub r15,r16,r17

dadd r18,r19,r20

(4ו-

ld r10,0(r2)

dadd r4,r5,r3

add.d f6,f7,f8

dadd r4,r22,r23

sd r8,8(r9)

label1:

dsub r15,r16,r17

dadd r18,r19,r20

( יש1 משום שבקטע nop השני יקבלו ALU וה-store פקודות וה-3המקביליות תקטע אחרי ( אין במעבד צינור שני2 של הפקודה השנייה, בקטע r4תלות של הפקודה הרביעית ב-

( משום שיש השמה חדשה ל-4( בגל שיש פקודת הסתעפות מותנית ובקטע 3לממשי, בקטע r4.

register renaming תלויות מדומות והסתרתם ע"י

נסתכל על הקוד הבא:

dadd r4,r5,r6

sd r9,0(r4)

dadd r4,r8,r12

ld r10,0(r4)

הפקודות האחרונות במקביל עם הראשונות2 הבסיסי לא נתן לבצע את Superscalerבמודל . הנקודה שה"תלות" בין הפקודותr4משום ששתי הקבוצות של זוג פקודות משתמשות ב-

מדומה. שתי הפקודות האחרונות לא משתמשות בתוצאות של שתי הפקודות הראשונות. קבוצות הפקודות. מספיק2, נשבר התלות בין r4ברגע שיש השמה של ערך בלתי תלוי ב-

( בכדי שיהיה אפשר לבצע את הפקודות במקביל:r22 באוגר בלתי תלוי )נניח r4להחליף את

dadd r4,r5,r6

sd r9,0(r4)

dadd r22,r8,r12

ld r10,0(r22)

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

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

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

, …. אזי סדרת הפקודות המקוריתIR1, IR2לדוגמא, נניח שהאוגרים הפנימיים במעבד נקראים תתרגם ל-

dadd IR1,r5,r6

sd r9,0(IR1)

dadd IR2,r8,r12

ld IR3,0(IR2)

כאשר בסוף התהליך, הערכים המיועדים לאוגרים הרשמיים הם:

r4, IR1 IR2

r10, IR3

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

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

הזה מוצבים ערכי האוגרים הפנימיים ליעדם הרשמי. בדוגמא שלעיל משמעות הדבר שלאוגרr4-יוצב הערך ב IR2 והאוגר r10-יוצב הערך ב IR3 .

Out of Order ו- in-order מימוש

נניח הקוד הבא:

dadd r4,r5,r6

ld r8,0(r4)

dadd r5,r8,r4

sd r10,0(r5)

add.d f15,f16,f17

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

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

לעומת זאת אם הקוד ייכתב:

dadd r4,r5,r6

add.d f15,f16,f17

sd r9,0(r4)

dadd r4,r8,r9

ld r10,0(r4)

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

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

.out of orderהסדר, טכניקה שנקראת

בטכניקה הזו, הפקודות נצברות במעבד אם הן תלויות או לא במבנה נתונים הנקראReservation Station או( RSהמעבד מבצע את הפקודות כאשר הוא יכול, כלומר כאשר .)

שבוRSהערכים שהפקודה זקוקה להם מתקבלים. כאשר חישוב מתבצע, התוצאה מדווחת מ- Common שאולי זקוקים במקביל ובעיקוב מינימלי לו דרך ערוץ שנקרא RSהוא התבצע ליתר ה-

Data Bus או COBתוצאות החישובים מועברים לתור פקודות בסדר שהם מופיעים בתוכנית . לאותם פקודות שהחישוב שלהםcommit(, והמעבד מבצע ROB )או Re Order Bufferהנקרא

ל-commit לא, המעבד יעשה 4 חושבו ו-1,2,3,5,6הסתיים ברצף. לדוגמא, אם הפקודות יתבצע.4 יתעכב עד שפקודה commit ה-5,6 ופקודות 1,2,3

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

Issue RSהעתקת הפקודה ל-פענוח ושינוי שמות

Execute חישוב הפקודה

בפועל

Write result RSרישום התוצאה ב-

ROB וב-COBוב-

Commit מימוש הפקודה במסגרת הגלויה

למתכנת )הארכיטקטוניתr1,r2).. ,

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

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

.control hazards ו-data hazardsבעקרון הן מתחלקות לשתי קטגוריות,

מתחלקים לכמה סוגים:data hazardsה-

RAW (Read After Write) hazard:

למשל:

add r1,r2,r3

add r5,r6,r1

לפני שיוצב בו הערך הנכוןr1יש סכנה שהפקודה השנייה תקרא את

WAR (Write After Read) hazard:

למשל:

add r5,r6,r1

add r1,r2,r3

לפני שיקרא ע"י הפקודה הראשונה.r1יש סכנה שהפקודה השנייה תציב ל-

WAW (Write After Write) hazard:

למשל:

add r1,r6,r7

ld r10,0(r1)

add r1,r2,r3

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

בנוסף ישנה סכנה של פקודת הסתעפות מותנית שעשויה להתבצע או שלא.

לדוגמא:

add r5,r6,r7

beqz r5,r9,Skip1

addi r5,r5,8

Skip1:

ניסיון לבצע את הפקודה השלישית במקביל עשוי לגלות שהוא אמור לא להתבצע )מהשנקרא חיזוי שגוי(.

ע"י מחיקת ה-Control hazards ואת ה-renaming ע"י Data Hazardsהטכניקה הזו פותרת את ה-RS.במקרה של חיזוי שגוי

לדוגמא, נסתכל על הקוד המקורי:

dadd r4,r5,r6

ld r8,0(r4)

dadd r5,r8,r4

sd r10,0(r5)

add.d f15,f16,f17

הקוד יראה כך:renamingאחרי ביצוע

dadd IR1,r5,r6

ld IR2,0(IR1)

dadd IR3,IR2,IR1

sd r10,0(IR3)

add.d IR4,f16,f17

איןIR1 כי ל-2,3 בפקודות IR1לדוגמא, עכשיו כאילו אי אפשר להשתמש "בערך קודם" של ערך קודם עד שיחושב.

טבלת הערכים המיועדים

r4, IR1

r8, IR2

r5, IR3

f15,IR4

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

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

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

אזי השלבי הביצוע של הוד יהיו:

הפקודה Issue Exe Write Result Commitdadd r4,r5,r6 1 2-4 5 6ld r8,0(r4) 2 6-9 9 10

dadd r5,r8,r4 3 10-12 13 14sd r10,0(r5) 4 14-16 17 18 add.d f15,f16,f17 5 5-8 9 19

אזי:FP 5, ALU 3 יחידות ו-6 זה load, store לא אחיד, נניח exeאם נניח זמן ה-

הפקודה Issue Exe Write Result Commitdadd r4,r5,r6 1 2-4 5 6ld r8,0(r4) 2 6-11 12 13dadd r5,r8,r4 3 13-15 16 17sd r10,0(r5) 4 17-22 23 24 add.d f15,f16,f17 5 6-10 11 25

דוגמא:

נניח הקוד היה קצת פחות תלוי:

dadd r4,r5,r6

ld r8,0(r4)

dadd r5,r11,r4

sd r10,0(r5)

add.d f15,f16,f17

:renamingה-

dadd IR1,r5,r6

ld IR2,0(IR1)

dadd IR3,r11,IR1

sd r10,0(IR3)

add.d IR4,f16,f17

טבלת הערכים המיועדים

r4, IR1

r8, IR2

r5, IR3

f15,IR4

:3זמנים לפי זמן אחיד לפעולה

הפקודה Issue Exe Write Result Commitdadd r4,r5,r6 1 2-4 5 6ld r8,0(r4) 2 6-9 9 10dadd r5,r11,r4 3 6-9 9 11sd r10,0(r5) 4 11-14 15 16 add.d f15,f16,f17 5 5-8 9 17

אזי:FP 5, ALU 3 יחידות ו-6 זה load, store לא אחיד, נניח exeאם נניח זמן ה-

הפקודה Issue Exe Write Result Commitdadd r4,r5,r6 1 2-4 5 6ld r8,0(r4) 2 6-11 12 13dadd r5,r11,r4 3 6-9 10 14sd r10,0(r5) 4 14-20 21 22 add.d f15,f16,f17 5 6-10 11 23