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

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

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

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

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

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

מרחב הכתובות של תהליך מרובה-חוטים 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 0x00000000 מערכות הפעלה (אביב 2009) חגית עטיה ©

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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