1. פרק 3 - תהליכים

2. פרק 3 - תהליכים תפישת התהליכים: תיזמון תהליכים:
פעולות על תהליכים: יצירת תהליך (fork, exec , createprocess), סיום תהליך
שיתוף תהליכים
תקשורת בין תהליכים
תקשורת במערכות שרת - לקוח

3. תפישת התהליכים מערכת הפעלה מבצעת מגוון תוכניות במערכות אצווה – jobs
במערכות שיתוף זמנים – תוכניות משתמש ומטלות
בספרי הלימוד משתמשים לפעמים במילה process ולפעמים במילה job
תהליך – process – תוכנית בביצוע; תהליך מתבצע בצורה טורית
תהליך כולל :
מונה תוכנית
ערמה - stack
אזור נתונים

4. תהליך בזיכרון Text- הקוד של התוכנית Data – משתנים גלובליים
Heap – קטע זיכרון שמיועד להקצאה דינאמית תוך כדי ביצוע התוכנית
Stack – מקום בזיכרון המיועד למשתנים זמניים, פרמטרים, כתובות להחזרת נתונים מפונקציות, משתנים מקומיים

5. מצב התהליך תוך כדי ביצוע התהליך משנה את מצבו: חדש – התהליך נוצר
תוך כדי ביצוע התהליך משנה את מצבו:
חדש – התהליך נוצר
מבוצע – ההוראות של התהליך מתבצעות
ממתין – התהליך ממתין לארוע כמו קלט פלט או אות.
מוכן - התהליך מחכה בתור למעבד
גמור – התהליך הסתיים

6. תרשים המצבים של התהליכים – (תרשים החילזון )

7. Process Control Block (PCB)
נתונים הקשורים לכל תהליך
מצב התהליך: חדש, מוכן, מתבצע, ממתין חסום וכו'
מונה תוכנית: מצביע על הכתובת של ההוראה הבאה
אוגרים של המעבד (המצביעים על מצב המערכת במקרה של פסיקה). מספר האוגרים שונה ממערכת למערכת.
נתוני תזמון של המעבד – קדימויות תזמון, מצביעים לתורים של התזמון וכו'.
נתוני ניהול הזיכרון – מצביעים לדפי הזיכרון גבולות הזיכרון וכו'.
נתוני Accounting))חישובים כמו מקום בזיכרון, זמן ביצוע, מגבלות זמן ביצוע, מספר תהליך ועוד.
נתוני מצב קלט פלט. כוללים רשימת ההתקנים המוקצבים לתהליך, רשימת קבצים פתוחים וכד'.

8. Process Control Block (PCB)

9. מעבר ה-CPUבין התהליכים

10. תורים לתזמון תהליכים
תור לביצוע - Job queue - תור של כל התהליכים במערכת
תור מוכנים - Ready queue - כל התהליכים בזיכרון הממתינים לביצוע
תור התקנים - Device queues התהליכים הממתינים להתקן קלט/פלט
תהליכים עוברים בין התורים השונים

11. Ready Queue And Various I/O Device Queues

12. הצגה של תזמון תהליכים

13. מתזמנים
מתזמן לזמן ארון - Long-term scheduler – מתזמן זה בוחר את התהליכים שיש להכניס למצב מוכן
מתזמן לזמן קצר - Short-term scheduler בוחר את התהליך הבא לביצוע ומקצה עבורו CPU
יש מערכות שבהם מוסיפים מתזמן לתווך בינוני

14. תוספת של תזמון לזמן בינוני

15. מתזמנים המשך
מתזמן לזמן קצר מופעל לעתים קרובות מאד – מילישניות => חייב להיות מהיר
מתזמן לזמן ארוך מופעל לעתים רחוקות – שניות, דקות => יכול להיות איטי
המתזמן לזמן ארוך קובע את רמת ריבוי התוכניות (multiprogramming) קובע את מספר התוכניות המופעלות בו זמנית
תהליך יכול להיות:
מונחה קלט/פלט – מבזבז את רוב הזמן בביצוע פעולות קלט ופלט פניה ל-cpu בפרקי זמן קצרים
מונחה CPU – מבלה את רוב הזמן בביצוע חישובים. פניות ל-CPU מעטות אבל ארוכות .
המתזמן לזמן ארוך חייב לשמור על האיזון ביניהם כדי שלא יווצר חוסר איזון ביניהם.
בחלק מהמערכות המתזמן לזמן ארוך הוא מינימלי או לא קיים בכלל. לדוגמה ב-unix וב-windows. כל תהליך חדש מתקבל ואז אין צורך במתזמן לתווך ארוך.

