This question spans 4 stages — each part below is tagged with, and links to, the stage it belongs to.
שאלה 3 - מטמונים (25 נק')
Full original question text (raw OCR)
שאלה 3 - מטמונים (25 נק')
(3 נק') בכמה זיכרון יותר איטי מהמעבד? בחרו סדר גודל. א. 10 ב. 100 ג. 1000 ד. 10000 הסבר:
Process state transitions(3 נק') מה הבעיה בכך שהזיכרון איטי יותר מהמעבד? בחרו את ההסבר המדויק ביותר ונמקו: א. המעבד צריך לטפל בהעתקה של דפים מהדיסק לזיכרון, ולכן זיכרון איטי יעכב את פעולת ההעתקה וימנע מהמעבד לעסוק בעבודה חיונית אחרת. ב. הזיכרון מנבא אילו נתונים המעבד יצטרך ומביא אותם מראש, ולכן זיכרון איטי לא יביא את הנתונים בזמן ויעכב את המעבד. ג. כאשר המעבד מבצע פקודת מכונה שהיא קריאה מהזיכרון, הזיכרון צריך קודם להעביר נתונים למטמון, ולכן זיכרון איטי יעכב את המעבד. ד. אף תשובה לא נכונה הסבר:
Copy-on-write fork memory protection(4 נק') נתון קטע הקוד הבא: // array's size is N, please disregard the accesses done while initializing the array 1: int A[] = initializeArray(); 2: for (i=0; i<N; i++) 3: int x = A[i]; האם דפוס הגישות לזיכרון בשורה 3 היא spatial locality או temporal locality סמן את הנכון: spatial locality temporal locality הסבר:
SRT / preemptive Gantt constructionreview:T5·9(4 נק') נתון קטע הקוד הבא: // array's size is N>10, please disregard the accesses done while initializing the array 1: int A[] = initializeArray(); 2: for (i=0; i<N; i++) { 3: int x = A[0]+i; 4: } האם דפוס הגישות לזיכרון בשורה 3 היא spatial locality או temporal locality סמן את הנכון: spatial locality temporal locality הסבר:
SRT / preemptive Gantt constructionreview:T5·9(4 נק') נתון קטעי קוד לשני חוטים שנכתב על ידי גדליה ואבינועם. הקוד מיועד לריצה מקבילית על מספר חוטים עם מערכת מרובת ליבות, נכונות האלגוריתם דורשת ש do_work יתבצע פעם אחת בלבד. // flag_a,flag_b are global variables initialized to zero 1: flag_b = 1; 2: while (flag_a) {}; 3: do_work(); //no synchronization inside do_work() // flag_a, flag_b are global variables initialized to zero 1: flag_a = 1; 2: while (flag_b == 0) { 3: do_work(); //no synchronization inside do_work() 4: return; 5: } הקוד רץ על שני מעבדים במקביל בשני חוטים. גדליה טוען שייתכן do_work יתבצע יותר מפעם אחת ולכן התוכנית אינה נכונה. אבינועם טוען, שמצב זה לא ייתכן ואם אחד החוטים ביצע 1=flag_a או 1=flag_b אז כל החוטים יראו מיד את השינוי. הכריעו מי צודק, בפרט, אם גדליה צודק, האם קיים פתרון לבעיה? נמקו.
libc syscall wrapper caching pitfallsPipe IPC semantics(3 נק') במערכת מרובת ליבות מהו המבנה הטיפוסי של המטמונים? סמנו את התשובה המתאימה ביותר. א. לכל ליבה יש מטמון משלה בלבד ואין מטמון משותף ב. יש מטמון משותף אחד בו משתמשות כל הליבות ג. לכל ליבה יש מטמון גדול ובנוסף קיים מטמון אחד קטן יותר משותף לכל הליבות ד. לכל ליבה יש מטמון קטן (או כמה רמות של מטמונים) ובנוסף קיים מטמון אחד גדול משותף לכל הליבות. ה. אף תשובה לא נכונה הסבר:
libc syscall wrapper caching pitfallsreview:T2·22(4 נק') בהנחה שלכל מעבד יש מטמון פרטי, איך מערכת ההפעלה יכולה לשפר את הביצועים של התהליכים הרצים במערכת? א. להצמיד תהליך לליבה ספציפית ב. בכל החלפת הקשר, מערכת ההפעלה תשמור את תוכן המטמון במבנה נתונים ייעודי בגרעין, ותשחזר אותו בעת חזרת התהליך לריצה ג. בין אם המטמון פרטי או משותף, מערכת ההפעלה לא יכולה לנצל זאת לשיפור הביצועים ד. אף תשובה לא נכונה הסבר:
Voluntary vs preemptive context switchlibc syscall wrapper caching pitfalls
The exam question — original PDF
pages 8, 9, 10, 11Exactly as it appears on the exam paper.
Built from these components
Ordered basic → advanced. Master the earlier ones first.
Review the material
Read these before you answer — each verified slide teaches a component this question tests, and nothing from an unrelated topic is included. Tutorial slides show the actual slide image.
Process states created service provided ready preempted scheduled waiting finished or killed requires “slow” service (notably I/O) zombie running termination process is process is status collected runnable sleeping OS (234123) - processes & signals 4
קריאת המערכת wait()pid_t wait(int *wstatus);פעולה: ממתינה עד אשר אחד מתהליכי הבן יסיים.פרמטרים:wstatus – מצביע למשתנה בו יאוחסנו פרטים על תהליך הבן שהסתיים.למשל, wstatus יכיל את ערך הסיום של הבן (הערך שהעביר כארגומנט ל-exit()). ערך הסיום מופיע בבית השני מתוך ארבעת בתי ה- wstatus. כדי לחלץ אותו יש לנצל את המאקרו WEXITSTATUS(*wstatus), המחזיר (*wstatus>>8) & 0xff. במידה ולא מעוניינים בסטטוס הבן שסיים, אפשר להעביר NULL.ערך מוחזר:אם אין בנים או שכל הבנים כבר סיימו ובוצע להם wait() – יוחזר מיד הערך -1.אם יש בנים שסיימו ועדיין לא בוצע עבורם wait() (כלומר הם במצב zombie – יפורט בשקופיות הבאות) – יוחזר מיד ה-pid של אחד הבנים הנ"ל.אחרת – המתנה עד שבן כלשהו יסיים.מערכות הפעלה - תרגול 214איך תהליך אב יכול לחכות לסיום כל תהליכי הבן?מבינים את החישוב?
סיום תהליכיםכדי לאפשר לאב לקבל מידע על סיום הבן, לאחר שתהליך מסיים את פעולתו הוא עובר למצב מיוחד – zombie – שבו התהליך קיים כרשומת נתונים בלבד ללא שום ביצוע משימה.הרשומה נמחקת לאחר שהאב קיבל את המידע על סיום הבן באמצעות wait().שאלה: מה קורה לתהליך "יתום" (orphan), כלומר תהליך שסיים לאחר שאביו כבר סיים בלי לקרוא ל-wait() ?התהליך הופך להיות בן של init.התהליך init ממשיך להתקיים לאורך כל פעולת המערכת.אחד מתפקידיו העיקריים – המתנה לכל בניו כדי לפנות את נתוניהם לאחר סיומם.מערכות הפעלה - תרגול 219
קריאות המערכת getpid(), getppid()pid_t getpid();קריאת מערכת המחזירה לתהליך הקורא את ה-pid של עצמו.pid_t getppid();קריאת מערכת המחזירה את ה-PID של תהליך האב של התהליך הקורא.שאלה: מה המשמעות של getppid() == 1 עבור תהליך משתמש טיפוסי?תשובה: תהליך האב הוא init. קורה למשל אם תהליך הבן יתום.מערכות הפעלה - תרגול 222
FD (file descriptors)כל פעולות קלט/פלט של תהליך בלינוקס מבוצעות דרך "קבצים":קבצים "רגילים" לאחסון מידע (/usr/file.txt) נמצאים בדיסק.התקני חומרה גם כן מיוצגים כקבצים, אבל נמצאים בזיכרון.למשל, העכברים המחוברים למחשב מיוצגים כ- /dev/input/mouseN .גם ערוצי תקשורת כמו pipes מיוצגים ע"י קבצים שנמצאים בזיכרון.הקשר בין תהליך לבין קובץ שהוא ניגש אליו נשמר, ברמת המשתמש, ע"י מספר שלם שנקרא file descriptor (FD).לדוגמה: קריאת המערכת open() מחזירה FD.המשתמש מעביר את ה-FD לקריאות מערכת כמו read(), write() כדי לקרוא ולכתוב לקובץ.מערכות הפעלה - תרגול 320
שחרור file objectשאלה: מי מבצע את שחרור הזיכרון של file object? מתי ניתן לשחררו? ייתכנו מצבים בהם תהליכים שונים מצביעים לאותו file object, לכן שחרור ה-file object יכול להתבצע רק לאחר ביצוע close() מכל התהליכים החולקים את אותו ה-file object. זכרו של-file object יש מונה (f_count) הסופר את כמות התהליכים המצביעים עליו בכל רגע נתון. המונה קטן באחד עם כל פעולת close() על האובייקט. כאשר המונה מתאפס, ה-file object ישוחרר.מערכות הפעלה - תרגול 342
דוגמת FCFSaverageResponseTime = (10 + 20 + 30) / 3 = 20כעת נסיר את הנחה 1 ("כל התהליכים רצים למשך אותו זמן"). לכל תהליך זמן ריצה משלו.תוכלו לחשוב על דוגמה שבה FCFS אינו יעיל?מערכות הפעלה - תרגול 59כל התהליכים רצים למשך אותו זמן.כל התהליכים מגיעים באותו זמן (t=0).אם תהליך התחיל לרוץ, אז הוא ירוץ עד לסיומו ללא הפסקות.התהליכים משתמשים רק במעבד ולא מבצעים I/O.זמן הריצה של כל התהליכים ידוע מראש.
מהי החלפת הקשר?מערכות הפעלה - תרגול 610
מהי החלפת הקשר?לכל תהליך יש "הקשר ביצוע" (execution context) המכיל את כל המידע הדרוש לביצוע התהליך.מחסניות, רגיסטרים, תכולת זיכרון, קבצים פתוחים, ..."החלפת הקשר" = עצירת הביצוע של התהליך הנוכחי ושמירת ההקשר שלו.טעינת ההקשר של התהליך הבא לביצוע.הקשר התהליך הנוכחי מתחלף – מכאן שם הפעולה "החלפת הקשר".מערכות הפעלה - תרגול 611
שני סוגים של החלפת הקשרהחלפת הקשר כפויה(== הפקעה)הגרעין מפקיע (כלומר, לוקח בכוח) את המעבד מהתהליך, למשל בעקבות:פסיקת שעון (מטופלת בשגרה scheduler_tick) אשר מגלה כי הזמן שהוקצב לתהליך הנוכחי אזל.אירוע אסינכרוני אשר מעיר תהליך בעל עדיפות טובה יותר מהתהליך הרץ כרגע.לדוגמה: פסיקת דיסק או שחרור מנעול שתהליך המתין לו.החלפת הקשר יזומההתהליך מוותר מרצונו על המעבד, למשל באמצעות:קריאת מערכת חוסמת (כמו wait(), read(), …) אשר מוציאה את התהליך להמתנה.קריאת מערכת exit() אשר מסיימת את התהליך.קריאת מערכת sched_yield() – קריאת מערכת ייעודית לוויתור על המעבד.מערכות הפעלה - תרגול 613
יצירת חוט חדשפרמטרים:thread – מצביע למקום בו יאוחסן מזהה החוט החדש במקרה של סיום הפונקציה בהצלחה.attr – מאפיינים המתארים את תכונות החוט החדש, כגון האם החוט הוא חוט גרעין או חוט משתמש, האם ניתן לבצע לו join, כלומר להמתין לסיומו, וכו'. בד"כ נספק ערך NULL המציין חוט ברירת המחדל של המערכת, שניתן להמתין לסיומו.void* (*start_routine)(void*) מצביע לפונקציה שתהווה את קוד החוט. הערך המוחזר מפונקציה זו במקרה של סיומה הטבעי הינו ערך הסיום של החוט.arg – פרמטר שיסופק לפונקציה עם הפעלתה.מערכות הפעלה - תרגול 714
מרחבי זיכרון וקריאות מערכתחוטים הנוצרים ע"י קריאת המערכתclone() משתפים את מרחב הזיכרון ע"י הצבעה לאותו מתאר מרחב הזיכרון של תהליך האב.יש להגדיל את מונה השיתוף (mm_users) של מתאר מרחב הזיכרון של תהליך האב.קריאת המערכת execv() ודומותיה טוענות תהליך חדש ולכן הן משחררות את מרחב הזיכרון ומקצות אחד חדש.קריאת המערכתfork() מקצה לתהליך הבן מרחב זיכרון משלו.במקרה שכזה צריך להעתיק את מרחב הזיכרון של האב לזה של הבן.בפועל, בדרך-כלל אין באמת העתקה בזכות מנגנון copy-on-write.23מערכות הפעלה - תרגול 10
הפתרון: copy-on-write (COW)הרעיון של מנגנון copy-on-write (COW) הוא:דפים הניתנים לכתיבה שאינם יכולים להיות משותפים (לדוגמה, המחסנית), מוגדרים בתחילה כמשותפים אבל מועתקים לעותק פרטי כאשר אחד התהליכים השותפים (האב או הבן) מנסה לכתוב אליהם לראשונה.שאר הדפים (כדוגמת דפי קוד או דפי נתונים לקריאה בלבד) הופכים למשותפים בין מרחבי הזיכרון של האב והבן.מנגנון COW פותר את שתי הבעיות שהוצגו קודם:COW מקטין את זמן הביצוע של fork() כי הוא "פורס לתשלומים" את ההעתקה של כל מרחב הזיכרון להרבה העתקות קטנות בגודל דף שיתבצעו בעתיד---בכל כתיבה ראשונה לדף שאינו משותף.במידה ותהליך הבן יבצע מיד execv(), מרחב הזיכרון שלו יימחק וכך תיחסך רוב פעולת ההעתקה.27מערכות הפעלה - תרגול 10
father processpage tablememory regionsדוגמה: לפני קריאת מערכת fork()28…PTE #11r/w = 1…frame #250count == 1מערכות הפעלה - תרגול 10region #1VM_MAYWRITE=1VM_WRITE=1region #2
The exam text, the skills it tests, and the exact slides are already in context.