מערכות הפעלה תרגול 6 – חוטים ב-linux. מערכות הפעלה - תרגול...

מערכות הפעלה

Linux- – חוטים ב6תרגול

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

תוכן התרגול

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

-ספריות המממשות תמיכה בחוטים בLinuxLinux Threads

POSIX Threads APIסקירה בסיסית – הקשר בין חוטים ותהליכים – כיצד השימוש בחוטים משפיע על

)(forkפקודות שלמדנו בנושא תהליכים כגון

:סינכרוניזציה בגרעין של מבוא לסינכרוניזציהLinux


)Linux )1מבוא לחוטים ב-

.חוט הוא יחידת ביצוע עצמאית בתוך תהליך-תהליך בLinux יכול לכלול מספר חוטים המשתפים

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

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

מחסנית ורגיסטרים משלו.


)Linux )2מבוא לחוטים ב-

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

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

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

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


)Linux )3מבוא לחוטים ב- החוט הראשי חוט יחיד, עםכשתהליך נוצר לראשונה

(primary thread חוטים נוספים נוצרים באמצעות ,))(. clone המערכתקריאת

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

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

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

משאבים נוספים כגון זיכרון, גישה לחומרה וכו'.


)Linux )4מבוא לחוטים ב-:יישומים שמתאימים במיוחד לריבוי חוטים

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

עדיף להפעיל חוט ו-זמנית:שרתים המטפלים במספר בקשות ב לכל בקשה מאשר תהליך לכל בקשה.

,במערכת יישומים המכילים חישובים "כבדים" הניתנים למיקבול ניצול החומרה לשיפור הביצועים.מרובת-מעבדים:

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


)Linux )1תמיכה בחוטים בגרעין Linux תומכת בחוטים ברמת גרעין מערכת ההפעלה. חוטי

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

-התמיכה בחוטים בLinux שואפת להתאים לתקן הכללי של או POSIX Threads הקרוי Unixמימוש חוטים במערכות

POSIX 1003.1c-לכל חוט, בהיותו תהליך רגיל, יש מתאר תהליך משלו וPID

משלו. עם זאת, המתכנת, בהתאם לתקןPOSIX מצפה שלכל ,

PIDהחוטים השייכים לאותו תהליך ניתן יהיה להתייחס דרך יחיד – של התהליך המכיל אותם.

-פעולות על הPIDשל התהליך צריכות להשפיע על כל החוטים בתהליך פעולתgetpid בכל חוט צריכה להחזיר אותו )(PID של התהליך המכיל –

את החוט


)Linux )2תמיכה בחוטים בגרעין כדי לאפשר את ההתייחסות לכל החוטים באותו תהליך, מוגדר

קבוצת ומעלה( העיקרון של X.2.4 )מגרסת Linuxבגרעין של (:thread group )חוטים

.כל החוטים השייכים לאותו תהליך נמצאים בקבוצה אחת מתארי התהליכים של כל החוטים באותה קבוצה מקושרים

במתאר התהליך.thread_groupבאמצעות שדה שדהtgid-במתאר התהליך מכיל את ה PID המשותף לכל

של החוט PIDהחוטים באותה קבוצה. למעשה, זהו ערך ה-הראשון של התהליך.

פעולתgetpid מחזירה את )(current->tgid.-פעולות על הPID המשותף מתורגמות לפעולה על קבוצת

.PIDהחוטים המתאימה ל- אם לחוט כלשהו יש בנים )תהליכים(, הם הופכים להיות

בנים של חוט אחר בקבוצת האב לאחר מותו.


)clone)( )1קריאת המערכת

קריאת המערכתclone)( מאפשרת לתהליך ליצור תהליך נוסף המשתף איתו משאבים ונתונים לפי בחירה

קריאת מערכת זאת היא הבסיס לספריות התמיכה בחוטים מתוךuser mode

:תחבירint clone(int (*fn)(void*), void *child_stack, int flags, void *arg);

:פרמטריםfn .מצביע לפונקציה שתהווה את הקוד הראשי של התהליך החדש –

כשביצוע הפונקציהfn)arg(מסתיים, נגמר התהליך החדש child_stack בלוק זיכרון המוקצה לטובת מחסנית של לסוף – מצביע

התהליך החדשתזכורת: המחסנית גדלה לכיוון הכתובות הנמוכות

Linuxתמיכה בחוטים בגרעין


)clone)( )2קריאת המערכת flags( מסכת דגלים – OR הקובעת את צורת השיתוף בין התהליך )

