1. מערכות הפעלה ( אביב 2008) חגית עטיה © 1 טיפול בקיפאון  בעיית הקיפאון  הימנעות מקיפאון  זיהוי קיפאון באמצעות מציאת מעגלים  אלגוריתם הבנקאי להתחמקות מקיפאון

2. מערכות הפעלה ( אביב 2008) חגית עטיה ©2 דוגמא : הפילוסופים הסועדים  כל פילוסוף מעביר את חייו ב - חשיבה (thinking) ניסיון להשיג מזלגות (hungry) אוכל (eating)

3. מערכות הפעלה ( אביב 2008) חגית עטיה ©3 פילוסופים סועדים : עם סמפורים ריצה פשוטה ? פיתרון פשוט סמפור fork[i] לכל מזלג wait(fork[i]) wait(fork[i+1]) eat signal(fork[i]) signal(fork[i+1]) בביצוע מסונכרן כל פילוסוף משתלט כל המזלג שמימינו ואז ממתין למזלג שמשמאלו  קיפאון 5 2 1 3 4 1 2 3 4 5

4. מערכות הפעלה ( אביב 2008) חגית עטיה ©4 גרף בקשות - הקצאות גרף מכוון ( דו - צדדי ) המתאר את מצב המערכת בזמן כלשהו עיגול לכל תהליך מלבן עם n נקודות למשאב עם n עותקים קשת מתהליך למשאב  התהליך ממתין למשאב קשת מעותק של משאב לתהליך  עותק של המשאב הוקצה לתהליך

5. מערכות הפעלה ( אביב 2008) חגית עטיה ©5 גרף בקשות - הקצאות : דוגמא  P1 מחזיק עותק של R2 ומחכה ל -R1  P2 מחזיק עותקים של R1 ו -R2 ומחכה ל -R3  P3 מחזיק עותק של R3 P1P1P2P2P3P3 R1R1 R2R2 R3R3

6. מערכות הפעלה ( אביב 2008) חגית עטיה ©6 עותק יחיד מכל משאב ניתן לפשט את גרף בקשות - הקצאות P1P1 P2P2P3P3 R1R1R2R2R3R3

7. מערכות הפעלה ( אביב 2008) חגית עטיה ©7 גרף לבעיית הפילוסופים הסועדים P5P5 P4P1P1 P3P3P2

8. מערכות הפעלה ( אביב 2008) חגית עטיה ©8 קיפאון קבוצת תהליכים / חוטים שבה כל אחד ממתין למשאב המוחזק על - ידי מישהו אחר בקבוצה. מתקיימים התנאים הבאים : 1. יש מניעה הדדית משאבים שרק תהליך אחד יכול לעשות שימוש בהם בו - זמנית  כמה עותקים של אותו משאב נחשבים למשאבים נפרדים משאבים שאין צורך במניעה הדדית עבורם אינם יכולים לגרום לקפאון ( למשל, read only file)

9. מערכות הפעלה ( אביב 2008) חגית עטיה ©9 קיפאון קבוצת תהליכים / חוטים שבה כל אחד ממתין למשאב המוחזק על - ידי מישהו אחר בקבוצה. מתקיימים התנאים הבאים : 1. יש מניעה הדדית 2. החזק והמתן תהליך מחזיק משאב ומחכה למשאב אחר שבשימוש אצל תהליך אחר

10. מערכות הפעלה ( אביב 2008) חגית עטיה ©10 קיפאון קבוצת תהליכים / חוטים שבה כל אחד ממתין למשאב המוחזק על - ידי מישהו אחר בקבוצה. מתקיימים התנאים הבאים : 1. יש מניעה הדדית 2. החזק והמתן 3. לא ניתן להפקיע משאבים

11. מערכות הפעלה ( אביב 2008) חגית עטיה ©11 קיפאון קבוצת תהליכים / חוטים שבה כל אחד ממתין למשאב המוחזק על - ידי מישהו אחר בקבוצה. מתקיימים התנאים הבאים : 1. יש מניעה הדדית 2. החזק והמתן 3. לא ניתן להפקיע משאבים 4. המתנה מעגלית... תהליכים P 0,P 1, …,P n-1 P i מחכה למשאב המוחזק ע " י P (i+1) mod n

12. מערכות הפעלה ( אביב 2008) חגית עטיה ©12 דרכי התמודדות עם הקיפאון  מניעה (prevention), על - ידי מדיניות שתימנע קיפאון מניעת המתנה מעגלית לחכות לכל המשאבים ביחד  פקודת WaitForMultipleObjects ב -Windows NT  מקצה את כל המשאבים בבת - אחת, אם כולם פנויים.  גילוי קפאון (detection)  היחלצות מקפאון (recovery)  התחמקות מקפאון (aviodance) שימוש בידע מוקדם על צרכיו של כל תהליך  רוב מערכות ההפעלה לא דואגות למנוע קיפאון ( התעלמות ) פעולה כבדה. האחריות נשארת אצל המתכנת. הריגת תהליך מאפשרת להיחלץ מקיפאון.  אך עלולה להשאיר את המערכת במצב לא תקין.

