‫‪20/7/2022‬‬

‫מערכות הפעלה‬
‫‪10-4080022-20‬‬
‫‪10-4080022-21‬‬
‫מועד ב'‬
‫ד"ר אליאב מנשה‬
‫תשפ״ב סמסטר ב'‬

‫מחשבון‪ ,‬דף נוסחאות ‪ A4‬אחד כתוב משני הצדדים‪.‬‬ ‫חומר עזר ‪-‬‬
‫הוראות לנבחן‬
‫‪ .1‬כתבו בכתב יד ברור ומסודר‪.‬‬
‫‪ .2‬פרטו כל שלב בפתרון‪.‬‬
‫‪ .3‬נדרש להגיש גם את טופס הבחינה וגם את המחברת שקיבלתם‪.‬‬
‫‪ .4‬במידה ויש מקום לפתרון יש לכתוב אותו בטופס הבחינה‪.‬‬

‫בהצלחה !‬ ‫השאלון מכיל ‪ 8‬דפים (כולל דף זה)‪.‬‬

‫========================================‬

‫‪1‬‬
 ‫(‪15‬נקודות) נתון ה‪ Resource Allocation Graph -‬הבא‪:‬‬ ‫‪.1‬‬

‫האם המערכת נמצאת בדדלוק? הוכח את טענתך‪.‬‬

‫תשובה‪ :‬לא‪ ,‬המערכת לא נמצאת בדדלוק כיוון ש‪:‬‬

‫יש משאב ‪ R3‬פנוי‬
‫תהליך ‪ 2‬יכול לקבל אותו ולסיים‪ ,‬הוא משחרר משאב ‪R2‬‬
‫תהליך ‪ 0‬יכול לקבל משאב ‪ R3‬ומשאב ‪ R2‬ולסיים‪ ,‬הוא משחרר ‪R3, R1‬‬
‫תהליך ‪ 1‬יכול לקבל ‪ R1‬ולסיים‪ ,‬הוא משחרר ‪R1 R2‬‬
‫תהליך ‪ 3‬יכול לסיים‪.‬‬

‫זה בעצם הרצה של ‪ detection algo‬על המערכת‪.‬‬

‫‪2‬‬
 ‫(‪ 15‬נקודות) במערכת מחשב עם ‪ CPU‬אחד ישנם ‪ 3‬תהליכים עם מאפייני הריצה הבאים‪:‬‬ ‫‪.2‬‬
‫תהליך ‪ A‬רץ במשך ‪ 3‬מילישניות‪ ,‬לאחר מכן יוצא ל‪ I/O -‬למשך ‪ 4‬מילישניות‪ ,‬לאחר מכן‬ ‫‪‬‬
‫רץ ‪ 2‬מילישניות ואז מבצע ‪.terminate‬‬

‫תהליך ‪ B‬רץ במשך ‪ 1‬מילישניות‪ ,‬לאחר מכן יוצא ל‪ I/O -‬למשך ‪ 3‬מילישניות‪ ,‬לאחר מכן‬ ‫‪‬‬
‫רץ ‪ 2‬מילישניות ואז מבצע ‪.terminate‬‬

‫תהליך ‪ C‬רץ במשך ‪ 2‬מילישניות‪ ,‬לאחר מכן יוצא ל‪ I/O -‬למשך ‪ 4‬מילישניות‪ ,‬לאחר מכן‬ ‫‪‬‬
‫רץ ‪ 1‬מילישניות ואז מבצע ‪.terminate‬‬

‫תהליך ‪ A‬נכנס למערכת בזמן ‪ .0‬תהליך ‪ B‬נכנס למערכת בזמן ‪ .1‬תהליך ‪ C‬נכנס למערכת בזמן ‪.2‬‬
‫הנח שאם שני תהליכים צריכים להיכנס לתור בו זמנית‪ ,‬אז קודם יכנס לתור התהליך החדש ורק‬
‫אחריו יכנס התהליך שכבר קיים במערכת‪ .‬הנח כי הזמן בפועל שלוקח לתהליך הוא בדיוק הזמן‬
‫הרשום בשאלה‪ ,‬ללא קשר למה שקורה במקביל במערכת (התעלם מזמן ה‪.)context switch -‬‬

‫(‪ 5‬נק׳) מהו ה‪average waiting time -‬במערכת כאשר משתמשים באלגוריתם ‪?FCFS‬‬ ‫א‪.‬‬
‫‪3‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪5‬‬ ‫‪3‬‬ ‫‪3‬‬
‫‪A3 B 4 C6 −A 9 B11 C12‬‬

