1. תרגול 4 – ניהול תהליכים, מבני נתונים למימוש תהליכים
מערכות הפעלה
תרגול 4 – ניהול תהליכים, מבני נתונים למימוש תהליכים

2. מה בתכנית? ניהול תהליכים מימוש תהליכים ב-XINU תרגילים טבלת תהליכים
מימוש תורי תהליכים
תרגילים
נובמבר 18
מערכות הפעלה - תרגול 2

3. ניהול תהליכים
המעבד מריץ את כל התהליכים אך בכל רגע נתון הוא מריץ תהליך בודד
התהליך המורץ במעבד נקרא תהליך נוכחי (current process)
תהליכים אחרים מחכים לביצוע במעבד, או מחכים לקבלת משאב אחר
נובמבר 18
מערכות הפעלה - תרגול 2

4. ניהול תהליכים
מערכת ההפעלה אחראית על כך שבכל רגע ורגע יהיה תהליך אחד מוגדר כתהליך הנוכחי
במידה והתהליך מוותר על מעמדו כתהליך הנוכחי או שמערכת ההפעלה מחליטה להחליפו, עליה לבחור תהליך אחר שיחליף אותו
נובמבר 18
מערכות הפעלה - תרגול 2

5. ניהול תהליכים
האלגוריתם המחליט האם להחליף את התהליך הנוכחי ומי התהליך שיחליפו נקרא זמן (Scheduler)
בזמן החלפת התהליך הנוכחי יש לשמור את ההקשר שלו (context) (הכולל את ערכי הרגיסטרים שונים) כדי שניתן יהיה לשחזר אותו בזמן החזרתו לביצוע (החלפת הקשר, Context Switching)
נובמבר 18
מערכות הפעלה - תרגול 2

6. מדיניות הזימון התהליך הנוכחי נבחר בין תהליכים המחכים למעבד
קיימות כמה שיטות לבחירת התהליך הנוכחי:
מדיניות FIFO
בחירה סדרתית (Round-Robin)
בחירה לפי עדיפות
בחירה לפי זמן ריצה
נובמבר 18
מערכות הפעלה - תרגול 2

7. First Come First Serve (or FIFO)
במקור, תהליך אחד משתמש במעבד עד לסיומו
כיום, תהליך משתמש במעבד עד שנחסם בהמתנה למאורע כלשהו
מדיניות ללא הפקעה (non-preemptive)
תהליכים קצרים "נתקעים" אחרי תהליכים ארוכים =>
תהליכים קצרים נמצאים הרבה זמן בתור המוכנים, יחסית
לזמן החישוב שהם צורכים
נובמבר 18
מערכות הפעלה - תרגול 2

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

9. מדיניות הזימון
לפי עדיפות: לכל תהליך משוייך מספר עדיפות. התהליך בעל עדיפות גבוהה ביותר המחכה למעבד הופך לתהליך הנוכחי
סדר העדיפויות: 1 6 8 9 10 13
נובמבר 18
מערכות הפעלה - תרגול 2

10. מדיניות הזימון לפי עדיפות
התהליך הנוכחי יאבד את המעבד רק אם תהליך בעל עדיפות גבוהה יותר ידרוש אותו, או שהנוכחי יוותר עליו
אם תהליך בעל עדיפות גבוהה יותר לא ישחרר את המעבד, תהליכים בעלי עדיפות נמוכה יותר לא יתבצעו
קיימות מ"ה בהן תהליך שמתבצע מאבד את עדיפותו עם הזמן, ותהליך שמחכה משפר את עדיפותו כדי לאפשר "צדק" גדול יותר בחלוקת משאב המעבד
נובמבר 18
מערכות הפעלה - תרגול 2

11. מדיניות הזימון – היישום ב-XINU
XINU משתמשת בשיטת העדיפויות כאשר בין התהליכים באותה עדיפות מתבצע Round-Robin
העדיפות של תהליך נקבעת בזמן יצירתו, אך ניתנת לשינוי בכל עת.
נובמבר 18
מערכות הפעלה - תרגול 2

