מבוסס על פרק 7 בספר של Allen and Kennedy

22/04/23 13:06 1

Allen and Kennedy בספר של7מבוסס על פרק

תלויות בקרהתלויות בקרה(Control

Dependence)

מבוא בהרצאות הקודמות ראינו כיצד מבצעים טרנפורמציות

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

בין הוראות בתוך גוף תלויות מידעלמדנו למצוא ע"י בניית גרף התלויות, ולמדנו להסיק מהגרף הלולאה

אופטימיזציות מותר לבצע.מתי ואלו

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

להופיע בגוף הלולאה.

מבוא:נתבונן למשל בקטע הקוד הבא

DO 100 I = 1, NS1 IF (A(I-1) > 0) GOTO 100S2 A(I) = A(I) + B(I)*C100 CONTINUE

אם נתבונן בתלויות המידע בקוד בלבד, נקבל את גרףהתלויות:

S1 S2-1

ולכן בהתייחס לתלויות מידע בלבד ניתן לבצע ולקבל: אופטימיזציה

P

מבוא

מבוצע ללא S2קוד לא שקול - בקוד שקיבלנו תנאי!

DO 100 I = 1, NS1 IF (A(I-1) > 0) GOTO 100S2 A(I) = A(I) + B(I)*C100 CONTINUE

S2 A(1:N) = A(1:N) + B(1:N)*CDO 100 I = 1, N

S1 IF (A(I-1) > 0) GOTO 100100 CONTINUE

איפה טעינו? אנו התייחסנו רק לתלויות מידע, ופספסנו תלות אחרת

בין S1-ל S2 שהיתה יוצרת מעגל בגרף התלויות ומונעת

להחליף את סדר ההוראות.מאיתנו S1 S2

-1

?

תלות בקרהתלות זו היא – Control dependent .

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

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

מאוד.

:אנו נראה שני דרכים לטיפול בתלויות בקרה – בדרך זו ננסה להחליף את כל If conversionא.

תלויותהבקרה בתלויות מידע רגילות, בכך שננסה להחליף

את.ifכל הוראות הקפיצה המותנית בהוראות

– בדרך זו )CDG )control dependence graphב.את כל תלויות הבקרה לגרף )בדומה לגרף תלויות נכניס

המידע( ונסיק מהגרף אלו אופטימיזציות מותר לבצע.

IF ConversionIF Conversion

דוגמא לחיזוק האינטואיציה

אם נצליח להיפטר מהוראהS1 נקבל קוד המכיל תלויות מידע

בלבד – אותו אנו כבר יודעים לנתח.

ברור כי לא ניתן להוציא "סתם" את ההוראה – בתוכנית גדול )A)I-1 מתבצעות רק כאשר S2, S3המקורית הוראות

מאפס.

?נתבונן בקטע הקוד הבא. האם ניתן למקבלוDO 100 I = 1, N

S1 IF (A(I-1) > 0) GOTO 100S2 A(I) = A(I) + B(I)*CS3 B(I) = B(I) + A(I)100 CONTINUE

דוגמא לחיזוק האינטואיציה )המשך(

( לכן נרצה להוסיף תנאיif להוראות )S2, S3 שיבטיח כי ,הן יתבצעו רק אם היא הן היו מתבצעות בתוכנית

המקורית.

:)נקבל את הקוד השקול הבא )הפעם ללא תלויות בקרה




DO 100 I = 1, NIF (A(I-1) >= 0) A(I) = A(I) + B(I)*CIF (A(I-1) >= 0) B(I) = B(I) + A(I)

100 CONTINUE




נשם לב כי הערכים שלA)I(-ו B)I( בהוראות S3-ו S4 )בנוסף לתלויות )A)I-1נקבעים עתה כפונקציה של

