Principles of Structure of Operating Systems

עקרונות מבנה מערכות הפעלה

בעיית הקטע הקריטי-

פתרונות בחומרה ובמ"ה

בעיות בפתרונות תוכנה לקטע קריטי

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

busy waitב. מבצעים ממתינים בלולאה אינסופית עד שתנאי מתקיים:–

while (flag); –flag הוא spin lockCPUצורך ––priority inversion עשוי לגרום ל deadlock

במציאות, נעזרים בפתרונות הנעזרים בחמרה

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

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

הוראה אחרת לא תרוץ, וכך לא יתבצעו שינויים לא צפויים במשתנה המשותף.

. מניעת multiprocessorהבעיה היא שפתרון זה לא אפשרי במערכת •interrupt ים במערכת-multiprocessor צורכת זמן, כאשר מעבירים את

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

-ים.interruptשתהייה על שעות המערכת, אם השעון מעודכן בעזרת

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

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

Test-and-Set-Lockפעולת

הגדרה :

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

אטומית.

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

יופעלו, הן Test-and-Set לכן, אם שתי הוראות ירוצו אחת אחרי השנייה בסדר כלשהו.

Test-and-Set-Lockמימוש ההוראה

int TaSL(int *target)

{

int save = *target;

*target = 1;

return save;

}

mutual, אזי ניתן לממש Test-and-Setאם המכונה תומכת בהוראה exclusion ע"י הצהרת משתנה בוליאני בשם lock-אשר יאותחל ל false קוד .

התהליך יראה בצורה הבאה:lock:=0 אתחול: •

do{ while TaSL ( &lock) ; critical section lock := 0; remainder section } while true;

הסבר

true ל-lock הראשון שנכנס הופך את threadה • לא יוכל להיכנס עד thread, ולכן אף CSונכנס אל

וברגע lock:=false ויבצע CSשהוא לא יסיים עם הראשון שיגיע אל threadשתתבצע שורה זו אז ה-

.CS ייכנס אל lock==falseהלולאה כאשר

: פעולה אטומיתיתרון•. חסימה מעסיקה.1 :חסרונות•

. סדר כניסה לא ידוע.2

מה קורה ברמת החומרה?

: enter_region TaSL register, lock | copy lock to register and set to 1

cmp register, #0 | was flag zero? jnz enter_region | if non-zero lock was set, loop

ret 

: leave_region mov lock, #0 | store 0 in lock

ret

פתרונות בעזרת פעולות אטומיות סיכום בחמרה:

יתרונות:•פשוטים–תומכים במספר כלשהו של תהליכים– אטומית–

חסרונות:•–busy waiting + priority inversionשתיתכן הרעבה, – בין חומרות שונות, ולכן לא מתאימים ברמת portableלא –

משתמש

לאפליקציות צרכי סנכרון נוספים מעבר לקטעים •קריטיים, למשל סדר בין פעולות

פתרון קטע קריטי ברמת מע' הפעלה

לאור החסרונות שהוצגו בפתרונות ברמת תוכנה וחומרה נרצה דרך פתרון אשר :

שתהיה קלה לשימוש•פתרונות פשוטים ברמת התכניתן–

שתספק ממשק אחיד מעל חמרה כלשהי•portableתכנת משתמש –

תתמוך בצרכי סנכרון שונים•המימוש של אבסטרקציה זו•

יוכל לנצל תמיכת חומרה כאשר היא קיימת (מוחבא)–priority inversion ו busy waitיוכל למנוע –

Semaphores

מה זה סמפור ??

:סמפור הגדרה

Semaphore הוא משתנה מסוג integer אשר ,פרט לשלב בו הוא מאותחל, ניתן לגשת אליו

. signal ו-waitרק דרך שתי פעולות אטומיות:

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

:signal ו-waitהגדרת הפעולות wait:

wait(S): { while(S ≤ 0); //המתנה לכניסה אל הקטע הקריטי S--;

}