‫‪Process‬‬ ‫‪Arr‬‬ ‫‪Cpu+io‬‬ ‫‪Term‬‬ ‫‪Wait‬‬

‫‪A‬‬ ‫‪0‬‬ ‫‪9‬‬ ‫‪9‬‬ ‫‪0‬‬

‫‪B‬‬ ‫‪1‬‬ ‫‪6‬‬ ‫‪11‬‬ ‫‪4‬‬

‫‪C‬‬ ‫‪2‬‬ ‫‪7‬‬ ‫‪12‬‬ ‫‪3‬‬

‫‪Avg waiting time = 7/3 = 2.333‬‬

‫פתרון קביל נוסף‪:‬‬

‫‪3‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪5‬‬ ‫‪3‬‬
‫‪A3 B 4 C6 −B 9 A11 C12‬‬

‫‪Process‬‬ ‫‪Arr‬‬ ‫‪Cpu+io‬‬ ‫‪Term‬‬ ‫‪Wait‬‬

‫‪A‬‬ ‫‪0‬‬ ‫‪9‬‬ ‫‪11‬‬ ‫‪2‬‬

‫‪B‬‬ ‫‪1‬‬ ‫‪6‬‬ ‫‪9‬‬ ‫‪2‬‬

‫‪C‬‬ ‫‪2‬‬ ‫‪7‬‬ ‫‪12‬‬ ‫‪3‬‬

‫תשובה סופית ‪2.333‬‬