המקוריות האחרות(.

קיבלנו לולאה עם תלויות מידע רגילות, שהגרף שלהםהוא:

DO 100 I = 1, NS3 IF (A(I-1) >= 0) A(I) = A(I) + B(I)*CS4 IF (A(I-1) >= 0) B(I) = B(I) + A(I)100 CONTINUE

S3 S4


DO 100 I = 1, NS3 IF (A(I-1) >= 0) A(I) = A(I) + B(I)*CS4 IF (A(I-1) >= 0) B(I) = B(I) + A(I)100 CONTINUE

ולכן ניתן למקבל אתS4 :ולקבל DO 100 I = 1, N

S3 IF (A(I-1) >= 0) A(I) = A(I) + B(I)*C100 CONTINUES4 WHERE (A(0:N-1) <= 0) B(1:N) = B(1:N)+A(1:N)

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

בתוכנית לשלושה סוגים:

– קפיצה מנקודה אחת בלולאה, Forward Branchא( לנקודה אחרת בלולאה )אותה רמת קינון(.קדימה

- קפיצה מנקודה אחת בלולאה,Backward Branchב(לנקודה אחרת בלולאה )אותה רמת קינון(.אחורה

ללולאהמחוץ – קפיצה מגוף הלולאה אל Exit branchג( )לפני הלולאה או אחריה(.

...assign gotos - קפיצות לתוך לולאות, שיקוצים שוניםד(

סוגי קפיצות מותנות – דוגמאות

DO 100 I = 1, NH: IF (A(I-1) > 0) GOTO L

A(I) = A(I) + B(I)*CIF (A(I) < 0) GOTO H

L: B(I) = B(I) + A(I)IF (B(I) > 0) GOTO R

100 CONTINUER: C = C + D;

Forward branch

Backward branch

Exit branch

PP P

קפיצות קדימהקפיצות קדימה

הגיע זמן להגדרה... של הוראה guard – הגדרה

בתוכנית הוא תנאי לוגי, כך שההוראה מבוצעת אם ורק אם

שלה )כאשר השליטה guardערך ה-בתוכנית מגיעה אליה( מוערך

.trueל-להוציא מהתוכנית את כל הקפיצות המותנות, : מטרתנו

שלה.guard( ביצוע כל הוראה בסיפוק ה-IFובמקומם להתנות )

שקף לחיזוק האינטואיציהS5 (G5)

S6 (G6)

S7 (G7)

S8 (G8)

S9 (G9)

S10 (G10)

S11 (G11)

S12 (G12)

S13 (G13)

M1

G5=G6=G7=G8G9=(G8 AND NOT(M1))

G10=G11=G9

G12=(G8 AND M1) OR G11

G13=G12

P P P P P

קפיצות קדימה – המקרה הקל ביותר

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

לכל הוראה נשמור ביטוי לוגי נוסף )פרטי שלה( ב.שיציין

התנאים להגיע אל ההוראה ע"י קפיצות אליה. -הcurrent-יאותחל ל true הוראה ראשונה מבוצעת( תמיד(

.falseוכל הביטויים הפרטיים של ההוראות יאותחלו ל-

בכל שלב נחזיק בזיכרון:( שיבטא את התנאי הדרושCurrentביטוי לוגי נוכחי )א.

כדי שנגיע להוראה ישירות מההוראה הקודמת.

P P P


ההוראה מבוצעת אינטואיציה: אם הגענו אליה ישירות מההוראה

הקודמת (אז יתקיים) או אם קפצנו אליהcurrentה-

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

-הguard המתאים לכל הוראה יחושב ע"י ביצוע ORבין לבין הביטוי הפרטי הנוכחי שלה. נעדכן ערך currentה- בהתאם.currentה-


-הguard המתאים לכל הוראה יחושב ע"י ביצוע ORבין לבין הביטוי הנוכחי שלה. נעדכן ערך currentה-

currentה-בהתאם.

אם ההוראה הנוכחית היא קפיצה מותנית לכתובתL:

לוגי בין OR ע"י ביצוע Lעדכן התנאי הפרטי של הוראה *הפרטי לתנאי שהקפיצה תתרחש.התנאי

CURRENT לוגי בין ה-AND: תנאי להתרחשות הקפיצה)תנאי להתרחשות הוראת הקפיצה( לבין תנאי הקפיצה.


NOT לוגי עם ערך ה-AND ע"י ביצוע currentעדכן ה-*של תנאי הקפיצה.





זהו התנאי לביצוע

ההוראה הבאה


NOT לוגי עם ערך ה-AND ע"י ביצוע currentעדכן ה-*של תנאי הקפיצה.





החלף הוראת הקפיצה המותנית במשתנה בוליאני ייחודי *את תנאי הקפיצה.המקבל

לפני כל הוראה, הוסף תנאיIF המכיל את CURRENT.כמעט

P

קפיצות קדימה – דוגמאC = C + 1

DO 100 I = 1, N

IF (A(I) > 10) GOTO 60

20 A(I) = A(I) + 10

IF (B(I) > 10) GOTO 80

40 B(I) = B(I) + 10

60 A(I) = B(I) + A(I)

80 B(I) = A(I) - 5

100 CONTINUE

C = C + D;

true guard:

80שורה מתבצעת תמיד

(current)

קפיצות קדימה – דוגמאIF (true) C = C + 1

DO 100 I = 1, N

IF (A(I) > 10) GOTO 60

A(I) = A(I) + 10

IF (B(I) > 10) GOTO 80

40 B(I) = B(I) + 10

60 A(I) = B(I) + A(I)

80 B(I) = A(I) - 5

100 CONTINUE

C = C + D;

true guard:

לפני הוראות לולאה לא(IFמוסיפים תנאים )

P


DO 100 I = 1, N

IF (A(I) > 10) GOTO 60

A(I) = A(I) + 10

IF (B(I) > 10) GOTO 80

40 B(I) = B(I) + 10

60 A(I) = B(I) + A(I)

80 B(I) = A(I) - 5

100 CONTINUE

C = C + D;

true guard:

if (true) C = C + 1

DO 100 I = 1, N

IF (A(I) > 10) GOTO 60

A(I) = A(I) + 10

IF (B(I) > 10) GOTO 80

40 B(I) = B(I) + 10

60 A(I) = B(I) + A(I)

80 B(I) = A(I) - 5

100 CONTINUE

C = C + D;

קפיצות קדימה – דוגמא

IF (A(I) > 10) GOTO 60 -> m1=(A(I)>10)

1true m

60שורה לש לתנאי הפרטייש להוסיף את הביטוי

לקפיצה "מוצלחת"

guard:

P


DO 100 I = 1, N

IF (true) m1 = (A(I) > 10)

A(I) = A(I) + 10

IF (B(I) > 10) GOTO 80

40 B(I) = B(I) + 10

60 A(I) = B(I) + A(I)

80 B(I) = A(I) - 5

100 CONTINUE

C = C + D;

1true m guard:


DO 100 I = 1, N

IF (true) m1 = (A(I) > 10)

IF (true AND NOT (m1)) A(I)=A(I)+10

IF (B(I) > 10) GOTO 80

40 B(I) = B(I) + 10

60 A(I) = B(I) + A(I)

80 B(I) = A(I) - 5

100 CONTINUE

C = C + D;

1true m guard:


DO 100 I = 1, N

IF (true) m1 = (A(I) > 10)


IF (B(I) > 10) GOTO 80 -> m2 = (B(I)>10)

40 B(I) = B(I) + 10

60 A(I) = B(I) + A(I)

80 B(I) = A(I) - 5

100 CONTINUE

C = C + D;

80לתנאי הפרטי של שורה יש להוסיף את הביטוי

לקפיצה מוצלחת

1 2true m m guard:


DO 100 I = 1, N

IF (true) m1 = (A(I) > 10)


IF (true AND NOT (m1)) m2 = (B(I)>10)

40 B(I) = B(I) + 10

60 A(I) = B(I) + A(I)

80 B(I) = A(I) - 5

100 CONTINUE

C = C + D;

1 2true m m guard:


DO 100 I = 1, N

IF (true) m1 = (A(I) > 10)



40 IF (true AND NOT (m1) AND NOT (m2)) B(I)=B(I)+10

60 A(I) = B(I) + A(I)

80 B(I) = A(I) - 5

100 CONTINUE

C = C + D;

1 2true m m guard:

אינו 60התנאי הפרטי של שורה FALSE ולכן הוא יש להוסיפו

הנוכחי.guard ל-ORב-

P

IF (true) C = C + 1

DO 100 I = 1, N

IF (true) m1 = (A(I) > 10)




60 A(I) = B(I) + A(I)

80 B(I) = A(I) - 5

100 CONTINUE

C = C + D;

קפיצות קדימה – דוגמא 1 2 1( )true m m true m guard:

IF (true) C = C + 1

DO 100 I = 1, N

IF (true) m1 = (A(I) > 10)




60 IF (… OR (true AND m1)) A(I) = B(I) + A(I)

80 B(I) = A(I) - 5

100 CONTINUE

C = C + D;

קפיצות קדימה – דוגמא 1 2 1( )true m m true m

הביטוי גדול מכדי להיכנס למצגת!

שוב תנאי פרטיFALSEאינו

guard:

P

IF (true) C = C + 1

DO 100 I = 1, N

IF (true) m1 = (A(I) > 10)





80 IF (… OR (true AND NOT(m1) AND m2)) B(I)=A(I)-5

100 CONTINUE

C = C + D;

קפיצות קדימה – דוגמא 1 2 1 1 2( ) ( )true m m true m true m m guard:

true שקול לוגית ל-guardה-

נימנע מלהוסיף תנאי לפני CONTINUE)טעות קומפילציה(

P

IF (true) C = C + 1

DO 100 I = 1, N

IF (true) m1 = (A(I) > 10)






100 CONTINUE

C = C + D;

קפיצות קדימה – דוגמאguard: 1 2 1 1 2( ) ( )true m m true m true m m

IF (true) C = C + 1

DO 100 I = 1, N

IF (true) m1 = (A(I) > 10)






100 CONTINUE

IF (…) C = C + D;

קפיצות קדימה – דוגמאguard: 1 2 1 1 2( ) ( )true m m true m true m m

קפיצות קפיצות החוצההחוצה

צא בחוץ!!

קפיצות החוצה – מתחיל להסתבךהמקרה של קפיצה החוצה מסובך יותר שכן אינטואיציה:

מרגע שהקפיצה מתרחשת הלולאה מפסיקה להתבצע:

DO I = 1, NS1

IF (p(I)) GOTO 100S2

END100 S3

, שלא בטווח הקפיצה, תלוי S1בפרט במקרה זה גם ביצוע

בתוצאת הקפיצה המותנת.

קפיצות החוצה – דוגמאDO 200 I = 1, 100

50 S1

DO 100 J = 1, 100

S2

IF (X(I,J) > 300) GOTO 300

S3

IF (Y(I,J) < 50) GOTO 50

S4

100 CONTINUE

S5

200 CONTINUE

300 S6

תחילה נטפל בשתיהקפיצות החוצה בלולאה הפנימית

P


50 S1Ex1 = TRUEEx2 = TRUEDO 100 J = 1, 100

S2IF (X(I,J) > 300) GOTO 300S3IF (Y(I,J) < 50) GOTO 50S4

100 CONTINUES5

200 CONTINUE300 S6

הוספת משתנים בוליאנים מתאימים לקפיצות



IF (Ex1 AND Ex2) S2IF (Ex1 AND EX2) IF (X(I,J) > 300) GOTO 300IF (Ex1 AND Ex2) S3IF (Ex1 AND Ex2) IF (Y(I,J) < 50) GOTO 50IF (Ex1 AND Ex2) S4

100 CONTINUES5

200 CONTINUE300 S6

קביעת תלות בין ביצוע כל הוראות הלולאה למשתנים הללו



IF (Ex1 AND Ex2) S2IF (Ex1 AND EX2) Ex1 = NOT (X(I,J) > 300)

IF (Ex1 AND Ex2) S3IF (Ex1 AND Ex2) Ex2 = NOT (Y(I,J) < 50)IF (Ex1 AND Ex2) S4

100 CONTINUES5

200 CONTINUE300 S6

שינוי הוראות הקפיצה המקוריות להוראות שיבטיחו

FALSEשהמשתנים יקבלו ברגע שהקפיצה התרחשה.



IF (Ex1 AND Ex2) S2IF (Ex1 AND EX2) Ex1 = NOT (X(I,J) > 300) IF (Ex1 AND Ex2) S3IF (Ex1 AND Ex2) Ex2 = NOT (Y(I,J) < 50)IF (Ex1 AND Ex2) S4

100 CONTINUEIF (NOT Ex1) GOTO 300IF (NOT Ex2) GOTO 50S5

200 CONTINUE300 S6

העברת הקפיצות אל מחוץ ללולאה


50 S1Ex1 = TRUEEx2 = TRUEJ’ = 1DO 100 J = 1, 100

IF (Ex1 AND Ex2) J’ = JIF (Ex1 AND Ex2) S2IF (Ex1 AND EX2) Ex1 = NOT (X(I,J) > 300) IF (Ex1 AND Ex2) S3IF (Ex1 AND Ex2) Ex2 = NOT (Y(I,J) < 50)IF (Ex1 AND Ex2) S4

100 CONTINUEJ = J’IF (NOT Ex1) GOTO 300IF (NOT Ex2) GOTO 50…

מוסיפים משתנה עזר ש-"יזכור" באיזה איטרציה קפצנו החוצה על מנת שנוכל לשחזר את המשתנה האיטרציה המקורי כשהקפיצה

"התרחשה".

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

P

סקירת קפיצות החוצה – האלגוריתם

עבור כל הוראת קפיצה החוצה:

-נגדיר משתנה בוליאני חדש שיאותחל לtrue.

בכך שערכו של הוראות הלולאה נתנה את ביצוע.trueהוא המשתנה

ה-נחליף את הוראת הקפיצה בהשמה שלNOT של בטיח כי המשתנה בכך נ. אל המשתנההקפיצהתנאי תרחש.אמורה להראשונה שהקפיצה הפעם ב falseיקבל

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

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

ע"י שימוש ברגע שהקפיצה היתה אמורה להתבצע )במשתנה זמני).

סקירת קפיצות החוצה – האלגוריתם

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

Branch Relocation.

– "תוצר התהליך כפי שאנחנו יצרנו אותו "רע למיקבולולכן ( המופיע בכל קוד הלולאה Ex1 משתנה סקלרי )יצרנו

כל הקוד.לאורך יוצר תלויות

– פתרוןScalar Expansion.

קפיצות החוצה – נקודות חשובות

:לדוגמא הקודDO J = 1, M

DO I = 1, NA(I,J) = B(I,J) + XIF (L(I,J)) GOTO LC(I,J) = A(I,J) + Y

ENDDOD(J) = A(N,J)

L: F(J) = C(10,J)ENDDO


:יהפוך לDO J = 1, M

am(0,J) = TRUEDO I = 1, N

IF (lm(I-1, J)) A(I,J) = B(I,J) + XIF (lm(I-1, J)) m1 = NOT(L(I,J))am(I, J) = am(I-1, J) AND m1IF (lm(I,J)) C(I,J) = A(I,J) + Y

ENDDOIF (NOT)am(I,J)) goto LD(J) = A(N,J)

L: F(J) = C(10,J)ENDDO

בו iמערך חדש נוסף, האיבר ה- באיטרציה Ex1הוא הערך של

ואיברו הראשון מאותחל iה-.trueל-

m1 משתנה זמני המקבל את NOTשל תנאי הקפיצה

)זהו התנאי שלא קפצנו(מרגע הקפיצה הראשונה, כל

falseאברי המערך יקבלו

PPP


עתה כל ההוראות בלולאה תלויות בחישוב המערךלא מעגלית( ולכן ניתן לווקטר ולקבל:)תלות

DO J = 1, Mlm(0,J) = TRUEDO I = 1, N

IF (lm(I-1, J)) m1 = NOT(L(I,J))lm(I, J) = lm(I-1, J) AND m1IF (lm(I,J)) C(I,J) = A(I,J) + Y

ENDDOENDDOWHERE (lm(0:N-1, 1:M)) A(1:N,1:M)=B(1:N,1:M)+XWHERE (lm(0:N-1, 1:M)) C(1:N,1:M)=A(1:N,1:M)+YWHERE (lm(N,1:M)) D(1:M) = A(N, 1:M)F(1:M) = C(10, 1:M)

קפיצות החוצה – נקודות חשובותות קיימות הפקודן ארכיטקטורות בהנןיש FirstTrueX,

FirstFalseXת את ערך האמת )השקר( הראשון ו המוצאבווקטור בוליאני )כלומר מחזירות את האינדקס שלו(.

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

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


-אחרי שימוש בFirstFalseX:נקבל ,DO J = 1, M

lm(0,J) = TRUEDO I = 1, N

IF (lm(I-1, J)) m1 = NOT(L(I,J))lm(I, J) = lm(I-1, J) AND m1IF (lm(I,J) C(I,J) = A(I,J) + Y

ENDDOX = FirstFalseX(lm(J))A(J, 1:X-1) = B(J, 1:X-1)C(J, 1:X-1) = A(J, 1:X-1)

ENDDO…

FirstFalseXנשם לב כי השימוש ב-"עלה" לנו בצורך להכניס הפעולות הווקטוריות חזרה ללולאה החיצונית.

P

קפיצות אחורהקפיצות אחורה

קפיצות אחורה( כל קפיצה אחורה יוצרת בעצם לולאהdo-while )

נסתרת.L: A = A – 1

IF (A > 2) GOTO LC של DO-WHILEשקול ללולאת

ברור כי לא נוכל פשוט להחליף הקוד הנ"ל בהוראותIF הגורמת לקוד להתבצע )מספר לא IFאין הוראת שכן

פעמים.מוגדר( של

יש אלגוריתמים המנסים להפוך קפיצות אחורה ללולאותDO רגילות, אך האלגוריתמים הנ"ל מסובכים ובמרבית

התוצאות אינן מצדיקות את הרצתם.המקרים

P

קפיצות אחורה מקובלת לטיפול בקפיצות לאחור, היא פשוט לא ההדרך

לטפל בהם ולקבוע שאסור לשנות את כל המשפטים שבטווח

הלולאה.

הבעיה שדרך זו יוצרת היא שאיננו יכולים לבצעif conversion גם לקפיצות קדימה, שכתובות הקפיצה

שלהם בטווח של הקפיצה אחורה.

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

if conversions לקפיצות קדימה, גם אם כתובת הקפיצה

נופלת בתחום של קפיצה אחורה.

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

IF (X) GOTO 200100 S1200 S2

IF (Y) GOTO 100

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

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

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

IF (X) GOTO 200 -> BR1 = XBB1 = FALSE

100 IF (NOT BR1 OR (BR1 AND BB1)) THEN S1200 IF (NOT BR1 OR (BR1 AND BB1) OR BR1) THEN S2

IF (Y) THEN DOBB1 = TRUEGOTO 100

ENDIF

מבוצעת רק אם 100שינינו את הקוד כך שהוראה הקפיצה

לא נלקחה או נלקחה הקפיצה אחורה.

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

של כתובת המטרה של guardל-( את ORהקפיצה אחורה מוסיפים )ב-

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

אחורה.

PPP

קפיצות אחורה:נתבונן על מקרה מסובך יותר

IF (X) GOTO 200100 S1

GOTO 300200 S2

IF (Y) GOTO 100300 S3

אנו נתייחס לקפיצה לא מותנית כאל קפיצה מותנית

TRUEשהתנאי שלה הוא

-נשם לב כי אין אפשרות שS2 יתבצע אם הקפיצה נלקחה.אחורה

קפיצות אחורה

BR1 = XBB1 = FALSE

100 IF (NOT BR1 OR (BR1 AND BB1)) THEN S1IF (NOT BR1 OR (BR1 AND BB1)) BR2 = TRUE

200 IF (BR1 OR BB1) THEN S2IF (Y) THEN DO

BB1 = TRUEGOTO 100

ENDIF300 S3 אינו מתבצע S2איבדנו את התנאי ש-

כאשר הקפיצה אחורה נלקחת!

P

:נחזור על הטריק שראינו קודם ונקבל

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

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

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

התרחשה.לא

אלגוריתם פורמלי והוכחתו מופיעים במאמר שלALLEN:

“Conversion of control dependence to data dependence”

קפיצות קפיצות ללולאותללולאות

ושיקוצים ושיקוצים אחריםאחרים

פינת הקוד המטורלל כפי שנלמד בקורס "שפות תכנות", לכלcontrol flow

תוכנית אמורה להיות כניסה יחידה ומספר כלשהו של של יציאות.

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

-הוראה שכזאת אומנם אסורה בFORTRAN אך חוקית .Cבשפות אחרות כמו

פינת הקוד המטורלל-הקוד הבא לעומת זאת כן חוקי בFORTRAN:

INTEGER RETURN_LABELASSIGN 100 TO RETURN_LABELGOTO 9000

100 S1…9000 GOTO RETURN_LABEL

נמנע מלבצע טרנפרומציותבמקרים הנ"ל

P

אלגוריתם אלגוריתם סימפליפיקציהסימפליפיקציה

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

מופיע רק בתחום הפונקציה.מוסיפים

לעומת זאת, עבור קפיצות קדימה הוספת התנאיםguardל-

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

:דוגמא ראינו כי הקודDO 100 I = 1, N

IF (A(I) > 10) GOTO 6020 S1

IF (B(I) > 10) GOTO 8040 S260 S380 S4100 CONTINUE

תלוי הן 60 ביצוע שורה :הערהבקפיצה הראשונה והן בשניה, ולכן לא

ניתןפשוט "להעלים" את משתנה הקפיצה

כאשר מגיעים לכתובת הקפיצהP

למה זה טוב?:הופך לקוד

DO 100 I = 1, NIF (true) m1 = (A(I) > 10)IF (true AND NOT (m1)) A(I)=A(I)+10IF (true AND NOT (m1)) m2 = (B(I)>10)

40 IF (true AND NOT (m1) AND NOT (m2)) B(I)=B(I)+1060 IF (… OR (true AND m1)) A(I) = B(I) + A(I)80 IF (… OR (true AND NOT(m1) AND m2)) B(I)=A(I)-5100 CONTINUE

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

בקורס חישוביות למדנו כי אם קיים אלגוריתם תזכורת :.P=NPכזה, אזי

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

עוד בסמסטר הראשון ללימודיו.מינימיזציה

לכל משבצת 1: נכניס תזכורתבטבלה המתאימה לערך בו הביטוי

.1מקבל ננסה להקיף את האחדים בעיגולים

מקסימליים.לאחר מכן נבחר כמות מינימלית של

עיגולים כך שכל האחדים יכוסו.

באופן מפתיע מפות קרנו לא יעבדו בשבילנו הפעם 6אם היינו יודעים לטפל בעזרתם ביותר מ-)אפילו

משתנים(

Quine-McCluskeyאלגוריתם האינטואיציה מאחורי האלגוריתם היא אותה אינטואיציה

העומדת מאחורי מפות קרנו.

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

-תחילה הופכים את הביטוי לDNF.)סכום מכפלות(

A B C A B C A C

אם יש שני מכפלות המזדהים על כל הליטרלים מלבדליטרל

אחד, והליטרל הנ"ל בביטוי הראשון הוא השלילה של זה מהביטוי השני, ניתן לאחדם למכפלה יחידה:

נציג כלTerm-מכפלה( ב( DNF כווקטור בינארי, כך מופיע i בווקטור יציין האם המשתנה ה-iשהביט ה-במכפלה

יציין המכפלה: 00000הוקטור בפאזה חיובית או שלילית.

יציין המכפלה: 01011הוקטור

1 2 3 4 5X X X X X

1 2 3 4 5X X X X X

Quine-McCluskeyאלגוריתם


בפאזה חיובית או שלילית.

אם קייםTERMשאינו מכיל את כל המשתנים, נשכפלו ונוסיף לעותקיו את כל צירופי הליטרלים החסרים.


1 3 5 1 2 3 4 5 1 2 3 4 5

1 2 3 4 5 1 2 3 4 5

X X X X X X X X X X X X X

X X X X X X X X X X


בפאזה חיובית או שלילית.

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

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


-נחזור על התהליך עד לfix point.

דוגמא

0000

0101

0111

1000

1001

1010

1011

1110

1111

קבוצת משתנים מקורית קבוצת מצומצמת א קבוצת מצומצמת ב

000-01-1

-111100-10-010-1101-1-101-11111-

9סה"כ 10סה"כ

10--

1-1-

2סה"כ

נותרנו המכפלות הבאות )לא סומנו(.

דוגמא

000-01-1

-111

10--

1-1-

בסוף שלב זה ניוותר עם קבוצה של מכפלות שלא סומנו -

.prime termsנקראות גם

כל שנותר הוא לבחור תת קבוצה מינימלית של אותםprime terms.שתחסה את כל המכפלות המקוריות ,

נהוג להיעזר בטבלה ששורותיה הם המכפלותהמקוריות,

X, והתא המתאים מכיל prime termsעמודותיה הם ה- מחסה את המכפלה prime termאם ורק אם ה-

המקורית.

במידה שיש שורה המכילהX אחד בלבד, הרי שרק prime term .אחד מחסה את המכפלה הנידונה

וחייביםessential prime termלמכפלה כזאת נקרא לבחור אותה.


בחזרה לדוגמא שלנו...נבנה את הטבלה שמתקבלת:

-00001-1-11110--1-1-0000X0101X0111XX1000XX1001X1010XX1011XX1110X1111XX

--’ הם דוגמאות 10’ ו-’01-1במקרה שלנו ’. essential prime termsל-

TERMים מקוריים

מכפלות שלא סומנו

-נעזוב בנתיים את אופן קבלת הDNF.

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

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

מקום אקספוננציאלית.דרישת

-מציאת הביטוי המינימלי בשלב האחרון מהprime terms

שקיבלנו אורך גם כן זמן אקספוננציאלי.

זהו האלגוריתם המקורי שנוסה כאלגוריתםסימפליפיקציה

.איטי מידי ונמצא IF Conversionל-

Quine-McCluskeyסיבוכיות

אנו נבצע סימפליפיקציה רק עבור קפיצות :תזכורת קדימה.

-בקפיצות קדימה אנו "מוסיפים" לguard משתנים כאשר:

ביןANDהחל מהוראת הקפיצה עצמה, מבצעים (1guard.נוכחי והשלילה של תנאי הקפיצה

( לתנאי הפרטי:ORבכתובת הקפיצה, מוסיפים )(2<(guard >בשלב הקפיצה AND .)>תנאי הקפיצה<

-לכן קל לשמור את הguard במצב DNF לכל אורך הריצה:

IF CONVERSIONסימפליפיקציה ל-

1 3 2 3 4 1 3 4 2 3 4X X X X X X X X X X X

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

מינימלישל משתנים.

:תזכורת - בקוד


DO 100 I = 1, NIF (A(I) > 10) GOTO 60

20 S1IF (B(I) > 10) GOTO 80

40 S260 S380 S4100 CONTINUE

תלויה בתוצאות שני הקפיצות.60שורה מתבצעת תמיד.80שורה

נאלץ להמתין60לכן לא נוכל להעיף משתנים משורה ,(.80לכתובת הקפיצה של הקפיצה השנייה )שורה

ניתן לסלק משתני קפיצה בסדר הפוך בלבד : משפט.לסדר בו פגשנו בהם


.הוכחת המשפט אינה טריוויאלית ולא תינתן

מתוך משפט זה ואלגוריתםQuine-McCluskey IFאלגוריתם סימפליפיקציה נוח עבור מקבלים

CONVERSION: מכיל את כל TERM בו כל DNFבכל שלב נחזיק א.

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

ים המתאימים להם.branchפגשנו את ה-בו

קיים brn בו מופיע המשתנה TERMנבדוק האם לכל ג.

( בו המשתנה מופיעה בשלילה. אם כןTERMבן זוג ).guardנסלק את המשתנה מה-


בספר מובא מימוש של אלגוריתם זה המוציאguardמה-

את כל המשתנים שניתן בזמן ליניארי.

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

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

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

סימליפיקציה אופטימלית.


IF IF ReconstructionReconstruction

ביצועIF Conversion כרוך במאמצים לא מבוטלים מצד, למשל בביצוע סימפליפיקציות.compilerה-

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

הלולאה, למשל:

IF Reconstruction

DO 100 I=1, NIF (A(I) > 0) GOTO 100

B(I) = A(I) * 2.0A(I+1) = B(I) + 1

100 CONTINUE

ביצועIF Conversion כרוך במאמצים לא מבוטלים מצד, למשל בביצוע סימפליפיקציות.compilerה-

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

הבקרה לתלויות מידע, עדיין לא ניתן לווקטר את הלולאה.

IF Reconstruction

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

שהייתה נלקחת לקראת תחילת ביצוע הלולאה, עתה

בהכרח יתבצעו עד סופם.

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

)האם ניתן יהיה למקבל את If Conversionשל התוצאה(.

גם אם הצלחנו למקבל את הלולאה, ייתכן שהקוד ירוץ

לאט יותר!

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

כי התוצאה אינה ניתנת למיקבול.

IF Reconstruction

IF Reconstruction קיימים אלגוריתם מתוחכמים יותר, אשר יודעים לקחת

ולהפוך אותה חזרה If conversionהתוצאה של את ים מיותרים branchמותנות בדרך יעילה כך ש-לקפיצות

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

משפחת אלגוריתמים אלו נקראתIF Reconstruction והיא

לא בתחום של הרצאה זאת.

תלויות בקרהתלויות בקרהשל לולאותשל לולאות

הרעיון: קיימת תלות בקרה בין ההוראות בגוף הלולאהלבין

תחום הלולאה.

:לדוגמא, נתבונן בקטע הקוד הבא

תלויות בקרה של לולאות

DO 120 I=1, 100

L = 2*I

DO 100 J=1, L

A(I,J) = 0

100 ENDDO

120 ENDDO

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

תלויות בקרה של לולאותDO 120 I=1, 100

L = 2*IDO 100 J=1, L

A(I,J) = 0 100 ENDDO120 ENDDO

אם נווקטר את הקוד כפי שביצענו עד היום נקבלהבאה:התוצאה

DO 120 I=1, 100L = 2*I

120 ENDDOA(1:100,1:L) = 0

קטע קוד לא שקולP

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

.הפתרון הוא שנהפוך גם תלות זאת לתלות מידע

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

המקורית.

נוסיף לגרף התלויות קשתות המציינות שכל הוראהבלולאה

תלויה )תלות מידע( במשתנה התחום של הלולאה.



DO 120 I=1, 100L = 2*IDO 100 J=1, L

A(I,J) = 0 100 ENDDO120 ENDDO

:הקוד של הדוגמא


irange1 = (1,100)DO 120 I=1, 100

L = 2*I (irange1)irange2 = (1,L) (irange1)DO 100 J=1, L

A(I,J) = 0 (irange2) (irange1)100 ENDDO120 ENDDO

:יהפוך ל

עתה נבצעconstant propagation:ונקבל

P

תלויות בקרה של לולאות20 DO 120 I=1, 10040 L = 2*I (1,100)60 DO 100 J=1, L80 A(I,J) = 0 (1,L) (1,100)100 ENDDO120 ENDDO

מצאנו תלותloop independent dependentבין ולכן הויקטור היחיד שנוכל לעשות הוא 80 ו-40הוראות

של80.20שורה DO 120 I=1, 100

40 L = 2*I A(I, 1:L) = 0

120 ENDDO

גרף התלויותגרף התלויות

רקע כללי כאמור, החיסרון העיקרי שלIF conversionהוא שאיננו

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

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

לבצע הוראות במקביל.לנו

קצת הגדרות...

הוא אוסף בלוק בסיסי – הגדרהשל הוראות כך שכל הוראה מקסימלי

מתבצעת אם ורק אם כל יתר באוסף מתבצעות.ההוראות

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

קצת הגדרות...*עבור תוכנית יוגדר: גרף הזרימה – הגדרה

קבוצת הצמתים תכיל צומת התחלה יחידוצומת סיום יחיד + צומת עבור כל בלוק

בסיסי.( מציינת x,yכל קשת בין שני צמתים )*

מבוצע yשקיים מסלול בקרה בו בלוק .xאחרי בלוק

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

דוגמא לגרף זרימה1

2 3

5 6

4

7

צומת הכניסה1צומת – – צומת היציאה7צומת

שתובילקפיצה יש הוראת 1בבלוק נלקחההקפיצה אם 2אותנו לבלוק

אחרת.3ולבלוק

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

מעגלים בגרף.

קצת הגדרות...נשלטת y – אנו נאמר כי צומת הגדרה

(postdominated) ע"י צומתx בגרף xהזרימה אם ורק אם כל מסלול בין צומת

.yלצומת הסיום עובד דרך צומת

דוגמא לתכונת השליטה1

2 3

5 6

4

7

3,4 נשלטת ע"י צמתים 6צומת.

2 אינו נשלט ע"י צומת 5צומת.

נשלט ע"י כל הצמתים7צומת האחרים.

לא נשלט ע"י אף צומת.2צומת

קצת הגדרות...נשלטת y – אנו נאמר כי צומת הגדרהע"י (imidiate postdominated)מיידית הוא הצאצא הראשון yאם ורק אם xצומת

xשל הנשלט על ידו בגרף הזרימה.

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

היותר.

בניית "עץ" שליטה מיידית1

2 3

5 6

4

7

1

3

4

6

7

5

2

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

"עץ" הפוך

קצת הגדרות...תלות בקרה y – אנו נאמר כי לצומת הגדרה

(control dependence) בצומתx אם ורק z≠x כך שלכל צומת y ל-xאם קיים מסלול מ-

אינה y, וכן z נשלטת ע"י yבמסלול נשלטת

.xע"י אם צומת x יש תלות בקרה בצומת y: לצומת אינטואיציה

x יכול לקבוע האם צומת y-יתבצע. כלומר יש מסלול מ x לא בהכרח y בו x בהכרח מתבצע, ויש מסלול מ-yבו

יתבצע.P

אלגוריתם מציאת תלויות בקרה.בצע מיון טופולוגי על "עץ" השליטה המיידית

, z נשלט מיידית ע"י x כך ש-zעבור כל צומת ב.(, )z(CD תלוי בה )z ש-yעבור על כל צומת

x אזי y לא נשלט מיידית ע"י xאם y :תלוי ב- CD x CD x y

.עבור על הצמתים ע"פ הסדר במיון: הצומת הנוכחי במיוןxיהי

לא נשלט x בגרף הזרימה, אם x של yעבור כל אב א.y: תלוי ב-x אזי yמיידית על ידי CD x CD x y

P P

אלגוריתם לבניית גרף בקרה1

2 3

5 6

4

7

1

3

4

6

7

5

2

בצע מיון טופולוגי על "עץ" השליטה המיידית ועבור על הצמתים ע"פ סדר המיון.

א

ב

ג

ד

ה

ו

ז


2 3

5 6

4

7

1

3

4

6

7

5

2

א

ב

ג

ד

ה

ו

ז

לא נשלט x בגרף הזרימה, אם x של yעבור כל אב א..y תלוי ב-x אזי yמיידית על ידי


2 3

5 6

4

7

1

3

4

6

7

5

2

א

ב

ג

ד

ה

ו

ז

עבור על כל ,z נשלט מיידית ע"י x כך ש-zעבור כל צומת ב. לא נשלט מיידית xאם (,)z(CD תלוי בה )z ש-yצומת

.y תלוי ב-xאזי yע"י


2 3

5 6

4

7

1

3

4

6

7

5

2

א

ב

ג

ד

ה

ו

ז


{1}


2 3

5 6

4

7

1

3

4

6

7

5

2

א

ב

ג

ד

ה

ו

ז



{1}


2 3

5 6

4

7

1

3

4

6

7

5

2

א

ב

ג

ד

ה

ו

ז


{1}

{2,3}


2 3

5 6

4

7

1

3

4

6

7

5

2

א

ב

ג

ד

ה

ו

ז

{1}

{2,3}




2 3

5 6

4

7

1

3

4

6

7

5

2

א

ב

ג

ד

ה

ו

ז


{1}

{2,3}


2 3

5 6

4

7

1

3

4

6

7

5

2

א

ב

ג

ד

ה

ו

ז

{1}

{2,3}



{1,2}


2 3

5 6

4

7

1

3

4

6

7

5

2

א

ב

ג

ד

ה

ו

ז

{1}

{2,3}

{1,2}

, אם נבחר בקשת הצהובה 1עבור צומת : 6דוגמא לתלות צומת וייתכן שלא6, אחרת יתכן שנבקר ב-6מובטח שנבקר ב-

תוצאת האלגוריתם עבור הדוגמא1

2 3

5 6

4

7

1

3

4

6

7

5

2

א

ב

ג

ד

ה

ו

ז

{1}

{2,3}

{1,2}

{1}

{2}

סיבוכיות האלגוריתם.בצע מיון טופולוגי על "עץ" השליטה המיידית O V E

.עבור על הצמתים ע"פ הסדר במיון O V


הצומת הנוכחי במיון:xיהי

עוברים על כל קשת בגרף הזרימה פעם אחת בדיוק

O E

נשם לב כי כל צומת שולטת מיידיתבצומת אחת לכל היותר, לכן ניתן

להכיל את "עץ" השליטה מיידית במערך

PPP

סיבוכיות האלגוריתם.בצע מיון טופולוגי על "עץ" השליטה המיידית

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

. y תלוי ב-x אזי yמיידית על ידי , z נשלט מיידית ע"י x כך ש-zעבור כל צומת ב.

(, )z(CD תלוי בה )z ש-yעבור על כל צומת x אזי y לא נשלט מיידית ע"י xאם

.yתלוי ב-

O V E

O V

O E

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

הבדיקה השנייה חסומה ע"י מספר תלויות הבקרה.

,O MAX V CD

P

סיבוכיות האלגוריתם :הסיבוכיות הכוללת יוצאת

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

לא קיים אלגוריתם טוב יותר מבחינה אסימפטותית.

נשם לב כי קבוצת התלויותCD יכולה להיות ריבועית בגודל

גרף הזרימה:

,O MAX V E CD

1

2 3

4 5

2n+2

{1,2}

{1,2,4}

{1}

{2}

סיבוכיות האלגוריתם

... ...

2n 2n+1

{1,2,4,6,…,2n}{2n-2}

2

1

1n

i

i O n

בניית גרף תלויות עבור לולאות הראנו אלגוריתם שמוצא את כל תלויות הבקרה שיש

בהוראות אחרות בתוכנית.xלהוראה

גרך תלויות הבקרהמהתלויות הללו ניתן לבנות את (The control dependence graph שצמתיו הם )

הבלוקיםהבסיסיים של התוכנית, ובין שני בלוקים קיימת קשת

אם הם.sinkתלויים זה בזה, שכיוונה מהמקור ל-

בהינתן לולאה בקוד נוסיף לגרף צומת שייצג את גוףהלולאה, ונוסיף קשת )תלות( בין צומת זאת לבין כל

הוראהבלולאה שביצוע לא תלוי בהוראה אחרת בלולאה.

1 DO I=1, 1002 A(I) = A(I) + B(I)3 IF (A(I) > 0) GOTO 504 A(I) = -A(I)5 B(I) = A(I) + C(I)

ENDDO

בניית גרף תלויות עבור לולאותדוגמא:

1

2 5

4

3F

'היא צומת הלולאה.1צומת מס

-הF( מציינת שהוראה 3,4 על קשת )מבוצעת רק אם 4 .false מוערך ל-3תנאי הקפיצה בהוראה

מודלמודללביצוע מקבילילביצוע מקבילי

מודל לביצוע מקבילי לכל הוראה )בלוק בסיסי( בקוד נתאים דגל ביצוע

בוליאני.

לכל הוראה שלא תלויה בהוראות אחרות, נאתחל דגל. לכל יתר ההוראות יאותחל הדגל trueהביצוע ל-

.falseל-

הדגל של הוראהx-ישונה מ false-ל true כאשר קיימת y, וחישוב תנאי התלות ב-y תלויה ב-x כך ש-yהוראה

.xמחייבת את ביצוע של

ניתן לבצע במקביל את כל ההוראות שהדגל שלהם, וכל ההוראות שהם תלויות בהן מקיימות: trueל-נקבע

או שהם התבצעו כבר.falseאו שהדגל שלהם

מודל לביצוע מקבילי כאשר מגיעים לביצוע ראש של לולאה נפריד לשני

:מקריםתחום הלולאה קבועא.

. trueנקבע את הדגל של הראש הלולאה ל-- עותקים )כאשר Nן יכנלכל צומת )הוראה( בלולאה -

Nהוא מספר האיטרציות הצפוי(.

קבע את הדגלים של כל הצמתים התלויים ישירות-.trueבראש הלולאה ל-

מודל לביצוע מקבילי

1

2 5

4

3F

בדוגמא הקודמת )תחום לולאה קבוע(:

יקבע ל-1הדגל הבוליאני של true.

פעמים,100 "ישוכפלו" 2,3,5צמתים .trueוכל צומת יקבל ערך

פעמים והדגל100 ישוכפל 4צומת וישונהfalseשלו יאותחל ל-

רק אם בחישובtrue ל- מתאימה נקבל כי3הוראה

.falseתנאי הקפיצה הוא

1 DO I=1, 1002 A(I) = A(I) + B(I)3 IF (A(I) > 0) GOTO 504 A(I) = -A(I)5 B(I) = A(I) + C(I)

ENDDO

מודל לביצוע מקבילי כאשר מגיעים לביצוע ראש של לולאה נפריד לשני

:מקרים תחום הלולאה אינו קבועב. זהi עותקים מכל הוראה בלולאה, כאשר iניצור -

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

לדגלים של כל העתקים שיצרנו.trueנקבע ערך - לדגל של צומת הלולאה אם היא trueנקבע ערך -

באחד הצמתים data dependenceתלויה בלולאה

נכונות המודל מושגת באינדוקציה על סדר ביצוע אחרת.falseו-Pהצמתים.

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

קדימה.

קפיצה קדימה יוצרתloop independent dependence.

ביצוע ההוראות בלולאה, בהנחה שאיננו משנים סדר loop fusion-ו loop distribution הם הטרנספורמציות

היחידות המושפעות מהתלות.

,מאחר שאנו לא מתייחסים לקפיצות החוצהloop fusion מתבצעת באופן נכון שכן מובטח שכתובת

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

המקורית.

שימוש במודל לביצוע מקבילי המצב שונה עבורloop distribution.

ברור כי הטרנספורמציה הבאה שגויה:DO I=1, N

1 IF (A(I) < B(I)) GOTO 32 B(I) = B(I) + C(I)3 CONTINUE

DO I=1, N1 IF (A(I) < B(I)) GOTO 3

ENDDODO I=1, N

2 B(I) = B(I) + C(I)ENDDO

3 CONTINUE

:הבעיהcontrol dependenceחוצה את שני קטעיהלולאה המחולקת

P

שימוש במודל לביצוע מקבילי המצב שונה עבורloop distribution:

DO I=1, N1 IF (A(I) < B(I)) GOTO 32 B(I) = B(I) + C(I)3 CONTINUE

DO I=1, N1 E(I) = (A(I) < B(I)

ENDDODO I=1, N

2 IF (NOT(E(I))) B(I) = B(I) + C(I)ENDDO

3 CONTINUE

: פתרון אפשרינתפוס את תנאיהקפיצה, בדומה

IF Conversionל-

P

שימוש במודל לביצוע מקבילי-בIF Conversion ניסינו להפוך כל תלויות בקרה

לתלויותמידע ואז למקבל.

.עתה אנו קודם מנסים למקבל, ומתבוננים בתוצאה

אם במהלך המיקבול פיצלנו לולאה למספר תתי לולאותכך

שיש תלות בקרה שחוצה עתה שני לולאות, נשמור את משתני ההחלטה במקור של התלות בווקטור חדש שנוסיף,

ונקרא המשתנים כשנזדקק להם בלולאה השנייה.

שימוש במודל לביצוע מקבילידוגמא:

DO I=1, N1 IF (A(I) < 0) THEN2 IF (B(I)-A(I)>1) GOTO 4

ENDIF3 A(I)=B(I)

GOTO 84 IF (A(I) > T) THEN5 T = B(I) – A(I) + T

ELSE6 T = T + B(I) - A(I)7 B(I) = A(I)

ENDIF8 C(I)=B(I)+C(I)

ENDDO

1

2

6

43

F

5

8 7

F

T F

T

T

גרף הזרימה


6

7

עץ" שליטה מיידית"

8

5

4

32

1


ENDIF3 A(I)=B(I)


ELSE6 T = T + B(I) - A(I)7 B(I) = A(I)


ENDDO



ENDIF3 A(I)=B(I)


ELSE6 T = T + B(I) - A(I)7 B(I) = A(I)


ENDDO

גרף תלויות בקרה

1

2

6

4

3

F

5

7

F

T F

T

T

F


ENDIF3 A(I)=B(I)


ELSE6 T = T + B(I) - A(I)7 B(I) = A(I)


ENDDO

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

1

2

6

4

3

F

5

7

F

T F

T

T

F

8

1לולאה מקבילית

לולאה 2

לאמקבילית

3לולאה מקבילית

P

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

1

2

6

4

3

F

5

7

F

T F

T

T

F

8

לולא1ה

לולא2ה

לולא3ה

ולכן עלינו 2, תלויה בהוראה 4הוראה להעביר

.4 להוראה 2את תוצאות הקפיצות בהוראה

רואים שיש 2כאשר מתבוננים בהוראה שלוש אפשרויות:

4 מבוצעת והקפיצה להוראה 2הוראה א.נלקחת.

4 מבוצעת והקפיצה להוראה 2הוראה ב.אינה נלקחת.

אינה מבוצעת כלל.2הוראה ג.

מכאן אנו למדים כי המערך שעלינו להעביר ערכים אפשריים:3 צריך להכיל 4להוראה

TRUE ,)תנאי הקפיצה היה אמת( FALSE .UNDEFINEDאו

אלגוריתם לטיפול בפיצול לולאות-נסמן בP את קוד הלולאה המקורי ונניח כי Piזו הלולאה

שהתקבלה מהלולאה המקורית.iה-

-עבור על כל הPi ים ע"פ הסדר, לכלPiבדוק בגרף תלויות Pj להוראה ב-Piהבקרה האם קיימת תלות מהוראה ב-

:לכל תלות כזאת. j≠iכך ש-.undefinedאתחל מערך של משתנים בוליאנים בגודל תחום הלולאה ל-א.החלף את הוראת הקפיצה בהוראה בה המשתנה הבוליאני שהוספנוב.

מקבל את הערך של תנאי הקפיצה. את צומת מקור התלות בגרף התלויות.uנסמן ב-ג.

( בגרף התלויות, הוסף לפני ההוראה u,v כך שהקשת )vלכל צומת המתאימה

הבודקת האם התא המתאים במערך שווה לערך הרשום ifלה בקוד הוראת על

הקשת )בגרף התלויות(., קבעv’ לפני כל צומת v( מגרף התלויות, הוסף צומת u,vמחק הקשתות )ד.

.v’ ו-v’ ותלות בקרה בין צמתי v ו-uתלות מידע בין הצמתים

שימוש במודל לביצוע מקבילי


ENDIF3 A(I)=B(I)


ELSE6 T = T + B(I) - A(I)7 B(I) = A(I)


ENDDO

PARALLEL DO I=1, NE2(I) = UNDEFINED

1 IF (A(I) < 0) THEN2 E2(I) = (B(I)-A(I)>1)

ENDIF3 IF (NOT(E2(I)) A(I)=B(I)

ENDDODO I=1, N

E4(I) = UNDEFINEDIF (E2(I)) THENE4(I) = (A(I) > T)

4 IF (E4(I)) THEN5 T = B(I) – A(I) + T

ELSE6 T = T + B(I) - A(I)

ENDIFENDIF

ENDDOPARALLEL DO I = 1, N

IF (NOT(E4(I))7 B(I) = A(I)


ENDDO

תוצאת האלגוריתם

1

2

6

4

3

F

5

7

F

T F

T

T

F

8

לולא1ה

לולא2ה

לולא3ה

שימוש במודל לביצוע מקבילי

תוצאת האלגוריתם

2

6

4

3

F

5

7

F

T F

T

T

F

8

‘4

7’

1 לולא1ה

לולא2ה

לולא3ה

ייצור קודייצור קוד

ייצור קוד:דוגמא

DO I=1, N

1 IF (p1) GOTO 3

2 S2

GOTO 5

3 IF (p3) THEN

4 S4

GOTO 6

ENDIF

5 S5

6 S6

ENDDO

1

2

1b

Fלולא

1ה

6

1aT F

3 5

4 לולא2ה

נכנסות5לצומת שני תלויות בקרה!

ייצור קוד צריך להיראות כך:5קוד להפעלת צומת

1

2

1b

Fלולא

1ה

6

1aT F

3 5

4 לולא2ה

DO I=1, N1 IF (p1) GOTO 32 S2

GOTO 53 IF (p3) THEN4 S4

GOTO 6ENDIF

5 S56 S6

ENDDO

DO I=1, Np1a3 = (E1(I) AND NOT p3)IF (p1a3) S4IF (NOT)p3) OR NOT(E1(I)) S5

ENDDO

F

קוד מקורי

ייצור קוד בדוגמא הקודמת רואים כי יותר פשוט ליצר קוד כאשר תלויות

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

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

.i>j במיון כאשר j לעץ iיופיעו רק מעץ

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

OR על כל התנאים הלוגיים שהיו דורשים ביצוע של v.

עתהv-תהיה תלויה תלות בקרה ב v-בלבד, ו ’vתהיה תלויה בכל ’הצמתים שקדמו לה.

ייצור קוד האלגוריתם שמבטיח מיון טופולוגי של העצים ביער )תחת תלויות

שנלמדloop fusionמידע( מסובך יותר ומבוסס על ורסיה על בהרצאה הקודמת.

עתה קיבלנו את הצורה הקנונית של גרף התלויות ואנו מוכניםלייצר

את הקוד.

עמודים3בספר יש תיאור של אלגוריתם המשתרע על פני המבצע את העבודה. הוא על המיון הטופולוגי, ו-"מחליט" באיזו

הוראתIFלעטוף כל בלוק בסיסי ע"פ תלות הבקרה היחידה שיש לו )לכל

היותר(.

Documents

מבוסס על פרק 7 בספר של Allen and Kennedy