Signal: Signal(S): {

S++; //יציאה מהקטע הקריטי ואיתות על כך }

לא מימושהגדרה,שימו לב: זו •counting semaphoreנקרא גם "סמפור סופר" •

הערות נוספות

בהוראות semaphoreעדכון ערכו של ה-• חייב להתבצע באופן שאינו signal ו-waitה-

ניתן לחלוקה. כלומר, כאשר תהליך אחד , אף תהליך semaphoreמעדכן את ערך ה-

אחר לא יכול לעדכן בו-זמנית את אותו semaphore בנוסף, במקרה של .wait(S) ,

S := S ולאחר מכן העדכון S<=0הבדיקה האם , חייבים גם כן לרוץ ללא הפרעות.1 –

בעיה בהגדרה שלנו והפתרון שלה

שהגדרנו עד כה הוא whileאחד החסרונות בלולאות ה-•. כאשר תהליך רוצה להיכנס לקטע busy waitingהשימוש ב-

entryהקריטי והוא צריך להמתין הוא מבצע לולאה בתור ה-code ללולאה זו יוצרת בעיה במערכות .multiprogramming ,

Busy waitingבהן מעבד אחד מתחלק בין מספר תהליכים. מבזבז משאבים של

CPU, בזמן שתהליכים אחרים היו יכולים להשתמש ב-CPUה-בצורה יעילה יותר.

נעדכן את הגדרת busy waitingכדי להתגבר על הצורך של • wait. כאשר תהליך מריץ את הוראת ה-signal ו-waitההוראות

שלילי, הוא יהיה חייב לחכות. semaphoreומגלה שערך ה-אבל, במקום להשתמש

את עצמו.(blockיחסום ), התהליך busy waitingב-

signal ו-waitהגדרת הפעולות :משופרת

wait:

wait(S): {if (S ≤ 0) block; S--;

} Signal:

signal(S): {S++; if (exists blocked process)

unblock a process;}

עבור semaphoreדוגמא לשימוש ב- תהליכיםNקטע קריטי בשימוש של

כדי להתמודד עם semaphores ניתן להשתמש ב-• התהליכים n תהליכים. nבעיית הקטע הקריטי עבור

.1 המאותחל ל-mutex בשם semaphoreחולקים כל תהליך מאורגן בצורה הבאה:•

repeat wait(mutex); critical section signal(mutex); remainder sectionuntil false

ו- block משמעות הפעולותunblock בהגדרה שלנו בהקשר

לתהליכים שלמדנו

פעולת החסימה ממקמת את התהליך בתור •, semaphore המקושר ל-blockingה-

.blockedוסטאטוס התהליך הופך ל-

תהליך שחסום יותחל מחדש כאשר תהליך •. התהליך יותחל signalאחר יריץ הוראת

, אשר משנה wakeupמחדש בעזרת הוראת , ready ל-blocked את סטאטוס התהליך מ-.ready ה-בתורוכך ממוקם התהליך שוב

ההשלכות הנובעות מהמשמעויות שהצגנו

תחת הגדרות אלו, נגדיר את semaphoreכדי לממש • בצורת מבנה המורכב מ-semaphore ה-integer מטיפוס valueמשתנה – של תהליכים ממתיניםListרשימה/תור –

PCBsמצביעים ל •

:הגדרת טיפוס המבנה תהיהtypedef struct semaphore {

int value;LIST List;

} * LIST .הוא טיפוס רשימת תהליכים

הסבר

יש ערך מספרי ורשימת semaphoreלכל • תהליכים. כאשר תהליך חייב לחכות ל-

semaphore .הוא מתווסף לרשימת התהליכים מסירה תהליך אחד מרשימת signalהוראת

התהליכים הממתינים, ומעירה אותו.

מימוש מבנה סמפורים

מטיפוס המבנהSנגדיר משתנה ספור •

semaphore: בצורה הבאה

struct semaphore S;

1 בערך valueנאתחל את השדה •

s.value=1;

למבנה signal ו-waitהגדרת הפעולות סמפורי

wait: wait(S): if (s.value < 0) {

add me to S.List;block;

} s.value--;

)block( אם ערך הסמפור שלילי אז נוסיף אותו אל הרשימה ונחסום אותו הסבר :

Signal: segnal(S): s.value++;

if (s.value ≤ 0) {remove a process P from S.List;wake-up P;

}, זה אומר שעדיין יש ממתינים ולכן נסיר 1 למרות שהעלנו ב 0 אם עדיין הסבר :

processמרשימת ההמתנה

הסבר נוסף

משהה את התהליך. הוראת blockהוראת •wakeup .מחדשת את ריצת התהליך שנחסם

שתי הוראות אלו מסופקות ע"י מערכת בסיסיות.system callההפעלה כ-

סיכום

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

מימוש•busy waitמונע –מנצל פעולות אטומיות בחמרה (כאשר קיימות)–