12. תהליך - דיאגרמת מצבים send receive RECEIVING signal WAITING wait
wake up
sleep
SLEEPING
resched
resched
CURRENT
READY
SUSPENDED
suspend
suspend
resume
Create
נובמבר 18
מערכות הפעלה - תרגול 2

13. טבלת תהליכים
קיימת טבלת תהליכים, המיוצגת כוקטור של רשומות, בה כל רשומה מייצגת הקשר של תהליך, ולכל תהליך מוקצת רשומה
רשומה מכילה את המידע על מצב התהליך ואת כל המידע על הקשר התהליך הדרוש להפעלתו
קיימים מספר משתנים המייצגים את מצב התהליך או שמציינים שתהליך מחכה למשאב כלשהו
נובמבר 18
מערכות הפעלה - תרגול 2

14. טבלת תהליכים
האינדקס בטבלת התהליכים משמש כמזהה של התהליך (pid – process identifier)
המזהה של התהליך הנוכחי שמור במשתנה נפרד המאפשר התיחסות לתהליך הנוכחי מקוד מ"ה
התהליכים המחכים למעבד שמורים בתור דו-כווני על פי עדיפותם. תור זה נקרא ready queue ומבוצע על ידי rdyhead, rdytail
נובמבר 18
מערכות הפעלה - תרגול 2

15. טבלת תהליכיםproc.h -
#define NULLPROC 0 /* id of the null process; it */
/* is always eligible to run */
extern struct pentry proctab[];
extern int numproc; /* currently active processes */
extern int nextproc; /* search point for free slot */
extern int currpid; /* currently executing process */
נובמבר 18
מערכות הפעלה - תרגול 2

16. טבלת תהליכיםproc.h - /* process table entry */ struct pentry {
char pstate; /* process state: PRCURR, etc. */
int pprio; /* process priority */
int psem; /* semaphore if process waiting */
int pmsg; /* message sent to this process */
int phasmsg; /* nonzero iff pmsg is valid */
char *pregs; /* saved environment */
char *pbase; /* base of run time stack */
word plen; /* stack length in bytes */
char pname[PNMLEN+1]; /* process name */
int pargs; /* initial number of arguments */
int (*paddr)(); /* initial code address */ };
נובמבר 18
מערכות הפעלה - תרגול 2

17. טבלת תהליכיםproc.h - #define NPROC 30 /* process state constants */
#define PRCURR '\01' // process is currently running
#define PRFREE '\02' // process slot is free
#define PRREADY '\03' // process is on ready queue
#define PRRECV '\04' // process waiting for message
#define PRSLEEP '\05' // process is sleeping
#define PRSUSP '\06' // process is suspended
#define PRWAIT '\07' // process is on semaphore queue
נובמבר 18
מערכות הפעלה - תרגול 2

18. תהליך ה-NULL מה עושה מ"ה כאשר אין תהליך הדורש מעבד?
אחת הדרכים האפשריות היא לתת לזמן לבצע לולאה ולחכות עד שתהליך כלשהו יהיה מוכן לחזור לביצוע אך לשם כך שקוד הזמן יהיה מורכב יותר
דרך מועדפת הינה ליצור תהליך שתמיד יהיה מוכן לחישוב
נובמבר 18
מערכות הפעלה - תרגול 2

19. תהליך ה-NULL תהליך זה נקרא NULL process ובנוי כלולאה אינסופית מהצורה
While (TRUE) /* Do nothing */;
תהליך ה-NULL יקבל את העדיפות המזערית האפשרית ולכן יהפך לנוכחי רק כאשר אין אף תהליך אחר שדורש את המעבד
המזהה של תהליך זה הוא 0
נובמבר 18
מערכות הפעלה - תרגול 2