הקורא והתהליך החדש. להלן מספר דגלים אופייניים:

arg הפרמטר המועבר לפונקציה – fn.בתחילת ביצוע התהליך החדש )(:במקרה של הצלחה, התהליך הקורא מקבל את ערך מוחזר

. 1 של התהליך החדש, אחרת -PIDה-


CLONE_VMשיתוף מרחב הזיכרון

CLONE_FILESשיתוף טבלת הקבצים הפתוחים

CLONE_FS שיתוף טבלת נתוני עבודה עם קבצים, המכילה נתונים כגוןספרית העבודה הנוכחית ועוד

CLONE_PARENT לתהליך החדש יהיה אותו אב כמו התהליך הקורא )אחרתהחדש יהיה הבן של הקורא(

CLONE_THREAD התהליך החדש הוא חוט באותה קבוצת חוטים כמוCLONE_PARENT(. גורר גם tgidהתהליך הקורא )אותו


)clone)( )3קריאת המערכת

,בתוך הגרעיןsys_clone קובץ גרעין( )(

arch/i386/kernel/process.c משתמשת למעשה בפונקציה )

do_fork עליה למדנו בתרגול קודם, ומעבירה לה את הדגלים )(

על-מנת לקבוע לכל משאב אם לשתף אותו או ליצור אותו

כחדש.

-עם שיפור התמיכה בחוטים בLinux צפויה הוספת דגלים ,

)(.cloneושינויים ב-



Linuxעבודה עם חוטים ב-

-הספרייה הנפוצה לעבודה עם חוטים בLinux נקראת Linux Threads.

המנגנון תואם )באופן מסורבל, חלקי ועם הרבה בעיות( את.POSIX Threadsתקן

לדוגמה, מנגנון זה עדיין חושףPID נפרד לכל חוט בקריאה )(.getpidל-

Linux Threads אינה מנצלת את התמיכה הקיימת בגרעין 2.4.X לחוטים, אלא מפעילה מנגנון ותיק )שקיים כבר

בגרסאות ישנות של הגרעין( של שיתוף משאבים בין תהליכים המהווים חוטים של אותו יישום.


: הדור הבאLinux ב-חוטיםLinux Threads תומך, בגרסאות הנוכחיות, בחוטי מערכת Kernel

Threads/Lightweight Processes) בלבד, כלומר חוטים )המנוהלים ומתוזמנים ע"י גרעין מערכת ההפעלה.

משמעותית השתפרה התמיכה בחוטים בגרסאות החדשות NPTL )Native POSIX Threadהספריה החדשה: באמצעות

