CPU Schedulinghigh-yield

Running → Ready

Ready → Running

Running → Waiting

Waiting → Ready

מה היתרון בשימוש ב quantum גדול (מספיק יתרון אחד)?

מה היתרון בשימוש ב quantum קטן (מספיק יתרון אחד)?

במידה והמערכת עמוסה (מכילה הרבה תהליכים מוכנים לריצה), מדוע עדיף להוסיף תהליכים חדשים בסוף התור?

עבור זמן תהליכים CFS, איזה בעיה פותרת ה min_granularity ?

איזה תהליך ירוץ בכל אחד מהזמנים הנתונים: [Table to fill]

איזה תהליך ירוץ בכל אחד מהזמנים הנתונים (נא להמשיך את הטבלה עד 17ms) [Table to fill]

האם תודפס ההודעה "Hello from CFS"? (הסבר)

אילו היינו משנים את מדיניות הזימון של תהליך A ל SCHED_RR במקום SCHED_FIFO, האם התשובה לסעיף הקודם היתה משתנה?

לדני יש מחשב בעל 2 מעבדים ורוצה לממש "איזון עומסים" במערכת זימון תהליכים שלו, כך שהתהליך יכול לבחור לאיזה מעבד לעבור דרך קריאת מערכת חדשה. להזכירכם: "איזון עומסים" או load balancing היא פעולה בה מעבירים תהליכים בין מעבד אחד לשני כדי לאזן את העומס על שני המעבדים. לדני עלתה 3 אופציות לממש את העברת תהליכים רגילים, בעלי מדיניות זימון CFS, ממעבד A למעבד B: • להשאיר את התהליך עם אותו vruntime שצבר עד כה. • לתת לתהליך vruntime = min_vruntime הזמן הוירטואלי המינימלי בין הזמנים הוירטואלים של התהליכים הרצים על המעבד B. • לתת לתהליך vruntime = max_vruntime הזמן הווירטואלי המקסימלי בין הזמנים הוירטואלים של התהליכים הרצים על המעבד B. מה לדעתכם האופציה העדיפה ביותר? ולמה?

