מערכות הפעלה

Linux (2)- – תהליכים ב4תרגול

מערכות הפעלה - תרגול 4 2(c) 2003 ארז חדד

תוכן התרגול

-אלגוריתם זימון התהליכים בLinux איך בוחרים, בכל נקודת זמן, את התהליך הבא

להרצה במעבד?

מערכות הפעלה - תרגול 4 3(c) 2003 ארז חדד

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

)X.2.6 (מופיע כחלק מהגרעין החדש Linuxשל 2.4אינו חלק מגרסת הגרעין הסטנדרטית.X אינו מופיע בספרUnderstanding the Linux Kernel אלגוריתם יעיל יותר ועל כן משולב בגרעין המתוקן של

RedHat 8.0שאיתו אנו עובדים ,לקבלת מידע באינטרנט:

2.6 חפשו מידע על על קבצי קוד הגרעין.X :הקבצים העיקרייםinclude/linux/sched.h-ו kernel/sched.c :ניתן לחפש גם לפי שם מחבר האלגוריתם החדשIngo Molnar

מערכות הפעלה - תרגול 4 4(c) 2003 ארז חדד

Linuxזימון תהליכים ב-Linux עובדת לפי עקרון של time sharing חלוקת זמן מעבד –

בין תהליכים. אלגוריתם הזימון קובע את סדר זימון התהליכים ואת זמן

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

הקשר. התהליכים בLinux : מתחלקים לשני סוגים

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

.הקביעה אם תהליך הוא תהליך זמן-אמת נעשית ע"י המשתמש .תהליכים רגילים

.תהליכי זמן-אמת מועדפים לריצה על-פני תהליכים רגילים תהליכים רגילים אינם זוכים לרוץ אם יש תהליכי זמן-אמת מוכנים

(TASK_RUNNINGלריצה (מצב

מערכות הפעלה - תרגול 4 5(c) 2003 ארז חדד

מדיניות זימון של תהליכי זמן-אמת

:עבור תהליכי זמן-אמת קיימים שני סוגים של מדיניות זימון

SCHED_FIFO) שיתוף פעולה :non-preemptive – עם עדיפויות (

המעבד מתפנה רק כאשר התהליך מחליט לוותר עליו או כאשר תהליך

עדיף יותר מוכן לריצה. המעבד מוקצה לאחד מהתהליכים העדיפים

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

SCHED_RR) חלוקת זמן שווה :Round Robin זמן המעבד מחולק – (

בצורה שווה בין כל התהליכים העדיפים ביותר המוכנים לריצה

מערכות הפעלה - תרגול 4 6(c) 2003 ארז חדד

זימון תהליכים רגילים התהליכים הרגילים מתחלקים לשני סוגים לפי אופי

הפעילות שלהם: תהליך חישובי

מעוניין להגדיל את זמן המעבד שלו ככל הניתן .לא מוותר על המעבד מרצונו אלא מופקע

תהליך אינטראקטיבי – קלט/פלט מול המשתמשמעוניין להקטין את זמן התגובה שלומוותר על המעבד מרצונו אחרי פרק זמן קצר

שני סוגי התהליכים הרגילים מזומנים לפי אותה), אך (נרחיב בהמשךSCHED_OTHERמדיניות זימון –

פרמטרי הזימון שונים.

מערכות הפעלה - תרגול 4 7(c) 2003 ארז חדד

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

120עדיפות בסיסית עבור תהליך רגיל היא עבור כל תהליך מוגדר הערךnice :19 , כך ש +nice 20.- :120העדיפות הסטטית של תהליך נקבעת לפי+nice

ככל שהערך המספרי של העדיפות גבוה יותר, כך העדיפות נמוכהיותר.

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

מערכות הפעלה - תרגול 4 8(c) 2003 ארז חדד

עיקרון זימון תהליכים – לכל תהליך מוקצב פרק זמן לשימוש במעבדtime slice

אורך פרוסת הזמן)time slice(.ליניארי בעדיפות

RR (בסדר יורד של עדיפויות) בין כל התהליכים המוכנים לריצה פרק זמן הנדרש כדי לבצע סבבRR שלם נקרא Epoch.

time slice מוקצה לתהליך במאקרו TASK_TIMESLICE:

#define MIN_TIMESLICE (10 * HZ / 1000) /* 10 msec */#define MAX_TIMESLICE (300 * HZ / 1000) /* 300 msec */#define TASK_TIMESLICE(p) \

MIN_TIMESLICE + (MAX_TIMESLICE – MIN_TIMESLICE) *

(MAX_PRIO – 1 – (p)->static_prio)/39

) 150) מקבל זמן טיפוסי 120תהליך בעדיפות בסיסית msec

מערכות הפעלה - תרגול 4 9(c) 2003 ארז חדד

)2עיקרון זימון תהליכים ( ביצירת תהליך חדש, תהליך האב מאבד מחצית

שלו לטובת תהליך הבןtime sliceמה- המטרה: למנוע מצב בו תהליך יכול להרוויח זמן מעבד

בתוך אותה תקופה, למשל באופן הבא:-לפני סיום הtime slice התהליך מייצר תהליך בן שממשיך ,

נוסף באותה תקופה וכ"וtime sliceלהריץ את הקוד למשך מימוש המנגנון בפונקציהdo_fork() שמבצעת את

fork() קובץ גרעיןkernel/fork.c

p->time_slice = (current->time_slice + 1) >> 1;current->time_slice >>= 1;

מערכות הפעלה - תרגול 4 10(c) 2003 ארז חדד

תהליכים אינטראקטיביים

תהליך אינטראקטיבי שנבחר לריצה רץ עד שמוותרעל המעבד.

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

ככל שעדיפותו של התהליך טובה יותר הוא יגיע לרוץ עלהמעבד מהר יותר =< זמן התגובה יקטן

אם הtime slice של התהליך נגמר הוא מקבל מייד time slice -נוסף, במסגרת ה Epoch.הנוכחי

מערכות הפעלה - תרגול 4 11(c) 2003 ארז חדד

תהליכים אלגוריתם הזימון של רגילים

זימון של כל התהליכים (גם חישוביים וגם scheduler(אינטראקטיביים) נעשה ע"י זמן תהליכים (

. אחד ,תמיד נבחר לריצה תהליך עם העדיפות הגבוהה ביותר

שלו.time sliceשמוכן לריצה, ושעוד נותר זמן מה- מבנה הנתוניםrunqueue המשמש את ,scheduler

לזימון תהליכים, גם הוא משותף לכל התהליכים הרגילים.

מערכות הפעלה - תרגול 4 12(c) 2003 ארז חדד

ן התהליכים Xָּמ Zזscheduler?מהו

ן התהליכים הוא רכיב תוכנה בגרעין Xָּמ ZזLinux שאחראי על זימון )()scheduleהתהליך הבא למעבד(מימוש – פונקציה

?מתי מופעל-בתגובה על פסיקת שעון – לאחר שתהליך כילה את הtime slice שלו

). ()scheduler_tick(בעקבות השגרה בטיפול בקריאת מערכת הגורמת לתהליך הקורא לעבור להמתנה, כך

שהמעבד מתפנה להריץ תהליך אחר. -בחזרה של תהליך מהמתנה – יש לשבץ את התהליך בrunqueue ולבדוק

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

sched_yield() .

מערכות הפעלה - תרגול 4 13(c) 2003 ארז חדד

runqueueמבט מקרוב על ה-

nr_running

curr

idle

active

expired

expired_ts

...

runqueue

prio_array_t

prio_array_t

nr_active

bitmapqueue....0 58

....1 112

....1 120

....

מתאר תהליךswapper

מערכות הפעלה - תרגול 4 14(c) 2003 ארז חדד

runqueue (2)מבט מקרוב על ה-runqueue.הוא מבנה נתונים המשמש את זמן התהליכים כלrunqueue:(על כל מעבד) מכיל את הנתונים הבאים

nr_running-מספר התהליכים ב – runqueue-לא כולל את ה) swapper(currמצביע למתאר התהליך שרץ כרגע – idle-מצביע למתאר תהליך ה – swapperactive כלומר הפעילים – מצביע למערך תורי העדיפויות של התהליכים ,

) שנותר להם זמן ריצה TASK_RUNNINGתהליכים מוכנים לריצה (במסגרת התקופה הנוכחית

expired מצביע למערך תורי העדיפויות של התהליכים המוכנים לריצה – שלהם בתקופה הנוכחית time sliceשכילו את ה-

expired_timestamp-מתי עבר התהליך הראשון מ – active-ל expired בתקופה הנוכחית

Linuxזימון תהליכים ב-

מערכות הפעלה - תרגול 4 15(c) 2003 ארז חדד

runqueue (3)מבט מקרוב על ה-

) מערך תורי עדיפויותstruct prio_array מכיל את (הנתונים הבאים:

nr_activeמספר התהליכים המצויים במערך זה – bitmap][ וקטור ביטים בגודל מספר דרגות העדיפות –

ביטים)140( ביטi) אם יש תהליכים בתור המתאים לעדיפות 1 דלוק (i התהליך הבא לזימון הוא התהליך הראשון בתור העדיפות הנמוך

O(1) שהביט שלו דלוק – חישוב ב-activeביותר ב-

queue][ מערך התורים עצמו, עם כניסה לכל דרגת – כניסות). כל כניסה מכילה ראש תור מסוג 140עדיפות (

list_t.כמתואר בתרגול הקודם

Linuxזימון תהליכים ב-

מערכות הפעלה - תרגול 4 16(c) 2003 ארז חדד

schedule() (1)הפונקציה

prev = current;rq = this_rq();..spin_lock_irq(&rq->lock);switch(prev->state) {

case TASK_INTERRUPTIBLE:if (signal_pending(prev)) {

prev->state = TASK_RUNNING;break;

}default:

deactivate_task(prev, rq);case TASK_RUNNING:

;}

prev(שמוותר על המעבד) מצביע למתאר התהליך הנוכחי rq-מכיל את ה runqueueשל המעבד הנוכחי

חסימת הפסיקות

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

למעט מצב של runqueueה-הפרעה בהמתנה

Linuxזימון תהליכים ב-

מערכות הפעלה - תרגול 4 17(c) 2003 ארז חדד

schedule() (2)הפונקציה

if (!rq->nr_running) {next = rq->idle;rq->expired_timestamp = 0;goto switch_tasks;

}

array = rq->active;if (!array->nr_active) {

rq->active = rq->expired;rq->expired = array;array = rq->active;rq->expired_timestamp = 0;

}

אם אין יותר תהליכים לזימון מתוךswapper, יזומן תהליך ה-runqueueה-

,active arrayאם לא נותרו תהליכים ב- (סיוםexpired וה-activeמחליפים בין ה-

תקופה והתחלת תקופה חדשה)

Linuxזימון תהליכים ב-

מערכות הפעלה - תרגול 4 18(c) 2003 ארז חדד

schedule() (3)הפונקציה

idx = sched_find_first_bit(array->bitmap);queue = array->queue + idx;next = list_entry(queue->next,

task_t, run_list);switch_tasks:clear_tsk_need_resched(prev);if (prev != next) {

..rq->curr = next;context_switch(prev, next);..spin_unlock_irq(&rq->lock);

}else

spin_unlock_irq(&rq->lock);

התהליך הבא לזימון ) הוא nextלמעבד (

התהליך הראשון בתור בעל active arrayב-

העדיפות הגבוהה ביותר

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

?()context_switchהקריאה ל-next התהליך תשובה:

ביצוע החלפת ההקשר ע"י ()context_switchקריאה ל-

Linuxזימון תהליכים ב-

מערכות הפעלה - תרגול 4 19(c) 2003 ארז חדד

שימו לב!

ברגע שנגמר הtime slice ,של תהליך חישובי expiredהוא עובר לתור ה

לעומתו, תהליך אינטראקטיבי שמסייםtime slice מיד מקבל time slice נוסף ונשאר בתור

activeהנראה את זה בתרגול הבא

מערכות הפעלה - תרגול 4 20(c) 2003 ארז חדד

)1אפיון התנהגות תהליך (Linux מודדת את "זמן ההמתנה הממוצע" של תהליך

זמן המתנה ממוצע" = סך כל זמן ההמתנה בטווח הבינוני פחות סך כל זמן"הריצה

בכל פעם שתהליך מוותר על המעבד, ערך השעון נשמר (פונקציתschedule():(

p->sleep_timestamp = jiffies; כאשר תהליך חוזר מהמתנה מוסף זמן ההמתנה לחשבון (פונקציה

activate_task() עד לגודל מקסימלי (MAX_SLEEP_AVG:#define MAX_SLEEP_AVG (2*HZ)sleep_time = jiffies – p->sleep_timestamp;p->sleep_avg += sleep_time;if (p->sleep_avg > MAX_SLEEP_AVG)

p->sleep_avg = MAX_SLEEP_AVG;

Linuxזימון תהליכים ב-

מערכות הפעלה - תרגול 4 21(c) 2003 ארז חדד

)2אפיון התנהגות תהליך (

כל פעימת שעון בה התהליך רץ מורידה) עד ()sheduler_tickמהממוצע (הפונקציה

0למינימום if (p->sleep_avg)

p->sleep_avg--;על-פי שיטת חישוב זו

תהליך עתיר חישוב (חישובי) צפוי להגיע ל"זמן המתנהממוצע" נמוך.

תהליך עתיר ק/פ (אינטראקטיבי) צפוי להגיע ל"זמןהמתנה ממוצע" גבוה.

Linuxזימון תהליכים ב-

מערכות הפעלה - תרגול 4 22(c) 2003 ארז חדד

)1חישוב דינמי של עדיפות תהליך (

Linux מעדכנת את העדיפות של כל תהליך "רגיל" באופן דינמי בהתאם לזמן ההמתנה הממוצע של התהליך.

עדיפויות תהליכי זמן-אמת מקובעות לערך הסטטי

החישוב מתבצע בפונקציהeffective_prio().:העדיפות הדינמית מחושבת לפי האלגוריתם הבא

2

1

__

_40%25

AVGSLEEPMAX

avgsleepbonus 55 bonus

prio = static_prio – bonusif (prio < MAX_RT_PRIO) prio = MAX_RT_PRIO;if (prio > MAX_PRIO - 1) prio = MAX_PRIO – 1;

Linuxזימון תהליכים ב-

מערכות הפעלה - תרגול 4 23(c) 2003 ארז חדד

)2חישוב דינמי של עדיפות תהליך (

-הגבלת גודל הbonus-נועדה למנוע מצב שבו יתבצע 5 ל היפוך עדיפויות בין תהליכים שעדיפויותיהם הבסיסיות

(הסטטיות) רחוקות זו מזו.

( יהפוך לעדיף 139 )עדיפות nice 19 למשל, תהליך בעל (120 )עדיפות nice 0יותר מתהליך בעל

שיטת חישוב זו משפרת את העדיפות של תהליך ש"ממתיןהרבה" (צפוי לתהליכים אינטראקטיביים) ומרעה את העדיפות

של תהליך ש"ממתין מעט" (צפוי לתהליכים חישוביים)

פעימות HZ, כלומר MAX_SLEEP_AVGהערך של מחצית או שניה אחת, נקבע בתור הסף בין "המתנה מרובה"

ל"המתנה מועטת"

Linuxזימון תהליכים ב-

מערכות הפעלה - תרגול 4 24(c) 2003 ארז חדד

)1תהליכים אינטראקטיביים(

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

אינטראקטיבי.nice = -20 >= .(כמעט בוודאות) תהליך אינטראקטיביnice = 19 .תהליך חישובי >=nice = 0 ההחלטה דינמית של ה >= scheduler.

מערכות הפעלה - תרגול 4 25(c) 2003 ארז חדד

)2תהליכים אינטראקטיביים (

סיווג תהליך כאינטראקטיבי מבוצע במאקרוTASK_INETRACTIVE:

#define TASK_INTERACTIVE(p) \((p)->prio <= (p)->static_prio – DELTA(p))

ניתנת להגדרה כדלקמן:DELTA(p)כאשר 2

20

)(_52

20

)(_

2

140%25)(

pNICETASKpNICETASKpDELTA

תהליך מסווג כאינטראקטיבי אם העדיפות (הדינמית) שלו"חורגת" מהעדיפות הסטטית שלו.

תוצאה של זמן המתנה ממוצע גבוה המקנה בונוס בחישוב העדיפותהדינמית של התהליך

Linuxזימון תהליכים ב-

מערכות הפעלה - תרגול 4 26(c) 2003 ארז חדד

)3תהליכים אינטראקטיביים (

ככל שמשתפרת העדיפות הסטטית של התהליך, "קליותר" לתהליך להיות מסווג כאינטראקטיבי.

קל יותר": התהליך צריך לצבור זמן המתנה ממוצע נמוך"יותר על-מנת להיחשב כאינטראקטיבי

לדוגמה: תהליך עםnice -20 יכול להיות "חזיר" בצריכת ועדיין 3-המעבד ולהגיע לעדיפות דינמית של בונוס שלילי

להיות מסווג כאינטראקטיבי. לעומת זאת, תהליך עםnice 19 לא יכול כלל להיות מסווג

והבונוס המקסימלי 7+כאינטראקטיבי כי נדרש בונוס של 5+הוא

Linuxזימון תהליכים ב-

מערכות הפעלה - תרגול 4 27(c) 2003 ארז חדד

נקודות למחשבה

מה קורה כשתהליך חישובי יוצא להמתנה ואזחוזר?

הוא יכול להיחשב אינטראקטיבי לפרק זמן מסויםולקבל "פיצוי" על ההמתנה.

מה קורה כשתהליך אינטראקטיבי מנצלtime slice?מלא

נוצרת בעיה : עלול "לתקוע" את האינטראקטיבייםהאחרים.

מערכות הפעלה - תרגול 4 28(c) 2003 ארז חדד

מניעת הרעבה כדי למנוע הרעבה של תהליכים חישוביים ע“י תהליכים

אינטראקטיביים, מוגדר "סף הרעבה" על זמן ההמתנה של :expiredהתהליכים ב-

#define EXPIRED_STARVING(rq) \((rq)->expired_timestamp && \(jiffies – (rq)->expired_timestamp >= \

STARVATION_LIMIT * ((rq)->nr_running + 1))

-כאשר התהליכים בexpired מורעבים מעבר לסף, מופסקת

נוספים לתהליכים אינטראקטיביים בתקופה time slicesהענקת

הנוכחית. -הסף המוגדר פרופורציוני למספר התהליכים בrunqueue כך שככל ,

שיש יותר תהליכים מוכנים לריצה, הסף גבוה יותר.

מערכות הפעלה - תרגול 4 29(c) 2003 ארז חדד

מניעת הרעבה - חסרון

:המנגנון הוא גס ,מאפשר לאינטראקטיביים להרעיב את החישוביים

במיוחד כשיש עומס על המערכת. לאחר שעוברים את הסף =< מאפשר לחישוביים

לעכב את האינטראקטיביים לזמן רב (כי אינט' לא נוספים) time slicesמקבלים