Library(-תאימות מלאה ומסודרת בPOSIX Threads-שיפורים ניכרים בביצועים ביחס לLinux Threads

בהמשך, אנו נתמקד במימוש הקיים לפיLinux Threads.בלבד


POSIX Threadsשימוש ב -כדי להשתמש בPOSIX Threads דרך ספריית

יש לבצע את הפעולות הבאות:Linux Threadsה-( בתחילת קוד התכניתCיש להוסיף )

#include <pthread.h> יש לחבר את התכנית עם הספריהpthread:לדוגמה ,

gcc –g –o myprog myprog.c –lpthread הספריהLinux Threads:מוסיפה לתוכנית שני שינויים

מממשת ממשק לעבודה עם חוטים הקרויPOSIX Threads API

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

-הספרייה מחליפה את הwrapper functions של קריאות המערכת הרלוונטיות


POSIX Threads API )1(יצירת חוט: pthread_create)( יוצרת חוט חדש -

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

ונהרג בסיום ביצוע start_routineבפרמטר הפונקציה.

תחביר:int pthread_create(pthread_t *thread, pthread_attr_t *attr, void* (*start_routine)(void*),

void *arg);

במקרה של הצלחה, ערך אחר במקרה 0: ערך מוחזר של כישלון. כמו כן, במקרה של הצלחה מוכנס מזהה

.threadהחוט החדש למקום המוצבע ע"י


POSIX Threads API )2(:פרמטרים

thread מצביע למקום בו יאוחסן מזהה החוט החדש – במקרה של סיום הפונקציה בהצלחה.

attr מאפיינים המתארים את תכונות החוט החדש, כגון – האם החוט הוא חוט מערכת או חוט משתמש, האם ניתן

, כלומר להמתין לסיומו, וכו'. בד"כ נספק ערך joinלבצע לו NULL.המציין חוט מערכת שניתן להמתין לסיומו

start_routine .מצביע לפונקציה שתהווה את קוד החוט – הערך המוחזר מפונקציה זו במקרה של סיומה הטבעי הינו

ערך הסיום של החוט.arg.פרמטר שיסופק לפונקציה עם הפעלתה –


POSIX Threads API )3(

:סיום חוטpthread_exit)( החוט הקורא מסיים את - פעולתו. ערך הסיום יוחזר לחוט שימתין לסיום חוט

זה.:תחביר

void pthread_exit(void *retval);:פרמטרים

retval בדומה לזה של( ערך סיום –exit))(איןערך מוחזר :

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



חוט יכול להסתיים כתוצאה ממספר אפשרויותשונות:

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

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

מחוט אחר כלשהו ביישום



קבלת מזהה החוט : pthread_self)( החוט הקורא - מקבל את המזהה של עצמו. מזהה זה הוא פנימי

PID ואינו קשור במישרין ל-Linux Threadsלספרייה של החוט.

:תחביר

pthread_t pthread_self();:איןפרמטרים :מזהה החוטערך מוחזר



:המתנה לסיום חוט pthread_join)( החוט הקורא - . thממתין לסיום החוט המזוהה ע"י

:תחבירint pthread_join(pthread_t th, void **thread_return);

:פרמטריםthמזהה החוט שממתינים לסיומו –

-לא ניתן להמתין ל"סיום חוט כלשהו" בדומה לwait.)(

thread_return מצביע למקום בו יאוחסן ערך הסיום של – החוט עבורו ממתינים

ניתן לצייןNULLכדי להתעלם מערך הסיום



:0 במקרה של הצלחה, וערך שונה מ-0 ערך מוחזר במקרה כישלון. כמו כן, במקרה הצלחה מוחזר ערך

(.NULL )אם אינו thread_returnהסיום מוצבע מ-:תכונות

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

כל חוט יכול להמתין לסיום כל חוט אחר באותו תהליך ההמתנה על סיום החוט משחררת את מידע הניהול של

וברמת הגרעיןLinux Threadsהחוט ברמת



:הריגת חוט pthread_cancel)( סיום ביצוע החוט - .threadהמזוהה ע"י

ערך סיום הביצוע של החוט שנהרג יהיהPTHREAD_CANCELED

:תחבירint pthread_cancel(pthread_t thread);

:פרמטריםthreadמזהה החוט המיועד לסיום –

:במקרה של הצלחה, וערך אחר במקרה 0 ערך מוחזר כישלון


)( בתוך חוטforkביצוע

-כאשר חוט קורא לfork נוצר תהליך חדש שהוא ,)(הבן של החוט הקורא בלבד

חוט אחר בקבוצה של החוט הקורא לא יכול לבצעwait )(על תהליך הבן שנוצר

לתהליך הבן החדש יש חוטים משלו. בהתחלה, חוטיחיד – החוט הראשי

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

)( על תהליך הבן פעם אחת בלבד – waitיכול לבצע להמתין לסיום תהליך הבן, כפי שנראה בהמשך

Linux Threadsחוטים ותהליכים ב-


)( בתוך חוטexecvביצוע

-אם קריאה לexecv מצליחה, החוט הקורא )(מתחיל מחדש בתור חוט ראשי בקבוצה חדשה

של תהליך חדש'כולל הקצאת משאבים מחדש: זיכרון וכוכל החוטים האחרים מופסקים



סיום ביצוע תהליך

-אם חוט כלשהו מתוך תהליך קורא לexit או שביצוע )(אחד החוטים גורם לתקלה לא-מטופלת, מתבצע סיום

ביצוע התהליך כולוכל החוטים בקבוצה מופסקים

כמו כן, כזכור מהתרגול הקודם, לאחר סיום ביצוע קוד)( exitהחוט הראשי מתבצעת קריאה אוטומטית –ל

הגורמת לסיום ביצוע התהליך אם כל החוטים בתהליך מסיימים באמצעות

pthread_exit אזי סיום החוט האחרון הוא סיום ,)(התהליך



Control Pathsמסלולי בקרה – גרעין מערכת ההפעלה מטפל בבקשות מסוגים שונים

)פסיקות, חריגות( ע“י ביצוע סדרת פקודות )פעולות(. סדרת פקודות המתבצעת מהרגע שמתקבלת בקשה

בגרעיןמסלול בקרה ועד שמסיימים לטפל בה נקראת (kernel control path.)

לדוגמה מסלול בקרה המטפל בקריאת מערכת של תהליך)( ומסתיים system_call מתחיל ב-user modeב- )(.ret_from_sys_callב-

למסלול בקרה איןdescriptor כי הוא לא חוט או תהליך, אלא מסלול ביצוע הוראות בתוך הגרעין.


מיתוג בין מסלולי בקרה המעבד יכול למתג בין מספר מסלולי בקרה בתוך

הגרעין, למשל בגלל:.ביצוע החלפת הקשר בין תהליכים בגרעין תוך-כדי ביצוע מסלול בקרה המטפל בפסיקה כלשהי, יש

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

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

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


מערכות עם מעבד בודד-מתי ועל מה צריך להגן?

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

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

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

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

page fault.אבל יכולה להיות פסיקה תוך כדי טיפול בחריגה ,) לחריגה. גורמתפסיקה אף פעם לא :ניתן לחלק את מבני הנתונים לשניים