20. רשימות תהליכים ב-XINU
במהלך הריצה, בכל רגע, חלק ניכר מתהליכים נמצאים במצב המתנה למשאבים (CPU, קלט, הודעה וכו')
מכיוון שמספר תהליכים עלולים להמתין לאותו משאב יש לנהל תור המתנה
כלל: התהליך יכול להופיע בכל זמן נתון בתור אחד
מספר התהליכים והתורים השונים הוא סופי
נובמבר 18
מערכות הפעלה - תרגול 2

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

22. מבנה רשומה qprev -מצביע האיבר הבא qnext -מצביע האיבר הקודם
qkey -מפתח, עדיפות של התהליך במקרה של תור ה- ready
נובמבר 18
מערכות הפעלה - תרגול 2

23. הגדרת תור – q.h מבנה רשומה: struct qent { int qkey; int qnext;
int qprev; };
נובמבר 18
מערכות הפעלה - תרגול 2

24. תורים ב-XINU תור התהליכים המחכים למעבד
תור עדיפויות, הכנסה לפי מפתח – עדיפות
בתור עדיפויות התהליכים מסודרים בסדר עולה בכיוון ראש => זנב
הוצאה – איבר אחרון
תור התהליכים המחכים לסמפור – FIFO
הוצאה – מראש התור
תור הרדומים – תור ההפרשים
נובמבר 18
מערכות הפעלה - תרגול 2

25. מימוש רשימה בעזרת מערך Key Next Prev 25 33 3 1 2 NPROC 3 14 0 32 ... 1 2
NPROC 3
...
איבר קודם
NPROC-1
איבר הבא
NPROC
...
2NSEM+4
Head=32
MININT
Tail=33
MAXINT
נובמבר 18
מערכות הפעלה - תרגול 2

26. הגדרת תור – q.h extern struct qent q[];
Inline list
manipulation
procedures
extern struct qent q[];
#define isempty(list) (q[(list)].qnext >= NPROC)
#define nonempty(list) (q[(list)].qnext < NPROC)
#define firstkey(list) (q[q[(list)].qnext].qkey)
#define lastkey(tail) (q[q[(tail)].qprev].qkey)
#define firstid(list) (q[(list)].qnext)
נובמבר 18
מערכות הפעלה - תרגול 2

27. פונקציות לטיפול ברשימות
enqueueהכנסת איבר לסוף הרשימה
dequeueניתוק איבר מהרשימה והחזרת האינדקס שלו
insertהכנסת תהליך לרשימה לפי ערכו של key
getfirst הסרת התהליך הראשון ברשימה והחזרת האינדקס
getlast הסרת התהליך האחרון ברשימה והחזרת האינדקס
newqueue איתחול רשימה חדשה במבנה ה-q
נובמבר 18
מערכות הפעלה - תרגול 2

28. הוצאה מתור – queue.c #include <conf.h> #include <kernel.h>
#include <q.h>
int dequeue(item)
int item; {
struct qent *mptr; /* q entry for item */
mptr = &q[item];
q[mptr->qprev].qnext = mptr->qnext;
q[mptr->qnext].qprev = mptr->qprev;
return(item); }
נובמבר 18
מערכות הפעלה - תרגול 2

29. הכנסה לפי מפתח – insert.c
#include <conf.h>
#include <kernel.h>
#include <q.h>
int insert(proc, head, key)
int proc; /* process to insert */
int head; /* q index of head of list */
int key; /* key to use for this process */ {
int next; /* runs through list */
int prev;
next = q[head].qnext;
while (q[next].qkey < key) /* tail key is MAXINT */
next = q[next].qnext;
q[proc].qnext = next;
q[proc].qprev = prev = q[next].qprev;
q[proc].qkey = key;
q[prev].qnext = proc;
q[next].qprev = proc;
return(OK); }
נובמבר 18
מערכות הפעלה - תרגול 2

30. הוספה לסוף התור – queue.c
#include <conf.h>
#include <kernel.h>
#include <q.h>
int enqueue(item, tail)
int item;
int tail; {
struct qent *tptr; /* tail entry */
struct qent *mptr; /* item entry */
tptr = &q[tail];
mptr = &q[item];
mptr->qnext = tail;
mptr->qprev = tptr->qprev;
q[tptr->qprev].qnext = item;
tptr->qprev = item;
return(item); }
נובמבר 18
מערכות הפעלה - תרגול 2

31. הסרת התהליך הראשון ברשימה – getitem.c
#include <conf.h>
#include <kernel.h>
#include <q.h>
int getfirst(head)
int head; /* q index of head of list */ {
int proc; /* first process on the list */
if ((proc=q[head].qnext) < NPROC)
return( dequeue(proc) );
else
return(EMPTY); }
נובמבר 18
מערכות הפעלה - תרגול 2

32. הסרת התהליך האחרון ברשימה – getitem.c
#include <conf.h>
#include <kernel.h>
#include <q.h>
int getlast(tail)
int tail; /* q index of tail of list */ {
int proc; /* last process on the list */
if ((proc=q[tail].qprev) < NPROC)
return( dequeue(proc) );
else
return(EMPTY); }
נובמבר 18
מערכות הפעלה - תרגול 2

33. איתחול רשימה חדשה – newqueue.c
int newqueue() {
struct qent *hptr; /* address of new list head */
struct qent *tptr; /* address of new list tail */
int hindex, tindex; /* head and tail indexes */
/* nextqueue is global variable */
hptr = &q[ hindex=nextqueue++ ];
/* giving next used q pos. */
tptr = &q[ tindex=nextqueue++ ];
hptr->qnext = tindex;
hptr->qprev = EMPTY;
hptr->qkey = MININT;
tptr->qnext = EMPTY;
tptr->qprev = hindex;
tptr->qkey = MAXINT;
return(hindex); }
נובמבר 18
מערכות הפעלה - תרגול 2

34. טבלת תהליכים/ תורים
יישום התורים של התהליכים מתבצע על ידי פונקציות ניהול תורים לכן:
אין בטבלת תהליכים מצביעים על סדר התורים
ניהול התורים נעשה בטבלת התורים (q)
לכל תהליך משוייכת רשומה בטבלת תהליכים וכן בטבלת התורים
נובמבר 18
מערכות הפעלה - תרגול 2

35. טבלת תהליכים/ תורים
בטבלת התורים יש יותר רשומות מטבלת התהליכים.NPROC רשומות ראשונות בטבלת התורים משוייכות לתהליכים המקבילים בטבלת התהליכים.
שאר הרשומות בטבלת התורים משמשות כראשי/זנבות תורים שונים (Ready ,סמפורים, ו-sleeping)
נובמבר 18
מערכות הפעלה - תרגול 2

36. תרגיל 3 יש למלא את המבנה של Q כפי שהוא נראה ברגע
שהתכנית הגיע אל הנקודה המסומנת ב- /**/
#include <kernel.h>
extern SYSCALL sleep(), wait();
int nop();
xmain() {
int sem = screate(1);
resume(create(sleep, INITSTK, 20, “pr1”, 1, 25));
resume(create(wait, INITSTK, 22, “pr2”, 1, sem));
resume(create(wait, INITSTK, 24, “pr3”, 1, sem));
resume(create(sleep, INITSTK, 21, “pr4”, 1, 10));
resume(create(nop, INITSTK, 20, “pr5”, 0));
resume(create(sleep, INITSTK, 20, “pr6”, 1, 30));
resume(create(wait, INITSTK, 20, “pr7”, 1, sem));
resume(create(nop, INITSTK, 20, “pr8”, 0));
create(sleep, INITSTK, 33, “pr9”, 1, 44);
/**/
nop(); }
nop() {
while(1){}; }
נובמבר 18
מערכות הפעלה - תרגול 2

37. תרגיל 3 … proc/list name prev next key pid pr3 pr7 SEM pr4 (10)
SLEEP 1
pr5 (20) 2
pr8 (20)
READY
נובמבר 18
מערכות הפעלה - תרגול 2