1. תרגול 3 – תהליכים, תאום תהליכים
מערכות הפעלה
תרגול 3 – תהליכים, תאום תהליכים

2. מה בתכנית? תיאום תהליכים – המשך עדיפויות תהליכים ב-UNIX
מערכות הפעלה - תרגול 3

3. תאום תהליכים
מערכות הפעלה - תרגול 3

4. תאום תהליכים – למה לתאם? סינכרון פעולות בין תהליכים
סינכרון פעולות בין תהליכים
מניעה הדדית – מנגנונים המבטיחים שרק תהליך אחד מבצע פעילות מסוימת
הגנה על משאב משותף
דוגמה: מדפסת, CD, זכרון, מסד נתונים
הגנה על קוד משתמש משותף (קטע קריטי)
מערכות הפעלה - תרגול 3

5. קטע קריטי (critical section)
קטע קריטי הוא קטע קוד שמבוצע רק על ידי תהליך אחד בו זמנית
מבנה:
shared section
trying/entry section
critical section
exit section
דוגמה – בנק הפועלים מהתרגול הקודם
מערכות הפעלה - תרגול 3

6. קטע קריטי (critical section)
אין הרעבה –> אין קיפאון
אבל ההיפך אינו נכון
תכונות רצויות:
רק תהליך אחד נמצא בקטע קריטי (מניעה הדדית – mutual exclusion)
אם יש בקשות לקטע הקריטי אזי לפחות תהליך אחד נכנס לקטע הקריטי (אין קיפאון no deadlock)
הוגנות (fairness)- אם תהליך מבקש להכנס לקטע הקריטי אזי יצליח בסופו של דבר (אין הרעבה no starvation)
מערכות הפעלה - תרגול 3

7. קטע קריטי (critical section)
אטומיות- פעולה (סדרת פקודות) של תהליך אחד מבוצעת ללא חפיפה עם פעולה (סדרת פקודות) של תהליך אחר
מניעה הדדית (ביצוע סדרת הפקודות בתוך קטע קריטי) הינה דרך להבטיח אטומיות באמצעות תוכנה
אבל לא הדרך היחידה אפשר גם בחומרה
מערכות הפעלה - תרגול 3

8. קטע קריטי (critical section)
semaphore lock;
...
read_security_code(screen);
amount = read_amount(screen);
wait(lock) // acquire lock
balance = get_balance(account);
balance -= amount; // 50K-20K
put_balance(account, balance);
return balance; // = 30K
קטע קריטי
signal(lock) // release lock
show_balance(screen, balance);
...
מערכות הפעלה - תרגול 3

9. דוגמאות לבעיות בתחום תאום תהליכים
כותבים/קוראים
המספרה והספר הישן
הפילוסופים הסועדים
מערכות הפעלה - תרגול 3

10. בעיית כותבים/קוראים מוטיבציה: גישה למסד הנתונים
שני סוגי תהליכים – קוראים וכותבים
כמה קוראים ביחד יכולים לגשת למסד נתונים בו זמנית
כותב אחד בלבד יכול לגשת בו זמנית
קוראים
כותב
מערכות הפעלה - תרגול 3