אין צורך להגן אם משחררים את נגישים מחריגות בלבד – 1. .scheduleהמשאב לפני קריאה ל-

יש צורך להגן. נגישים גם מפסיקות וגם מחריגות – 2.


סנכרון גישה למבני הנתונים הגנה על מבני הנתונים נעשית ע“י הגדרת קטעים

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

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

נתונים.קריטיים אמצעים להגן על קטעים יש מגוון...


אמצעי סנכרון: הוראות אטומיות ( הוראות אטומיותatomic operations:) פעולות

( המבוצעות read-modify-writeעדכון נתונים )באופן אטומי ברמת המכונה ביחס לכל המעבדים.

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

הנועלת את ערוץ הגישה של כל )lock )IA32הוראת ( עד לסיום ההוראה memory busהמעבדים לזיכרון )

שאחריה. :דוגמה להוראה אטומיתtest_and_set_bit המדליקה ,)(

ביט ומחזירה את ערכו הקודם


אמצעי סנכרון: חסימת פסיקות( חסימת פסיקות מקומיתLocal Interrupt

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

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

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

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

כיבויו, מפני שהדגל לא דלק בהכרח לפני הכיבוי.


אמצעי סנכרון: סמפורים כללים

:סוג של מנעול המיועד לשימוש פנימי בגרעין בלבד גורמת להמתנת לסמפורהמתנה של מסלול בקרה

התהליך שרץ כרגע. ,משמשים בקריאות מערכת ואינם משמשים סמפורים לכן

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

טיפוסstruct semaphore גרעין בקובץ include/asm-i386/semaphore.h


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

- Spin Lockסנכרון שהזכרנו קודם עם מנגנון סנכרון הנקרא

.busy waitלמעשה, מנעול הממומש כ- קיים רק במערכת מרובת מעבדים, מפני שאילולי כן, במערכת מעבד

נעול, והיה עלול להמתין לנצח spin lockיחיד מסלול בקרה היה נתקל ב-– כי המסלול שהחזיק את המנעול נקטע ואינו יכול לחזור לרוץ עד

שהממתין יסיים. ,למעשהbusy wait הוא המתנה יעילה כאשר מדובר בנעילות קצרות

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

טיפוסspinlock_t בקובץ גרעין include/linux/spinlock.h


סיכום: אמצעי הסנכרון עבור מבני נתונים

הנגישים מפעולות שונותKernel control paths accessing the data structure

Uni-processor protection

Addition for Multi-processor protection

ExceptionsSemaphoreNone

InterruptsLocal interrupt disabling

Spin lock

Exception+InterruptLocal interrupt disabling

Spin lock

מערכות הפעלה תרגול 6 – חוטים ב-linux. מערכות הפעלה - תרגול...

Documents