תורת הקומפילציה תרגול 12: אופטימיזציה

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

:12תרגול

אופטימיזציה

sakogan@cs)נכתב ע"י אלכס קוגן )סמסטר חורף, תשס"ח

2012עודכן: סמסטר אביב

Control Flow Graph (CFG(

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

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

)מסוף הבלוק). אם:Bk לבלוק Biקשתות: יש קשת מבלוק •

–Bi-מסתיים בקפיצה )אולי מותנית) ל Bk ,או–Bi-מסתיים בקפיצה מותנית או ללא קפיצה ו Bk

בקוד המקורי.Biמופיע אחרי

דוגמה

100: x := y + 1200: if (x > 10( goto 500300: z := 0400: goto 700500: z := x - 10600: goto 700700: y := z * x800: a := y * y

x := y + 1if (x > 10( goto 500

z := 0goto 700

z := x - 10goto 700

y := z * xa := y * y

?backpatchingאיזה מבנה בקרה יכול ליצור קוד כזה בשיטת

?CFGאיך בונים

נגדיר:•leader:כל פקודה המקיימת אחת הדרישות -

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

, 500, 300, 100בדוגמה: פקודות בכתובות •700

CFGאלגוריתם לבניית

בתכנית.leadersמצא את כל ה-1.

הינו:leader: הבלוק הבסיסי של ה-leaderעבור כל 2. הבא )לא leaderסדרת הפקודות החל ממנו )כולל) ועד ל-–

כולל). נוסף אחריו).leaderאו עד לסוף התכנית )אם אין –

הוסף קשתות בהתאם לקפיצות בסוף כל בלוק בסיסי.3.

בו כל צומת מכיל פקודה CFGלעתים נתעניין ב-•יחידה.

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

תמיד ניתן להוסיף בלוקים ריקים בהתחלה ובסוף.–

דוגמה ממבחן

) unreachable תיקרא בלתי ישיגה )uפקודה • אינה מתבצעת באף הרצה של תכנית.uאם

הציעו אלגוריתם למחיקת פקודות בלתי ישיגות •.CFGמה-

אינה נמצאת על uפתרון: נבחין שאם פקודה •, לא ייתכן CFGאף מסלול מהצומת התחילי ב- בלתי uשהיא מתבצעת בריצה כלשהי

ישיגה.

דוגמה ממבחן - המשך

אלגוריתם:•

) וסמן את DFS או CFG( BFSבצע סריקה ב-1. שבהם נתקלת בסריקה.CFGכל הצמתים ב-

כל צומת שאינו מסומן - מחק מהגרף.2.

האם הפתרון אופטימלי? כלומר, האם כל •הפקודות בלתי-ישיגות יימחקו?

הערה כללית

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

התכנית לא תשתנה.

ככלל, עדיף תכנית פחות יעילה על פני תכנית •לא נכונה.

Branch Chainingדוגמא -

הציעו אלגוריתם המבצע את האופטימיזציה •Branch Chaining:

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

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

הרעיון:•100: x:= y + z 100: x:= y + z 200: goto 300 200: goto 400300: goto 400

Branch Chaining

) מיועדת לסילוק?gotoמתי קפיצה )פקודות •חייבת להיות קפיצה לא מותנית–וגם, חייבת להיות פקודה יחידה בבלוק הבסיסי שלה–

מתחילים בלוק חדש.gotoהיא אחרונה כי תמיד אחרי • כי יש פקודה שקופצת אליה.leaderהיא •

, נציע אלגוריתם הבא:CFGבהינתן • v" שנמצאת לבד בצומת goto xמצא פקודות "1.

כלשהו. u וגם v ל-u שיש קשת מ-CFG ב-uלכל צומת 2.

מסתיים בקפיצה לא מותנית, החלף את כתובת .x לכתובת uהקפיצה בפקודה האחרונה של

מהגרף.v, מחק את vאם אין יותר קשתות נכנסות ל-3.

כל עוד יש מועמדים מתאימים.1חזור ל-4.

Branch Chaining

שאלה: אילו אופטימיזציות כדאי להריץ לפני •Branch Chaining על מנת להגדיל את

יעילותה?תשובה: אופטימיזציות שיעזרו להחליף קפיצות •

מותנות בקפיצות לא מותנות:–Copy & Constant Propagation

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

–Constant Foldingפישוט של ביטויים המורכבים מקבועים בלבד.•

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