(5 נק') מה הצירוף של פקודות מכונה השקול לפקודה "call 0x12345"? a. after_call: pushl after_call jmp $0x12345 b. jmp $0x12345 pushl after_call c. pushl after_call after_call: jmp $0x12345 d. jmp $0x12345 pushl after_call after_call: e. pushl after_call jmp $0x12345 after_call: f. pushl after_call after_call: jmp $0x12345

(5 נק') מה הקוד החסר בשורות 6--7? תזכורת: פקודת movl a,b מעתיקה את התוכן של a ל-b. a. movl next->thread.esp, %esp movl %esp, prev->thread.esp b. movl %esp, prev->thread.esp movl next->thread.esp, %esp c. movl %esp, next->thread.esp movl prev->thread.esp, %esp d. movl prev->thread.esp, %esp movl %esp, next->thread.esp e. movl %esp, prev->thread.esp movl %esp, next->thread.esp f. movl prev->thread.esp, %esp movl next->thread.esp, %esp

(5 נק') למרבה הצער, הקוד החדש של בני לא עובד (הגרעין קורס מיד בשלב האיתחול). מה הקוד שיש להוסיף בין שורות 10,11 כדי לתקן את הגרעין? a. ret b. iret c. jmp $1f d. jmp next->thread.eip e. call $1f f. call next->thread.eip

(5 נק') למרבה הצער, גם הקוד של משה לא עובד (הגרעין קורס מיד בשלב האיתחול). מה הקוד שיש להוסיף בין שורות 10,11 כדי לתקן את הגרעין? a. ret b. iret c. jmp $1f d. jmp next->thread.eip e. call $1f f. call next->thread.eip

(5 נק') כצפוי, גם הקוד של אבי לא עובד (הגרעין קורס מיד בשלב האתחול). מה הקוד שיש להוסיף בין שורות 10,11 כדי לתקן את הגרעין? a. jmp next->thread.eip popl %eax popl %edx b. popl %eax popl %edx jmp next->thread.eip c. ret popl %eax popl %edx d. popl %eax popl %edx ret e. ret popl %eax popl %edx popl %eax f. pop1 %edx popl %eax ret

(3 נק): מגיעים שלושה תהליכים יחד: P1,P2,P3. זמן הריצה של תהליך P1 הוא 3Q. זמן הריצה של תהליך P2 הוא Q. זמן הריצה של תהליך P3 הוא 6Q. התהליכים מסתדרים בתור למעבד (run queue) בסדר הבא: קודם P1 אחר כך P2 ואחר כך P3. רשמו בתרשים מטה באיזה תזמון תהליכים הולכים לרוץ. איזה תהליך ירוץ באיזה יחידת זמן?

(3 נק): כמה epochs ייקח עד שכל התהליכים יסיימו את ריצתם? מה יהיה אורך של כל epoch ביחידות זמן של Q? מספר epochs: אורך של כל אחד:

(3 נק): האם IRR הוא זמן הוגן? אם כן, סמן והסבר מדוע? אם לא, סמן והסבר איזה תהליכים יכולים להיות מורעבים? (כן / לא)

(3 נק): האם IRR יכול לגרום לאפקט השיירה (convoying effect)? הסבר את תשובתך. (כן / לא)

(3 נק): איזה סוג תהליכים (IO-bound,CPU-bound,או אף אחד מהם) יעדיפו לעבוד עם זמן IRR? הסבר את תשובתך. (CPU-bound) (I/O-bound) (אף אחד מהם)

(5 נק): האם תמיד זמן תגובה ממוצע של RR טוב יותר מ- או שווה ל- IRR הוכח / הפרך: (נכון / לא נכון)

(5 נק): האם תמיד זמן תגובה ממוצע של IRR טוב יותר מ- או שווה ל- RR הוכח / הפרך: (נכון / לא נכון)

(5 נק): הוכח שאם במערכת יש רק ליבה אחת ואין מחיר להחלפת הקשר כל התהליכים מגיעים יחד ומשתמשים רק ב-CPU (אין ס/ו) זמן ריצה של תהליכים הוא Q∑ i עבור ח כלשהו אז avgResponseTime(IRR)<=2*avgResponseTime(SJF) הוכחה:

EASY

LXF - Largest eXpansion Factor

SJBF - Shortest Job Backfilled First

LJBF - Longest Job Backfilled First

(5 נק') כפי שלמדנו, תחת תנאים מסוימים אלגוריתם SJF הינו אופטימלי עבור מדד זמן תגובה ממוצע. מהם שלושת התנאים?

(3 נק') תנאי שלא מתקיים: דוגמא לאי אופטימליות:

(3 נק') תנאי שלא מתקיים: דוגמא לאי אופטימליות:

(3 נק') תנאי שלא מתקיים: דוגמא לאי אופטימליות:

(3 נק') מדד זמן ההמתנה הממוצע (average wait-time):

(3 נק') מדד זמן התגובה הממוצע (average response-time):

(3 נק') מדד הניצולת (utilization):

(4 נק') בהנחה שכל התהליכים למעלה מגיעים בזמן 0. איזו מדיניות זימון יכולה לשפר את הניצולת כפי שחושבה בסעיף הקודם? נמקו (ראו מצורפת טבלת זימון ריקה על מנת להמחיש את הזימון החדש לפי האלגוריתם, עליכם למלא את הטבלה בהתאם)

(4 נק') מנו 2 יתרונות ו-2 חסרונות של מדיניות זימון מסוג batch-scheduling על פני מדיניות Round-robin. נמקו.

(4 נק') האם BSAF סובל מ-convoy effect? נמקו (עליכם להמחיש בעזרת הטבלה הנתונה).

(4 נק') האם אלגוריתם הזימון BSAF הינו אופטימלי מבחינת מדד הניצולת? הוכיחו או הפריכו (עליכם להמחיש בעזרת הטבלה הנתונה)

1. (2 נק') במערכת עם ליבה אחת, בה כל התהליכים מגיעים יחד וזמני הריצה שלהם ידועים מראש, איזה אלגוריתם batch scheduling (כלומר בלי הפקעות תהליכים) ימזער ככל הניתן את ה-average wait time? (אין צורך בנימוק) a. SJF (shortest job first) algorithm b. FCFS (first come first serve) algorithm c. EASY (FCFS + backfilling) algorithm d. RR (round robin) algorithm e. תלוי בחומרת המערכת f. אם קיים תהליך שרץ על כל המעבדים במערכת – Round Robin, ואחרת SJF g. תלוי כמה מהתהליכים שייכים למערכת ההפעלה

2. (5 נק') נגדיר מערכת בעלת 3 ליבות (המסוגלת להריץ תהליכים במקביל, בהתאם לדרישות של התהליכים), בה ישנם אך ורק 4 תהליכים המעוניינים לרוץ: תהליך 1 דורש 2 ליבות וירוץ למשך 2 שניות עד לסיום תהליך 2 דורש 1 ליבות וירוץ למשך 4 שניות עד לסיום תהליך 3 דורש 3 ליבות וירוץ למשך 1 שניות עד לסיום תהליך 4 דורש 2 ליבות וירוץ למשך 2 שניות עד לסיום התהליכים נשלחים למעבד בסדר זה (קודם תהליך 1 מגיע, אחרי זה תהליך 2, אחרי זה תהליך 3, ואחרון מגיע תהליך 4). לאחר הגעת תהליך 4 אך לפני תחילת הרצת תהליך 1 נקצה את כולם למעבדים ונחלק לוח זמנים לכל מעבד (כלומר לכל מעבד נקבע מתי להריץ איזה תהליך). איזה אלגוריתם יגרום לסיום כל התהליכים ראשון? a. כל האלגוריתמים יסיימו את הריצה באותו זמן b. FCFS c. SJF d. EASY e. תשובות b, c נכונות f. תלוי עד כמה יש את "אפקט השיירה" (convoy effect) במערכת לפני תחילת ריצת התהליכים g. תשובות c, d נכונות נימוק:

3. (3 נק') במערכת ההפעלה לינוקס אנו משתמשים באלגוריתם זימון תהליכים המורכב ממערכת תזמון round robin או FIFO עבור תהליכי זמן-אמת, ובאלגוריתם CFS (כפי שנלמד בתרגולים) עבור תהליכים "רגילים". נניח שיש תהליך רגיל אחד ותהליך זמן-אמת אחד. מהו החיסרון המשמעותי ביותר בשימוש באלגוריתם CFS גלובלי על כל התהליכים? כלומר, מה החיסרון בכך שנתייחס לתהליכי זמן-אמת בתור תהליכים רגילים, וניתן להם niceness מקסימלי כדי לתת להם עדיפות גבוהה באלגוריתם? a. לאלגוריתם CFS יש סיבוכיות זמן ריצה של בחירת התהליך הבא ((O(log(n ולכן לא נרצה לאלץ את התהליך זמן-האמת לחכות לריצה שלו b. אלגוריתם round robin יותר הוגן מאשר אלגוריתם CFS כיוון שהוא לא מתייחס למשקול (niceness) של תהליך c. אלגוריתם CFS גלובלי לא יתן לתהליך זמן האמת את כל זמן המעבד d. אלגוריתם CFS לא מתחשב בזמן שתהליכים לוקחים לבצע ס/ו e. תהליכים חדשים מתווספים עם זמן ריצה וירטואלי מינימאלי ולכן יכולים לגרום להרעבת תהליך זמן האמת f. אף תשובה לא נכונה נימוק:

4. (3 נק') באלגוריתם CFS (כפי שנלמד בתרגול), כאשר מעבירים תהליך P ממעבד A למעבד B (למשל, לצורך איזון עומסים בין מעבדים שונים), איזה זמן ריצה וירטואלי יקבל תהליך P אחרי שמעבירים אותו? a. זמן הריצה הוירטואלי המינימאלי מבין התהליכים של מעבד A b. זמן הריצה הוירטואלי המקסימאלי מבין התהליכים של מעבד A c. אותו זמן ריצה וירטואלי כפי שהיה לו במעבד A לפני שהועבר d. זמן הריצה הוירטואלי המינימאלי מבין התהליכים של מעבד B e. זמן הריצה הוירטואלי המקסימאלי מבין התהליכים של מעבד B נימוק:

5. (4 נק') אלגוריתם CFS מגדיר לתהליכים חדשים את זמן הריצה הוירטואלי _________, ואילו מגדיר לתהליכים שחוזרים משהייה ארוכה את זמן הריצה הוירטואלי a. חדשים: המינימאלי, חוזרים משהייה: המינימאלי b. חדשים: המקסימאלי, חוזרים משהייה: המקסימאלי c. חדשים: המינימאלי, חוזרים משהייה: המקסימאלי d. חדשים: המקסימאלי, חוזרים משהייה: המינימאלי e. חדשים: המקסימאלי, חוזרים משהייה: שהיה לו לפני היציאה לשהייה f. חדשים: הממוצע, חוזרים משהייה: שהיה לו לפני היציאה לשהייה g. חדשים: הממוצע, חוזרים משהייה: הממוצע h. אף תשובה לא נכונה נימוק:

6. (4 נק') במערכת בה תהליכים מגיעים בזמנים שרירותיים, באיזה אלגוריתם תזמון נעדיף להשתמש – SRTF או SJF? מדוע? הערה: נגדיר "אלגוריתם מועדף" בתור אלגוריתם שמשפר את ה-average wait time כפי שהוגדר בסעיף הראשון. נימוק:

7.(4 נק') ד"ר פישבך, חוקר אלגוריתמי תזמון במערכות הפעלה, מתבאס מכל אלגוריתמי התזמון המסובכים ומציע אלגוריתם מאוד פשוט: כל מעבד יעבור לתהליך חדש בכל פסיקת שעון (בלי התנגשויות כמובן, כך שלא יקרה מצבו בוזוג מעבדים יריצו את אותו תהליך), וככה חלוקת הזמנים בין התהליכים תהיה הכי הוגנת שהיא יכולה להיות, כי בכל epoch כל התהליכים יקבלו את אותה כמות זמן. הוא מגביל את האלגוריתם למערכות שמבצעות רק תהליכים שלא נכנסים למצב המתנה, ובעלי niceness אחיד קבוע. ד״ר טאוב שהשקיע הרבה זמן בתרגילי הבית במערכות הפעלה נרתע מאלגוריתם זה ומעדיף להשתמש במערכת הקיימת. הוא טוען שישנה בעיה מאוד חמורה באלגוריתם זה. מה הבעיה? נימוק:

(4 נק') האם SJF יכול לשמש אותנו לצורך בניית מערכת כזו, בהנחה שכל התהליכים הגיעו בזמן 0. אם כן, הוכיחו. אם לא, תנו דוגמה נגדית.

(5 נק') הוכיחו או הפריכו אופטימליות של EDD עבור קבוצת תהליכים שמגיעים ביחד ביחס למדד זה, כלומר: הוכיחו שאלגוריתם EDD יביא למינימום של המדד L או תנו דוגמה נגדית.

(5 נק') עבור N תהליכים מחזוריים במערכת עם מעבד יחיד, שלכל תהליך יש זמן ריצה (למחזור) ;R ומחזור C תנו נוסחה לחישוב הניצולת (utilization) של המערכת תחת זימון EDD. הסבירו את תשובתכם.

(4 נק') עבור אילו ערכים של ניצולת אין אפשרות למצוא סידור שיספק דרישות של כל התהליכים?

(4 נק') זמן Earliest Deadline First בשימוש נרחב במערכות RT. זה אלגוריתם עם הפקעות. כל פעם שתהליך מסתיים או יוצא להמתנה או נוסף לתור של תהליכים מוכנים לריצה, אלגוריתם זה בוחן את כל התהליכים הזמינים ובוחר את התהליך עם זמן סף הקרוב ביותר. נתונה מערכת עם תהליכים הבאים (שכולם הגיעו למערכת בזמן 0): תהליך R C A 1 8 B 2 6 C 4 11 על פני 20 יחידות זמן ראשונות: מה יהיה הסידור שאלגוריתם EDF יפיק?

(3 נק') מה הניצולת של מערכת זו?

(4 נק') הסבר מדוע חשוב שכל התהליכים של עבודה מסויימת (ג׳וב) ירוצו במקביל? מה עשוי לקרות אם הם לא ירוצו במקביל?

(5 נק') בהנחה שעבודות 4,5,6 הגיעו בזמן 3, וכל שאר העבודות הגיעו בזמן 0, מהו זמן ההמתנה (wait) הממוצע? הסבירו

(4 נק') תחת ההנחה של סעיף ב׳, מהו זמן התגובה (response) הממוצע? הסבירו

(4 נק') תחת ההנחה של סעיף ב', מהו זמן ההאטה (slowdown) הממוצע? הסבירו

(4 נק') תחת ההנחה של סעיף ב׳, מהי הניצולת של המערכת? הסבירו

(4 נק') בהנחה שכל העבודות הגיעו בזמן ״0״ לפי סדר המיספור שלהן, אם נפעיל אלגוריתם זימון EASY, מה תהיה הניצולת של המערכת? הסבירו

הטבלה הבאה מתארת משימות שנוצרו ע"י 4 תהליכים A,B,C ו-D. עבור כל משימה נתון זמן היווצרותה, מספר יחידות החישוב שהיא דורשת, איזה תהליך יצר אותה ומה המספר הסידורי שלה (A2 נוצרה על ידי תהליך A והמספר הסידורי שלה 2). Task | A1 | B1 | C1 | D1 | A2 | B2 | A3 Computational units | 74 | 146 | 98 | 122 | 72 | 80 | 128 Time of Arrival (sec) | 0 | 0 | 4 | 5 | 8 | 12 | 12 נניח שהמעבד יכול לבצע 24 יחידות חישוב לשנייה. מלאו את הטבלה של הזימון. קבעו את אורך האינטרוול של הזמן והמשימות המתבצעות בו. למשל עבור מערכת בה בזמן 0 עד 3 מתבצעת משימה A1 ומזמן 4 עד 6 מתבצעות A1 ו-B1 הטבלה נראית כך: Time Interval | 0-4 | 4-6 Executing tasks | A1 | A1,B1

נתונה מערכת עם שני תהליכים A ו-B עם משקלים 1 ו-4 בהתאמה. A מיצר משימה בזמן 0 ואילו B מיצר משימה בזמן 4. גודל של כל משימה 200 יחידות חישוב ומעבד יכול לבצע 25 יחידות חישוב לשנייה. תנו תיאור של הזימון עד גמר הביצוע של שתי המשימות. (שימו לב שצריך להתחשב במשקלי התהליכים). תשובה:

חשבו את הגדלים של המשימות: A1: A2: A3: B1: B2: C1: מלאו את טבלת התזמון של WFQ: Time Interval Executing tasks

מלאו טבלה זו עבור זימון של WFQ: Time Interval Executing tasks

השיפור של WFQ נקרא WF2Q. כמו WFQ גם WF2Q בוחר במשימה עם זמן הסיום המוקדם ביותר לפי GPS. אבל הבחירה היא רק בין הפקטות ש-GPS כבר התחיל לבצע. ז"א אם בזמן t אנחנו רוצים לבחור משימה לביצוע ומשימה A מסתיימת לפני B לפי GPS, אז נבחר את A רק אם בזמן t גם אלגוריתם GPS התחיל לבצע את המשימה A. חזרו על הסעיף הקודם (סעיף 4.1) ומלאו טבלה זו עבור זימון של WF2Q: Time Interval Executing tasks

(5 נק') איזה אירוע מבין הבאים יוביל בהכרח להחלפת הקשר כפויה (כלומר הפקעה)? a. פסיקת חומרה אשר מעירה תהליך עדיף יותר מהתהליך הנוכחי. b. חריגת דף בעקבות גישה לא חוקית של התהליך לזיכרון. c. ניסיון לתפוס מנעול שכבר תפוס ע"י קריאה ל-()pthread_mutex_lock. d. קריאת מערכת ()wait. e. קריאת מערכת ()read. f. קריאת מערכת ()exit.

(5 נק') מה משמעות המושג "גרעין שאינו ניתן להפקעה"? a. תהליך חישובי לא יפקיע את המעבד מתהליך גרעין. b. תהליך אינטראקטיבי לא יפקיע את המעבד מתהליך גרעין. c. תהליך (חישובי או אינטראקטיבי) לא יפקיע את המעבד מתהליך גרעין. d. מערכת ההפעלה לא תפקיע את המעבד מתהליך חישובי שרץ במצב גרעין. e. מערכת ההפעלה לא תפקיע את המעבד מתהליך אינטראקטיבי שרץ במצב גרעין. f. מערכת ההפעלה לא תפקיע את המעבד מתהליך (חישובי או אינטראקטיבי) שרץ במצב גרעין.

(5 נק') איזה תרחיש הוא בלתי אפשרי בגרעין שאינו ניתן להפקעה במערכת מעבד יחיד? הבהרה: A עלול לחתוך את B פירושו ש-A עלול להיכנס באמצע הביצוע של B. a. קריאת מערכת חוסמת עלולה לחתוך קריאת מערכת חוסמת. b. קריאת מערכת לא-חוסמת עלולה לחתוך קריאת מערכת חוסמת. c. קריאת מערכת חוסמת עלולה לחתוך קריאת מערכת לא-חוסמת. d. פסיקת חומרה עלולה לחתוך קריאת מערכת חוסמת. e. פסיקת חומרה עלולה לחתוך קריאת מערכת לא-חוסמת. f. פסיקת חומרה עלולה לחתוך פסיקת חומרה.

(5 נק') מדוע נגן המוזיקה סובל מגרעין שאינו ניתן להפקעה? a. כי הוא תהליך חישובי אשר רגיש להשהיות במהלך הריצה (latency sensitive). b. כי הוא תהליך אינטראקטיבי אשר רגיש להשהיות במהלך הריצה (latency sensitive). c. כי הוא תהליך חישובי אשר רגיש לזמן הריצה הכולל (throughput sensitive). d. כי הוא תהליך אינטראקטיבי אשר רגיש לזמן הריצה הכולל (throughput sensitive). e. כי הוא תהליך חישובי אשר רגיש לנצילות המעבד (utilization sensitive). f. כי הוא תהליך אינטראקטיבי אשר רגיש לנצילות המעבד (utilization sensitive).

(5 נק') מי מהחברים של פרדי הציע דרך שתצמצם את הבעיה? נתון כי: • במחשב של פרדי רצים רק שני תהליכים: נגן המוזיקה + קומפילציה של קוד. • שני התהליכים הם בעלי ערך 0 = nice (ערך ברירת המחדל). • תהליך הקומפילציה רץ הרבה על המעבד ויוצא מעט להמתנה. • במחשב של פרדי יש מעבד יחיד. a. אף אחד מבין החברים. b. רק בריאן. c. רק רוג'ר. d. רק ג'ון. e. רק רוג'ר וג'ון. f. כל שלושת החברים.

(5 נק') מה סיבוכיות החיפוש של התהליך הבא לזימון? אלגוריתם 2.4 אלגוריתם 2.6 הסבר:

(5 נק') לאיזה סוג משתייך כל אחד מהאלגוריתמים מבין אלגוריתמי זימון התהליכים שנלמדו בהרצאה (כגון: FCFS, EASY, Round Robin, Gang, Multi-Level Priority Queue, SJF, ועוד)? אלגוריתם 2.4 אלגוריתם 2.6 הסבר:

(5 נק') האם יש הבדל בקביעת העדיפות הסטטית של תהליך באלגוריתם 2.4 לעומת אלגוריתם 2.6? אם יש שוני כזה, הסבירו מהו. הקיפו את הנכון: כן / לא הסבר:

(5 נק') איזה מהאלגוריתמים (או אולי שניהם) לוקחים בחשבון את המחיר של העברת תהליך בין ליבות מעבד שונות (כלומר זימון של תהליך לליבה 1 ולאחר מכן לליבה 2)? הקיפו את הנכון: אלגוריתם 2.4 / אלגוריתם 2.6 / שניהם הסבר:

(5 נק') נקרא לנוסחת התרגום של העדיפות הסטטית למספר פסיקות שעון: SP2T (Static Priority 2 Ticks). בקוד של אלגוריתם 2.4 הנוסחה מחושבת באמצעות המאקרו NICE_TO_TICKS, ואילו באלגוריתם 2.6 באמצעות המאקרו TASK_TIMESLICE כאשר תהליך מתחיל epoch חדש, מחושב עבורו quantum - הזמן המותר לריצה ב-epoch הנוכחי ביחידות של פסיקות שעון. מה הנוסחה לחישוב זה עבור שני האלגוריתמים? בתשובתכם אין צורך לכתוב קוד, אלא רק את הקשר בין SP2T לבין ה-quantum המחושב. אלגוריתם 2.4 אלגוריתם 2.6 הסבר:

(4 נק') אם מוחקים את שורה 12 (sched_yield), אז הקוד שנוצר ידפיס את אותו הפלט ביחס לתוכנית המקורית. נכון / לא נכון . נימוק:

(4 נק') יתכן שהמחרוזת msg2 תודפס לפני המחרוזת msg1. נכון / לא נכון . נימוק:

(5 נק') אם מוחקים את שורה 15 (לולאת ה-while), אז סדר ההדפסה הינו בהכרח: msg1 msg2 נכון / לא נכון . נימוק:

(4 נק') בהנחה שהמעבד מרובה ליבות, אז סדר ההדפסה של התוכנית המקורית (עם לולאת ה- while) הינו בהכרח: msg1 msg2 נכון / לא נכון . נימוק:

איזו שורה צריכה להיכנס בין שורות 5 ו-6? א. pushl %eip ב. pushl $1f ג. pushl prev->thread.eip ד. pushl next->thread.eip ה. pushl ret_from_fork ו. אין צורך להוסיף דבר במקום הנ"ל

איזו שורה צריכה להיכנס בין שורות 11 ו-12? א. popl %eip ב. addl $4, esp ג. popl prev->thread.eip ד. popl next->thread.eip ה. jmp ret_from_fork ו. אין צורך להוסיף דבר במקום הנ"ל

מה צריך להתווסף במקום שורה 9? א. p->thread.esp -= 4; ב. p->thread.esp -= 4; *(unsigned long*)p->thread.esp = (unsigned long) ret_from_fork; ג. childregs->esp -= 4; ד. *(unsigned long*)childregs->esp = (unsigned long) ret_from_fork; ה. childregs->esp -= 4; *(unsigned long*)childregs->esp = (unsigned long) ret_from_fork; ו. אין צורך להוסיף דבר במקום הנ"ל

(4 נק') בהנחה שלכל מעבד יש מטמון פרטי, איך מערכת ההפעלה יכולה לשפר את הביצועים של התהליכים הרצים במערכת? א. להצמיד תהליך לליבה ספציפית ב. בכל החלפת הקשר, מערכת ההפעלה תשמור את תוכן המטמון במבנה נתונים ייעודי בגרעין, ותשחזר אותו בעת חזרת התהליך לריצה ג. בין אם המטמון פרטי או משותף, מערכת ההפעלה לא יכולה לנצל זאת לשיפור הביצועים ד. אף תשובה לא נכונה הסבר:

חאסן טוען שאם נסיר את הקריאה ל-schedule(), התהליך לעולם לא ירוץ במדיניות SCHED_FIFO בפועל. האם אתם מסכימים? הסבירו.