11. מי ירוץ יותר – קוראים או כותבים?
בעיית כותבים/קוראים
int readers = 0 // # of reading processes
semaphore rc_access = 1; // controls access to rc
semaphore db = 1; // controls database access
void reader(void){
while(TRUE){
wait(rc_access);
readers = readers + 1;
if(readers == 1)
wait(db);
signal(rc_access);
read_data_base();
readers = readers - 1;
if(readers == 0)
signal(db);
signal(rc_access); } }
void writer(void){
while(TRUE){
wait(db);
write_data_base()
signal(db) }
מי ירוץ יותר – קוראים או כותבים?
מערכות הפעלה - תרגול 3

12. בעיית כותבים/קוראים
אף קורא לא מחכה אם הגישה למסד נתונים היא לא בידי הכותב (סמפור db)
אם קוראים חדשים מגיעים כל הזמן ומחזיקים בסמפור db– הרעבה של כותב
עדיף לדרוש תנאי: אף כותב לא מחכה עם הוא "מוכן" – אם כותב מחכה אף קורא נוסף לא יכול להתחיל לקרא
מערכות הפעלה - תרגול 3

13. המספרה, או בעיית הספר הישן
קיים ספר אחד ו-N כסאות ללקוחות שמחכים
אם אין לקוחות אז הספר יושב בכיסא וישן (כמו בתמונה)
כשמגיע לקוח חדש והספר ישן הוא יעיר את הספר
כשהלקוח מגיע והספר עסוק הוא ישב על אחד הכסאות, אם קיים כיסא פנוי, אחרת (הכל מלא) הוא יעזוב
מערכות הפעלה - תרגול 3

14. בעיות שעלולות להתעורר:
לקוח מגיע, רואה שהספר עסוק, מתיישב ומחכה. כשהו בדרכו להתיישב, הספר מסיים את התספורת והולך לבדוק את חדר ההמתנה. מאחר ואין שם אף אחד הוא חוזר לישון.
שני לקוחות מגיעים באותו זמן, רואים שהספר עסוק, רואים שיש כיסא אחד פנוי ומנסים להתיישב. שנייהם ינסו להתיישב באותו כיסא.
מערכות הפעלה - תרגול 3

15. המספרה, או בעיית הספר הישן
int customers = 0;
access = semaphore(1);
customer = semaphore(0);
barber = semaphore(0);
void customer (void) {
while(TRUE){
wait(access);
if (customers>=CHAIRS) {
signal(access);
leave_shop(); }
customers +=1;
signal(customer);
wait(barber);
getHairCut();
customers -=1;
void barber (void) {
while(TRUE){
wait(customer);
signal(barber);
cutHair(); }
מערכות הפעלה - תרגול 3

16. הפילוסופים הסועדים חמישה פילוסופים מעבירים את זמנם באכילה ומחשבה
כל פילוסוף צריך 2 מזלגות כדי לאכול
פילוסוף לא יכול לקחת יותר ממזלג אחד בו זמנית
* פילוסוף – תהליך, מזלג - משאב
מערכות הפעלה - תרגול 3

17. הפילוסופים הסועדים האם הכל בסדר? void philosopher() { while(1) {
think();
get_left_fork();
get_right_fork();
eat();
put_left_fork();
put_right_fork(); }
אם כל פילוסוף יבחר במזלג שמאלי
באותו זמן אף אחד לא הולך
לאכול... אף פעם! סכנה של Deadlock!
מערכות הפעלה - תרגול 3

18. הפילוסופים – מה עושים? קח מזלג מצד שמאל. אם המזלג מצד ימין פנוי קח
אותו גם. אם לא, תחזיר מזלג שלקחת, חכה ונסה שוב.
2 בעיות:
אם כל הפילוסופים מחכים אותו פרק זמן – חוזרים לאותו מצב כמו קודם
אם הזמנים הם שונים עדיין ייתכן ויהיה פילוסוף חסר מזל שיישאר רעב (במובן המילולי והטכני)
מערכות הפעלה - תרגול 3

19. אז מה בכל זאת?
רעיון: להשתמש בגורם נוסף שממנו יבקשו משאבים, והוא לא ירשה לקחת מזלג חמישי.
מערכות הפעלה - תרגול 3

20. הפילוסופים הסועדים
ולבעיה האמיתית...
מערכות הפעלה - תרגול 3

21. עדיפויות תהליכים
מערכות הפעלה - תרגול 3

22. עדיפויות תהליכים
עדיפות משפיעה על תדירות ההכנסה של תהליך לריצה פעילה ועל מיקומו בתור התהליכים המחכים למעבד
הגדרת עדיפות גבוהה לתהליך מבטיחה שירוץ ללא הפרעות מצידם של תהליכים עם עדיפות נמוכה (למשל, אנטיוירוס)
במ"ה מודרניות עדיפויות יכולות להשתנות בזמן ריצה של התהליך כתלות בהתנהגותו
מערכות הפעלה - תרגול 3

23. תהליכים עם עדיפויות זהות
ריצת תהליכים ב-CPU
תור תהליכים 2 1 3 2 2 A 1 A 1 3 2 1 2 2 B 1 1 2 2 2 3 A 2 1 2 3 2 1 A 3 1 2 2 B 1 2 2 3 A 1 2
זמן
תהליך במעבד
מערכות הפעלה - תרגול 3

24. תהליכים עם עדיפויות שונות
pid1 – עדיפות20 , pid2- עדיפות 20, 3pid – עדיפות 21
ריצת תהליכים ב-CPU
תור תהליכים B 1 1 2 2 2 1 1 2 2 2 3 A A 1 1 2 2 2 2 1 1 A 1 2 A 2 1 2 1 A 1 2
זמן
מערכות הפעלה - תרגול 3

25. יצירת תהליכים עם עדיפויות שונות ex8.c
int count1 = 0, count2 = 0, count3 = 0;
xmain() {
int Inc(), Pr();
resume( create(Inc, INITSTK, INITPRIO, "proc 1", 1, &count1) );
resume( create(Inc, INITSTK, INITPRIO, "proc 2", 1, &count2) );
resume( create(Inc, INITSTK, INITPRIO - 1, "proc 3", 1, &count3) );
resume( create(Pr, INITSTK, INITPRIO + 1, "proc 4", 0) ); }
Inc<i> - מוסיף 1 ל-count<i>
Pr – מדפיס מונים count1, count2, count3
האם ניתן למחוק sleep()?
Inc(int ptr) {
int *ptr1;
ptr1 = (int *)ptr;
while (1)
(*ptr1)++; }
Pr() {
while(1)
sleep(3);
printf("count1 = %d, count2 = %d, count3 = %d\n",
count1, count2, count3); }
מערכות הפעלה - תרגול 3

26. יצירת תהליכים עם עדיפויות שונות ex8.c
למה המספרים מודפסים
עם "-"?
מערכות הפעלה - תרגול 3

27. יצירת תהליכים עם עדיפויות שונות ex8.c
unsigned long int count1 = 0, count2 = 0, count3 = 0;
xmain() {
int Inc(), Pr();
resume( create(Inc, INITSTK, INITPRIO, "proc 1", 1, &count1) );
resume( create(Inc, INITSTK, INITPRIO, "proc 2", 1, &count2) );
resume( create(Inc, INITSTK, INITPRIO - 1, "proc 3", 1, &count3) );
resume( create(Pr, INITSTK, INITPRIO + 1, "proc 4", 0) ); }
Inc(int ptr) {
unsigned long int *ptr1;
ptr1 = (unsigned long int *)ptr;
while (1)
(*ptr1)++; }
Pr() {
while(1)
char str[80];
sleep(3);
sprintf("count1 = %lu, count2 = %lu,
count3 = %lu \n", count1, count2, count3);
printf(str); }
מערכות הפעלה - תרגול 3

28. יצירת תהליכים עם עדיפויות שונות ex8.c
מערכות הפעלה - תרגול 3

29. תהליכים בסביבת LINUX/UNIX
מערכות הפעלה - תרגול 3

30. תהליכים בסביבת LINUX/UNIX
כל תהליך נוצר כעותק של תהליך קיים
התהליך המקורי נקרא תהליך אב (או הורה)
התהליך החדש נקרא תהליך בן
תהליך הבן נוצר בעקבות ביצוע קריאת מערכת הפעלה fork() על-ידי תהליך האב
תהליך אב יכול ליצור יותר מתהליך בן אחד
מערכות הפעלה - תרגול 3

31. יצירת תהליך קריאת המערכת fork() תחביר:
pid_t fork();
פעולה: מעתיקה את תהליך האב לתהליך הבן וחוזרת בשני התהליכים
קוד זהה (ומיקום בקוד)
זיכרון זהה (משתנים וערכיהם, חוצצים)
סביבה זהה (קבצים פתוחים, file descriptors, ספרית עבודה נוכחית)
פרמטרים: אין
ערך מוחזר:
במקרה של כישלון: -1 לאב (אין בן)
במקרה של הצלחה: לבן מוחזר 0 ולאב מוחזר ה-pid של הבן
מערכות הפעלה - תרגול 3

32. יצירת תהליך
לאחר פעולת fork() מוצלחת, אמנם יש לאב ולבן את אותם משתנים בזיכרון, אך בעותקים נפרדים
כלומר, שינוי ערכי המשתנים אצל האב לא ייראה אצל הבן, וההיפך
כמו כן, תהליך הבן הוא תהליך נפרד מתהליך האב לכל דבר. בפרט, יש לו pid משלו
מה מדפיס הקוד הבא?
main() {
fork();
printf(“hello”); }
מערכות הפעלה - תרגול 3

33. איך מבדילים בן אב לבן? תשובות אפשריות (בהנחה ש-fork() הצליחה):
hellohello
hheellollo
הסיבה: שני תהליכים כותבים פלט בצורה לא מתואמת
מבנה תכנית אופייני המשתמש ב-fork():
status = fork();
if (status < 0)
// fork() failed – handle error (e.g. message & exit)
if (status == 0)
// son process – do son code
else
// father process – do father code
מערכות הפעלה - תרגול 3

34. הרצת תכנית אחרת קריאת המערכת execv() תחביר:
int execv(const char *filename, char *const argv[]);
פעולה: טוענת תכנית חדשה לביצוע על-ידי התהליך הקורא
פרמטרים:
filename – מסלול אל הקובץ המכיל את התכנית לטעינה
ערך מוחזר:
במקרה של כישלון: -1
במקרה של הצלחה: הקריאה אינה חוזרת. איזורי הזיכרון של התהליך מאותחלים לתכנית החדשה שמתחילה להתבצע מההתחלה.
argv – מערך מצביעים למחרוזות המכיל את הפרמטרים עבור התכנית. האיבר הראשון מקיים argv[0] == filename או רק מכיל את שם קובץ התכנית. האיבר שאחרי הפרמטר האחרון מכיל NULL
מערכות הפעלה - תרגול 3

35. הרצת תכנית אחרת מה ידפיס הקוד הבא? התשובה: main() {
char *argv[] = {“date”, NULL};
execv(“/bin/date”, argv);
printf(“hello”); }
התשובה:
אם execv() מצליחה: את התאריך והשעה
אם execv() נכשלת: hello
מערכות הפעלה - תרגול 3

36. דוגמה לשילוב דוגמה אופיינית לשילוב fork() עם execv(): pid = fork();
if (pid < 0) {
handle fork() error }
if (pid > 0)
// do father code
else
execv(“son_prog”, argv_son);
מערכות הפעלה - תרגול 3

37. עצירת תהליך קריאת המערכת exit() תחביר:
void exit(int status);
פעולה: מסיימת את ביצוע התהליך הקורא ומשחררת את כל המשאבים שברשותו. התהליך עובר למצב zombie עד שתהליך האב יבקש לבדוק את סיומו ואז יפונה לחלוטין
פרמטרים:
status – ערך סיום המוחזר לאב אם יבדוק את סיום התהליך
ערך מוחזר: הקריאה אינה חוזרת
מערכות הפעלה - תרגול 3

38. תהליכי Zombie
כדי לאפשר לאב לקבל מידע על סיום הבן, לאחר שתהליך מסיים את פעולתו הוא עובר למצב מיוחד – zombie – שבו התהליך קיים כרשומת נתונים בלבד ללא שום ביצוע משימה
הרשומה נמחקת לאחר שהאב קיבל את המידע על סיום הבן
מה קורה לתהליך שהופך ל"יתום" (orphan) לאחר שאביו כבר סיים?
התהליך הופך להיות בן של תהליך איתחול במערכת ההפעלה
מערכות הפעלה - תרגול 3

39. בשיעור הבא...
מימוש תהליכים ב-XINU
מערכות הפעלה - תרגול 3