מערכות הפעלה תרגול 4 – תהליכים ב-linux (2). מערכות הפעלה -...
Post on 22-Dec-2015
261 views
TRANSCRIPT
מערכות הפעלה
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מקבלים