Transcript מערכות הפעלה

‫מערכות הפעלה‬
‫תרגול ‪ - 2‬קריאות מערכת הפעלה וסינכרוניזציה‪.‬‬
‫מה בתכנית?‬
‫שימוש בקריאות מערכת הפעלה – המשך‬
‫‪ ‬תהליכים ‪ -‬חזרה‬
‫‪ ‬העברת הודעות‬
‫‪ ‬תאום תהליכים‬
‫‪2‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫קריאות מערכת הפעלה‬
‫‪‬‬
‫משתמש יכול לגשת רק‬
‫לקריאות מערכת‬
‫הפעלה‬
‫‪‬‬
‫פונקציות פנימיות של‬
‫מערכת הפעלה מוגנות‬
‫מפני המשתמש‬
‫‪3‬‬
‫תכניות משתמש‬
‫קריאות‬
‫מערכת‬
‫הפעלה‬
‫מערכת ההפעלה‬
‫חומרה‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫תהליכים‬
‫תהליך הוא ביצוע של תכנית‬
‫‪ ‬תהליכים יוצרים אשליה של הרצת מספר‬
‫אפליקציות במקביל‬
‫‪ ‬לכל תהליך – תכנית אחת‪ ,‬לתכנית אחת יכולים‬
‫להיות תהליכים רבים מתבצעים בו זמנית‬
‫‪4‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫ דיאגרמת מצבים‬- ‫תהליך‬
sleep
wake up
SLEEPING
resched
resched
CURRENT
READY
suspend
SUSPENDED
suspend
resume
Create
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
5
‫יצירת תהליכים ‪create -‬‬
‫‪ XINU‬תומכת בריבוי תהליכים‪ .‬יצירת תהליך מתבצעת באמצעות‬
‫קריאת מערכת הפעלה ‪create‬‬
‫‪>,‬שם הפונקציה הראשית< (‪сreate‬‬
‫‪>,‬גודל מחסנית לתהליך<‬
‫‪>,‬עדיפות<‬
‫‪>,‬שם התהליך<‬
‫;) >פרמ' ‪>, …, < n‬פרמ' ‪>, <2‬פרמ' ‪>, <1‬מס' פרמטרים<‬
‫‪6‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫הכנסת תהליך מושעה לריצה‬
‫תהליך מושעה (לדוגמא‪ :‬תהליך חדש שנוצר כרגע)‬
‫עובר למצב בו הוא מוכן (‪ )READY‬לריצה ע"י קריאת‬
‫מערכת הפעלה ‪.resume‬‬
‫;) >מזהה תהליך< ( ‪resume‬‬
‫התהליך עובר למצב ‪ READY‬ומהרגע הזה מחכה‬
‫בתור לכניסה למעבד‬
‫‪7‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫השעיית תהליך‬
‫ניתן להשעות תהליך מריצה באמצעות קריאת מערכת‬
‫הפעלה ‪.‬‬
‫;) >מזהה תהליך< (‪suspend‬‬
‫ניתן להשעות תהליך רק אם הוא רץ כרגע או מוכן‬
‫לריצה‪.‬‬
‫‪8‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫סיום תהליך‬
‫סיום נורמלי של תהליך מתבצע כאשר מסתיימת‬
‫הפונקציה הראשית שלו‪.‬‬
‫ניתן לגרום לסיום התהליך לפני כן (להרוג אותו) על ידי‬
‫קריאת מ"ה ‪kill‬‬
‫;) >מזהה תהליך< (‪kill‬‬
‫תהליך יכול להרוג את עצמו‪ .‬קריאת התאבדות‪:‬‬
‫;))(‪kill(getpid‬‬
‫)(‪ – getpid‬מחזיר את המזהה של התהליך‬
‫‪9‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫דוגמה‬
#include <conf.h>
#include <kernel.h>
xmain()
{
int prA(), prB();
resume( create)prA, INITSTK, INITPRIO, “proc 1”, 0) );
resume( create)prB, INITSTK, INITPRIO, “proc 2”, 0) );
}
prA()
{
while(1)
putc)CONSOLE, ‘A’(;
}
prB()
{
while(1)
putc)CONSOLE, ‘B’(;
}
15 ‫אפריל‬
:‫פלט‬
AAAAABBBBBBBAAAAA
AAAAAAAAAAAAAABBB
BAAAAAAAAAAAAAA
2 ‫ תרגול‬- ‫מערכות הפעלה‬
10
‫תאום תהליכים‬
‫‪ ‬ניתן לתאם בין כמה תהליכים על ידי פנייה‬
‫לקריאות מיוחדות של מערכת הפעלה (אם קיימות‬
‫שם)‪.‬‬
‫‪ ‬כל תהליך המעוניין בתאום מבקש ממערכת‬
‫"תעצרי אותי ותפעילי מחדש כשייתקימו התנאים‬
‫שאקבע"‬
‫‪ ‬התאום לא יקרה אוטומטי‪ ,‬על כותב התכנית לדאוג‬
‫לכך שהתאום יתבצע‬
‫‪11‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫תאום תהליכים‬
‫התאום האפשרי‪:‬‬
‫‪ ‬תהליך מחכה עד שתהליך אחר יסיים פעולה‬
‫מסויימת (יצרן‪/‬צרכן)‬
‫‪ ‬ביצוע מניעה הדדית על משאב משותף‪ ,‬כך שלא‬
‫ייתכן ששני תהליכים ישנו אותו באותו זמן‬
‫‪12‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫תאום תהליכים‬
‫בנק הפועלים‬
‫‪‬‬
‫מימשנו פונקציה למשיכת כסף מחשבון בנק‪.‬‬
‫{ )‪int withdraw( account, amount‬‬
‫;) ‪balance = get_balance( account‬‬
‫;‪balance -= amount‬‬
‫;)‪put_balance( account, balance‬‬
‫;‪return balance‬‬
‫}‬
‫‪‬‬
‫‪13‬‬
‫בחשבון יש ‪ ,$50000‬ושני בעלי החשבון ניגשים לכספומטים שונים‬
‫ומושכים ‪ $30000‬ו‪ $20000-‬בו‪-‬זמנית‪.‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
?‫בנק הפועלים – אין כסף‬
‫ תהליך נפרד מבצע כל פעולת משיכה (על אותו‬
)‫מעבד‬
balance = get_balance(account);
balance -= amount;
// 50K-30K
put_balance(account, balance);
return balance;
// = 20K
balance = get_balance(account);
balance -= amount;
// 20K-20K
put_balance(account, balance);
return balance;
// = 0
....$0 ‫בחשבון‬
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
14
‫בנק הפועלים – יש כסף‬
‫ תהליך נפרד מבצע כל פעולת משיכה (על אותו‬
.)‫מעבד‬
balance = get_balance(account);
balance -= amount;
// 50K-30K
balance = get_balance(account);
balance -= amount;
// 50K-20K
put_balance(account, balance);
return balance;
// = 30K
put_balance(account, balance);
return balance;
15 ‫אפריל‬
// = 20K
2 ‫ תרגול‬- ‫מערכות הפעלה‬
?‫מי שמח עכשיו‬
15
‫בעיית יצרן‪/‬צרכן‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪16‬‬
‫קיימים שני תהליכים‪ .‬תהליך ראשון מייצר קלט עבור‬
‫תהליך שני‪.‬‬
‫תהליך שני צורך קלט המיוצר על ידי תהליך ראשון‬
‫תהליך ראשון ממתין עד שהתהליך השני יצרוך את הקלט‬
‫שנוצר‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫בעיית יצרן‪/‬צרכן – סדר אירועים‬
‫יצרן‬
‫יצרתי‬
‫צרכן‬
‫צרוך‬
‫צור‬
‫יצרתי‬
‫צרוך‬
‫יצרתי‬
‫צור‬
‫צרוך‬
‫צור‬
‫יצרתי‬
‫‪17‬‬
‫צרכתי‬
‫צרכתי‬
‫צרכתי‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫דוגמה – הדפסת מספרים‬
‫‪ ‬המשימה – להדפיס סדרת מספרים מ‪ 1-‬עד ‪2000‬‬
‫תוך כדי שימוש בשני תהליכים‬
‫‪ ‬תהליך ‪ – prod‬מייצר מספרים מ‪ 1-‬עד ‪2000‬‬
‫‪ ‬תהליך ‪ – cons‬מדפים מספרים המיוצרים על ידי‬
‫‪prod‬‬
‫‪18‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫דוגמה – הדפסת מספרים‬
‫נראה ‪ 4‬מימושים שונים‪:‬‬
‫‪ ‬המימוש הנאיבי‬
‫‪ ‬סינכרון באמצעות משתנים‬
‫‪ ‬סמפורים‬
‫‪ ‬שליחת הודעות‬
‫‪19‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
NEWSRC/ex41.c – ‫מימוש נאיבי‬
int n=0;
‫מהו הפלט של‬
?‫התכנית‬
xmain)(
{
int prod(), cons();
resume(create(cons,INITSTK,INITPRIO,"cons",0));
resume(create(prod,INITSTK,INITPRIO,"prod",0));
}
prod()
{
int i;
for (i=0; i<2000; i++)
n++;
}
15 ‫אפריל‬
cons()
{
int i;
for (i=0; i<2000; i++)
printf)“n is %d\n”, n(;
}
2 ‫ תרגול‬- ‫מערכות הפעלה‬
20
)‫ בחוברת‬15 '‫מימוש נאיבי – פלט (עמ‬
С:\XINU4WIN\NEWSRC\EXAMPLES>
tcc –Ic:\xinu4win\newsrc ex41.c
c:\xinu4win\newsrc\xinu.lib
Turbo C++ Version3.0.0 Copyright(c) 1992 Borland International
: ex41.c
…
С:\XINU4WIN\NEWSRC\EXAMPLES> ex41.exe
Initializing…
….
‫מה לא‬
__________________________________________________
?‫בסדר‬
?‫איך מתקנים‬
!!!‫מסנכרנים‬
n is 2000
n is 2000
n is 2000
n is 2000
n is 2000
n is 2000
….
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
21
NEWSRC/ex5a.c – ‫סינכרון עם משתנים‬
produced, consumed – ‫ משתנים חדשים‬2 ‫נוסיף‬
int n=0;
volatile int
produced, consumed;
xmain)(
{
int prod(), cons();
produced = 1;
consumed = 0;
resume(create(cons,INITSTK,INITPRIO,"cons",0));
resume(create(prod,INITSTK,INITPRIO,"prod",0));
}
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
22
NEWSRC/ex5a.c – ‫סינכרון תהליכים‬
/* prod -- increment n 2000 times,*/
/* cons -- print n 2000 times, */
/* waiting for it to be consumed
*/
/* waiting for it to be produced */
prod )(
cons)(
{
{
?
‫הבעיה‬
‫מה‬
.
1
int i, k;
int i;
?‫ מהו הפלט‬.2
for (i=1; i<=2000; i++)
{
while(consumed == 0)
;
n++;
produced = 1;
consumed = 0;
}
for (i=1; i<=2000; i++)
{
while(produced == 0)
;
printf("n is %d\n", n);
consumed = 1;
produced = 0;
}
CPU ‫ צריכה מוגברת של משאבי‬,Busy Wait
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
23
)‫ בחוברת‬17 '‫פלט (עמ‬
С:\XINU4WIN\NEWSRC\EXAMPLES>
tcc –Ic:\xinu4win\newsrc ex5a.c
c:\xinu4win\newsrc\xinu.lib
Turbo C++ Version3.0.0 Copyright(c) 1992 Borland International
: ex5a.c
…
С:\XINU4WIN\NEWSRC\EXAMPLES> ex5a.exe
Initializing…
….
__________________________________________________
…
n is 1994
n is 1995
n is 1996
n is 1997
n is 1998
n is 1999
n is 2000
….
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
24
‫תאום באמצעות סמפורים‬
‫סמפור הוא אמצעי תאום עבור תהליכים‬
‫לסמפור שני שדות‪:‬‬
‫‪‬ערך שלם‬
‫‪‬תור של תהליכים ממתינים‬
‫]‪[Dijkstra, 1968‬‬
‫‪25‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫פעולות על סמפור‬
‫)‪wait(semaphore‬‬
‫‪ ‬מקטין את ערך המונה ב‪1-‬‬
‫‪ ‬ממתינים עד שערכו של‬
‫הסמפור אינו שלילי‬
‫)‪signal(semaphore‬‬
‫‪ ‬מגדיל את ערך המונה ב‪1-‬‬
‫‪ ‬משחרר את אחד הממתינים‬
‫‪26‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫תאום תהליכים באמצעות סמפורים‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪27‬‬
‫פעולת ‪ wait‬גורמת לתהליך לחכות עד אשר יתבצע‬
‫‪ signal‬שישחרר אותו‪.‬‬
‫אם בוצע ‪ signal‬לפני כן‪ wait ,‬ממשיך בלי לחכות‪.‬‬
‫אם בוצעו כמה ‪signal‬ים‪ ,‬על כל ‪ signal‬תאופשר‬
‫פעולת ‪ wait‬נוספת ללא המתנה‪.‬‬
‫בעת אתחול הסמפור ניתן ערך המציין את מספר‬
‫פעולות ה‪ wait-‬שיכולות שלא לחכות‪ ,‬ללא קריאות‬
‫ל‪ signal-‬כלל‪.‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫דוגמה – תור לקופה בקולנוע‬
‫‪‬‬
‫התשלום בקופה הוא קטע קריטי‪ :‬רק לאחד מותר‬
‫לבצעו בכל רגע נתון‬
‫‪‬‬
‫כניסה לתור‪wait :‬‬
‫בכל רגע‪ ,‬רק קונה אחד מטופל בקופה‬
‫בסיום התשלום‪ <= signal :‬שחרור הקונה הבא‬
‫לתשלום בקופה‬
‫‪‬‬
‫‪‬‬
‫‪28‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫דוגמה – תור לקופה בקולנוע‬
‫מקרי קצה‪:‬‬
‫‪ ‬כאשר התור אינו ריק הקונה הבא תמיד יחכה‬
‫‪ ‬כאשר תור ריק‪ :‬יש לזכור בנוסף אם הקונה‬
‫הבא צריך לחכות‪ .‬ביצירת הסמפור התור ריק‪,‬‬
‫וערך ההתחלה צריך להיות ‪ 1‬כדי שהקונה‬
‫הראשון לא יחכה‬
‫‪29‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫איתחול הסמפור‬
‫;)>ערך התחלתי<(‪screate‬‬
‫‪ screate ‬תיצור סמפור חדש‬
‫‪ ‬הערך ההתחלתי מציין את מספר פעולות ה‪wait-‬‬
‫שיכולות שלא לחכות‪ .‬ערך זה חייב להיות אי‪-‬שלילי‬
‫(כלומר גדול‪/‬שווה לאפס)‬
‫‪ ‬מחזירה את מזהה הסמפור‪ .‬במקרה של כשלון תחזיר‬
‫‪.SYSERR‬‬
‫‪30‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫‪Wait/Signal‬‬
‫‪‬‬
‫‪ wait‬מבצעת המתנה לסמפור (אם נדרש)‬
‫;)>מזהה סמפור<(‪wait‬‬
‫‪ signal ‬גורמת ל‪ wait-‬נוסף להצליח‪ .‬אם יש תהליכים‬
‫מחכים‪ ,‬ישתחרר הראשון שביקש ‪ wait‬מבין המחכים‬
‫;) >מזהה סמפור< (‪signal‬‬
‫‪31‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫ דיאגרמת מצבים מעודכנת‬- ‫תהליך‬
send
receive
RECEIVING
wait
signal
WAITING
sleep
wake up
SLEEPING
resched
resched
CURRENT
READY
suspend
SUSPENDED
suspend
resume
Create
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
32
NEWSRC/ex5.c – ‫סינכרון עם סמפור‬
int
n=0;
xmain)(
{
int prod(), cons();
int produced, consumed;
consumed = screate(0);
produced = screate(1);
resume(create(prod,INITSTK,INITPRIO,"prod", 2, consumed, produced));
resume(create(cons,INITSTK,INITPRIO,"cons",2, consumed, produced));
}
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
33
NEWSRC/ex5.c – ‫סינכרון עם סמפור‬
prod (consumed, produced)
int consumed, produced;
{
int i;
for (i=1; i<=2000; i++)
{
wait(consumed);
n++;
signal(produced);
cons)consumed, produced)
int consumed, produced
{
int i;
for (i=1; i<=2000; i++)
{
wait(produced);
printf("n is %d\n", n);
signal(consumed);
}
}
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
34
1/0 – ‫דוגמה של מספרים‬
cons_sem
15 ‫אפריל‬
prod_sem
prod
cons
1
0
0
0
0
0
0
1
signal(prod_sem);
-1
1
wait(cons_sem);
-1
0
wait(prod_sem);
-1
0
printf)…(;
0
0
signal(cons_sem);
0
-1
wait(prod_sem);
0
0
0
1
wait(cons_sem);
n++;
n++;
signal(prod_sem);
3 ‫ תרגול‬- ‫מערכות הפעלה‬
35
‫דוגמה של מספרים – ‪0/0‬‬
‫‪cons‬‬
‫‪prod‬‬
‫;)‪wait(cons_sem‬‬
‫;)‪wait(prod_sem‬‬
‫‪prod_sem‬‬
‫‪cons_sem‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪-1‬‬
‫‪-1‬‬
‫‪0‬‬
‫אף אחד לא מצליח להתקדם!!!‬
‫‪36‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪3‬‬
‫אפריל ‪15‬‬
0/1 – ‫דוגמה של מספרים‬
cons_sem
prod
cons
0
1
-1
1
-1
0
wait(prod_sem);
-1
1
printf)…(; // print 0
0
1
signal(cons_sem);
0
0
n++;
0
1
signal(prod_sem);
-1
1
wait(cons_sem);
-1
0
wait(prod_sem);
-1
0
printf)…(; // print 1
0
15 ‫אפריל‬
prod_sem
wait(cons_sem);
0
signal(cons_sem);
3 ‫ תרגול‬- ‫מערכות הפעלה‬
37
1/1 – ‫דוגמה של מספרים‬
cons_sem
15 ‫אפריל‬
prod_sem
prod
cons
1
1
0
1
0
1
0
2
signal(prod_sem);
-1
1
wait(cons_sem);
-1
1
wait(prod_sem);
-1
1
printf)…(; // print 1
0
1
signal(cons_sem);
0
0
wait(prod_sem);
0
0
printf)…(; // print 1
wait(cons_sem);
n++;
3 ‫ תרגול‬- ‫מערכות הפעלה‬
?‫מה נקבל בפלט‬
1 1 …. 2
38
‫העברת הודעות‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪39‬‬
‫תהליכים יכולים לשלוח הודעות אחד לשני‬
‫גודל ההודעה ב‪ XINU-‬הוא ‪ 16( int‬ביט)‬
‫אופן קבלת ההודעה – סינכרוני או אסינכרוני‬
‫לכל תהליך יש "תיבה" שיכולה להכיל הודעה אחת‬
‫שלא נקראה‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫שליחת הודעה‬
‫) >הודעה< ‪>,‬מזהה תהליך< (‪send‬‬
‫‪ send‬שולחת הודעה לתהליך שהמזהה שלו ניתן‬
‫כפרמטר‬
‫‪40‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫שליחת הודעה‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪41‬‬
‫‪ send‬שולחת הודעה לתהליך שמזהה התהליך שלו‬
‫ניתן כפרמטר‬
‫אם לתהליך כבר קיימת הודעה שעדיין לא נקראה‬
‫‪ send‬נכשלת וההודעה לא נשלחת‬
‫‪ send‬מחזירה ‪ SYSERR‬במקרה של כישלון ואת‬
‫הערך של ההודעה במקרה של הצלחה‬
‫‪ send‬לא מחכה עד שהתהליך המקבל יקרא את‬
‫ההודעה‪ ,‬אבל בודק אם התהליך הממתין מחכה‬
‫להודעה‪ .‬אם כן‪ ,‬הוא ישחרר אותו ל – ‪READY‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫שליחת הודעה‬
‫) >הודעה< ‪>,‬מזהה תהליך< (‪sendf‬‬
‫‪ sendf‬שולחת הודעה בדומה ל‪ send-‬אך דורסת‬
‫הודעה קודמת אם עדיין לא נקראה אצל המקבל‬
‫‪42‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫קבלת הודעה‬
‫;)(‪receive‬‬
‫‪‬‬
‫‪‬‬
‫‪43‬‬
‫מחכה לקבלת הודעה ומחזירה אותה כשמגיעה‬
‫אם קיימת הודעה חדשה בזמן הקריאה ל‪,receive-‬‬
‫תקרא ההודעה מבלי לחכות‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
‫קבלת הודעה‬
‫;)(‪receiveclr‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪44‬‬
‫קוראת את ההודעה המחכה אם יש כזאת‪.‬‬
‫אם אין הודעה מחכה‪ ,‬מוחזר ‪OK‬‬
‫בכל מקרה ‪ recvclr‬לא תחכה‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
NEWSRC/ex7.c – ‫הודעות‬
int
int
Int
n=0;
produced;
consumed;
xmain)(
{
int prod(), cons();
consumed = create(cons,INITSTK,INITPRIO,"cons",0);
produced = create(prod,INITSTK,INITPRIO,"prod",0);
resume(consumed);
resume(produced);
}
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
45
NEWSRC/ex7.c – ‫הודעות‬
prod )(
{
int i, k;
for (i=1; i<=2000; i++) {
n++;
send(consumed, n);
k = receive;)(
}
}
?‫ מה יהיה הפלט של התכנית‬
1-‫<< התכנית מדפיסה מספרים מ‬
2000 ‫עד‬
cons )(
{
int i, msg;
for (i=1; i<=2000; i++) {
msg = receive;)(
printf("n is %d\n", msg);
send(produced, 1);
}
}
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
46
‫מצבי קיפאון ‪deadlock -‬‬
‫מצב קיפאון נוצר אם יש קבוצת תהליכים שבה כל‬
‫תהליך ממתין למאורע שיכול להגרם רק על ידי‬
‫תהליך אחר בקבוצה‬
‫‪47‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬
deadlock - ‫מצבי קיפאון‬
‫תהליך ב‬
‫תהליך א‬
wait(sem1)
wait(sem2)
wait(sem2)
wait(sem1)
signal(sem1)
signal(sem2)
signal(sem2)
signal(sem1)
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
48
livelock - ‫מצבי קיפאון‬
pid2 '‫תהליך ב‬
pid1 '‫תהליך א‬
send(pid2, msg);
send(pid1, msg);
while (send(pid2,msg2) == SYSERR);
while (send(pid1, msg2) == SYSERR);
gmsg = receive();
gmsg2 = receive();
gmsg = receive();
gmsg2 = receive();
15 ‫אפריל‬
2 ‫ תרגול‬- ‫מערכות הפעלה‬
49
‫בשעור הבא‪...‬‬
‫‪ ‬קריאות מ"ה לניהול זכרון‬
‫‪ ‬עדיפויות‬
‫‪ ‬מבנה ה‪PC-‬‬
‫‪50‬‬
‫מערכות הפעלה ‪ -‬תרגול ‪2‬‬
‫אפריל ‪15‬‬