unix chapter 6

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

קריאות מערכת ההפעלה – 6תרגול

Shayke Bilu PhD Chapter 6 - System Calls 1

Chapter 6 - System Calls 2 Shayke Bilu PhD

?מה בתכנית

המשך –שימוש בקריאות מערכת הפעלה

חזרה -תהליכים

העברת הודעות

תאום תהליכים


קריאות מערכת הפעלה

משתמש יכול לגשת רק

לקריאות מערכת

הפעלה

פונקציות פנימיות של

מערכת הפעלה מוגנות

מפני המשתמש

תכניות משתמש

מערכת ההפעלה

חומרה

קריאות

מערכת

הפעלה


תהליכים

של תכנית ביצועהוא תהליך

של הרצת מספר אשליהתהליכים יוצרים

אפליקציות במקביל

לתכנית אחת יכולים , תכנית אחת –לכל תהליך

להיות תהליכים רבים מתבצעים בו זמנית


דיאגרמת מצבים -תהליך

SUSPENDED

CURRENT READY

SLEEPING

Create

suspend

resume

suspend

resched resched

sleep wake up


create -יצירת תהליכים

XINU יצירת תהליך מתבצעת באמצעות. תומכת בריבוי תהליכים

createקריאת מערכת הפעלה

сreate( <שם הפונקציה הראשית>,

,<גודל מחסנית לתהליך>

,<עדיפות>

,<שם התהליך>

< פרמטרים' מס >, < 1' פרמ >, < 2' פרמ >, …, < n פרמ ' > );


הכנסת תהליך מושעה לריצה

(תהליך חדש שנוצר כרגע: לדוגמא)תהליך מושעה

י קריאת"לריצה ע( READY)בו הוא מוכן עובר למצב

resume. מערכת הפעלה

resume ( <מזהה תהליך> );

ומהרגע הזה מחכה READYהתהליך עובר למצב

בתור לכניסה למעבד


השעיית תהליך

ניתן להשעות תהליך מריצה באמצעות קריאת מערכת

.הפעלה

suspend( <מזהה תהליך> );

ניתן להשעות תהליך רק אם הוא רץ כרגע או מוכן

.לריצה


סיום נורמלי של תהליך מתבצע כאשר מסתיימת

.הפונקציה הראשית שלו

על ידי( להרוג אותו)ניתן לגרום לסיום התהליך לפני כן

killה "קריאת מ

kill( <מזהה תהליך> );

:קריאת התאבדות. תהליך יכול להרוג את עצמו

kill(getpid());

getpid() – מחזיר את המזהה של התהליך

סיום תהליך


<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’(;

}

:פלט

AAAAABBBBBBBAAAAA

AAAAAAAAAAAAAABBB

BAAAAAAAAAAAAAA



ניתן לתאם בין כמה תהליכים על ידי פנייה

אם קיימות )לקריאות מיוחדות של מערכת הפעלה

(.שם

כל תהליך המעוניין בתאום מבקש ממערכת

תעצרי אותי ותפעילי מחדש כשייתקימו התנאים "

"שאקבע

על כותב התכנית לדאוג , התאום לא יקרה אוטומטי

לכך שהתאום יתבצע



:התאום האפשרי

תהליך מחכה עד שתהליך אחר יסיים פעולה

(צרכן/יצרן)מסויימת

כך שלא , ביצוע מניעה הדדית על משאב משותף

ייתכן ששני תהליכים ישנו אותו באותו זמן



בנק הפועלים

מימשנו פונקציה למשיכת כסף מחשבון בנק.

int withdraw( account, amount) {

balance = get_balance( account );

balance -= amount;

put_balance( account, balance);

return balance;

}

ושני בעלי החשבון ניגשים לכספומטים שונים , 50000$בחשבון יש

.זמנית-בו 20000$-ו 30000$ומושכים


?אין כסף –בנק הפועלים

על אותו )תהליך נפרד מבצע כל פעולת משיכה

(מעבד

.... 0$בחשבון

balance = get_balance(account);

balance -= amount; // 50K-30K

put_balance(account, balance);

return balance; // = 20K




return balance; // = 0


יש כסף –בנק הפועלים

על אותו )תהליך נפרד מבצע כל פעולת משיכה