16. החלפת סביבת עבודה - Context Switch
כאשר ה-CPU עובר לתהליך אחר המערכת חייבת לשמור את המצב של התליך הישן ולטעון את המצב של התהליך החדש
זמן המעבר הוא זמן תקורה, המערכת לא עובדת בצורה יעילה בזמן המעבר
הזמן תלוי בתמיכת החומרה: במעבדי spark יש מספר סטים של אוגרים לכן שינוי context מבוצע ע"י שינוי מצביע

17. יצירת תהליך
תהליך אב יוצר תהליכי בנים ואלה יכולים ליצור עוד תהליכים, התוצאה היא עץ של תהליכים.
שיתוף משאבים – יכולים להווצר מספר אפשרויות
הורה וילדים שותפים לכל המשאבים
ילדים שותפים רק בחלק מהמשאבים של האב
אב וילדים לא שותפים למשאבים
ביצוע – יכולים להיות המצבים הבאים
אב וילדים מתחרים על הביצוע (CPU, קלט/פלט ...)
אב ממתין לסיום הבנים

18. יצירת תהליך המשך לכל תהליך יש מספר מזהה pid מרחב הכתובות בזיכרון
בן משוכפל מאב
לבן יש תוכנית טעונה במרחב
דוגמה UNIX
Fork קריאת מערכת היוצרת תהליך חדש
Exec קריאת מערכת אחרי ה-fork להחלפת הזיכרון שנוצר בתוכנית החדשה
עד כאן לא כולל 19.9

19. יצירת תהליך