דוגמה100: x:=1+5200: y:=x300: if (y > 0( goto 400400: goto 500

100: x:=1+5200: y:=x300: if (x > 0( goto 400400: goto 500

100: x:=6200: y:=x300: if (x > 0( goto 400400: goto 500

100: x:=6200: y:=6300: if (6 > 0( goto 400400: goto 500

100: x:=6200: y:=6300: goto 400400: goto 500

100: x:=6200: y:=6300: goto 500

copy propagation

constant folding

constantpropagation

החלפתקפיצה branch

chaining

, ניתן למחוק גם את שתי הפקודות הראשונותy וב-xואם אין יותר שימוש ב-(Dead Code Elimination(

Dead Code Elimination

בנקודה חי הוא x נאמר כי משתנה הגדרה:• שיש בו שימוש ייתכןמסויימת של תכנית אם

)קריאת ערך) לפני שכותבים אליו מחדש.?CFGכיצד זה יתורגם במונחים של –

אינו חי מייד אחרי פקודת השמה xאם משתנה •x.פקודה זו מיותרת ,… =::Dead Code Eliminationאופטימיזציית –

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

Dead Code Elimination

אחרי כל פקודת השמה צריך לזהות אילו •משתנים חיים.

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

- חישוב גלובלי Data Flow Analysisהפתרון: •שמטרתו לזהות את כל הפקודות / משתנים /

ביטויים אשר מקיימים תכונה מסויימת בנקודה מסוימת בתכנית.

–DFA.משמש לעוד אופטימיזציות רבות

DFAבעיות , כאשר כל צומת הוא בלוק בסיסיCFG: קלט•

CFG ב-B לכל צומת )out(B ו- )in(B: קבוצות פלט•–in(B(-מתייחסת לנק' שלפני הפקודה הראשונה ב - B.

–out(B(-מתייחסת לנק' שאחרי הפקודה האחרונה ב - B.

מה מכילות הקבוצות?–תלוי בבעיה - משתנים / השמות / ביטויים וכו'•

הערה: בד"כ לאופטימיזציה עצמה נצטרך רק אחת משתי •

הקבוצות, אבל בשביל החישוב צריך את שתיהן.

B

in

out

לניתוח חיּותDFAשימוש ב

בתכנית, נרצה למצוא את pמטרת החישוב: בכל נקודה •

כל המשתנים החיים בה.

)בלוק בסיסי) נגדיר את פריטי CFG ב- Bעבור כל צומת •

המידע הבאים:–in(B( כל משתני התוכנית שחיים לפני תחילת הבלוק – B.

–out(B( כל משתני התוכנית שחיים מיד לאחר הבלוק – B.

- המשךDFAבעיות

מושפעת משני in/out על Bההשפעה של •

מרכיבים:–gen(B(-דברים שנוצרים ב - B.

–kill(B(-דברים ש - B."הורג"

במקרה של ניתוח חיּות נגדיר:• gen(B( = { x | B משתנה שנעשה בו שימוש ב x

{ ואין כתיבה לתוכו לפני השימוש

kill(B( = { x | B הוא משתנה אשר מבוצעת אליו כתיבת ערך בx }

- המשךDFAבעיות

צורת החישוב - אחת מהשתיים:•סריקה קדמית - המידע "זורם" קדימה–

)בהרצאה).reaching definitionsלמשל, בחישוב של •דוגמאות נוספות בתרגול הבא.•

סריקה אחורית - המידע "זורם" אחורה–למשל, בניתוח חיּות – שימוש במשתנה יגרום להגדרתו •

כחי מיד לפני השימוש.

לניתוח חיּות - DFAשימוש ב המשך

gen(B( = { x | B משתנה שנעשה בו שימוש ב x

{ ואין כתיבה לתוכו לפני השימוש

kill(B( = { x | B הוא משתנה אשר מבוצעת אליו כתיבת ערך בx }

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

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

in(B( = gen(B( [ out(B( \ kill(B( ]

out(B( = in(D( (B,D( CFG

לניתוח חיּות - DFAשימוש ב המשך

מבוצע תמיד בצורה )In(B(, Out(Bאתחול הפריטים •

שמרנית:

במקרה שלנו, במהלך הסריקה האחורית פריטים –

.outמתווספים לקבוצה

.out(Bfin( = Ø, נאתחל : Bfinלכן עבור הבלוק הסופי –

בסוף התוכנית בוודאי אף משתנה אינו חי.•

out(B( = in(D( (B,D( CFG

print(x(;

לניתוח חיּות - דוגמאDFAשימוש ב in(B( = gen(B( [ out(B( \ kill(B( ]

out(B( = in(D( (B,D( CFG

x:=z;print(x(;goto 300;

print(y(;goto 300;

print(z(;z:=12;y:=4;z:=16;if y>0 goto 100;

out={ }

in={ x }out={ x }

in={ x , y }

out={ x }

in={ z } out={ x, y, z }

in={ x, z }

אתחולהערה: בדוגמאות מסובכות יותר

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

לניתוח חיּותDFAשימוש ב

יכיל את קבוצת )B, out(Bהתוצאה: לכל בלוק •המשתנים החיים ביציאה מהבלוק.

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

היתרון שהושג: • CFG ב כל הבלוקיםקיבלנו את המשתנים החיים עבור –

בבת אחת..DFAזהו היתרון ב –

in(B( = gen(B( [ out(B( \ kill(B( ]

out(B( = in(D( (B,D( CFG

סיכום – מה ראינו:

:CFGדוגמאות לאופטימיזציות כלליות על ה •מחיקת פקודות לא ישיגות.–

–Branch Chaining.

:DFAדוגמאות לאופטימיזציות בשיטת •–Dead Code Elimination.

.DFAבתרגול הבא: עוד •