(.מעבד

?מי שמח עכשיו










צרכן/בעיית יצרן

קלט עבור מייצרתהליך ראשון . קיימים שני תהליכים

. תהליך שני

קלט המיוצר על ידי תהליך ראשון צורךתהליך שני

תהליך ראשון ממתין עד שהתהליך השני יצרוך את הקלט

שנוצר


סדר אירועים –צרכן /בעיית יצרן

צרכן יצרן

צרוך

צור

צרוך

צור

צרוך

צור

.

.

.

יצרתי

צרכתי

צרכתי

צרכתי

יצרתי

יצרתי

יצרתי


הדפסת מספרים –דוגמה

2000עד 1-להדפיס סדרת מספרים מ –המשימה

תוך כדי שימוש בשני תהליכים

תהליךprod – 2000עד 1-מייצר מספרים מ

תהליךcons – מדפים מספרים המיוצרים על ידי

prod


הדפסת מספרים –דוגמה

:מימושים שונים 4נראה

המימוש הנאיבי

סינכרון באמצעות משתנים

סמפורים

שליחת הודעות


int n=0;

xmain)(

{

int prod(), cons();

resume(create(cons,INITSTK,INITPRIO,"cons",0));

resume(create(prod,INITSTK,INITPRIO,"prod",0));

}

NEWSRC/ex41.c –מימוש נאיבי

prod()

{

int i;

for (i=0; i<2000; i++)

n++;

}

cons()

{

int i;

for (i=0; i<2000; i++)

printf)“n is %d\n”, n(;

}

מהו הפלט של

?התכנית


(בחוברת 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

….

מה לא

?בסדר ?איך מתקנים

!!!מסנכרנים


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));

}

NEWSRC/ex5a.c –סינכרון עם משתנים

produced, consumed –משתנים חדשים 2נוסיף


NEWSRC/ex5a.c –סינכרון תהליכים

/* prod -- increment n 2000 times,*/

/* waiting for it to be consumed */

prod )(

{

int i, k;

for (i=1; i<=2000; i++)

{

while(consumed == 0)

;

n++;

produced = 1;

consumed = 0;

}

/* cons -- print n 2000 times, */

/* waiting for it to be produced */

cons)(

{

int i;

for (i=1; i<=2000; i++)

{

while(produced == 0)

;

printf("n is %d\n", n);

consumed = 1;

produced = 0;

}

?מה הבעיה. 1

Busy Wait , צריכה מוגברת של משאביCPU

?מהו הפלט. 2


(בחוברת 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

….


תאום באמצעות סמפורים

הוא אמצעי תאום עבור תהליכים סמפור

:לסמפור שני שדות

ערך שלם

תור של תהליכים ממתינים

[Dijkstra, 1968]


פעולות על סמפור

wait(semaphore)

1-מקטין את ערך המונה ב

ממתינים עד שערכו של הסמפור

אינו שלילי

signal(semaphore)

1-מגדיל את ערך המונה ב

משחרר את אחד הממתינים


תאום תהליכים באמצעות סמפורים

פעולתwait גורמת לתהליך לחכות עד אשר יתבצע

signal שישחרר אותו.

אם בוצעsignal לפני כן ,wait ממשיך בלי לחכות .

תאופשר signal על כל , יםsignalאם בוצעו כמה

.נוספת ללא המתנה waitפעולת

בעת אתחול הסמפור ניתן ערך המציין את מספר

ללא קריאות, שיכולות שלא לחכות wait-פעולות ה

.כלל signal-ל


רק לאחד מותר : התשלום בקופה הוא קטע קריטי

לבצעו בכל רגע נתון

כניסה לתור :wait

רק קונה אחד מטופל בקופה, בכל רגע

בסיום התשלום : signal= < שחרור הקונה הבא

לתשלום בקופה

תור לקופה בקולנוע –דוגמה


תור לקופה בקולנוע –דוגמה

:מקרי קצה

כאשר התור אינו ריק הקונה הבא תמיד יחכה

יש לזכור בנוסף אם הקונה : כאשר תור ריק

, ביצירת הסמפור התור ריק. הבא צריך לחכות

כדי שהקונה 1וערך ההתחלה צריך להיות

הראשון לא יחכה


איתחול הסמפור

screate(<ערך התחלתי>);

screateתיצור סמפור חדש

הערך ההתחלתי מציין את מספר פעולות ה-wait

שלילי-ערך זה חייב להיות אי. שיכולות שלא לחכות

(שווה לאפס/כלומר גדול)

במקרה של כשלון תחזיר . מחזירה את מזהה הסמפור

SYSERR .


Wait/Signal

wait (אם נדרש)מבצעת המתנה לסמפור

wait(<מזהה סמפור>);

signal גורמת ל-wait אם יש תהליכים. נוסף להצליח

מבין המחכיםwait ישתחרר הראשון שביקש , מחכים

signal( <מזהה סמפור> );


דיאגרמת מצבים מעודכנת -תהליך

SUSPENDED

CURRENT READY

SLEEPING

Create

suspend

resume

suspend

resched resched

sleep wake up

WAITING

RECEIVING

receive send

wait signal


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));

}

NEWSRC/ex5.c –סינכרון עם סמפור


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);

}


