```c pthread_mutex_t m; //Global vars pthread_cond_t cond; void* func(void* arg) { pthread_mutex_lock(&m); pthread_cond_wait(&cond,&m); printf("Andrey\n"); sleep(1); printf("Sasha\n"); pthread_mutex_unlock(&m); return NULL; } void* func2(void* arg) { pthread_mutex_lock(&m); pthread_cond_wait(&cond,&m); printf("Leonid\n"); pthread_mutex_unlock(&m); return NULL; } int main(){ pthread_t t[2]; pthread_mutex_init(&m, NULL); //Initialize an unlocked mutex cond_init(&cond, NULL); //Initialize a standard condition variable pthread_create(&(t[0]), NULL, func, NULL); pthread_create(&(t[1]), NULL, func2, NULL); pthread_cond_signal(&cond); //send a signal pthread_cond_signal(&cond); //send a signal return 0; } ``` ```cpp class Counter { private: int val; mutex_t m; public: Counter() { val = 1; mutex_init(&m); //Initialize an unlocked mutex } int getVal() { int ret_val; mutex_lock(&m); ret_val = val; mutex_unlock(&m); return ret_val; } void plusOne() { val+=1; mutex_lock(&m); mutex_unlock(&m); } void doubleVal() { mutex_lock(&m); val+=this->getVal(); mutex_unlock(&m); } // more code for the destructor } ``` הנחות כלליות על המנעול m: המנעול מומש עם תור, ומאפשר לחוטים כניסה למנעול לפי סדר הגעתם. המנעול לא בודק שגיאות. ```cpp class Counter { private: int val; mutex_t m_get, m_one,m_double; public: Counter() { val = 1; mutex_init(&m_get); //Initialize an unlocked mutex mutex_init(&m_one); mutex_init(&m_double); } int getVal() { int ret_val; mutex_lock(&m_get); ret_val = val; mutex_unlock(&m_get); return ret_val; } void plusOne() { mutex_lock(&m_one); val+=1; mutex_unlock(&m_one); } void doubleVal() { mutex_lock(&m_double); val+=this->getVal(); mutex_unlock(&m_double); } // more code for the destructor } ``` הנחות כלליות על המנעולים: המנעול מומש עם תור, ומאפשר לחוטים כניסה למנעול לפי סדר הגעתם. המנעול לא בודק שגיאות. ```cpp class Counter { private: int val; public: Counter(){ val = 1; } int getVal() { int ret_val; // Thread Local variable atomicSet(&ret_val,val); return ret_val; } void plusOne() { int plus_tmp; // Thread Local variable atomicSet(&plus_tmp,val); plus_tmp +=1; atomicSet(&val,plus_tmp); } void doubleVal() { int double_tmp; // Thread local variable atomicSet(&double_tmp,val); double_tmp += double_tmp; atomicSet(&val, double_tmp); } // more code for the destructor } ```
Full original question text (raw OCR)
חלק 1 - סינכרון (30 נק') pthread_mutex_t m; //Global vars pthread_cond_t cond; void* func(void* arg) { pthread_mutex_lock(&m); pthread_cond_wait(&cond,&m); printf("Andrey\n"); sleep(1); printf("Sasha\n"); pthread_mutex_unlock(&m); return NULL; } void* func2(void* arg) { pthread_mutex_lock(&m); pthread_cond_wait(&cond,&m); printf("Leonid\n"); pthread_mutex_unlock(&m); return NULL; } int main(){ pthread_t t[2]; pthread_mutex_init(&m, NULL); //Initialize an unlocked mutex cond_init(&cond, NULL); //Initialize a standard condition variable pthread_create(&(t[0]), NULL, func, NULL); pthread_create(&(t[1]), NULL, func2, NULL); pthread_cond_signal(&cond); //send a signal pthread_cond_signal(&cond); //send a signal return 0; } 1. (7 נק') לקוד זה 7 אופציות להדפסה מתוך ה-15 הבאות. יש להקיף את האופציות הנכונות. אין צורך להסביר את פתרונכם. כלום Andrey Leonid Sasha Andrey Leonid Andrey Sasha Sasha Leonid Andrey Andrey Andrey Leonid Sasha Sasha Andrey Leonid Leonid Sasha Leonid Andrey Leonid Sasha Andrey Sasha Andrey Leonid Andrey Sasha Leonid שימו לב: הסעיפים הבאים אינם תלויים בסעיף א'. במסגרת עבודתה בחברת EMD-TooMuchIO, ניסתה אחינועם לממש מונה משותף למספר חוטים: class Counter { private: int val; mutex_t m; public: Counter() { val = 1; mutex_init(&m); //Initialize an unlocked mutex } int getVal() { int ret_val; mutex_lock(&m); ret_val = val; mutex_unlock(&m); return ret_val; } void plusOne() { val+=1; mutex_lock(&m); mutex_unlock(&m); } void doubleVal() { mutex_lock(&m); val+=this->getVal(); mutex_unlock(&m); } // more code for the destructor } הנחות כלליות על המנעול m: המנעול מומש עם תור, ומאפשר לחוטים כניסה למנעול לפי סדר הגעתם. המנעול לא בודק שגיאות. 2. (6 נק') הקוד של אחינועם בעייתי כאשר מספר חוטים משתמשים במחלקה במקביל. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות: a. הקוד בזבזני בגלל שמבצע Busy Wait לשווא b. השימוש במחלקה יכול לגרום ל-Deadlock c. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל d. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל e. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל f. בקוד זה תתכן הרעבה של כותבים g. בקוד זה תתכן הרעבה של קוראים נימוק סעיף 2: הסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו. לאחר Code-Review מעמיק מצד אחד המהנדסים הבכירים בצוות, שינתה אחינועם למימוש הבא: class Counter { private: int val; mutex_t m_get, m_one,m_double; public: Counter() { val = 1; mutex_init(&m_get); //Initialize an unlocked mutex mutex_init(&m_one); mutex_init(&m_double); } int getVal() { int ret_val; mutex_lock(&m_get); ret_val = val; mutex_unlock(&m_get); return ret_val; } void plusOne() { mutex_lock(&m_one); val+=1; mutex_unlock(&m_one); } void doubleVal() { mutex_lock(&m_double); val+=this->getVal(); mutex_unlock(&m_double); } // more code for the destructor } הנחות כלליות על המנעולים: המנעול מומש עם תור, ומאפשר לחוטים כניסה למנעול לפי סדר הגעתם. המנעול לא בודק שגיאות. 3. (6 נק') הקוד החדש של אחינועם עדיין בעייתי. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות: a. הקוד בזבזני בגלל שמבצע Busy Wait לשווא b. השימוש במחלקה יכול לגרום ל-Deadlock c. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל d. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל e. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל f. בקוד זה תתכן הרעבה של כותבים g. בקוד זה תתכן הרעבה של קוראים נימוק סעיף 3: הסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו. לאחר המלצה נוספת מאותו מהנדס, השתמשה אחינועם בפקודה האטומית: atomicSet(int* x, int y) אשר מקבלת כתובת x של תא בזיכרון ומציבה לתוכו באופן אטומי את הערך ע. אחינועם ניצלה פקודה זו לכתיבת הקוד הבא: class Counter { private: int val; public: Counter(){ val = 1; } int getVal() { int ret_val; // Thread Local variable atomicSet(&ret_val,val); return ret_val; } void plusOne() { int plus_tmp; // Thread Local variable atomicSet(&plus_tmp,val); plus_tmp +=1; atomicSet(&val,plus_tmp); } void doubleVal() { int double_tmp; // Thread local variable atomicSet(&double_tmp,val); double_tmp += double_tmp; atomicSet(&val, double_tmp); } // more code for the destructor } 4. (6 נק') בקוד הנתון בעיה חמורה בעת שימוש במחלקה זו ע"י מספר חוטים במקביל. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות: a. הקוד בזבזני בגלל שמבצע Busy Wait לשווא b. השימוש במחלקה יכול לגרום ל-Deadlock c. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל d. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל e. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל f. בקוד זה תתכן הרעבה של כותבים g. בקוד זה תתכן הרעבה של קוראים נימוק סעיף 4: הסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו. 5.5 נק') שימו לב: בסעיף זה נתייחס לנכונות הפונקציה getVal בלבד. נביט בסעיף זה על המימוש הראשוני מסעיף (ב). המהנדס הנודע (וחובב הטחינה המושבע) איליה טען שאין צורך במנעול בפונקציה getVal, והציע מימוש חדש לפונקציה getVal: מימוש קודם int getVal() { int ret_val; mutex_lock(&m); ret_val = val; mutex_unlock(&m); return ret_val; } מימוש חדש מוצע int getVal() { return val; } בהנחה שהמשתנה val יכול להיקרא ולהיכתב במקביל בפונקציות אחרות בקוד ע"י מספר חוטים, כתבו במשפט אחד את התנאי לכך שהמימוש שאיליה הציע יהיה נכון: הסבירו: This is how the JSON output should look like. I will fill in the details for each part. I will use the provided `assembled_id` prefix. I will also add the `shared_context` for each question where applicable. For parts that are explanations, I will set `points` to 0. For MCQs, I will list all options in the `text` and then identify the `correct_options` based on the solution PDF. For `part_type`, I will use `mcq`, `short_answer`, `code`. For `source_pages`, I will use the page numbers from the OCR. I will set `confidence` to 1.0 and `needs_human_review` to false as I am confident in the extraction based on the provided solution.```jsonc { "exam_id": "2018A_Winter_B", "questions": [ { "question_id": "exam2_2018A_Winter_B_q1", "number": 1, "title": "חלק 1 - סינכרון", "points": 30, "parts": [ { "part_id": "exam2_2018A_Winter_B_q1_1", "label": "1", "text": "(7 נק') לקוד זה 7 אופציות להדפסה מתוך ה-15 הבאות. יש להקיף את האופציות הנכונות. אין צורך להסביר את פתרונכם.\nכלום\nAndrey\nLeonid\nSasha\nAndrey Leonid\nAndrey Sasha\nSasha Leonid\nAndrey Andrey\nAndrey Leonid Sasha\nSasha Andrey\nLeonid Leonid\nSasha Leonid Andrey\nLeonid Sasha Andrey\nSasha Andrey Leonid\nAndrey Sasha Leonid", "confidence": 1.0, "needs_human_review": false, "part_type": "mcq", "points": 7, "source_pages": [ 2 ] }, { "part_id": "exam2_2018A_Winter_B_q1_2", "label": "2", "text": "(6 נק') הקוד של אחינועם בעייתי כאשר מספר חוטים משתמשים במחלקה במקביל. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות:\na. הקוד בזבזני בגלל שמבצע Busy Wait לשווא\nb. השימוש במחלקה יכול לגרום ל-Deadlock\nc. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל\nd. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל\ne. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל\nf. בקוד זה תתכן הרעבה של כותבים\ng. בקוד זה תתכן הרעבה של קוראים", "confidence": 1.0, "needs_human_review": false, "part_type": "mcq", "points": 6, "source_pages": [ 3 ] }, { "part_id": "exam2_2018A_Winter_B_q1_2_explanation", "label": "נימוק סעיף 2", "text": "הסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו.", "confidence": 1.0, "needs_human_review": false, "part_type": "short_answer", "points": 0, "source_pages": [ 4 ] }, { "part_id": "exam2_2018A_Winter_B_q1_3", "label": "3", "text": "(6 נק') הקוד החדש של אחינועם עדיין בעייתי. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות:\na. הקוד בזבזני בגלל שמבצע Busy Wait לשווא\nb. השימוש במחלקה יכול לגרום ל-Deadlock\nc. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל\nd. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל\ne. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל\nf. בקוד זה תתכן הרעבה של כותבים\ng. בקוד זה תתכן הרעבה של קוראים", "confidence": 1.0, "needs_human_review": false, "part_type": "mcq", "points": 6, "source_pages": [ 5 ] }, { "part_id": "exam2_2018A_Winter_B_q1_3_explanation", "label": "נימוק סעיף 3", "text": "הסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו.", "confidence": 1.0, "needs_human_review": false, "part_type": "short_answer", "points": 0, "source_pages": [ 6 ] }, { "part_id": "exam2_2018A_Winter_B_q1_4", "label": "4", "text": "(6 נק') בקוד הנתון בעיה חמורה בעת שימוש במחלקה זו ע"י מספר חוטים במקביל. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות:\na. הקוד בזבזני בגלל שמבצע Busy Wait לשווא\nb. השימוש במחלקה יכול לגרום ל-Deadlock\nc. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל\nd. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל\ne. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל\nf. בקוד זה תתכן הרעבה של כותבים\ng. בקוד זה תתכן הרעבה של קוראים", "confidence": 1.0, "needs_human_review": false, "part_type": "mcq", "points": 6, "source_pages": [ 7 ] }, { "part_id": "exam2_2018A_Winter_B_q1_4_explanation", "label": "נימוק סעיף 4", "text": "הסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו.", "confidence": 1.0, "needs_human_review": false, "part_type": "short_answer", "points": 0, "source_pages": [ 8 ] }, { "part_id": "exam2_2018A_Winter_B_q1_5", "label": "5", "text": "(5 נק') שימו לב: בסעיף זה נתייחס לנכונות הפונקציה getVal בלבד. נביט בסעיף זה על המימוש הראשוני מסעיף (ב). המהנדס הנודע (וחובב הטחינה המושבע) איליה טען שאין צורך במנעול בפונקציה getVal, והציע מימוש חדש לפונקציה getVal:\nמימוש קודם\nint getVal() {\nint ret_val;\nmutex_lock(&m);\nret_val = val;\nmutex_unlock(&m);\nreturn ret_val;\n}\nמימוש חדש מוצע\nint getVal() {\nreturn val;\n}\nבהנחה שהמשתנה val יכול להיקרא ולהיכתב במקביל בפונקציות אחרות בקוד ע\"י מספר חוטים, כתבו במשפט אחד את התנאי לכך שהמימוש שאיליה הציע יהיה נכון:\nהסבירו:", "confidence": 1.0, "needs_human_review": false, "part_type": "short_answer", "points": 5, "source_pages": [ 8 ] } ], "shared_context": "```c\npthread_mutex_t m; //Global vars\npthread_cond_t cond;\nvoid* func(void* arg) {\n pthread_mutex_lock(&m);\n pthread_cond_wait(&cond,&m);\n printf(\"Andrey\\n\");\n sleep(1);\n printf(\"Sasha\\n\");\n pthread_mutex_unlock(&m);\n return NULL;\n}\nvoid* func2(void* arg) {\n pthread_mutex_lock(&m);\n pthread_cond_wait(&cond,&m);\n printf(\"Leonid\\n\");\n pthread_mutex_unlock(&m);\n return NULL;\n}\nint main(){\n pthread_t t[2];\n pthread_mutex_init(&m, NULL); //Initialize an unlocked mutex\n cond_init(&cond, NULL); //Initialize a standard condition variable\n pthread_create(&(t[0]), NULL, func, NULL);\n pthread_create(&(t[1]), NULL, func2, NULL);\n pthread_cond_signal(&cond); //send a signal\n pthread_cond_signal(&cond); //send a signal\n return 0;\n}\n```\n\n```cpp\nclass Counter {\nprivate:\n int val;\n mutex_t m;\npublic:\n Counter() {\n val = 1;\n mutex_init(&m); //Initialize an unlocked mutex\n }\n int getVal() {\n int ret_val;\n mutex_lock(&m);\n ret_val = val;\n mutex_unlock(&m);\n return ret_val;\n }\n void plusOne() {\n val+=1;\n mutex_lock(&m);\n mutex_unlock(&m);\n }\n void doubleVal() {\n mutex_lock(&m);\n val+=this->getVal();\n mutex_unlock(&m);\n }\n // more code for the destructor\n}\n```\n\nהנחות כלליות על המנעול m: המנעול מומש עם תור, ומאפשר לחוטים כניסה למנעול לפי סדר הגעתם. המנעול לא בודק שגיאות.\n\n```cpp\nclass Counter {\nprivate:\n int val;\n mutex_t m_get, m_one,m_double;\npublic:\n Counter() {\n val = 1;\n mutex_init(&m_get); //Initialize an unlocked mutex\n mutex_init(&m_one);\n mutex_init(&m_double);\n }\n int getVal() {\n int ret_val;\n mutex_lock(&m_get);\n ret_val = val;\n mutex_unlock(&m_get);\n return ret_val;\n }\n void plusOne() {\n mutex_lock(&m_one);\n val+=1;\n mutex_unlock(&m_one);\n }\n void doubleVal() {\n mutex_lock(&m_double);\n val+=this->getVal();\n mutex_unlock(&m_double);\n }\n // more code for the destructor\n}\n```\n\nהנחות כלליות על המנעולים: המנעול מומש עם תור, ומאפשר לחוטים כניסה למנעול לפי סדר הגעתם. המנעול לא בודק שגיאות.\n\n```cpp\nclass Counter\n{\nprivate:\n int val;\npublic:\n Counter(){\n val = 1;\n }\n int getVal() {\n int ret_val; // Thread Local variable\n atomicSet(&ret_val,val);\n return ret_val;\n }\n void plusOne() {\n int plus_tmp; // Thread Local variable\n atomicSet(&plus_tmp,val);\n plus_tmp +=1;\n atomicSet(&val,plus_tmp);\n }\n void doubleVal() {\n int double_tmp; // Thread local variable\n atomicSet(&double_tmp,val);\n double_tmp += double_tmp;\n atomicSet(&val, double_tmp);\n }\n // more code for the destructor\n}\n```", "source_pages": [ 2, 3, 4, 5, 6, 7, 8 ], "text": "חלק 1 - סינכרון (30 נק')\n\npthread_mutex_t m; //Global vars\npthread_cond_t cond;\nvoid* func(void* arg) {\n pthread_mutex_lock(&m);\n pthread_cond_wait(&cond,&m);\n printf(\"Andrey\\n\");\n sleep(1);\n printf(\"Sasha\\n\");\n pthread_mutex_unlock(&m);\n return NULL;\n}\nvoid* func2(void* arg) {\n pthread_mutex_lock(&m);\n pthread_cond_wait(&cond,&m);\n printf(\"Leonid\\n\");\n pthread_mutex_unlock(&m);\n return NULL;\n}\nint main(){\n pthread_t t[2];\n pthread_mutex_init(&m, NULL); //Initialize an unlocked mutex\n cond_init(&cond, NULL); //Initialize a standard condition variable\n pthread_create(&(t[0]), NULL, func, NULL);\n pthread_create(&(t[1]), NULL, func2, NULL);\n pthread_cond_signal(&cond); //send a signal\n pthread_cond_signal(&cond); //send a signal\n return 0;\n}\n\n1. (7 נק') לקוד זה 7 אופציות להדפסה מתוך ה-15 הבאות. יש להקיף את האופציות הנכונות. אין צורך להסביר את פתרונכם.\nכלום\nAndrey\nLeonid\nSasha\nAndrey Leonid\nAndrey Sasha\nSasha Leonid\nAndrey Andrey\nAndrey Leonid Sasha\nSasha Andrey\nLeonid Leonid\nSasha Leonid Andrey\nLeonid Sasha Andrey\nSasha Andrey Leonid\nAndrey Sasha Leonid\n\n\nשימו לב: הסעיפים הבאים אינם תלויים בסעיף א'.\nבמסגרת עבודתה בחברת EMD-TooMuchIO, ניסתה אחינועם לממש מונה משותף למספר חוטים:\n\nclass Counter {\nprivate:\n int val;\n mutex_t m;\npublic:\n Counter() {\n val = 1;\n mutex_init(&m); //Initialize an unlocked mutex\n }\n int getVal() {\n int ret_val;\n mutex_lock(&m);\n ret_val = val;\n mutex_unlock(&m);\n return ret_val;\n }\n void plusOne() {\n val+=1;\n mutex_lock(&m);\n mutex_unlock(&m);\n }\n void doubleVal() {\n mutex_lock(&m);\n val+=this->getVal();\n mutex_unlock(&m);\n }\n // more code for the destructor\n}\n\nהנחות כלליות על המנעול m: המנעול מומש עם תור, ומאפשר לחוטים כניסה למנעול לפי סדר הגעתם. המנעול לא בודק שגיאות.\n\n2. (6 נק') הקוד של אחינועם בעייתי כאשר מספר חוטים משתמשים במחלקה במקביל. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות:\na. הקוד בזבזני בגלל שמבצע Busy Wait לשווא\nb. השימוש במחלקה יכול לגרום ל-Deadlock\nc. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל\nd. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל\ne. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל\nf. בקוד זה תתכן הרעבה של כותבים\ng. בקוד זה תתכן הרעבה של קוראים\n\nנימוק סעיף 2: הסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו.\n\nלאחר Code-Review מעמיק מצד אחד המהנדסים הבכירים בצוות, שינתה אחינועם למימוש הבא:\n\nclass Counter {\nprivate:\n int val;\n mutex_t m_get, m_one,m_double;\npublic:\n Counter() {\n val = 1;\n mutex_init(&m_get); //Initialize an unlocked mutex\n mutex_init(&m_one);\n mutex_init(&m_double);\n }\n int getVal() {\n int ret_val;\n mutex_lock(&m_get);\n ret_val = val;\n mutex_unlock(&m_get);\n return ret_val;\n }\n void plusOne() {\n mutex_lock(&m_one);\n val+=1;\n mutex_unlock(&m_one);\n }\n void doubleVal() {\n mutex_lock(&m_double);\n val+=this->getVal();\n mutex_unlock(&m_double);\n }\n // more code for the destructor\n}\n\nהנחות כלליות על המנעולים: המנעול מומש עם תור, ומאפשר לחוטים כניסה למנעול לפי סדר הגעתם. המנעול לא בודק שגיאות.\n\n3. (6 נק') הקוד החדש של אחינועם עדיין בעייתי. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות:\na. הקוד בזבזני בגלל שמבצע Busy Wait לשווא\nb. השימוש במחלקה יכול לגרום ל-Deadlock\nc. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל\nd. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל\ne. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל\nf. בקוד זה תתכן הרעבה של כותבים\ng. בקוד זה תתכן הרעבה של קוראים\n\nנימוק סעיף 3: הסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו.\n\nלאחר המלצה נוספת מאותו מהנדס, השתמשה אחינועם בפקודה האטומית:\natomicSet(int* x, int y)\nאשר מקבלת כתובת x של תא בזיכרון ומציבה לתוכו באופן אטומי את הערך ע.\nאחינועם ניצלה פקודה זו לכתיבת הקוד הבא:\n\nclass Counter\n{\nprivate:\n int val;\npublic:\n Counter(){\n val = 1;\n }\n int getVal() {\n int ret_val; // Thread Local variable\n atomicSet(&ret_val,val);\n return ret_val;\n }\n void plusOne() {\n int plus_tmp; // Thread Local variable\n atomicSet(&plus_tmp,val);\n plus_tmp +=1;\n atomicSet(&val,plus_tmp);\n }\n void doubleVal() {\n int double_tmp; // Thread local variable\n atomicSet(&double_tmp,val);\n double_tmp += double_tmp;\n atomicSet(&val, double_tmp);\n }\n // more code for the destructor\n}\n\n4. (6 נק') בקוד הנתון בעיה חמורה בעת שימוש במחלקה זו ע\"י מספר חוטים במקביל. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות:\na. הקוד בזבזני בגלל שמבצע Busy Wait לשווא\nb. השימוש במחלקה יכול לגרום ל-Deadlock\nc. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל\nd. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל\ne. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל\nf. בקוד זה תתכן הרעבה של כותבים\ng. בקוד זה תתכן הרעבה של קוראים\n\nנימוק סעיף 4: הסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו.\n\n5.5 נק') שימו לב: בסעיף זה נתייחס לנכונות הפונקציה getVal בלבד. נביט בסעיף זה על המימוש הראשוני מסעיף (ב). המהנדס הנודע (וחובב הטחינה המושבע) איליה טען שאין צורך במנעול בפונקציה getVal, והציע מימוש חדש לפונקציה getVal:\nמימוש קודם\nint getVal() {\nint ret_val;\nmutex_lock(&m);\nret_val = val;\nmutex_unlock(&m);\nreturn ret_val;\n}\nמימוש חדש מוצע\nint getVal() {\nreturn val;\n}\nבהנחה שהמשתנה val יכול להיקרא ולהיכתב במקביל בפונקציות אחרות בקוד ע\"י מספר חוטים, כתבו במשפט אחד את התנאי לכך שהמימוש שאיליה הציע יהיה נכון:\nהסבירו:"
(7 נק') לקוד זה 7 אופציות להדפסה מתוך ה-15 הבאות. יש להקיף את האופציות הנכונות. אין צורך להסביר את פתרונכם. כלום Andrey Leonid Sasha Andrey Leonid Andrey Sasha Sasha Leonid Andrey Andrey Andrey Leonid Sasha Sasha Andrey Leonid Leonid Sasha Leonid Andrey Leonid Sasha Andrey Sasha Andrey Leonid Andrey Sasha Leonid
Voluntary vs preemptive context switchlibc syscall wrapper caching pitfallsSignal delivery and handler timing(6 נק') הקוד של אחינועם בעייתי כאשר מספר חוטים משתמשים במחלקה במקביל. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות: a. הקוד בזבזני בגלל שמבצע Busy Wait לשווא b. השימוש במחלקה יכול לגרום ל-Deadlock c. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל d. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל e. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל f. בקוד זה תתכן הרעבה של כותבים g. בקוד זה תתכן הרעבה של קוראים
Pipe IPC semanticsSpinlock implementation propertiesMutex correctness and deadlock avoidanceBanker's algorithm safety checkהסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו.
Voluntary vs preemptive context switchlibc syscall wrapper caching pitfallsSignal delivery and handler timing(6 נק') הקוד החדש של אחינועם עדיין בעייתי. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות: a. הקוד בזבזני בגלל שמבצע Busy Wait לשווא b. השימוש במחלקה יכול לגרום ל-Deadlock c. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל d. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל e. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל f. בקוד זה תתכן הרעבה של כותבים g. בקוד זה תתכן הרעבה של קוראים
Pipe IPC semanticsSpinlock implementation propertiesMutex correctness and deadlock avoidanceBanker's algorithm safety checkהסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו.
Voluntary vs preemptive context switchlibc syscall wrapper caching pitfallsSignal delivery and handler timing(6 נק') בקוד הנתון בעיה חמורה בעת שימוש במחלקה זו ע"י מספר חוטים במקביל. סמנו את כל התשובות הנכונות (תיתכן יותר מאחת) מהתשובות הבאות: a. הקוד בזבזני בגלל שמבצע Busy Wait לשווא b. השימוש במחלקה יכול לגרום ל-Deadlock c. יתכן Race condition אם החוטים קוראים לפונקציה plusOne במקביל d. יתכן Race condition אם החוטים קוראים לפונקציות getVal ו-plusOne במקביל e. יתכן Race condition אם החוטים קוראים לפונקציות doubleVal ו-getVal במקביל f. בקוד זה תתכן הרעבה של כותבים g. בקוד זה תתכן הרעבה של קוראים
Pipe IPC semanticsSpinlock implementation propertiesMutex correctness and deadlock avoidanceBanker's algorithm safety checkהסבירו רק על הבעיות שסימנתם, ללא התייחסות לסעיפים שלא סומנו.
Voluntary vs preemptive context switchlibc syscall wrapper caching pitfallsSignal delivery and handler timing(5 נק') שימו לב: בסעיף זה נתייחס לנכונות הפונקציה getVal בלבד. נביט בסעיף זה על המימוש הראשוני מסעיף (ב). המהנדס הנודע (וחובב הטחינה המושבע) איליה טען שאין צורך במנעול בפונקציה getVal, והציע מימוש חדש לפונקציה getVal: מימוש קודם int getVal() { int ret_val; mutex_lock(&m); ret_val = val; mutex_unlock(&m); return ret_val; } מימוש חדש מוצע int getVal() { return val; } בהנחה שהמשתנה val יכול להיקרא ולהיכתב במקביל בפונקציות אחרות בקוד ע"י מספר חוטים, כתבו במשפט אחד את התנאי לכך שהמימוש שאיליה הציע יהיה נכון: הסבירו:
Pipe IPC semanticsMutex correctness and deadlock avoidance
The exam question — original PDF
pages 2, 3, 4, 5, 6, 7, 8Exactly 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.
קריאות המערכת getpid(), getppid()pid_t getpid();קריאת מערכת המחזירה לתהליך הקורא את ה-pid של עצמו.pid_t getppid();קריאת מערכת המחזירה את ה-PID של תהליך האב של התהליך הקורא.שאלה: מה המשמעות של getppid() == 1 עבור תהליך משתמש טיפוסי?תשובה: תהליך האב הוא init. קורה למשל אם תהליך הבן יתום.מערכות הפעלה - תרגול 222
קריאת המערכת kill#include <sys/types.h>#include <signal.h>int kill(pid_t pid, int sig);פעולה: שולחת את הסיגנל שמספרו sig לתהליך המזוהה ע"י pid.אם הערך של sigהוא 0, אז הפעולה רק בודקת שהתהליך pid קיים, מבלי לשלוח signal (שימושי לבדיקת תקפות pid).ערך מוחזר:0 בהצלחה-1 בכישלון (למשל, אם אין תהליך בעל מזהה pid)מערכות הפעלה - תרגול 38
העברת סיגנלים בשני שלביםרישום – מערכת ההפעלה רושמת ב-PCB של תהליך היעד שיש לו סיגנל ממתין (pending signal).הרישום מתבצע במערך בינארי בין 31 ביטים, ולכן לכל תהליך יכול להיות לכל היותר סיגנל ממתין אחד מכל מספר.טיפול – בכל פעם שהתהליך חוזר ממצב גרעין למצב משתמש, מערכת ההפעלה בודקת אם יש סיגנלים ממתינים ומטפלת בהם.בסיום הטיפול בסיגנל, מערכת ההפעלה תאפס את הביט המתאים במערך. במידה ויש מספר סיגנלים ממתינים, סדר הטיפול מתחילת המערך לסופו.מערכות הפעלה - תרגול 39
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
מהי החלפת הקשר?מערכות הפעלה - תרגול 610
מהי החלפת הקשר?לכל תהליך יש "הקשר ביצוע" (execution context) המכיל את כל המידע הדרוש לביצוע התהליך.מחסניות, רגיסטרים, תכולת זיכרון, קבצים פתוחים, ..."החלפת הקשר" = עצירת הביצוע של התהליך הנוכחי ושמירת ההקשר שלו.טעינת ההקשר של התהליך הבא לביצוע.הקשר התהליך הנוכחי מתחלף – מכאן שם הפעולה "החלפת הקשר".מערכות הפעלה - תרגול 611
שני סוגים של החלפת הקשרהחלפת הקשר כפויה(== הפקעה)הגרעין מפקיע (כלומר, לוקח בכוח) את המעבד מהתהליך, למשל בעקבות:פסיקת שעון (מטופלת בשגרה scheduler_tick) אשר מגלה כי הזמן שהוקצב לתהליך הנוכחי אזל.אירוע אסינכרוני אשר מעיר תהליך בעל עדיפות טובה יותר מהתהליך הרץ כרגע.לדוגמה: פסיקת דיסק או שחרור מנעול שתהליך המתין לו.החלפת הקשר יזומההתהליך מוותר מרצונו על המעבד, למשל באמצעות:קריאת מערכת חוסמת (כמו wait(), read(), …) אשר מוציאה את התהליך להמתנה.קריאת מערכת exit() אשר מסיימת את התהליך.קריאת מערכת sched_yield() – קריאת מערכת ייעודית לוויתור על המעבד.מערכות הפעלה - תרגול 613
יצירת חוט חדשפרמטרים:thread – מצביע למקום בו יאוחסן מזהה החוט החדש במקרה של סיום הפונקציה בהצלחה.attr – מאפיינים המתארים את תכונות החוט החדש, כגון האם החוט הוא חוט גרעין או חוט משתמש, האם ניתן לבצע לו join, כלומר להמתין לסיומו, וכו'. בד"כ נספק ערך NULL המציין חוט ברירת המחדל של המערכת, שניתן להמתין לסיומו.void* (*start_routine)(void*) מצביע לפונקציה שתהווה את קוד החוט. הערך המוחזר מפונקציה זו במקרה של סיומה הטבעי הינו ערך הסיום של החוט.arg – פרמטר שיסופק לפונקציה עם הפעלתה.מערכות הפעלה - תרגול 714
מנעולים עם/בלי המתנהspinlockכאשר חוט מנסה לתפוס מנעול נעול, הוא בודק את ערך המנעול שוב ושוב מבלי לצאת מתור הריצה.טכניקה כזו נקראת גם: polling, busy waiting, busy looping.יתרון: התהליך יכול להמשיך לרוץ עוד בקוונטום הנוכחי, וכך לחסוך את התקורה על החלפת הקשר.עדיף כאשר זמן ההמתנה המשוער נמוך יותר מהמחיר של החלפת הקשר (כלומר, כאשר הקטע הקריטי קצר, כפי שקורה לרוב בקוד גרעין).mutexכאשר חוט מנסה לתפוס מנעול נעול, מערכת ההפעלה תעביר אותו לתור המתנה ותבצע החלפת הקשר.כאשר המנעול ישוחרר, מערכת ההפעלה תעיר את אחד החוטים המחכים למנעול.יתרון: תהליך חדש יכול לרוץ מיד, וכך לא מתבזבז זמן מעבד יקר.עדיף כאשר זמן ההמתנה המשוער גבוה יחסית (כלומר, כאשר הקטע הקריטי ארוך, כפי שקורה לרוב בקוד משתמש).מערכות הפעלה - תרגול 745
משתנה תנאי (condition variable)משתנה תנאי הוא אובייקט סנכרון המאפשר לחוט לצאת להמתנה בתוך קטע קריטי.כלומר, לפנות את המעבד ולצאת לתור המתנה.ההמתנה תתבצע עד לקיום תנאי כלשהו.ההמתנה מאפשרת לאכוף סדר בביצוע של החוטים. שימוש תכנותי נכון במשתני תנאי מחייב להגדיר גם:משתנה מצב – החוט עובר להמתנה או חוזר מהמתנה בהתאם לערכו של משתנה המצב.מנעול mutex – מבטיח לנו אטומיות והגנה על הקטע הקריטי.מערכות הפעלה - תרגול 86
סכימה כללית למשתני תנאיcond_t c; // should be initializedmutex_t m; // should be initializedint state_var = 0;החוט הממתין לאירוע יקרא ל:while (!condition_holds(state_var)) cond_wait(&c, &m);החוט שמסמן לחוטים הממתינים להמשיך יקרא ל:if (condition_holds(state_var)) cond_signal(&c);מערכות הפעלה - תרגול 87מדוע cond_wait() מקבלתגם את המנעול?
המתנה על משתני תנאיint pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);פעולה: משחררת את המנעול ומעבירה את החוט להמתין על משתנה התנאי באופן אטומי (ראינו קודם מדוע זה הכרחי).החוט הממתין חייב להחזיק במנעול mutex לפני הקריאה.בחזרה מהמתנה על משתנה התנאי, החוט עובר להמתין על המנעול. החוט יחזור מהקריאה ל-pthread_cond_wait() רק לאחר שינעל מחדש את ה-mutex.ערך מוחזר: הפעולה תמיד מצליחה ומחזירה 0.11מערכות הפעלה - תרגול 8
שחרור חוטים ממתיניםint pthread_cond_signal(pthread_cond_t *cond); משחררת את אחד החוטים הממתינים (הגינות לא מובטחת).int pthread_cond_broadcast(pthread_cond_t *cond);משחררת את כל החוטים הממתינים.כל החוטים מפסיקים להמתין על משתנה התנאי ועוברים להמתין על המנעול. החוטים יחזרו לפעילות בזה אחר זה (בסדר כלשהו, לאו דווקא הוגן) לאחר שינעלו מחדש את ה-mutex.שימו לב: אם אין אף חוט שממתין באותו רגע על משתנה התנאי cond, הפעולות חסרות השפעה (הסיגנל הולך לאיבוד ואינו נזכר הלאה).ערך מוחזר: הפונקציות תמיד מצליחות ומחזירות 0.מערכות הפעלה - תרגול 812
The exam text, the skills it tests, and the exact slides are already in context.