1. מרץ 2002אלן אזאגורי ©1 סנכרון תהליכים וחוטים Process and Thread Synchronization חלק ראשון

2. מרץ 2002 אלן אזאגורי ©2עמוד נושאים מוטיבציה הגדרות פיתרון כללי מנעולים ותמיכתם בחומרה

3. מרץ 2002 אלן אזאגורי ©3עמוד מוטיבציה הנחות –קריאה/כתיבה של משתנה היא אטומית –פעולה אריתמטית על המשתנה אינה אטומית מי זוכה?לפעמים A ולפעמים B האם תמיד יש זוכה?לא האם שניהם עשויים לזכות?כן, כאשר הפקודה kill אסינכרונית int c = 0; // Global variable Thread A: while (c < 10) c = c + 1; kill B; print “A wins”; Thread B: while (c > -10) c = c - 1; kill A; print “B wins”;

4. מרץ 2002 אלן אזאגורי ©4עמוד בעית יצרן/צרכן הגדרות –שני חוטים (יצרן וצרכן) רצים באותו מרחב זיכרון –מערך חסום (מעגלי) מכיל את העצמים המיוצרים –ליצרן מצביע (pp) למקום הפנוי הבא במערך –לצרכן מצביע (cp) למקום הבא המכיל את העצם המוכן הבא –מספר העצמים המוכנים הוא c 0n-1 cppp c

5. מרץ 2002 אלן אזאגורי ©5עמוד בעית יצרן/צרכן (המשך) בעיות –עדכון בו זמנית (לא מוגן) של c –לכן ערכו של c יכול להיות גבוה (נמוך) מן הערך הנכון int c = 0; // Global variable Producer: repeat while (c>=n) nop; buf[pp] = new item; pp = (pp+1) mod n; c = c + 1; until false; Consumer: repeat while (c<1) nop; consume buf[cp]; cp = (cp+1) mod n; c = c - 1; until false;

6. מרץ 2002 אלן אזאגורי ©6עמוד בעית החלב את/ה: מסתכל במקרר הולך לסופר קונה חלב חוזר הביתה מכניס חלב למקרר שותף: מסתכל במקרר הולך לסופר קונה חלב חוזר הביתה מכניס חלב למקרר בעיה: יותר מדי חלב!

7. מרץ 2002 אלן אזאגורי ©7עמוד בעית החלב פיתרון 1  פיתרון: להשאיר פיתקה בעיה: כל אחד קפץ לחדר לכתוב פתק ולא שם לב לכך שהשני השאיר פתק מסתכל במקרר אם אין חלב אם אין פתקה השאר פתקה קנה חלב הורד פתקה

8. מרץ 2002 אלן אזאגורי ©8עמוד בעית החלב פיתרון 2  פיתרון: לאחר השארת הפיתקה, בודקים האם גם השותף השאיר פיתקה בעיה: קיים תסריט בו אף אחד לא יקנה חלב! Thread A: leave note A if (no note B) then if (no milk) then buy milk remove note A Thread B: leave note B if (no note A) then if (no milk) then buy milk remove note B

9. מרץ 2002 אלן אזאגורי ©9עמוד בעית החלב פיתרון 3  פיתרון: שבירת הסימטריה במקרה של "תחרות" (שניהם משאירים פתק בו זמנית), A יקנה חלב! חסרונות –רק לשני תהליכים –לא הוגן Thread A: leave note A X:while (note B) do nop if (no milk) then buy milk remove note A Thread B: leave note B Y:if (no note A) then if (no milk) then buy milk remove note B

10. מרץ 2002 אלן אזאגורי ©10עמוד הגדרות מרוץ (Race Condition) –בד"כ התכנית (המקבילית) עובדת נכון –קיים תסריט בו התכנית לא עובדת נכון לרוב בגלל שבירה איזושהי הנחת אטומיות שאינה מתקיימת בדוגמת בעית החלב –השארת פיתקה –בדיקה האם השותף השאיר פיתקה

