1. תהליכים-דייאט: חוטים מוטיבציה חוטי משתמש וחוטי מערכת
תמיכת מערכת ההפעלה
דוגמאות ושימושים
(8/4/2013)
מערכות הפעלה (אביב 2009)
חגית עטיה ©

2. תקורה של ריבוי תהליכים תהליכים דורשים משאבי מערכת
מרחב כתובות, גישה לקלט/פלט (file table)...
זימון תהליכים הינה פעולה שדורשת תקורה
context switch לוקח זמן, כפי שראינו
תקשורת בין תהליכים עוברת דרך מערכת ההפעלה (תלוי במודל התקשורת)
מערכת ההפעלה שומרת על הגבולות בין תהליכים שונים
לעבור דרך הגרעין גם כן דורש תקורה
מערכות הפעלה (אביב 2009)
חגית עטיה ©

3. טבעי לי מקבילי
למרות התקורה, לעיתים עדיף לפתור בעיות באמצעות ריבוי תהליכים
דוגמא 1: מעבד תמלילים
מציג פלט, ממתין לקלט מהמשתמש, בודק איות,...
דוגמא 2: שרת קבצים / דואר
ממתין לקבל בקשה
כאשר מקבל בקשה, חייב להפסיק לחכות ולעבור לטפל בבקשה
פתרון:
לבצע fork
תהליך הבן מטפל בבקשה שהגיעה
האב ממשיך להמתין לבקשות חדשות
פתרון זה עלול להיות לא אופטימלי בשל התקורה (הקצאת מרחב כתובות, PCB, וכו')
אחר-כך, נחזור לדוגמא הזו בפירוט רב יותר.
מערכות הפעלה (אביב 2009)
חגית עטיה ©

4. שומרי משקל רעיון! אבל התהליכים שנוצרים לטיפול בבקשות דומים זה לזה:
אותו קוד
אותם משאבים ונתונים
למרות שהם לא זהים:
מטפלים בבקשות שונות
נמצאים בשלבים שונים במהלך הטיפול
תהליכים-דייאט (lightweight processes) אשר משתפים מרחב כתובות, הרשאות ומשאבים
רעיון!
מערכות הפעלה (אביב 2009)
חגית עטיה ©

5. תהליכים-דייאט = חוטים חוט (thread) הינו יחידת ביצוע (בקרה) בתוך תהליךP1 P3 P2
חוט (thread) הינו יחידת ביצוע (בקרה) בתוך תהליך
במערכות הפעלה קלאסיות
"חוט" יחיד בכל תהליך
במערכות הפעלה מודרניות
תהליך הוא רק מיכל לחוטים
לכל חוט מוקצים המשאבים הבאים:
program counter
מחסנית
רגיסטרים
נמצאים ב Thread Control Block (TCB) P1 T1 T2 T3
תהליכים קלאסיים: חוט יחיד בכל תהליך
לכל חוט יש thread control block (TCB)
מערכות הפעלה (אביב 2009)
חגית עטיה ©

6. תזכורת: מרחב הכתובות של תהליך
0xFFFFFFFF
code
(text segment)
static data
(data segment)
heap
(dynamic allocated mem)
stack
Program Counter
Stack Pointer
address space 0x
מערכות הפעלה (אביב 2009)
חגית עטיה ©

7. מרחב הכתובות של תהליך מרובה-חוטים
0xFFFFFFFF
code
(text segment)
static data
(data segment)
heap
(dynamic allocated mem)
Stack for thread 1
PC thread 2
SP thread 1
Stack for thread 2
SP thread 2
PC thread 1
address space 0x
מערכות הפעלה (אביב 2009)
חגית עטיה ©

8. חוטים לעומת תהליכים ייחודי לתהליך ייחודי לחוט Program Counter
ייחודי לתהליך ייחודי לחוט
Program Counter
Registers
Execution Stack
Address Space
Open Files
File position √ √ √ √ √ √ X √ X √ X √
מערכות הפעלה (אביב 2009)
חגית עטיה ©

9. תהליך מרובה חוטים: תרשים
מערכות הפעלה (אביב 2009)
חגית עטיה ©

10. דוגמה: שרת קבצים התהליך מחזיר: תהליך מקבל בקשות עם הפרמטרים הבאים:
מחרוזת תווים (במקרה של קריאה)
סטאטוס (הצלחה/כישלון)
אורך קריאה/כתיבה (בפועל)
תהליך מקבל בקשות עם הפרמטרים הבאים:
קריאה או כתיבה?
זיהוי קובץ
מיקום בקובץ
אורך
חוצץ (buffer)
מערכות הפעלה (אביב 2009)
חגית עטיה ©

11. שרת קבצים: מימוש עם חוט יחיד
פשטות
ניצול משאבים לקוי, למשל בהמתנה לקלט/פלט
ניתן ליעל ע"י קלט / פלט אסינכרוני וטיפול במספר בקשות בו זמנית
do forever
get request;
execute request;
return results;
end;
מערכות הפעלה (אביב 2009)
חגית עטיה ©

12. מימוש באמצעות חוטים חוט מנהל חוט עבודה תפוקה גבוהה יותר
מקבל בקשה
מייצר חוט עבודה, ומעביר אליו את הבקשה
חוט עבודה
מבצע את הבקשה
מחזיר תשובה
תפוקה גבוהה יותר
תכנות מורכב יותר
בקשה
חוט עבודה
תשובה
אפשר גם לשמור קבוצת חוטים "קבועה", על-מנת לחסוך ייצור / השמדה של חוטים.
מערכות הפעלה (אביב 2009)
חגית עטיה ©

13. יתרונות וחסרונות יצירת חוט יעילה/קלה יותר (לעומת תהליכים)
רק יצירת thread control block והקצאת מחסנית
החלפת הקשר בין חוטים של אותו תהליך מהירה יותר
ניצול טוב יותר של משאבים (לעומת שימוש בחוט אחד בלבד)
חוט אחד נחסם (למשל על IO), חוטים אחרים של אותו תהליך ממשיכים לרוץ
מקביליות אמתית במערכות מרובות מעבדים
תקשורת נוחה (?) יותר בין חוטים השייכים לאותו תהליך
זיכרון משותף – יותר יעיל אם לא עוברים דרך הגרעין, אבל פתח לעוד באגים
חוסר הגנה בין חוטים באותו תהליך
חוט עלול לדרוס את המחסנית של חוט אחר
גישה לא מתואמת למשתנים גלובליים
החלפת הקשר בין חוטים של אותו תהליך מהירה יותר
ניצול משאבים: חוט אחד נחסם, חוטים אחרים של אותו תהליך ממשיכים לרוץ
מערכות הפעלה (אביב 2009)
חגית עטיה ©

14. חוטי משתמש וחוטי מערכת חוט משתמש (user threads)
מוגדרים ע"י סביבת התכנות
לא דורשים קריאות מערכת
זימון בשיתוף פעולה (ע"י פקודת yield)
אין החלפת הקשר בגרעין
מה קורה כאשר חוט נחסם?
מה עם מקביליות אמתית?
חוט מערכת (kernel threads)
מוכרים למערכת ההפעלה
נקראים lightweight processes
חוטי משתמש מאפשרים לאפליקציה לחקות ריבוי חוטים גם במערכת הפעלה שלא תומכות בחוטים (= היסטוריה, לא רלוונטי לימינו)
kernel
process
(לא מוכרים ע"י מערכת ההפעלה)
בד"כ מדיניות הזימון בין חוטי משתמש מבוססת על שיתוף פעולה (non-preemptive)
מערכות הפעלה (אביב 2009)
חגית עטיה ©

15. תמיכה בחוטים יצירת והריסת חוטים, לדוגמא מבני נתונים פנימיים
thread_create(char *stack)
thread_exit(…)
thread_join(…)
thread_kill(…)
מבני נתונים פנימיים
thread control block
Program counter, stack, registers
מנגנוני סנכרון
למשל, תיאום גישה לזיכרון משותף
תיאום בין חוטים ותהליכים הוא הנושא המרכזי הבא בקורס!
מערכות הפעלה (אביב 2009)
חגית עטיה ©

16. דוגמא: חוטי POSIX ממשק סטנדרטיIEEE 1003.1c) ) ליצירת וניהול חוטים.
רק Application Program Interface.
דומה מאוד לפעולות המתאימות עבור ניהול תהליכים:
pthread_create
pthread_exit
pthread_join
כולל מנגנונים רבים לתיאום בין חוטים.
נתמך בכל מערכות ההפעלה המודרניות ממשפחת UNIX
אפשריים מימושים שונים; רוב מימוש הספרייה הוא user-mode
נתמך גם ב Windows
מערכות הפעלה (אביב 2009)
חגית עטיה ©

17. השוואת ביצועים (Pthreads)
במיקרו שניות, על 700MHz Pentium, עם Linux
[Steve Gribble, 2001]
זמן יצירה / סיום:
יחס
תהליכים
fork / exit
251 56
חוטי גרעין
pthread_create / pthread_join 94 21
חוטי משתמש
4.5 —
מערכות הפעלה (אביב 2009)
חגית עטיה ©

18. השוואת ביצועים Solaris
במיקרו שניות, על SPARCstation2 (Sun 4/75).
[Solaris Multithreading Guide]
זמן יצירה
יחס
תהליכים
1700 33
חוטי גרעין
350 7
חוטי משתמש 52 —
מערכות הפעלה (אביב 2009)
חגית עטיה ©

19. דוגמא: Windows NT היחידה הבסיסית הינה תהליך.
תהליך יכול להכיל כמה חוטים – kernel threads.
חוט יכול להכיל כמה סיבים (fibers),
שהם בעצם user threads
זימון נעשה ברמת החוטים
תהליך רק מגדיר את מרחב הזיכרון, ומהווה מיכל לחוטים
מערכות הפעלה (אביב 2009)
חגית עטיה ©

20. כמה חוטים ליצור בשרת?
אם כל חוט צריך tc יחידות זמן ולתהליך מוקצים tp יחידות זמן (בכל שניה). כמה חוטים כדאי לתהליך לייצר?
אין טעם לייצר יותר מ- tp / tc חוטים.
ניצול מלא של זמן המעבד המוקצה לתהליך
פחות תקורה להחלפת הקשר
פחות פעולות סינכרון
יותר מחסנית לכל חוט
חוט עבודה
מערכות הפעלה (אביב 2009)
חגית עטיה ©

21. מאגר חוטים thread pooling
יוצרים מספר קבוע של חוטי עבודה וחוט ראשי אחד
החוט הראשי מאכסן את הבקשות המגיעות בתור FIFO
חוטי העבודה מריצים את הקוד הבא בלולאה אינסופית:
קח משימה מהתור
בצע את המשימה
שלח תשובה ללקוח
(כל חוטי העבודה במקביל)
משימה
חוט עבודה
תשובה
מערכות הפעלה (אביב 2009)
חגית עטיה ©

22. מאגר חוטים בגודל דינאמי
tp ו tc אינם ידועים, ואולי אפילו אינם קבועים
ערכו של tc עשוי לקבוע את tp
pool דינאמי
מתחילים עם מספר חוטים קבוע
אם אורך תור המשימות גדל והתהליך לא מנצל את כל מנת הזמן שלו, מגדילים את מספר החוטים
תוספת קבועה או כפלית
עד לסף עליון קבוע
אם יש הרבה חוטים מובטלים, ניתן לבטל חוטים
מערכות הפעלה (אביב 2009)
חגית עטיה ©

23. האם כל זה באמת משנה? מבחינת ביצועים של יצירה/הריסה וצריכת משאבים
מעולם לא ראיתי מדידה של benchmark אמתי עם עומס אמתי (לא micro-benchmark, אלא אפליקציה/עומס שלאנשים אכפת מהם) שתוכיח את הטענה כי יש באמת יתרון לחוטים
מבחינת ביצועים של תקשורת והעברת נתונים
בהחלט סביר – תקשורת דרך זיכרון משותף בלי לעבור דרך הגרעין יכולה להיות יעילה מאוד (אך יש לזכור שעל הגרעין לעיתים להיות מעורב בסנכרון שדורש תקורה שעלולה לדפוק את הביצועים אם לא נזהרים)
הימנעות מזיהום זיכרון מטמון
מבחינת קושי/קלות המודל התכנותי
קצוות: כשיש מבנה נתונים / מודל תכנות שמאפשרים לחוטים לחלוק מבלי לדאוג לסנכרון, אז התכנות עשוי להיות קל ונעים. אם המתכנת צריך לדאוג לסינכרונים (עדינים) בעצמו אז התכנות עלול להפוך לקשה, מסובך, ומתסכל
מערכות הפעלה (אביב 2009)
חגית עטיה ©