20. דוגמה של תוכנית בשפת C היוצרת תהליך חדש
int main() {
pid_t pid;
/* fork another process */
pid = fork();
if (pid < 0) { /* error occurred */
fprintf(stderr, "Fork Failed");
exit(-1); }
else if (pid == 0) { /* child process */
execlp("/bin/ls", "ls", NULL);
else { /* parent process */
/* parent will wait for the child to complete */
wait (NULL);
printf ("Child Complete");
exit(0);

21. עץ תהליכים על מערכת Solaris
Pageout – אחראי לניהול הזיכרון
Fsflush – אחראי לניהול מערכת הקבצים.
init – הוא התהליך האחראי לאיתחול המערכת
Inetd – אחראי ללשרותי רשת
Dtlogin – אחראי למסך הכניסה של המשתמש

22. יצירת תהליך ב-windows

23. יצירת תהליך ב-windows

24. סיום תהליך
התהליך מבצע את ההוראה האחרונה ומבקש ממערכת ההפעלה לבטל אותו (exit)
הוצאת נתונים מבן לאב (דרך wait)
משאבי התהליך משוחררים ע"י מערכת ההפעלה
אב יכול לסיים ביצוע של ילדים (abort)
בן גמר את המשאבים המוקצבים לו
המשימה שיועדה לבן לא נדרשת יותר
אם ההורה יוצא
במערכות הפעלה מסוימות לא מרשים לילד להמשיך אם ההורה הסתיים
כל הילדים גמורים – סיום בקסקדה

25. שיתוף בין תהליכים
תהליך עצמאי לא יכול להשפיע או להיות מושפע ע"י תהליך אחר. Independent process
תהליך שיתופי יכול להשפיע או להיות מושפע ע"י תהליך אחר – cooperating process
יתרונות של שיתוף תהליכים
שיתוף מידע
חישובים מהירים יותר
מודולריות
נוחות

26. שיתוף בין תהליכים -שיטות
יש שתי שיטות
זיכרון משותף – Shared Memory Systemמהירה יותר אין צורך לערב את ה-kernel רק בהקמה. קשה יותר למימוש.
העברת הודעות - יותר בטוחה קלה יותר למימוש. איטית יותר. ה-לקרמקל מעורב בכל העברה של חבילה. חבילות קטנות.

27. שיתוף בין תהליכים -שיטות
A –העברת הודעות b – שיתוף זיכרון

28. שיתוף בין תהליכים –זיכרון משותף
בשיטה זו התהליכים משתפים זיכרון משותף.
התהליכים המשתפים צריכים להוריד את האיסור לגשת למרחב הזיכרון שלהם.
תהליך יוצר במרחב הזיכרון שלו קטע זיכרון לשיתוף
תהליך או תהליכים אחרים מצרפים את הקטע הזה למרחב הזיכרון שלהם.
כל תהליך השיתוף הוא באחראיות התהליכים עצמם.
אחת הבעיות שנוצרות בזיכרון משותף היא בעית יצרן צרכן.

29. שיתוף בין תהליכים -בעית יצרן - צרכן
המודל של שיתוף תהליכים תהליך יצרן מפיק מידע שתהליך צרכן משתמש בו. צריך להיות תאום כדי שהצרכן לא ידרוש נתון שעדין היצרן לא יצר.
חוצץ לא מוגבל - אין מגבלה על מיקום החוצץ ואין מגבלה על גודלו. במקרה זה הצרכן צריך להמתין לנתונים חדשים ואילו היצרן יכול ליצור בלי מגבלה
חוצץ מוגבל – הנחה היא שגודל החוצץ מוגבל. יכול להיות שהצרכן ימתין לנתונים שיוצרו ע"י היצרן או שהיצרן ימתין עד שמקום יתפנה (הצרכן יצרוך).

30. זיכרון משותף – פתרון לבעית החוצץ המוגבל
נתונים משותפים
#define BUFFER_SIZE 10
typedef struct {
. . .
} item;
item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
הפתרון נכון אבל ניתן להשתמש רק ב- BUFFER_SIZE-1 פריטים

31. הליך להוספת פריט בחוצץ מוגבל Insert()
while (true) { /* Produce an item */
while (((in = (in + 1) % BUFFER SIZE) == out)
; /* do nothing -- no free buffers */
buffer[in] = item;
in = (in + 1) % BUFFER SIZE; }

32. הליך להוספת פריט בחוצץ מוגבל Remove()
while (true) {
while (in == out)
; // do nothing -- nothing to consume
// remove an item from the buffer
item = buffer[out];
out = (out + 1) % BUFFER SIZE;
return item; }

33. תקשורת בין תהליכים -Interprocess Communication (IPC)
המנגנון של התהליכים לתקשר ולתאם את הפעולות שלהם
מערכת הודעות – תהליכים מתקשרים ביניהם ללא משתנים משותפים
ה-IPC מספק שתי פעולות:
Send שלח הודעה – הודעה קבועה בגודלה או משתנה
Receive קבל הודעה
אם P ו-Q רוצים לתקשר ביניהם הם צריכים:
ליצור ערוץ תקשורת ביניהם
להעביר הודעות דרך send/receive
מימוש ערוץ תקשורת
פיזי
לוגי

34. שאלות מימוש איך יוצרים את הקשר
האם הקשר יכול להיות בין יותר משני תהליכים
כמה קשרים יכולים להיות בין כל שני תהליכים
מה הקיבולת של קשר
האם הגודל של ההודעה הוא קבוע או משתנה
האם הקשרר הוא חד כיווני או דו כיווני

35. תקשורת ישירה התהליכים צריכים לציין את השם של התהליך האחר:
send (P, message) – שלח הודעה לתהליך P
receive(Q, message) – קבל הודעה מתהליך Q
תכונות ערוץ התקשורת
הערוץ נוצר באופן אוטומטי
הערוץ נוצר בין שני תהליכים בלבד
בין כל זוג תהליכים קיים רק ערוץ תקשורת אחד
הערוץ יכול להיות חד כיווני אבל בדרך כלל הוא דו כיווני
בתקשורת סימטרית Q (למעלה) הוא מזהה של הצד השני בתקשורת.
בתקשורת אסימטרית Q (למעלה) הוא מזהה של הצד פונה כלשהוא בתקשורת.

36. תקשורת עקיפה הודעות מופנות או מתקבלות מתאי דואר (ports)
כל port בעל ID יחודי
תהליכים יכולים לתקשר רק אם הם בעלי תאי דואר משותפים
תכונות ערוץ התקשורת
תקשורת נוצרת רק אם לתהליכים יש תיבת דואר משותפת
קשר יכול לשרת הרבה תהליכים
כל זוג תהליכים יכולים להיות בעלי ערוצי תקשורת רבים
ערוץ תקשורת יכול להיות דו כיווני או חד כיווני
עד כאן 10.10

37. תקשורת עקיפה פעולות יצירת תיבת דואר לשלוח ולקבל הודעות דרך תיבת הדואר
לסגור את תיבת הדואר
פקודות
send(A, message) – לשלוח הודעה לתיבת דואר A
receive(A, message) – לקבל הודעה מתיבת דואר

38. תקשורת עקיפה שיתוף תאי דואר P1, P2,P3 משתפים תא דואר A
מי מקבל את ההודעה?
פתררון:
לאפשר רק לזוג תהליכים ליצור קשר
לאפשר רק לתהליך אחד פעולת קבלה receive-
לאפשר למערכת לבחור בצורה אקראית את המקבל. השולח מקבל הודעה מי קיבל.
הבעלים של התא יכול להיות תהליך או מערכת ההפעלה
המקבל היחיד שיכול לקבל הוא הבעלים אבל הוא יכול להעביר הרשאות קבלה גם לאחרים.
כאשר תהליך מסתיים התא נסגר וצריך להודיע על כך.

39. סינכרון הודעות העוברות יכולות להיות משני סוגים חוסמים או לא חוסמים
חוסמים נחשבים סינכרוניים
שולח חוסם השולח חסום עד שההודעה נתקבלה
מקבל חוסם המקבל חסום עד שההודעה התקבלה
לא חוסם נחשב לאסינכרוני
שולח לא חוסם השולח שולח את ההודעה וממשיך
מקבל לא חוסם מקבל הודעה או null

40. חציצה
תור של הודעות מוצמד לערוץ התקשורת והוא יכול להיות ממומש באחד מהדרכים הבאות
קיבולת 0 – 0 הודעות בתור. השולח חייב לחסום עד שההודעה תעבור.
קיבולת מוגבלת – אורך מוגדר של n הודעות. השולח חייב לחכות עם התור מלא
קיבולת לא מוגבלת – אורך התור אין סופי – השולח אינו ממתין אף פעם

41. דוגמה לתקשורת בעזרת חוצץ מערכות unix
יצירת סגמנט משותף בעזרת פקודה:
Seg_id=shmget(IPC_PRIVATE,size,S_IWUSR|S_IWUSR);
צרוף הסגמנט הנוצר אל התהליך בעזרת פקודה:
Shared_memory=(char*)shmat (seg_id,NULL,0);
ניתן לכתוב בזיכרון שנוצר ע"י פקודה :
Sprintf(shared_memory,”Hi there!”);
ניתן להדפיס את ההודעה
Printf(“%s”,Shared_memory);
ניתן להפריד את הסגמנט:
Shmdt(Shared_memory);
ולבסוף ניתן להסיר את הסגמנט מהזיכרון:
Shmctl(seg_id,IPC_RMID,NULL);

42. תקשורת שרת - לקוח Sockets תהליכי קריאה מרחוק rpc
Remote Method Invocation (Java)

43. Sockets socket מוגדר כקצה של תקשורת הקשר בין IP ל-port
אם מחשב מסויים בעל כתובת IP= רוצה ליצור תקשורת עם שרת ip= המחשב היוצר את הקשר יצור socket בעל IP= ויתן ל-socket מספר port שהוא גדול מ למשל 1625
השרת מאזין בפורט 80 (פורט פיזי) ואז נוצר הקשר ראה ציור בהמשך
אם המחשב רוצה ליצור תקשורת נוספת הוא יצור socket בעל אותו ip אבל פורט אחר גדול מ אבל לא שווה ל-1625 שנמצא בשימוש בקשר הקודם

44. תקשורת דרך Socket

45. תהליכי קריאה מרחוק - RPC
תהליכי קריאה מרחוק – תהליכי קריאה אבסטרקטיים בין תהליכים ברשת
Remote procedure call (RPC) abstracts procedure calls between processes on networked systems.
Stubs – client-side proxy for the actual procedure on the server.
The client-side stub locates the server and marshalls the parameters.
The server-side stub receives this message, unpacks the marshalled parameters, and peforms the procedure on the server.

46. ביצוע RPC

47. Remote Method Invocation
RMI זה מנגנון דומה ל-RPC של java
RMI מאפשר לתוכנית java להפעיל מטודה באוביקט הנמצא במחשב מרוחק

48. סוף פרק 3