‫‪3‬‬
MLFQ ‫ במקרה שהמערכת משתמשת במנגנון‬,average waiting time -‫ נק׳) מהו ה‬10( .‫ב‬
.)preemptive( 4 -‫ ו‬2 ,1 ‫ של‬quantum time ‫ עם שלוש רמות העובדות עם‬scheduler
1 1 1 2 4 3
Q 1 ( 1 ) : A 1 B2 C3 B 6− A10 C12
3 2 3 5
Q 2 ( 2 ) : A5 C7 B8 A 11

Q 3 (4 ):

Process Arr Cpu+io Term Wait

A 0 9 11 2

B 1 6 8 1

C 2 7 12 3

Avg waiting time = 6/3 = 2

4
 :‫ נק) התבונן בקטע קוד הבא‬15( .3
:‫ ומאותחלים באופן הבא‬,N-1 ‫ עד‬0-‫ מוגדרים כמערכים בוליאניים מ‬T,B ‫משתני האלגוריתם‬

i, T[i] = false, B[i] = true ‫לכל‬

value = 3 :‫ המאותחל כך‬integer ‫ מסוג‬value ‫בנוסף קיים משתנה גלובלי נוסף‬
.‫ מתבצעות באופן אטומי‬wait -‫ ו‬signal ‫הפעולות‬

:i ‫הקוד הנ״ל הוא עבור תהליך‬

wait(i){
if((T[i] == false) && (B[i] == true)){
value--
}
if (value<0){
T[i] = true
}else{
B[i] = false
}
}

signal(i){
value++
B[i] = true
if (value <= 0){
int j=0
for(j=0;T[j]==false;j++){
}
T[j] = false
B[j] = false
}
}

//To enter Critical Section Process i performs the following code

while (B[i] == true) wait(i)

//CS

signal(i)

5
 ‫(‪ 5‬נק) הסבר איזו בעיה הקוד הזה פותר אם בכלל?‬ ‫א‪.‬‬

‫הקוד הזה מגביל כניסה של ‪ 3‬תהליכים לקטע קריטי‪.‬‬

‫(‪ 10‬נק) יוסי שינה את ערך ה‪ value -‬באתחול מ‪ 3 -‬ל‪ ,1 -‬חבר שלו דני טוען שהקוד‬ ‫ב‪.‬‬
‫לאחר העדכון של יוסי אינו עונה על כל הדרישות עבור פתרון תקין של קטע קוד קריטי‬
‫עבור ‪ N‬תהליכים הרצים במקביל‪ ,‬האם דני צודק או לא? הסבר‬

‫פתרון תקין צריך לענות על הדרישות הבאות‪:‬‬

‫‪ :Mutual exclusion‬רק תהליך אחד יכול להיות הזמן נתון בקטע הקריטי‬ ‫‪.1‬‬
‫התקדמות‪ :‬התהליכים שמנסים לנעול הם אלו שמשתתפים בנעילה‬ ‫‪.2‬‬
‫המתנה מוגבלת‪ :‬במקרה שלנו כשתהליך בא לשחרר נעילה ויש תהליכים נוספים‬ ‫‪.3‬‬
‫שממתינים‪ ,‬הוא בוחר את התהליך הראשון במערך (תהליך עם האינדקס הכי קטן)‪ ,‬לכן‬
‫יתכן שתהליך עם אינדקס גבוה יתקע לנצח בהמתנה לנעילה ותהליכים אחרים יוכלו לנעול‬
‫ולשחרר פעמים רבות כל עוד האינדקס שלהם קטן יותר‪.‬‬

‫לכן הפתרון המוצע אינו מספיק טוב‪.‬‬

‫כמובן שאפשר לסדר זאת בצורת הסריקה של המערך‪...‬‬

‫‪6‬‬
 ‫(‪ 10‬נק׳) להלן שני תהליכים (‪ )processes‬הרצים במקביל‪:‬‬ ‫‪.4‬‬

‫‪Process 1:‬‬
‫{)‪for (i=0 ; i<5 ; i++‬‬
‫;‪y=y+1‬‬
‫}‬

‫‪Process 2:‬‬
‫{)‪for(j=0 ; j<10 ; j++‬‬
‫;‪y=y+5‬‬
‫}‬

‫הניחו כי במערכת מעבד יחיד‪ ,‬וכי משתנה ‪ y‬משתנה משותף לשני התהליכים והוא מאותחל ל ‪.0‬‬
‫במידה והפעולה “‪ ”;y=y+1‬הינה פעולה אטומית וכל שאר הפעולות בקוד הן לא פעולות אטומיות‪,‬‬
‫מהם הערכים הסופיים ש – ‪ y‬יכול לקבל? (הערה‪ :‬בתשובה יש להתייחס לערך האפשרי‬
‫המינימלי והמקסימלי)‬
‫ערך מקסימלי‪55 :‬‬ ‫‪‬‬
‫ערך מינימלי‪50 :‬‬ ‫‪‬‬

‫(‪ 5‬נק) בקשות קריאה מהדיסק מגיעות ל‪ disk driver -‬עבור ‪:cylinders‬‬ ‫‪.5‬‬
‫‪( 76 ,12 ,80 ,4 ,40 ,44 ,20‬על‪-‬פי סדר משמאל לימין)‪ .‬בדיסק ‪ 120‬צילינדרים (‪)0-119‬‬
‫והראש נמצא כרגע מעל צילינדר ‪ 70‬ונע לכיוון ‪ .cylinder 0‬מהו המרחק (מספר הצילינדרים)‬
‫שתצטרך הזרוע לעבור‪ ,‬בהנחה שהאלגוריתם בו עושים שימוש הוא ‪?C-Look‬‬

‫תשובה‪142 :‬‬

‫‪70-> 4 -> 12 -> 20 -> 40 -> 44 -> 76 -> 80 = 66 + 76 = 142‬‬

‫‪7‬‬
‫(‪ 10‬נק׳) מערכת ‪ paging‬משתמשת ב ‪ frame‬בגודל של )‪ .4KB (4096‬להלן ה‪page-‬‬ ‫‪.6‬‬
‫‪ tables‬ו‪ TLBs‬של תהליך במערכת‪:‬‬

‫תרגמו את הכתובת הלוגית ‪ 3300‬לכתובת פיזית וחשבו את כמות הגישות לזיכרון (‪.)RAM‬‬

‫הכתובת הפיזית המתאימה‪7396 :‬‬ ‫א‪.‬‬

‫‪3300 = 4096 % 3300‬‬

‫‪0 = 4096 / 3300‬‬
‫פייג ‪ ,0‬אופסט בפייג ‪3300‬‬
‫פייג ‪ 0‬הוא פריים ‪ 1‬שמתחיל בכתובת ‪4096‬‬
‫לכן‪:‬‬
‫‪Add = 4096 + 3300 = 7396‬‬

‫מספר גישות לזיכרון‪2 :‬‬ ‫ב‪.‬‬

‫‪8‬‬
 ‫(‪ 5‬נק׳) נתונה סדרת הקריאות הבאה ל – ‪ PAGES‬של תהליך מסוים (משמאל לימין)‪:‬‬ ‫‪.7‬‬
‫‪1,5,4,2,0,1,3,2,3,4,3,5,1,2,5‬‬
‫במקרה שלתהליך זה מוקצים ‪ ,FRAMES 4‬כמה ‪ PAGE FAULTS‬יהיו אם ההחלפות‬
‫מתבצעות על‪-‬פי האלגוריתם ‪?LRU‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪4‬‬ ‫‪2‬‬
‫‪5‬‬ ‫‪1‬‬ ‫‪5‬‬
‫‪4‬‬ ‫‪3‬‬
‫‪2‬‬ ‫‪1‬‬

‫תשובה‪11 :‬‬

‫(‪ 5‬נק׳) איזה מהטיעונים הבאים לגבי שחלוף (‪ )Swapping‬וכיווץ (‪ )Compaction‬בזיכרון‬ ‫‪.8‬‬
‫ממשי נכון?‬

‫אין טעם לתמוך‪ ,‬באותה מערכת‪ ,‬הן בכיווץ והן בשחלוף‪.‬‬ ‫א‪.‬‬
‫כדאי לבצע את ההעתקה לצורך כיווץ ע"י יחידת בקר עצמאית כמו ‪.DMA‬‬ ‫ב‪.‬‬
‫התוכנית שהוחלפה תוחזר תמיד לאותו מקום בזיכרון‪.‬‬ ‫ג‪.‬‬
‫כדאי לבצע את ההעתקה לצורך שחלוף ע"י יחידת בקר עצמאית כמו ‪.DMA‬‬ ‫ד‪.‬‬

‫(‪ 5‬נק׳) האם תיתכן מקביליות אמיתית ( ‪ )True Concurrency‬במחשב בעל מעבד אחד (‬ ‫‪.9‬‬
‫‪?)Uniprocessor‬‬

‫כן‪.‬‬ ‫א‪.‬‬
‫לא‪ ,‬זוהי אשליה הנוצרת בגלל פער המהירות בין פעולות ‪ IO‬לבין מהירות מעבד‪.‬‬ ‫ב‪.‬‬
‫לא‪ ,‬המקביליות המדומה מתאפשרת בגלל היכולת לשחזר בדיוק מחדש תהליך שהופסק‬ ‫ג‪.‬‬
‫זמנית‪.‬‬
‫לא‪ ,‬כי המעבד יכול לשרת רק תהליך אחד בכל "רגע"‪.‬‬ ‫ד‪.‬‬

‫(‪ 5‬נק) כאשר מערכת מחשב נמצאת במצב של ‪ ,trashing‬אילו פעולות יש לבצע במערכת כדי‬ ‫‪.10‬‬
‫לצאת ממצב זה?‬
‫הקטנת מספר התהליכים הנמצאים ב‪ready queue -‬‬ ‫א‪.‬‬
‫הגדלת מספר התהליכים הנמצאים ב‪ready queue -‬‬ ‫ב‪.‬‬
‫הגדלת ה‪ quantum -‬ב‪Round Robin -‬‬ ‫ג‪.‬‬
‫הקטנת ה‪ quantum -‬ב‪Round Robin -‬‬ ‫ד‪.‬‬

‫‪9‬‬
‫(‪ 5‬נק) איזה משיטות הזימנון (‪ )Scheduling‬הבאות סובלת מאפקט השיירה (‪Convoy‬‬ ‫‪.11‬‬
‫‪?)Effect‬‬

‫)‪.FCFS (First Come First Serve‬‬ ‫א‪.‬‬

‫)‪.SRTF (Short Remaining Time First‬‬ ‫ב‪.‬‬
‫זימנון מעגלי (‪.)Round Robin‬‬ ‫ג‪.‬‬
‫כל אלגוריתמי הזימנון עם לקיחה בכוח (‪.)Preemptive‬‬ ‫ד‪.‬‬

‫(‪ 5‬נק) במרחב זיכרון וירטואלי של ‪ 16‬סיביות‪ ,‬גודל הדף הוא ‪ 8192‬בתים‪ .‬כמה דפים ישנם?‬ ‫‪.12‬‬
‫ואיך הם ממוספרים?‬

‫‪ 16‬דפים ממוספרים ‪.0-15‬‬ ‫א‪.‬‬

‫‪ 8‬דפים ממוספרים ‪.1-8‬‬ ‫ב‪.‬‬
‫‪ 8‬דפים ממוספרים ‪.0-7‬‬ ‫ג‪.‬‬
‫‪ 16‬דפים ממוספרים ‪.1-16‬‬ ‫ד‪.‬‬
‫אף תשובה לא נכונה‪.‬‬ ‫ה‪.‬‬
‫‪8192 = 2^10 * 8 = 2^13‬‬
‫‪Page bits are: 2^3 = 8‬‬

‫‪10‬‬