11. מרץ 2002 אלן אזאגורי ©11עמוד הגדרות (המשך) מניעה הדדית – mutual exclusion –מנגנונים המבטיחים שרק חוט אחד מבצע סדרת פעולות מסוימות בזמן נתון אטומיות ביחס לחוטים אחרים קטע קריטי – critical section –קטע קוד שרק חוט אחד מבצע בזמן נתון לא קריטי יציאה קריטי

12. מרץ 2002 אלן אזאגורי ©12עמוד הגדרות (המשך) אטומיות – Atomicity –בביצוע סדרת פקודות ע"י חוט אחד,חוטים אחרים אינם יכולים לראות תוצאות חלקיות - סדרת הפקודות נראית כמו פעולה אחת שאיננה ניתנת לחלוקה ("פעולה אטומית") –ניתן להשיג בעזרת מנגנון של מניעה הדדית דוגמא –העברת כספים מחשבון לחשבון –לא נאפשר לחוטים אחרים לראות מצב בו הכסף נמשך מחשבון א' אך לא הגיע לחשבון ב' Thread A: account1:= account1 – sum; account2:= account2 + sum; Thread B: if (account1+account2<min) then …

13. מרץ 2002 אלן אזאגורי ©13עמוד תכונות של פתרון לבעיית הקטע הקריטי חובה –רק חוט אחד בקטע קריטי (מניעה הדדית) –אם יש בקשות להיכנס לקטע קריטי, אזי חוט אחד ייכנס (אין קיפאון – deadlock) רצוי –חוט המבקש להיכנס לקטע קריטי בסופו של דבר יצליח (אין הרעבה – starvation) –עבור כל זוג חוטים, אם הם יתחרו n פעמים להיכנס לקטע קריטי, הם יזכו מספר דומה של פעמים (fairness)

14. מרץ 2002 אלן אזאגורי ©14עמוד Thread i: initially number[i]=0 number[i]=max{number[1],…,number[n]}+1; for all j  i do wait until number[j]=0 or (number[j]>number[i]) critical section number[i]=0 // Exit critical section אלגוריתם קופת חולים (bakery) לפיתרון בעית הקטע הקריטי (1) שימוש במספרים –חוט נכנס לוקח מספר –חוט שמספרו הקטן ביותר נכנס לקטע הקריטי ניסיון ראשון

15. מרץ 2002 אלן אזאגורי ©15עמוד אלגוריתם קופת חולים (bakery) לפיתרון בעית מניעה הדדית (1) בעיה –חוט i ו-j קוראים את המערך בו זמנית –שניהם "בוחרים" את אותו מספר קיפאון!

16. מרץ 2002 אלן אזאגורי ©16עמוד אלגוריתם קופת חולים (bakery) לפיתרון בעית מניעה הדדית (2) נשתמש במס' הזהות של התהליך כדי לשבור סימטריה Thread i: initially number[i]=0 number[i]=max{number[1],…,number[n]}+1; for all j  i do wait until number[j]=0 or ()number[j],j)>(number[i],i)) // lexicographical // comparison critical section number[i]=0 // Exit critical section

17. מרץ 2002 אלן אזאגורי ©17עמוד אלגוריתם קופת חולים (bakery) לפיתרון בעית מניעה הדדית (2) בעיה –חוט i ו-j קוראים את המערך בו זמנית (i>j) –חוט i כותב את המספר, בודק את ערכו כנגד number ונכנס לקטע הקריטי (number[j] עדיין 0!) –חוט j ממשיך וגם הוא נכנס לקטע הקריטי! אין מניעה הדדית! –התהליך עם מספר זהות גבוה (i) מזדרז להיכנס לקטע הקריטי לפני ש-j הספיק לכתוב את number[j]

18. מרץ 2002 אלן אזאגורי ©18עמוד אלגוריתם קופת חולים (bakery) לפיתרון בעית מניעה הדדית (3) נוודא שאין חוטים באמצע בחירת מספר לפני ביצוע ההשוואות Thread i: initially number[i]=0 choosing[i]=true number[i]=max{number[1],…,number[n]}+1; choosing[i]=false for all j  i do wait until choosing[j]=false for all j  i do wait until number[j]=0 or ()number[j],j)>(number[i],i)) critical section number[i]=0 // Exit critical section

