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

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

ארז חדד

מבוסס על חומר מהקורס )("מערכות הפעלה" בטכניון

Linuxזימון תהליכים ב- 2(c) 2003 ארז חדד

תוכן

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


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

ומעלהX.2.5 – גרסאות גרעין Linux של החדש מופיע בספר אינואלגוריתם זה אינו מתועד כיאות ובפרט

Understanding the Linux Kernel לקבלת מידע באינטרנט על האלגוריתם החדש, חפשו

מידע על על קבצי קוד הגרעין העוסקים בזימון בגרסאות X.2.5בטא של הגרעין העתידי

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


Linux (1)זימון תהליכים ב-Linux מאפשרת למספר תהליכים לרוץ "בו זמנית" על

timeהמעבד באמצעות חלוקת זמן המעבד ביניהם (sharing(

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

עבור תהליכים "רגילים", חלוקת הזמן נאכפתבאמצעות מערכת ההפעלה, גם אם תהליכים לא

מוותרים מרצונם על המעבדPreemptive multitasking

-מדיניות זימון התהליכים ה"רגילים" בLinux מסומנת SCHED_OTHER

ישנן מדינויות זימון נוספות כפי שנראה מידלכל תהליך מוגדר מהי מדיניות הזימון לה הוא כפוףבהמשך נתמקד במדיניות זו בלבד


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

Linux תומכת, בנוסף לתהליכים "רגילים", בתהליכי זמן-אמת )real-time(

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

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

תהליכים רגילים אינם זוכים לרוץ אם יש תהליכי זמן-אמת מוכנים לריצה)TASK_RUNNING(מצב

:עבור תהליכי זמן-אמת קיימים שני סוגים נוספים של מדיניות זימוןSCHED_FIFO) שיתוף פעולה :non-preemptive עם עדיפויות – המעבד (

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

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

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


)SCHED_OTHERאלגוריתם הזימון (

) "זמן המעבד מחולק ל"תקופותepochs( – לכל תהליך מוקצב פרק זמן לשימוש במעבדtime slice

-בסיום הtime slice-נבחר מתוך ה runqueueתהליך לריצה במעבד ) התהליך הנבחר לריצה הוא תהליך מוכן לריצהTASK_RUNNING (

time sliceבעל העדיפות הגבוהה ביותר שנותר לו זמן ריצה מתוך ה-שלו

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

תקופה מסתיימת כאשר כל תהליך שעדיין מוכן לריצה סיים שלוtime sliceאת ה-

לאחר סיום תקופה מתחילה תקופה חדשה בה לכל תהליך חדשtime sliceהמוכן לריצה מוקצה


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

אלגוריתם הזימון ממומש בגרעיןLinux ע"י רכיבי הקוד הבאים )kernel/sched.c(בקובץ

) ן התהליכים Tָּמ Vזscheduler שאחראי על בחירת התהליך הבא לריצה (במעבד ועל החלפת תקופות

הפונקציהschedule() מנגנון עדכון דינמי (מדי פעימת שעון) של נתוני זימון של התהליך הנוכחי

ן לפי הצורךtime_sliceשרץ במעבד (עדיפות, Tָּמ Vוכו') והפעלת הז , הפונקציהscheduler_tick()

:כמו כן, כפי שנראה בהמשך, ביציאה ובחזרה מהמתנהמעודכנים נתוני הזימון של התהליך שיוצא/חוזרן כדי לבחור מחדש תהליך לריצה במעבד Tָּמ Vמופעל הז הפונקציות)de(activate_task()


מדידת זמן

הזמן נמדד במחשב באמצעות פעימות שעוןבתדר מוגדר מראש

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

-בLinux השעון מתוכנת לתדר של HZ=100Hz (בפעימות שעון) הזמן מאז הפעלת המחשב

jiffies בתוך מונה הקרוי Linuxנמדד ב-


)1עדיפות תהליך ( בחירת התהליך הבא לזימון למעבד מבוססת על

)process priorityעדיפות התהליך (עדיפות תהליך נקבעת באופן דינמי במהלך חייו

ערך בסיסי קבוע - עדיפות סטטיתתהליך בן יורש את העדיפות הסטטית מאביו ניתן לשנות עדיפות סטטית על-ידיAPI קריאות כדוגמת) nice()(

שינוי דינמי לערך הבסיס בהתאם לפעילות התהליך הרעיון: "לפצות" תהליך שצריך להמתין הרבה בטווח הבינוני/ארוך

על-ידי הגברת עדיפותו לריצה בטווח הקצר) באופן כללי, תהליכים שהם עתירי ק/פIO-BOUND מועדפים (

) בעלי אותה CPU-BOUNDעל-פני תהליכים שהם עתירי חישוב (עדיפות סטטית


)2עדיפות תהליך (

:העדיפות של תהליך נקבעת כדלהלן 139..0דרגות העדיפות הן) MAX_PRIO-1( 99..0עדיפויות) MAX_RT_PRIO-1מיועדות לתהליכי זמן-אמת ( מיועדות לתהליכים רגילים139..100עדיפויות

ערך עדיפות מספרי גבוה מציין עדיפות נמוכה, וההפך 120תהליך רגיל מתחיל בדרך-כלל עם עדיפות

120הכוונה לעדיפות סטטית-מוגדר 120ההפרש בין העדיפות הסטטית של תהליך ל

) של התהליךnice (ערך nicenessכ--עבור תהליך רגיל, ערך הnice 19 ל-20- נע בין+ החישוב מקובע במאקרוTASK_NICE:

#define TASK_NICE(p) ((p)->static_prio – MAX_RT_PRIO – 20)


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

-הrunqueue הוא מבנה נתונים המאחסן את כל ) של process descriptorsמתארי התהליכים (

התהליכים הרצים או מוכנים לריצה על מעבד מסוים ("הטווח הקצר")

כלrunqueue (על כל מעבד) מכיל את הנתונים הבאים:

nr_running-מספר התהליכים ב – runqueue לא כולל את) )swapperה-

currמצביע למתאר התהליך שרץ כרגע – idle-מצביע למתאר תהליך ה – swapper



active מצביע למערך תורי העדיפויות של התהליכים – , כלומר תהליכים מוכנים לריצה (נמצאים במצב הפעילים

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

תהליך החוזר מהמתנה בטווח הבינוני משובץ לריצה בתורי מערך()activate_taskזה לפי עדיפותו בפונקציה

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

הנוכחית expired_timestamp מתי עבר התהליך הראשון –

בתקופה הנוכחיתexpired ל-activeמ-



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

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

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

O(1) שהביט שלו דלוק – חישוב ב-activeהנמוך ביותר ב-queue][ מערך התורים עצמו, עם כניסה לכל –

כניסות). כל כניסה מכילה ראש 140דרגת עדיפות (.list_tתור מסוג



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


)1נתוני תהליך המשמשים לזימון (

מתאר תהליך מכיל את הנתונים הבאיםהמשמשים בזימון:

policyמהי מדיניות הזימון של התהליך – need_resched דגל: האם התהליך אמור לוותר –

על המעבד המאקרוset_tsk_need_reschedמדליק את הדגל המאקרוclear_tsk_need_resched מכבה את הדגל


)2נתוני תהליך המשמשים לזימון (prioעדיפות התהליך – static_prio – העדיפות הסטטית של התהליך –

נראה בהמשךsleep_timestamp מתי לאחרונה בוצעה החלפת –

הקשר מהתהליך (כלומר התהליך הנ"ל הוא זה שוויתר על המעבד)

sleep_avgזמן המתנה "ממוצע" של התהליך – משמש לאפיון התנהגות התהליך – פרטים בהמשך

time_slice כמות הזמן (בפעימות שעון) הנותרת – ) הנוכחיתepochלתהליך לריצה במהלך התקופה (


ן התהליכים – ה- Tָּמ Vזscheduler (1) ן התהליכים הוא רכיב תוכנה בגרעין Tָּמ VזLinux שאחראי על

זימון התהליך הבא למעבד קוד הזמן – הפונקציהschedule() הזמן בוחר את התהליך הבא ואז מפעיל את פונקצית החלפת ההקשר

context_switch()פירוט בהמשך – :הזמן מופעל במספר מקרים אופייניים

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

בטיפול בקריאת מערכת הגורמת לתהליך הקורא לעבור להמתנה, כך)()sleep_onשהמעבד מתפנה להריץ תהליך אחר (שגרות כדוגמת

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

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

sched_yield()


ן התהליכים – ה- Tָּמ Vזscheduler (2)

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

) הפעלת הזמן באופן ישירdirect invocation מבוצעת על-ידי ( ()scheduleקריאה ל-

למשל מתוך פונקציות המתנה) הזמן מופעל גם באופן עקיףlazy invocation על-ידי הדלקת (

kernel במתאר התהליך לפני חזרה מ-need_reschedדגל mode-ל user mode

בכל חזרה מפסיקה הקוד בודק אם הדגל הנ"ל דלוק ואם כן מפעיל אתschedule()

-דוגמה אופיינית: במהלך טיפול בפסיקת השעון, אם נגמר הtime slice מדליקה את הדגל ()scheduler_tickשל התהליך, השגרה

need_reschedבמתאר התהליך


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מוצא מתוך ה-

מצב של הפרעה בהמתנה



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מחליפים בין ה-

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



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;prev = context_switch(prev, next);..spin_unlock_irq(&rq->lock);

}else

spin_unlock_irq(&rq->lock);

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

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

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

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

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

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


עדכון דינמי של נתוני זימון

הפונקציהscheduler_tick() מופעלת מדי פעימת – שעון

מעדכנת את נתוני הזימון של התהליך הנוכחי שרץבמעבד:

אפיון התנהגות התהליך באמצעות איסוף סטטיסטיקה "זמן המתנה ממוצע"

-הקטנת הtime_slice:ובסיומו ,חישוב מחדש של העדיפות הדינמית בהתאם לאופי התהליך הקצאתtime_sliceחדש -בדיקת תהליך אינטראקטיבי והעברת התהליך בהתאם: לexpired או

activeשוב ל- – ן Tָּמ Vבקשה להפעלת הזneed_resched


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

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

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

):()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;


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

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

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

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

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

"תהליך עתיר ק/פ צפוי להגיע ל"זמן המתנה ממוצעגבוה


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

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

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

חישוב העדיפות הדינמית מתבצע בפונקציה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;



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

הבסיסיות (הסטטיות) רחוקות זו מזו למשל, שתהליך בעלnice 19 יהפוך לעדיף 139 (עדיפות (

)120 (עדיפות nice 0יותר מתהליך בעל שיטת חישוב זו משפרת את העדיפות של תהליך

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

לתהליכים עתירי חישוב) הערך של מחציתMAX_SLEEP_AVG כלומר ,HZ פעימות

או שניה אחת, נקבע בתור הסף בין "המתנה מרובה" ל"המתנה מועטת"



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

תהליך חוזר מהמתנה תהליך המקבל עדיפות גבוהה בעקבות המתנה

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


)1 לתהליך (time sliceהקצאת

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

10כל תהליך מקבל לפחות msec-300 זמן ריצה תלוי ליניארית בעדיפות הסטטית אך לא יותר מ msec) "150) מקבל זמן טיפוסי 120תהליך בעדיפות "רגילה msec

חישובtime slice-מחדש מבוצע אך ורק עם סיום ה time slice הנוכחי כפי שנראה בפונקציה scheduler_tick()בהמשך

-כלומר, אם תהליך יוצא להמתנה בטווח הבינוני וחוזר לטווח הקצר, עליו לסיים תחילה את שארית הtime slice שלו לפני שיקבל הקצאה חדשה


)2 לתהליך (time sliceהקצאת

-ביצירת תהליך חדש, תהליך האב מאבד מחצית מהtime sliceשלו לטובת תהליך הבן

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

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

-לפני שהtime slice..של הבן מסתיים, הבן מייצר נכד, וכן הלאה

מימוש המנגנון בפונקציהdo_fork() שמבצעת את fork() קובץ גרעיןkernel/fork.c

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

current->time_slice >>= 1;


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

-תהליכים אינטראקטיביים מקבלים בLinux העדפה נוספים בתקופה time slicesמיוחדת: זכות לרוץ

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

, תוכנה חלונאית וכו' – המתנות shellמהמשתמש, כדוגמת ארוכות במיוחד

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

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

לכך שתהליכים לא-אינטראקטיביים שסיימו את בתקופה הנוכחית "יורעבו", כלומר לא time sliceה-

יינתן להם לרוץ ולהתקדם



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

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

STARVATION_LIMIT * ((rq)->nr_running + 1))-כאשר התהליכים בexpired מורעבים מעבר לסף, מופסקת

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

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

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

המשתמש



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

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

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

220

)(_52

20

)(_

2

140%25)(

pNICETASKpNICETASKpDELTA

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

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



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

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

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

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

הרעיון: תהליכים בעלי עדיפות סטטית נמוכה הם) שאינם כוללים batchבדרך-כלל תהליכי אצווה (

אינטראקציה עם המשתמש'דוגמאות: חישובים מדעיים, גיבוי אוטומטי, וכו


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

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

גם פונקציה זו מופעלת כשהפסיקות חסומות כדי למנוע שיבוש נתוניםע"י הפעלת הפונקציה במקביל

הפונקציה תגרום להפעלתschedule() אם התהליך הנוכחי סיים את שלוtime sliceה-

הפונקציה משתמשת בפונקציותenqueue_task()-ו dequeue_task() )expired או activeלהוצאה והכנסה של תהליך לאחד ממערכי התורים (

task_t *p = current;runqueue_t *rq = this_rq();..if (p->sleep_avg)

p->sleep_avg--; של sleep_avgעדכון ה-

התהליך הנוכחי


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

if (!--p->time_slice) {

dequeue_task(p, rq->active);

set_tsk_need_resched(p);

p->prio = effective_prio(p);

p->time_slice = TASK_TIMESLICE(p);

if (!TASK_INTERACTIVE(p) || EXPIRED_STARVING(rq)) {

if (!rq->expired_timestamp)

rq->expired_timestamp = jiffies;

enqueue_task(p, rq->expired);

} else

enqueue_task(p, rq->active);

אם התהליך הנוכחי כילה של עצמו, time sliceאת ה-

, activeהוא מוצא מה- timeהעדיפות הדינמית וה-

slice הבא שלו מחושבים מחדש, ויבוצע לו

schedule()בהמשך

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

, מעודכן expiredל-expired_timestamp

תהליך אינטראקטיבי מוחזר time slice לרוץ activeל-

נוסף בתקופה הנוכחית כאשר אין הרעבה

Documents

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