13. מערכות הפעלה ( אביב 2008) חגית עטיה ©13 מניעת המתנה מעגלית תהליכים P 0,P 1, …,P n-1 P i מחכה למשאב המוחזק ע " י P (i+1) mod n  נקבע סדר מלא בין המשאבים F(tape)=1, F(printer)=2, F(scanner)=3, …  תהליכים יבקשו משאבים רק בסדר עולה תהליך שמחזיק את ה -printer לא יוכל לבקש את ה -tape או... תהליך שמבקש משאב מסדר נמוך חייב לשחרר קודם משאבים מסדר גבוה

14. מערכות הפעלה ( אביב 2008) חגית עטיה ©14 מניעת המתנה מעגלית בבעיית הפילוסופים הסועדים בקשת מזלגות בסדר עולה... if ( i = 5) then wait(fork[1]) wait(fork[5]) else wait(fork[i]) wait(fork[i+1]) eat signal(fork[i+1]) signal(fork[i]) 5 2 1 3 4 1 2 3 4 5

15. מערכות הפעלה ( אביב 2008) חגית עטיה ©15 גילוי קיפאון עם עותק יחיד קיפאון קורה כשיש מעגל מכוון בגרף בקשות - הקצאות נובע מתנאי " החזק והמתן " ו -" המתנה מעגלית " גילוי קיפאון על - ידי זיהוי מעגל  אלגוריתם ידוע למציאת מעגל בגרף מכוון, המבוסס על מיון טופולוגי  סיבוכיות O(m), כאשר m מספר הקשתות P1P1 P2P2 P3P3 P4P4

16. מערכות הפעלה ( אביב 2008) חגית עטיה ©16 מספר עותקים מכל משאב לא חייב להיות קיפאון כאשר יש מעגל מכוון בגרף בקשות - הקצאות עם כמה עותקים מכל משאב יכול להיות מעגל אבל לא קיפאון. גם עבור מערכת עם כמה עותקים מכל משאב קיים אלג ' לגילוי קפאון P1P1P2P2P3P3 R1R1 R2R2

17. מערכות הפעלה ( אביב 2008) חגית עטיה ©17 היחלצות מקיפאון Recovery  ביטול כל התהליכים המצויים במצב קיפאון.  ביטול תהליכים אחד - אחד עד להיחלצות.  הפקעת משאבים. מציאת קבוצה אופטימאלית ( של תהליכים או משאבים ) לביטול היא בעיה קשה מאוד.

18. מערכות הפעלה ( אביב 2008) חגית עטיה ©18 התחמקות מקיפאון Avoidance  דואגים להשאיר את המערכת במצב בטוח תהליכים מצהירים על כוונתם לבקש משאבים אסור לתהליך לבקש משאב שלא הצהיר עליו מצב הוא בטוח אם קיימת סדרת הקצאות לכל המשאבים שהוצהרו, מבלי להיכנס לקיפאון.  אם היענות לבקשה עלולה להכניס את המערכת למצב לא בטוח, אז הבקשה נידחת.  אלגוריתם שמרני הנחות מחמירות לגבי דרישות התהליכים

19. מערכות הפעלה ( אביב 2008) חגית עטיה ©19 התחמקות מקיפאון : דוגמא  P 1 ו -P 2 מצהירים על כוונה לבקש את המדפסת והדיסק  P 1 מבקש את המדפסת הבקשה נענית  P 2 מבקש את הדיסק הבקשה נדחית... אם בהמשך P 2 יבקש את המדפסת ו - P 1 את הדיסק, אזי יהיה קיפאון  בבעית הפילוסופים הסועדים - שמים את המזלגות במרכז השולחן לוקח מזלג, אלא אם כן : זה המזלג האחרון ולאחד הממתינים עדיין חסר מזלג אחד ובאופן כללי, אלגוריתם הבנקאי...

20. מערכות הפעלה ( אביב 2008) חגית עטיה ©20 התחמקות : אלגוריתם הבנקאי  כאשר תהליך מגיע למערכת, מצהיר כמה עותקים ירצה ( לכל היותר ) מכל משאב.  אם תהליך מבקש עותק ממשאב, הבקשה תיענה רק אם יש מספיק עותקים פנויים. לא חורג מההצהרה ההתחלתית. ההקצאה משאירה את המערכת במצב בטוח : תוכל לספק את הבקשות של תהליכים שכבר נמצאים במערכת עד למקסימום המוצהר לכל סוג משאב