19. מרץ 2002 אלן אזאגורי ©19עמוד אלגוריתם קופת חולים (bakery) לפיתרון בעית מניעה הדדית (3) אין הרעבה (ולכן אין קיפאון) והפתרון הוגן –הוכחה בתרגול פיתרון מסורבל –הרבה פעולות, הרבה משתנים הפיתרון לא יעבוד בסביבות מרובות מעבדים –Out of order execution קיימים אלגוריתמים אחרים בהמשך נלמד על פתרונות אחרים

20. מרץ 2002 אלן אזאגורי ©20עמוד מנעולים (locks) מבטיחים גישה בלעדית למידע באמצעות שתי פונקציות –lock_acquire(lock) – פעולה חוסמת (אם המנעול תפוס) –lock_release (lock) – משחרר את המנעול

21. מרץ 2002 אלן אזאגורי ©21עמוד מנעולים (locks) – דוגמא דוגמא – בעית יצרן/צרכן האם מספיק להגן רק על שינוי c ב-?while –מה קורה במקרה של יותר מצרכן אחד? Producer: repeat while (c>n) nop; buf[pp] = new item; pp = (pp+1) mod n; lock_acquire(c_lock) c = c + 1; lock_release(c_lock) until false; Consumer: repeat while (c<1) nop; consume buf[cp]; cp = (cp+1) mod n; lock_acquire(c_lock) c = c - 1; lock_release(c_lock) until false;

22. מרץ 2002 אלן אזאגורי ©22עמוד lock_release(L): disableInterrupts() L := FREE enableInterrupts() מימוש מנעולים אטומיות –מובטחת ע"י חסימת פסיקות Busy wait –ניתן למנוע ע"י ניהול תור החוטים המחכים למה חשוב לאפשר פסיקות בתוך הלולאה? ומה קורה במערכות מרובות מעבדים? –חסימת פסיקות אינה מבטיחה אטומיות... –דורש תמיכה מהחומרה לפקודות "חזקות" יותר lock_acquire(L): disableInterrupts() while L  FREE do enableInterrupts() disableInterrupts() L := BUSY enableInterrupts()

23. מרץ 2002 אלן אזאגורי ©23עמוד מימוש מנעולים תמיכת חומרה test&set test&set(boolvar) –כתוב ערך true והחזר ערך קודם –L = false – מנעול פנוי –L = true – מנעול תפוס lock_release(L): L := false lock_acquire(L): while test&set(L) do nop

24. מרץ 2002 אלן אזאגורי ©24עמוד מימוש מנעולים תמיכת חומרה compare&swap compare&swap(mem, r1, r2) –אם בזיכרון (mem) ערך זהה לרגיסטר r1, כתוב ערך r2 והחזר הצלחה –אחרת החזר ערך כישלון ניתן לממש מונה אטומי lock_acquire(L): r1 = false r2 = true while not compare&swap(L, r1, r2)) do nop lock_release(L): L := false

25. מרץ 2002 אלן אזאגורי ©25עמוד מימוש מנעולים מודרני load-linked & store conditional ממומש ברוב הארכיטקטורות החדישות –Compaq’s Alpha, IBM’s PowerPC, MIPS4000 צמד פקודות –LL(mem) – קרא את ערך הזיכרון –SC(mem, val) – אם לא היתה כתיבה ל-mem מאז ה- LL(mem) האחרון, כתוב ערך val והחזר הצלחה (אחרת כשלון) יותר כח מאשר ל-compare&swap –ניתן לזהות כתיבות עוקבות של אותו ערך

26. מרץ 2002 אלן אזאגורי ©26עמוד מימוש מנעולים load-linked & store conditional lock_acquire(L): success = false repeat LL(L) if not L then success = SC(L, true) until success lock_release(L): L := false

27. מרץ 2002 אלן אזאגורי ©27עמוד load-linked & store conditional מתי חשוב לזהות כתיבות עוקבות של אותו ערך? –ברשימה מקושרת, הוצאת האיבר הראשון remove_first(head): element = NULL A:if head  NULL then LL(head) next_head = head->next element = head if not SC(head, next_head) goto A; return element