חסימה הדדית
שבוע #3
פרקDeadlock :
חסימות הדדיות
קורס מערכות הפעלה ב'
מכללת הדסה /מכללה חרדית
צבי מלמד
Tzvi.Melamed@gmail.com
הרצאות הקורס מבוססות במידה רבה ביותר על ההרצאות של ד"ר יורם ביברמן
© כל הזכויות שמורות לד"ר יורם ביברמן ולצבי מלמד
©צבי מלמד
1
המכיניות
האילו -
למה נטשו
אותן?
©צבי מלמד
2
חסימה הדדית – deadlockזה לא רק קריקטורה,
וגם לא רק עניין לפילוסופים...
זאת תופעה יומיומית.
נפוצה ,שיכולה לקרות בכל רגע,
אלא אם כן ,דואגים שהיא לא תקרה
©צבי מלמד
3
©צבי מלמד
4
הצעת חוק שהועברה –איפה?
• "כששתי רכבות מגיעות להצטלבות דרכים ,הן תעצורנה לפני הצומת
עצירה מוחלטת .אף אחת מהן לא תתחיל לנסוע לפני שהרכבת השניה
עברה במלואה את הצומת"
• when two trains approach each other at a crossing,
both shall come to a full stop and neither shall start up
”again until the other has gone
• האם זאת המצאה של חכמי חלם או חוק אמיתי שתוקן במקום
נידח?
• על פי ספר הלימוד – – Silberschatzזהו חוק שחוקק במדינה
Kensasבארה"ב בתחילת המאה ה.20-
©צבי מלמד
5
חסימה הדדית deadlock
• חסימה הדדית היא מצב שבו קיימת קבוצה של nתהליכים ,וכל
תהליך בקבוצה מחכה )ממתין ,חסום (...לאירוע שיכול להגרם רק
על ידי מי מחברי הקבוצה
• האירוע – משאב שתהליך כלשהו יכול לייצר אותו או לשחרר אותו
©צבי מלמד
6
מודל המערכת The System model
נעסוק במערכת שמתאימה למודל שמתואר להלן:
• המערכת כוללת מספר סופי של משאבים ,עליהם מתחרים n
תהליכים.
• המשאבים הם מסוגים\טיפוסים שונים.
• מכל סוג משאב קיימות אחד או יותר יחידות זהות זו לזו
– דוגמה למשאבים :שטח זיכרון ,מחזורי מעבד ,קובץ ,ציוד קו"פ
כזה או אחר ,כדוגמת מדפסת ,רמקול.
• כאשר תהליך מבקש משאב מטיפוס כלשהו ,ניתן להעמיד לרשותו
איזשהו משאב מאותו טיפוס )אחרת המשאבים לא נחשבים מאותו
טיפוס(.
©צבי מלמד
7
מודל המערכת The System model
• השימוש במשאבים מתנהל בסדר הבא:
.1בקשה : Requestהתהליך חייב לבקש את המשאב ,ועליו להמתין
)חסום( כל עוד הבקשה לא נענתה
.2שימוש : Useהתהליך משתמש במשאב
.3שחרור :Releaseהתהליך משחרר את המשאב
• תהליך עשוי לבקש כמות כלשהי של פריטים ממשאב מסוג כלשהו
– אם הוא מבקש שבע מדפסות ,ולמערכת מחוברות רק שלוש ,אזי
בקשתו לא תענה.
• בקשה ושחרור של משאב נעשית באמצעות קריאת מערכת )לדוגמה:
openאו (close
• כאשר המערכת מקצה לתהליך את המשאב הוא מוער ורשאי להשתמש
בו
©צבי מלמד
8
מודל המערכת The System model
•
המערכת עוקבת אחרי:
.1המשאבים הפנויים
.2עבור כל משאב מוקצה :מי מחזיק בו.
.3קבוצת התהליכים שממתינים על כל משאב מוקצה
©צבי מלמד
9
איפיון חסימה הדדית
•
לאחר שהצגנו את מודל-המערכת ,נעסוק בנושאים הבאים:
.1איפיון החסימה ההדדית
.1תנאים הכרחיים לקיום deadlock
.2גרף הקצאת משאבים
.2שיטות למניעה של deadlock
– אם נדאג שלא יתקיים אחד מהתנאים ההכרחיים – נוכל למנוע את
הdeadlock-
.3שיטות המנעות avoidance
– דרישת מידע נוסף – הסדר והכמות של השימוש והשחרור של
המשאבים על ידי התהליכים
– בנוסף :ידע שקיים במערכת על כמויות של המשאבים ופניותם
)) (availabilityאו זמינותם(
– מאפשרים להפעיל אלגורתימים שימנעו deadlockבזמן )כחלק מ(-
ההחלטה האם להענות לבקשת משאב
.4איתור חסימה הדדית deadlock detection
©צבי מלמד
10
תנאים הכרחיים לdeadlock -
.1בלבדיות :Mutual Exclusionצריך שיהיה משאב שלא ניתן
להקצאה במקביל לכמה תהליכים
–
רק כך תיווצר המתנה ,בפרט :המתנה מעגלית
.2החזקה והמתנה ) :(hold and waitצריך שתהליך יאחז במשאב x
וימתין על משאב yהמוחזק ע"י תהליך אחר
–
שוב :רק כך יוכל להיווצר מעגל של ממתינים
.3אי-חטיפה ) :(no preemptionלא ניתן לחטוף\לגזול משאב
מתהליך המחזיק בו — על המחזיק לשחררו ביוזמת
–
אחרת לא ייווצר מעגל של המתנה :א' במקום להמתין ל -ב' -
יחטוף לו
©צבי מלמד
11
תנאים הכרחיים לdeadlock -
.4ההמתנה צריכה להיות מעגלית ):(circular wait
–
צריך שתהיה קבוצה } {P0,…,Pnשל תהליכים כך שכל Pi
ממתין ל Pi+1 -עבור ,i=0,…,n-1ו Pn -ממתין ל. P0 -
–
אחרת Pn ,יוכל לסיים ,עתה Pn-1יוכל לקבל את המשאב
שלו הוא ממתין ולסיים ,וכך הלאה.
©צבי מלמד
12
גרף הקצאת-המשאבים Resource-Allocation Graph
•
•
•
•
•
•
גרף הקצאת-המשאבים משמש לתיאור מצב המערכת
מצב המערכת :תהליכים ,משאבים ,בקשות תלויות, ,הקצאות
בהינתן הגרף ,ניתן לזהות האם המערכת נמצאת בdeadlock-
הגרף מכיל )כמובן (...קשתות וצמתים
צמתים משני סוגים:
– צומת תהליך
– צומת משאב
קשתות משני סוגים:
– בקשה להקצאת משאב
– הקצאת משאב
©צבי מלמד
13
גרף הקצאת-המשאבים Resource-Allocation Graph
קודקודי הגרף:
• } {P1, … , Pnהתהליכים הפעילים במערכת )צומת
עיגול(.
• } {R1, … , Rmסוגי המשאבים הקיימים במערכת.
– כל סוג משאב יופיע כצומת בצורת מלבן ,המכיל
נקודות כמספר הפריטים הקיימים מסוג משאב זה.
קשתות הגרף:
• קשת בקשה מ Pi -אל :Rjמייצגת תהליך Piמבקש
וממתין לפריט בודד מהמשאב Rj
• קשת הקצאה :כאשר תהליך Piמקבל את הפריט ,Rj
קשת הבקשה מתהפכת להיות קשת הקצאה )של הפריט
הבודד( וכיוונה מתהפך :מ Rj -אל .Pi
• כאשר תהליך משחרר את המשאב שהוקצה לו ,הקשת
מוסרת מהגרף
©צבי מלמד
14
גרף הקצאת-המשאבים Resource-Allocation Graph
• האם המערכת מצויה ב?deadlock-
• נניח ש P3 -מבקש פריט מ .R2 -האם
המערכת תהיה ?deadlock
• נניח ש R2 -היה מכיל רק פריט יחיד ,האם
כאשר P3היה מבקש פריט מ R2 -היינו
נקלעים ל?deadlock-
©צבי מלמד
15
Resource-Allocation Graph המשאבים-גרף הקצאת
.R2 - מבקש פריט מP3 •
!deadlock-• המערכת ב
:• קיימים בגרף המעגלים
• P1R1P2R3P3R2P1
• P2R3P3R2P2
16
©צבי מלמד
גרף הקצאת-המשאבים Resource-Allocation Graph
• דוגמא נוספת :קיים מעגל – אבל..
• המערכת איננה בdeadlock-
• קיים בגרף המעגלים:
• P1R1P3R2P1
©צבי מלמד
17
גרף הקצאת-המשאבים -אובזרבציות
•
תנאי הכרחי ל deadlock-הוא קיומו של
מעגל בגרף.
•
אם )ורק אם( במערכת קיים משאב יחיד
מכל סוג ,אזי קיומו של מעגל הוא גם
תנאי מספיק לכך שהמערכת מצויה ב-
; deadlockכל התהליכים שמשתתפים
במעגל הם אלה שחסומים הדדית.
©צבי מלמד
18
שיטות לטיפול בdeadlock -
.1
פיתוח פרוטוקולים שימנעו מראש מהמערכת )מהתהליכים במערכת( להיכנס
למצב של חסימה-הדדית
–
פרוטוקולים =רצף של פעולות וכללים שעל-פיהם התהליכים מתנהגים
.2
התהליכים רצים באופן חופשי .מערכת ההפעלה עוקבת אחר "המצב" .כאשר
מתברר בדיעבד שהמערכת נקלעה ל - deadlock-מתאוששים מהמצב ע"י
העפת חלק מהתהליכים שמעורבים בחסימה
.3
התעלמות מהבעיה
–
ההנחה היא שהמשתמש או ה) system administrator-המפעיל או "איש
ה (system-ישים לב שתהליך תקוע
–
אזי – מעיפים )ידנית( את התהליכים עד שנפתר הdeadlock-
–
כך נוהגות מערכות ההפעלה המסחריות כיום
©צבי מלמד
19
מניעת חסימה הדדית Deadlock Prevention
• מנינו ארבעה תנאים הכרחיים לחסימה הדדית.
• אם נצליח למנוע התרחשות של לפחות אחד מהם ,מובטח
שהמערכת לא תק ַ לע לחסימה הדדית
• נבחן את התנאים ונראה האם וכיצד ניתן למנוע מהם להתממש
©צבי מלמד
20
מניעת חסימה הדדית Deadlock Prevention
בלבדיות:
• תנאי זה מתייחס למשאבים אותם לא ניתן לחלוק; למשל :מדפסת
לא יכולה להדפיס שני קבצים בו זמנית ,והמעבד אינו יכול להריץ
שתי תכניות בו זמנית; מנגד ,מספר קוראים כן יכולים לקרוא קובץ
במקביל.
מסקנה :לא ניתן להניח כי ניתן למנוע את תנאי הבלבדיות באופן
מלא
©צבי מלמד
21
מניעת חסימה הדדית Deadlock Prevention
החזקה והמתנה
.1צריך שתהליך יאחז במשאב xוימתין על משאב yהמוחזק ע"י תהליך אחר וכך
יכול להיווצר מעגל של ממתינים
• פתרון אפשרי" :הכל או לא-כלום" -נדרוש מהתהליך לבקש מראש את כל
המשאבים שהוא צריך בו זמנית ,והם יוקצו לו רק כאשר ניתן לספק את כולם.
• החלשת הדרישה :תהליך יורשה לקבל משאבים רק אם הוא לא מחזיק ברשותו
משאבים כלשהם )ייתכן שהיו ברשותו בעבר ,אך הוא שיחררם(.
• זאת דרישה קלה יחסית ליישום במערכת ההפעלה :עליה רק להחזיק משתנה
בוליאני )או מונה( שיודעים באיזה משאבים התהליך משתמש בכל רגע
חסרונות הפתרון\התנאי:
• התהליך צריך לבקש משאב שלו הוא צפוי להזדקק בעתיד הרחוק -פגיעה
במקביליות.
• חשש להרעבה של תהליך הזקוק למשאב 'מבוקש'
©צבי מלמד
22
מניעת חסימה הדדית Deadlock Prevention
אי-חטיפה preemption
•
התנאי השלישי היה :המשאב שהוקצה לתהליך נותר ברשותו עד
שהוא )האוחז במשאב( משחרר אותו מרצונו הטוב.
•
אפשר להפר תנאי זה בכמה אופנים ,ולהבטיח חופש מ:deadlock-
.1תהליך האוחז במשאבים R1, … ,Rmומבקש משאב נוסף
Rm+1שאינו פנוי ,מאבד את כל המשאבים שהיו ברשותו,
ומושהה\נחסם .התהליך יחזור לרוץ כאשר ניתן יהיה להקצות
לו את R1, … ,Rm+1
©צבי מלמד
23
מניעת חסימה הדדית Deadlock Prevention
.2כאשר התהליך מבקש משאב:
(aאם המשאב זמין :התהליך מקבל אותו )כמובן(
(bאם המשאב מוחזק ע"י תהליך אחר שממתין :המשאב
ייחטף מהממתין ,ויוקצה לזה שביקשו )ורוצה להשתמש בו
עכשיו ומיד – כלומר אינו תקוע(.
(cאחרת )המשאב מוחזק ע"י תהליך אחר שרץ ]שאינו
ממתין[( :התהליך המבקש ימתין )ובכך הוא חושף את עצמו
לחטיפה של מה שברשותו(.
הוא יצא ממצב ההמתנה כאשר ניתן יהיה להקצות לו גם
את המשאב שהוא ביקש ,וגם את כל המשאבים שנחטפו
ממנו בזמן שהוא המתין.
©צבי מלמד
24
מניעת חסימה הדדית Deadlock Prevention
אי-חטיפה preemption
•
התנאי השלישי היה :המשאב שהוקצה לתהליך נותר ברשותו עד
שהוא )האוחז במשאב( משחרר אותו מרצונו הטוב.
•
.......
•
כלומר :השיטה נותנת עדיפות לתהליכים שרצים כרגע
•
ההיגיון :אם התהליך רץ כרגע ,אז הוא עשוי לסיים ולשחרר את
המשאבים שברשותו
©צבי מלמד
25
מניעת חסימה הדדית Deadlock Prevention
המתנה מעגלית Circular Wait
•
כדי למנוע המתנה מעגלית נטיל יחס סדר מלא על המשאבים ,ונדרוש שתהליך
יבקש את המשאבים על-פי יחס הסדר שהטלנו
–
אם על-פי יחס הסדר Ri < Rjאזי תהליך שזקוק הן ל Ri -והן לRj -
בו זמנית ,חייב לבקש ראשית את Riורק אח"כ את .Rj
•
)לחילופין :התהליך יכול לבקש את ,Rjולשחרר אותו ,ואח"כ לבקש את .(Ri
תהליך שזקוק למספר יחידות ממשאב חייב לבקש אותן בו זמנית.
•
כיצד יוטל יחס הסדר:
•
–
שרירותית.
–
על-פי סדר הגיוני כלשהו :למשל ,נשתמש בקובץ לפני שנקבל את המדפסת
©צבי מלמד
26
הקצאת המשאבים באופן שמונע deadlock
•
•
•
•
בסעיף הקודם "טיפלנו" בתנאים ההכרחיים לחסימה הדדית
הוספנו תנאים גורפים שמונעים חסימה הדדית
המחיר :הטלת מגבלות יחסית קשות על התהליכים
התוצאה )ההשלכות( :ניצול מופחת של הציוד
– למשל ,תהליך צריך לבקש כעת ,משאב שהוא יידרש לו בעתיד
– התהליך לא מקבל משאב פנוי וזמין כרגע ,רק כי הוא אינו
יכול לקבל משאב אחר
נדון כעת בגישה שונה – "נטיל" מגבלה מסוג אחר:
– כל תהליך בתחילת ריצתו יצהיר מה המשאבים שבהם הוא
עשוי לעשות שימוש....
©צבי מלמד
27
הקצאת המשאבים באופן שמונע deadlock
•
•
•
•
כל תהליך בתחילת ריצתו יצהיר מה המשאבים בהם הוא עשוי לעשות
שימוש.
המערכת תפעיל אלגוריתם חכם שמשתמש במידע הזה -כדי להישמר
מהקצאה של המשאבים באופן שעלול לקלוע אותה לdeadlock -
– תהליך Pעלול שלא לקבל משאב Rרק מפני שההקצאה עלולה
להכניס את המערכת לחסימה הדדית בהמשך.
מנגד :איננו מטילים תנאים גורפים על התהליכים ,כדוגמת:
– "לא תוכל לקבל משאב אם כבר ביקשת אחד"
– "אם בקשת משאב שאינו פנוי המשאבים שהוקצו לך נחטפים
ממך"
לשם כך נגדיר "מצב בטוח" – "אני סמוך ובטוח שהתהליכים שכרגע
רצים לא יגיעו לחסימה הדדית"
©צבי מלמד
28
מצב בטוח Safe State
•
מצב בטוח =
בכל תרחיש אפשרי ,יש ברשות המערכת די משאבים לכך שהיא
תוכל לאפשר לתהליכים שרצים לקבל את כל מה שהם הצהירו
שהם עשויים לרצות
)לאו דווקא בו זמנית ,אלא ,אולי בזה אחר זה(.
©צבי מלמד
29
מצב בטוח - Safe Stateהמחשה
מצב נוכחי -תהליכים
תמונת המשאבים
תהליך
משאב
עשוי
לבקש
מוקצה
כרגע
משאב
כמות
כרגע
מוקצה
כרגע
פנוי
P1
R1
1
0
R1
2
1
1
R2
2
1
R2
2
1
1
R1
2
1
R2
1
0
P2
•
נניח למערכת שני משאבים ,R1, R2מכל משאב יש שני פריטים .נניח שP1 -
הצהיר שהוא עשוי לבקש יחידה אחת מ ,R1 -ושתי יחידות מP2 .R2 -הצהיר
שהוא עשוי לבקש שתי יחידות מ R1 -ויחידה אחת מ .R2 -כאשר המערכת
הקצתה יחידה אחת מ R2 -ל ,P1 -ויחידה אחת מ R1 -לP2 -
• האם המערכת במצב בטוח?
©צבי מלמד
30
תמונת המשאבים
מצב נוכחי
תהליך
משאב
עשוי
לבקש
מוקצה
כרגע
משאב
כמות
כרגע
מוקצה
כרגע פנוי
P1
R1
1
0
R1
2
1
1
R2
2
1
R2
2
1
1
R1
2
1
R2
1
0
P2
בקשות עתידיות אפשריות
תהליך
משאב
עשוי לבקש
P1
R1
1
כן
R2
2
כן
R1
2
כן
R2
1
כן
P2
• האם המערכת במצב בטוח?
ניתן לספק
כן
כן
• כן .יש ברשותה עוד יחידה מ R1 -ועוד יחידה מ , R2 -ולכן הראשון
מבין שני התהליכים )לא משנה איזה( שיזדקק לשתי היחידות )אחת
מכל סוג( יוכל לקבלן ,לסיים ,ולפנות את היחידות לתהליך השני
©צבי מלמד
31
תמונת המשאבים
מצב נוכחי
תהליך
משאב
עשוי
לבקש
מוקצה
כרגע
משאב
כמות
כרגע
מוקצה
כרגע
פנוי
P1
R1
1
1
R1
2
2
0
R2
2
1
R2
2
2
0
R1
2
1
R2
1
1
P2
• אם ,לעומת זאת ,המערכת הקצתה לכל תהליך יחידה אחת מכל משאב
האם עכשיו היא במצב בטוח?
• אזי לא נותרו ברשותה כל משאבים פנויים ,ולכן יש חשש שמי משני התהליכים
שיזדקק לעוד משאב יחיד )כפי שהוא הצהיר בתחילת ריצתו שהוא עשוי לדרוש(
כדי לסיים לא יוכל לקבלו .ולכן המערכת תקלע לחסימה הדדית
©צבי מלמד
32
מצב בטוח - Safe Stateהגדרה פורמלית
• מערכת המריצה nתהליכים כלשהם נמצאת במצב בטוח ביחס
להקצאת משאבים כלשהי שכבר בוצעה אם ורק אם קיימת סדרה
בטוחה של תהליכים > <P0, …Pn-1כך שלכל Piבסדרה מתקיים
שכמות המשאבים ש Pi -רשאי עוד לדרוש קטנה או שווה מכמות
המשאבים הפנויים +כמות המשאבים המוקצים לתהליכים
שלפניו בסדרה ).(P0, …,Pi-1
• אם לא קיימת סדרת תהליכים בטוחה אזי המערכת במצב לא
בטוח ).(unsafe
©צבי מלמד
33
המשמעות של - Safe/Unsafe State
•
מערכת המצויה במצב בטוח -איננה ב ,deadlock-ומובטחת לה אפשרות
שתסתיים ההרצה של כל התהליכים מבלי שתקלע ל.deadlock -
•
מערכת במצב לא בטוח איננה בהכרח ב ,deadlock-אולם היא עלולה להיקלע
ל – deadlock-גם אם היא נורא "תתאמץ" להמנע מזה
– למשל :לתזמן את הענקת המשאבים לתהליכים בסדרה כזאת שתבטיח
שלא יהיה deadlock
– זאת למה? כי לא קיימת סדרה כזאת )אחרת היא הייתה במצב בטוח!(
•
לדוגמה :במצב בו המערכת הקצתה יחידה אחת מכל משאב לכל תהליך ,אם
אחד התהליכים יסיים בלי לבקש את המשאב הנוסף שהוא הצהיר שהוא עשוי
לבקש ,אזי המערכת לא תקלע ל ,deadlock-אולם אם שני התהליכים כן יבקשו
את המשאב הנוסף לו הם זכאים אזי המערכת תקלע ל(..deadlock-
©צבי מלמד
34
מצב בטוח - Safe Stateדוגמא
• ב ַ מערכת משאב מטיפוס יחיד ,וקיימים ממנו
12פריטים.
•
במערכת רצים שלושה תהליכים כמתואר
בטבלה
•
•
תהליך
כמות
מרבית
כמות
מוקצית
P0
10
5
במצב הנוכחי קיימת סדרה בטוחה:
P1P0P2
P1
4
2
P2
9
2
ולכן המערכת מצויה במצב בטוח.
סה"כ
9
מדוע הסדרה P1P0P2בטוחה?
.1התהליך P1רשאי לבקש עוד 2יח' .המערכת יכולה להקצותן לו ,והוא יוכל לסיים .עתה
ברשות המערכת יהיו 5יח' מהמשאב.
.2התהליך P0רשאי לבקש עוד 5יח' .המערכת יכולה להקצותן לו ,והוא יוכל לסיים .עתה
ברשות המערכת יהיו 10יח' מהמשאב.
.3התהליך P2רשאי לבקש עוד 7יח' .המערכת יכולה להקצותן לו ,והוא יוכל לסיים.
©צבי מלמד
35
מצב בטוח - Safe Stateדוגמא
•
לעומת זאת ,אם המערכת במצב הנוכחי ,תקצה
יח' נוספת ל P2 -היא תעבור למצב שמתואר
בטבלה ממול
•
במצב הנוכחי לא קיימת סדרה בטוחה !
•
•
•
P1עדיין יכול לקבל את שתי היח' להן הוא זקוק ,ולסיים
ברשות המערכת יהיו 4יח' מהמשאב
וזה עלול לא להספיק:
– P0עשוי להידרש לעוד 5יח'
– P2עשוי להידרש לעוד 6יח'
תהליך
P0
10
5
P1
4
2
P2
9
3
סה"כ
©צבי מלמד
כמות
מרבית
כמות
מוקצית
10
36
מצב בטוח Safe State
• מסקנה :למרות שכאשר P2מבקש עוד יחידה מהמשאב המערכת
יכולה להקצות אותה ,אסור לה לעשות את זה ,כי זה מוציא אותה
ממצב בטוח למצב לא-בטוח
• השאלה:
– כיצד לזהות שהקצאת היחידה הנוספת ל P2 -תכניס אותה
למצב לא בטוח?
©צבי מלמד
37
תכנות מערכת ומבוא לתכנות מקבילי
חסימות הדדיות -המשך
יום א' 18.3.2012
©צבי מלמד
38
אלגוריתמים לזיהוי מצב לא-בטוח
• השאלה:
– כיצד לזהות שהקצאת היחידה הנוספת ל P2 -תכניס אותה
למצב לא בטוח?
• נציג שתי תשובות לשאלה:
– עבור מערכת בה קיים משאב יחיד מכל סוג
• במצב זה ,נוכל להפעיל אלגוריתם פשוט יותר )במקום
להשתמש באלגוריתם שמשתמע מהתיאור שהוצג עד כה(
– עבור מערכת בה קיימים מספר משאבים מכל סוג
• נשתמש באלגוריתם שהצגנו
©צבי מלמד
39
אלג' המבוסס על גרף הקצאת משאבים
Resource-Allocation Graph Algorithm
•
נשתמש בווריאנט של גרף הקצאת המשאבים שראינו קודם
•
קשתות בקשה )מייצגות :תהליך מבקש משאב(
•
וקשתות הקצאה )מייצגות :התהליך מחזיק במשאב(.
•
ובנוסף :קשתות היתכנות ):(claim edge
– קשת היתכנות Pi Rjמציינת שPi -עשוי לבקש את Rjבמהלך ריצתו.
– קשתות ההיתכנות מצוירות מקווקוות.
•
כאשר תהליך מוּסף לגרף – מוספות גם כל קשתות ההיתכנות שלו
– ניתן להקל בדרישה הזאת:
• ניתן להוסיף לתהליך קשת התכנות בשלב מאוחר יותר ,אבל בתנאי,
שכל הקשתות הקשורות בו הן רק קשתות היתכנות )כלומר :עדיין לא
ביצע בקשה ,ולא כל שכן ,מחזיק במשאב(
©צבי מלמד
40
אלג' המבוסס על גרף הקצאת משאבים
Resource-Allocation Graph Algorithm
• תהליך מבקש משאב – קשת ההיתכנות הופכת לקשת בקשה
• תהליך מקבל משאב – קשת הבקשה הופכת לקשת הקצאה
• תהליך משחרר משאב – קשת ההקצאה הופכת לקשת היתכנות
• והעיקר :כאשר התהליך מבקש משאב ,ההקצאה תאושר רק אם
הפיכת צלע הבקשה Pi Rjלכדי צלע הקצאה Rj Piלא יוצרת
מעגל בגרף.
– אם היענות לבקשה יוצרת מעגל – ההקצאה לא תאושר,
והתהליך ימתין חסום
– בגלל ש ...הקצאת המשאב תכניס את המערכת למצב לא בטוח
©צבי מלמד
41
דוגמה
R1
P1
P2
כ"א משני
התהליכים עשוי
לבקש כ"א משני
המשאבים
R2
R1
P1
P2
P1ביקש ,וגם קיבל
את R1
R2
©צבי מלמד
42
דוגמה
R1
P2
P2מבקש את R2
P1
R2
R1
P1
P2
R2
אישור הבקשה של P2יביא אותנו
לגרף הזה.
רואים שיש בו מעגל ,שמייצג סכנה
של חסימה הדדית :במקרה שכל אחד
מהתהליכים יבקש את המשאב השני.
לכן הבקשה של P2לא תאושר
©צבי מלמד
43
מסקנה מהדוגמא
• נשים לב שאם מ R2 -היו שני פריטים אזי ניתן היה לאשר לP2 -
את הבקשה בלי שייווצר חשש מהיקלעות ל.deadlock -
• מסקנה:
– האלגוריתם מתאים רק למערכת בה קיים משאב יחיד מכל
סוג.
– אם נשתמש בו במערכת בה קיימים כמה משאבים מכל סוג
נהיה קפדניים יתר על המידה :לא נאשר בקשות שניתן לאשר,
בקשות שאינן מביאות אותנו למצב בלתי בטוח
©צבי מלמד
44
אלגוריתם הבנקאים The Banker's Algorithm
• מכונה "אלגוריתם הבנקאים" בגלל שמקורו בהקשר הבנקאי:
– האם הבנק יכול להקצות אשראי\משאב נוסף ,ועדיין להישאר
במצב בטוח? ,כלומר כזה בו הוא יוכל לפרוע את כל
התחייבויותיו
– יש חשש שבכמה בנקים לא הקפידו על הרצתו בתכיפות
מספקת...
• סימונים:
– – nמספר התהליכים
– – mמספר סוגי המשאבים
©צבי מלמד
45
אלגוריתם הבנקאים
The Banker's Algorithm
– n
– m
מספר התהליכים
מספר סוגי משאבים
מבני הנתונים :
• ] = available[mשומר כמה יחידות נתרו בידי המערכת מכל
סוג משאב.
• ] = max[n][mמציין עבור תהליך Pכמה משאבים מסוג Rהוא
עשוי לצרוך )לכל היותר(.
• ] = allocation[n][mמציין עבור תהליך Pכמה משאבים
מסוג Rהוא כבר הוקצו לו.
• ] = need[n][mמציין עבור תהליך Pלכמה משאבים מסוג R
הוא עוד עשוי להזדקק )למעשה ,משתנה מיותר שכן:
(need = max –allocation
• ] finish[nמציין האם התהליך הוסף כבר לסדרה בטוחה
)כלומר אנו יכולים להניח שהוא "סיים" או "יסיים"(
©צבי מלמד
46
אלגוריתם הבנקאים
סימונים
• ] = max[pשורה pבמערך דו-ממדי כדוגמת .max
• עבור וקטורים שווי מימד )אורך( נאמר ש:
v1<=v2אם לכל iמתקיים.v1[i]<=v2[i] :
©צבי מלמד
47
Safety Algorithm
•
הרעיון באלגוריתם הבנקאים הוא לוודא שכל הקצאה מותירה
את המערכת במצב בטוח = מצב שבו קיימת סדרה בטוחה
•
לב האלגוריתם הוא תת-אלגוריתם שבודק האם הקצאת משאבים
לתהליך משאירה את המערכת במצב בטוח.
•
הבדיקה הזאת מתבצעת ** בטרם ** שמאשרים את ההקצאה:
–
כאשר יש צורך לבדוק הקצאה מסוימת אז:
.1נשנה את מצב המערכת כאילו המשאבים כבר הוקצו.
.2נבצע את הבדיקה – הרצת הsafety-algorithm -
©צבי מלמד
48
Safety Algorithm
•
•
•
•
תת-האלגוריתם לבדיקת בטיחות הוא אינטואיטיבי למדי:
בצע שוב ושוב בלולאה )כל עוד יש "התקדמות"(
.1חפש תהליך שכל מה שהוא עוד רשאי לבקש >= מכמות
המשאבים שברשותך.
.2אם מצאת כזה אזי סמן שתהליך זה "סיים" )למעשה :יוכל
לסיים( ולפיכך לשחרר את משאביו
– הגדל את המשאבים הפנויים בכמות שמוקצית כעת
לתהליך
אם בתום הלולאה כל התהליכים מסומנים ככאלה שיכולים
לסיים אזי המצב בטוח
אחרת המצב אינו בטוח
©צבי מלמד
49
תיאור פורמלי-Safety Algorithm
1. initialize:
מספר התהליכים
int temp[m] = available
מספר סוגי משאבים
bool finish[n] = {false}
2. repeat:
– find p such that:
(finish[p]==false) && (need[p] <= temp)
– if not found – break from loop
– update:
• temp += allocation[p]
• finish[p] = true
3. the system is in safe-state IFF
for (all i<n) finish[i]==true
50
©צבי מלמד
– n
– m
דוגמה לבדיקה האם המערכת במצב בטוח
• נניח מערכת בה שלושה משאבים A, B, C
• ומכל משאב הכמות הינה:
10 5 7
• במערכת מורצים חמישה תהליכים ,אשר מוקצים להם משאבים
כמתואר.
• מטרת הבדיקה להודיע האם המערכת במצב בטוח
©צבי מלמד
51
quantity
A
B
C
10
5
7
מוקצה
רשאי
-
A
B
C
=
A
B
C
P1
7
5
3
-
0
1
0
=
7
4
3
P2
3
2
2
-
2
0
0
=
1
2
2
P3
9
0
2
-
3
0
2
=
6
0
0
P4
2
2
2
-
2
1
1
=
0
1
1
P5
4
3
3
-
0
0
2
=
4
3
1
allocation
7
2
5
available
3
3
2
דוגמה לבדיקה האם
המערכת במצב בטוח
מקסימום
1.
P2 may request {1, 2, 2}. avail={3, 3, 2} P2 can finish. new avail={5, 3, 2}
2.
P4 may request {0, 1, 1}. avail={5, 3, 2} P4 can finish. new avail={7, 4, 3}
3.
P1 may request {7, 4, 3}. avail={7, 4, 3} P1 can finish. new avail={7, 5, 3}
4.
etc. with P3 and P5
52
המערכת הזאת במצב בטוח:מסקנה
©צבי מלמד
אלגוריתם בקשת משאבים Resource-Request
)Algorithm (the main algorithm
• האלגוריתם הראשי ,בין היתר ,בודק האם בעקבות הקצאת
המשאבים הדרושים לתהליך המערכת נותרת במצב בטוח )לשם
כך ,קוראים ל.(safety-algorithm -
• האלגוריתם מקבל כל פעם וקטור בקשה של משאבים מצד תהליך
ומאשר או דוחה את הבקשה.
• נסמן את וקטור הבקשה של התהליך כint request[m] :
©צבי מלמד
53
אלגוריתם בקשת משאבים Resource-Request
)Algorithm (the main algorithm
.1אם ]request + allocation[p] > max[p
)או(request > need[p] :
אזי עצור את התהליך בשל שגיאה.
.2אם request > availableאזי החזר כי על התהליך להמתין
עד שישוחררו משאבים.
.3הקצאת המשאבים לתהליך תעביר את המערכת למצב:
available -= request
; allocation[p] += request
; need[p] -= request
בדוק האם מצב זה הינו בטוח ,ואשר את הבקשה אם"ם המצב
הינו בטוח
©צבי מלמד
54
רשאי
מקסימום
מוקצה
P2מבקש{1, 0, 2} :
C
B
A
=
C
B
A
-
C
B
A
7
5
10
quantity
3
4
7
=
0
1
0
-
3
5
7
P1
2
2
1
=
0
0
2
-
2
2
3
P2
0
0
6
=
2
0
3
-
2
0
9
P3
1
1
0
=
1
1
2
-
2
2
2
P4
1
3
4
=
2
0
0
-
3
3
4
P5
5
2
7
allocation
2
3
3
available
•
נניח ש P2 :מבקש{1, 0, 2} :
•
הבקשה תקינה מבחינת ההצהרות שלו בתחילת ריצתו.
•
הבקשה תקינה מבחינה זאת שלמערכת יש משאבים להקצות.
•
אם נאשר את ההקצאה נעבור למצב) ... :בשקף הבא(
©צבי מלמד
55
quantity
A
B
C
10
5
7
מוקצה
רשאי
-
A
B
C
=
A
B
C
P1
7
5
3
-
0
1
0
=
7
4
3
P2
3
2
2
-
3
0
2
=
0
2
0
P3
9
0
2
-
3
0
2
=
6
0
0
P4
2
2
2
-
2
1
1
=
0
1
1
P5
4
3
3
-
0
0
2
=
4
3
1
allocation
8
2
7
available
2
3
0
{1, 0, 2} : מבקשP2
מקסימום
{1, 0, 2} : ביקש וקיבלP2 :נניח ש
1.
P2 may request {0, 2, 0}. avail={2, 3, 0} P2 can finish. new avail={5, 3, 2}
2.
P4 may request {0, 1, 1}. avail={5, 3, 2} P4 can finish. new avail={7, 4, 3}
3.
P1 may request {7, 4, 3}. avail={7, 4, 3} P1 can finish. new avail={7, 5, 3}
56
©צבי מלמד
•
P1מבקש
{0, 2, 0} :
רשאי
מקסימום
מוקצה
C
B
A
=
C
B
A
-
C
B
A
7
5
10
quantity
3
4
7
=
0
1
0
-
3
5
7
P1
0
2
0
=
2
0
3
-
2
2
3
P2
0
0
6
=
2
0
3
-
2
0
9
P3
1
1
0
=
1
1
2
-
2
2
2
P4
1
3
4
=
2
0
0
-
3
3
4
P5
7
2
8
allocation
0
3
2
available
•
נניח שמעבר לבקשה הנ"ל P1מבקש{0, 2, 0} :
•
הבקשה תקינה מבחינת ההצהרות שלו בתחילת ריצתו.
•
הבקשה תקינה מבחינה זאת שלמערכת יש משאבים להקצות.
•
אם נאשר את ההקצאה נעבור למצב ... :תרגיל :הראו שזה מצב לא-בטוח
©צבי מלמד
57
P1קיבל
{0, 2, 0} :
רשאי
מקסימום
מוקצה
C
B
A
=
C
B
A
-
C
B
A
7
5
10
quantity
3
2
7
=
0
3
0
-
3
5
7
P1
0
2
0
=
2
0
3
-
2
2
3
P2
0
0
6
=
2
0
3
-
2
0
9
P3
1
1
0
=
1
1
2
-
2
2
2
P4
1
3
4
=
2
0
0
-
3
3
4
P5
7
4
8
allocation
0
1
2
available
•
נניח שנעתרנו לבקשת P1שביקש וקיבל{0, 2, 0} :
•
...תרגיל :הראו שזה מצב לא-בטוח
©צבי מלמד
58
מקסימום
מוקצה
A
B
C
quantity
10
5
7
P1
7
5
P2
3
P3
רשאי
-
A
B
C
=
A
B
C
3
-
0
1
0
=
7
4
3
2
2
-
2
0
0
=
1
2
2
9
0
2
-
3
0
2
=
6
0
0
P4
2
2
2
-
2
1
1
=
0
1
1
P5
4
3
3
-
0
0
2
=
4
3
1
allocation
7
2
5
available
3
3
2
59
©צבי מלמד
אבחון חסימה הדדית Deadlock Detection
• עד כה ראינו אלגוריתם אשר שמרו שהמערכת לא תיקלע ,ל-
deadlock
– אופן הפעולה :הם לא אפשרו הקצאה של משאבים אשר עלולה
להוציא את המערכת ממצב בטוח
• גישה חלופית" :ישחקו נא הנערים לפנינו"
– נאפשר לתהליכים לרוץ באופן חופשי ,אבל ננטר )או נמנטר –
מלשון (monitoringאת ריצתם
– כאשר נגלה שתהליכים נקלעו ל – deadlock-נעיף אי אלו
תהליכים על-מנת לשחרר את ה'-פלונטר'.
©צבי מלמד
60
אבחון חסימה הדדית Deadlock Detection
• מערכת הפעלה שנוקטת בסגנון התמודדות כזה:
– עליה להיות מסוגלת לזהות שקבוצת תהליכים מצויה ב-
deadlock
– עליה להיות מסוגלת להתאושש מהמצב
• גם במקרה הזה נבחין נבחין בין המקרים:
– יש פריט יחיד מכל סוג משאב
– ייתכנו כמה פריטים מסוג מסוים של משאב
©צבי מלמד
61
– Deadlock Detectionפריט יחיד מכל משאב
• נשתמש ב) wait-for graph -גרף המתנה ל:( -
– צומת עבור כל תהליך המורץ במערכת.
– צלע Pi Pjמציינת ש Pi -ממתין למשאב המוחזק ע"י Pj
• המערכת מצויה בחסימה-הדדית אם"ם הגרף כולל מעגלים
• לפיכך מה נדרש מהמערכת בכדי לזהות חסימה הדדית:
– לתחזק את הגרף באופן שוטף.
– מעת לעת ,להריץ אלגוריתם שיבדוק האם הגרף כולל מעגלים
©צבי מלמד
62
– Deadlock Detectionמספר פריטים מכל משאב
• דרוש אלגוריתם מורכב יותר
– דומה לאלגוריתם הבנקאים ,אבל,
– בשונה ממנו – הוא איננו מורץ בכל פעם שתהליך מבקש
משאבים )וכך מונע מלהיכנס ל ,( deadlock-אלא מעת לעת
)ולכן רק בודק האם המצב אליו כבר הגיעה המערכת הינו מצב
בטוח או לא(.
©צבי מלמד
63
– Deadlock Detectionמספר פריטים מכל משאב
•
מבני הנתונים שמשמשים את האלגוריתם:
• ] – available[mכמה פריטים זמינים )לא מוקצים( מכל סוג משאב
קיימים במערכת ברגע זה )בזמן הריצה/בדיקה של האלגוריתם(
• ] – allocation[n][mשומר כמה משאבים מסוג jמוקצים לתהליך #i
• ] – request[n][mעבור כל תהליך iבמערכת ,לכמה משאבים נוספים
מסוג jהתהליך ממתין .
– באלגוריתם הבנקאים )או למעשה :ב (resource-request alg. -זה היה
מערך חד-ממדי ,שמכיל את בקשתו הנוכחית של תהליך יחיד
•
איננו שומרים עוד את...
– כמות המשאבים המרבית שתהליך רשאי לבקש
– כמה עוד מותר לתהליך לבקש
הקלה בדרישות :תהליך רשאי לבקש כמה שהוא חפץ ולא צריך להתחייב
לזה מראש.
©צבי מלמד
64
– מספר פריטים מכל משאבDeadlock Detection
:הגדר ואתחל
.1
:חזור
.2
int temp[m] = available ;
bool finish[n] = {false} ;
: שמקייםp אתר תהליך.א
finish[p]==false &&
request[p] <= temp
(break) כנ"ל אזי צא מהלולאהp אם לא מצאת
.ב
:סמן
.ג
finish[p] = true ;
temp += allocation[p]
finish[p]==false : כך שp אם"ם קיים. deadlock המערכת מצויה ב
65
©צבי מלמד
.3
דוגמה
מספר פריטים
מכל משאב
במצב זה אין
חסימה הדדית
הקצאה
המתנה
C
B
A
C
B
A
6
5
7
quantity
0
1
0
P1
0
0
2
P2
0
0
2
3
0
3
P3
0
0
1
1
1
2
P4
2
0
0
2
0
0
P5
6
2
7
allocation
0
3
0
available
•
במצב הנוכחי P1, P3יכולים לסיים.
•
כשהם יסיימו מצב המשאבים הפנויים יהיה:
}available = {0, 3, 0} + {0, 1, 0} + {3, 0, 3} = {3, 4, 3
•
ואז גם P1, P4, P5יוכלו לסיים
©צבי מלמד
66
דוגמה
מספר פריטים מכל משאב
המתנה
C
B
הקצאה
C
B
A
A
6
5
7
quantity
0
1
0
P1
0
0
2
0
0
2
P2
1
0
0
3
0
3
P3
0
0
1
1
1
2
P4
2
0
0
2
0
0
P5
6
2
7
allocation
0
3
0
available
הדרישה הזאת
התוספה לP3-
במצב זה קיימת
חסימה הדדית
•
במצב הנוכחי P1יכול לסיים.
•
כשהוא יסיים מצב המשאבים הפנויים יהיה:
}available = {0, 3, 0} + {0, 1, 0} = {0, 4, 0
•
וזה לא מספיק לאף אחד מהתהליכים האחרים לסיים = .deadlock
©צבי מלמד
67
דוגמה
מספר פריטים מכל משאב
האם להרוג את
P5יפתור את
החסימה?
הריגת P5תשחרר
את הdeadlock-
המתנה
C
B
הקצאה
C
B
A
A
6
5
7
quantity
0
1
0
P1
0
0
2
0
0
2
P2
1
0
0
3
0
3
P3
0
0
1
1
1
2
P4
2
0
0
2
0
0
P5
6
2
7
allocation
0
3
0
available
•
האם להרוג את P5יפתור את החסימה?
•
כש P5מסתיים מצב המשאבים יהיהavailable = {0, 3, 0}+{0, 0, 2} = {0, 3, 2} :
•
במצב זה P3יכול לסיים ונעבור למצב } {3, 3, 5ואז P2, P4יכולים לסיים
אין יותר חסימה הדדית
©צבי מלמד
68
תדירות הפעלת Deadlock detection
•
•
•
•
כאשר איננו מונעים deadlockמראש אלא מאתרים אותו ופותרים
בדיעבד
שאלה :כל כמה זמן נפעיל את אלגוריתם האיתור?
– תלוי בשכיחות בה חלות חסימות הדדיות במערכת שלנו
– deadlockמשבית מרכיבים ציוד ומעכב תהליכים – עד כמה חשוב
ודחוף לנו למזער את הדגרדציה ) (degradationהזאת
– מהי העלות של הפעלת אלגוריתם הdetection-
במקרה הקיצוני :כל פעם שתהליך מבקש משאב ונאלץ להמתין
)בקשתו לא מסופקת( יופעל האלגוריתם
לחילופין :עת ניצולת המעבד/מערכת יורדת מתחת לסף כלשהו )(40%
עשוי הדבר לעורר חשד שהמערכת ב ,deadlock -ונפעיל את ה-
detection
©צבי מלמד
69
התאוששות ) (recoveryמdeadlock -
•
ביצוע אפשרי בכמה אופנים:
– מערכת ההפעלה מדווחת למפעיל על קיומה של חסימה
הדדית ומיהם התהליכים שמעורבים בה .המפעיל מטפל
ידנית בחסימה
•
מערכת ההפעלה בעצמה מחליטה את מי לסיים ,ומבצעת
)"הורגת" אותו(
•
מערכת ההפעלה לא הורגת תהליכים אלא רק חוטפת מהם
משאבים שדרושים בכדי להתיר את החסימה ההדדית
©צבי מלמד
70
- deadlock recoveryבחירת הקורבן
•
קריטריונים להחלטה את מי מהתהליכים להעיף
)כאשר מערכת ההפעלה בעצמה מבצעת זאת(:
.1קדימויות התהליכים השונים.
.2כמה זמן חישוב כבר הושקע בתהליך ,וכמה זמן חישוב עוד צפוי להיות
מושקע בו.
.3בכמה משאבים התהליך משתמש ,ומה סוג המשאבים )עד כמה הם
מבוקשים(.
.4לכמה משאבים עוד צפוי התהליך להידרש.
.5כמה תהליכים נוספים עוד צריך יהיה לסיים פרט לתהליך הנוכחי.
.6האם מדובר בתהליך אינטראקטיבי או אצווה.
.7אילו פעולות בלתי הפיכות irreversibleהתהליך כבר עשה )כתב על קובץ,
על המסך ,על מדפסת(.
.8כיצד נישמר מהרעבה
©צבי מלמד
71
© Copyright 2024