21. מערכות הפעלה ( אביב 2008) חגית עטיה ©21 אלגוריתם הבנקאי : משתנים m מספר המשאבים, n מספר התהליכים Available :vector of size m the number of available copies of each resource type Max : n x m matrix the maximum demand of each process for each resource type Allocation : n x m matrix number of currently allocated copies of each resouce type to each process Need: n x m matrix the remaining copies that might be needed by each process Need = Max - Allocation Work and Finish : (temporary) vectors of size n

22. מערכות הפעלה ( אביב 2008) חגית עטיה ©22 אלגוריתם הבנקאי : פסאודו - קוד Initialize Work := Available; Finish := [false,…,false]; While (Finish[i] = false & Need[i] ≤ Work), for some i Work := Work + Allocation[i]; Finish[i] := true; End while The system is safe if and only if Finish[i] = true, for all i לפני אישור בקשה למשאב : ודא שהמערכת נשארת במצב בטוח אם הבקשה מתקבלת ניתן יהיה להיענות לדרישותיו בעתיד שחרר את המשאבים שמחזיק כעת

23. מערכות הפעלה ( אביב 2008) חגית עטיה ©23 אלגוריתם הבנקאי – דוגמא  האם המצב הבא של המערכת הוא " בטוח “?  ניתן לצמצם את P2 ABC P1010 P2210 P3103 Total 323 ABC 311 214 323 ABC 034 ABC 301 004 220 AllocationMaxAvailableNeed 034 Work F F F Finish

24. מערכות הפעלה ( אביב 2008) חגית עטיה ©24 אלגוריתם הבנקאי – דוגמא  האם המצב הבא של המערכת הוא " בטוח “?  ניתן לצמצם את P2  עכשיו, ניתן לצמצם את P3 ABC P1010 P2210 P3103 Total 323 ABC 311 214 323 ABC 034 ABC 301 004 220 AllocationMaxAvailableNeed 244 Work F T F Finish

25. מערכות הפעלה ( אביב 2008) חגית עטיה ©25 אלגוריתם הבנקאי – דוגמא  האם המצב הבא של המערכת הוא " בטוח “?  ניתן לצמצם את P2  עכשיו, ניתן לצמצם את P3  עכשיו, ניתן לצמצם את P1 ABC P1010 P2210 P3103 Total 323 ABC 311 214 323 ABC 034 ABC 301 004 220 AllocationMaxAvailableNeed 347 Work F T T Finish

26. מערכות הפעלה ( אביב 2008) חגית עטיה ©26 אלגוריתם הבנקאי – דוגמא  האם המצב הבא של המערכת הוא " בטוח “?  ניתן לצמצם את P2  עכשיו, ניתן לצמצם את P3  עכשיו, ניתן לצמצם את P1 ABC P1010 P2210 P3103 Total 323 ABC 311 214 323 ABC 034 ABC 301 004 220 AllocationMaxAvailableNeed 357 Work T T T Finish

27. מערכות הפעלה ( אביב 2008) חגית עטיה ©27 Watchdog  מכניזם פרקטי, הממומש בחומרה מונה חומרה מיוחד שסופר אחורה כשהמונה מתאפס, מבצע reset להתקן ( מכבה ומדליק ההתקן מחדש ) החוטים מדי פעם ומעדכנים את המונה לערך גבוה התחלתי אם יש קפאון – החוטים לא יוכלו לעדכן את המונה ויהיה reset  מחייב שיתוף פעולה של החוטים העובדים  אם רוצים לוודא שאף חוט לא מעורב בשום קפאון, צריך להשתמש ברגיסטר נפרד לכל חוט

28. מערכות הפעלה ( אביב 2008) חגית עטיה ©28 מימוש Watchdog בתוכנה שיטה 1: כמו בחומרה, רק שחוט מיוחד בודק את המונה ואם מגלה שלא עודכן הרבה זמן, הורג את התהליך מחייב שיתוף פעולה של כל החוטים העובדים שיטה 2: חוט מיוחד A מנסה, אחת לכמה זמן, לתפוס את כל המשאבים במערכת לפי סדר נתון ואז לשחרר אחת לכמה זמן כותב את הזמן הנוכחי למונה חוט אחר B בודק את המונה, ואם מגלה שלא עודכן הרבה זמן, מניח שחוט A בקיפאון, הורג את התהליך ( וכל החוטים ) מחייב ידע של חוט A לגבי כל משאבי התוכנית, אבל לא מחייב שיתוף פעולה של כל החוטים העובדים השיטה פוגעת קצת בביצועי התוכנית (intrusive) כי A תופס משאבים