1/0 –דוגמה של מספרים

cons_sem prod_sem prod cons

1 0

0 0 wait(cons_sem);

0 0 n++;

0 1 signal(prod_sem);

-1 1 wait(cons_sem);

-1 0 wait(prod_sem);

-1 0 printf)…(;

0 0 signal(cons_sem);

0 0 n++;


0 -1 wait(prod_sem);




0 0


0 -1 wait(prod_sem);

!!!אף אחד לא מצליח להתקדם




0 1

1- 1 wait(cons_sem);

1- 0 wait(prod_sem);

-1 1 printf)…(; // print 0


0 0 n++;









1 1

0 1 wait(cons_sem);

0 1 n++;






0 0 printf)…(; // print 1

0 0 wait(prod_sem);

?מה נקבל בפלט

1 1 …. 2


תהליכים יכולים לשלוח הודעות אחד לשני

גודל ההודעה ב-XINU הואint (16 ביט)

סינכרוני או אסינכרוני –אופן קבלת ההודעה

שיכולה להכיל הודעה אחת " תיבה"לכל תהליך יש

שלא נקראה

העברת הודעות


send( <הודעה> ,<מזהה תהליך> )

send שולחת הודעה לתהליך שהמזהה שלו ניתן

כפרמטר

שליחת הודעה



send שולחת הודעה לתהליך שמזהה התהליך שלו

ניתן כפרמטר

אם לתהליך כבר קיימת הודעה שעדיין לא נקראה

send נכשלת וההודעה לא נשלחת

send מחזירה SYSERR במקרה של כישלון ואת

הערך של ההודעה במקרה של הצלחה

send לא מחכה עד שהתהליך המקבל יקרא את

אבל בודק אם התהליך הממתין מחכה , ההודעה

READY –הוא ישחרר אותו ל , אם כן. להודעה



sendf( <הודעה> ,<מזהה תהליך> )

sendf שולחת הודעה בדומה ל-send אך דורסת

הודעה קודמת אם עדיין לא נקראה אצל המקבל


קבלת הודעה

receive();

מחכה לקבלת הודעה ומחזירה אותה כשמגיעה

אם קיימת הודעה חדשה בזמן הקריאה ל-receive ,

תקרא ההודעה מבלי לחכות


קבלת הודעה

receiveclr();

קוראת את ההודעה המחכה אם יש כזאת.

מוחזר , אם אין הודעה מחכהOK

בכל מקרהrecvclr לא תחכה


int n=0;

int produced;

Int consumed;

xmain)(

{

int prod(), cons();

consumed = create(cons,INITSTK,INITPRIO,"cons",0);

produced = create(prod,INITSTK,INITPRIO,"prod",0);

resume(consumed);

resume(produced);

}

NEWSRC/ex7.c –הודעות


NEWSRC/ex7.c –הודעות

prod )(

{

int i, k;

for (i=1; i<=2000; i++) {

n++;

send(consumed, n);

k = receive )(;

}

} cons )(

{

int i, msg;

for (i=1; i<=2000; i++) {

msg = receive )(;

printf("n is %d\n", msg);

send(produced, 1);

}

}

מה יהיה הפלט של התכנית? 1-התכנית מדפיסה מספרים מ>>

2000עד


deadlock -מצבי קיפאון

מצב קיפאון נוצר אם יש קבוצת תהליכים שבה כל

תהליך ממתין למאורע שיכול להגרם רק על ידי

תהליך אחר בקבוצה


deadlock -מצבי קיפאון

תהליך ב תהליך א

wait(sem1)

wait(sem2)

wait(sem2)

wait(sem1)

signal(sem1)

signal(sem2)

signal(sem2)

signal(sem1)


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();


ה לניהול זכרון"קריאות מ

עדיפויות

מבנה ה-PC

...בשעור הבא

unix chapter 6

Documents