שאלת מבחן במערכות הפעלה - האוניברסיטה הפתוחה 2016 - תהליכונים

הסבירו מה עושה התוכנית ורשמו מה יהיה הפלט שלה : ```c #define THREAD_NUM 2 /* Set by the signal handler. */ static volatile int currThreadNum; /* The contexts. */ static ucontext_t uc[THREAD_NUM + 1]; /* This is the function doing the work. */ static void f(int n) { while (1) { printf("in thread %d\n", n); sleep(1); } } /* This is the signal handler which swaps between the threads. */ void handler(int signal) { alarm(3); currThreadNum = (currThreadNum % THREAD_NUM) + 1; printf("in signal handler: switching from %d to %d\n", currThreadNum, THREAD_NUM + 1 - currThreadNum); swapcontext(&uc[currThreadNum], &uc[THREAD_NUM + 1 - currThreadNum]); } int main(void) { struct sigaction sa; char st1[8192]; char st2[8192]; /* Initialize the data structures for SIGALRM handling. */ sa.sa_flags = SA_RESTART; sigfillset(&sa.sa_mask); sa.sa_handler = handler; /* Install the signal handler and get the context we can manipulate. */ if (sigaction(SIGALRM, &sa, NULL) < 0 || getcontext(&uc[1]) == -1 || getcontext(&uc[2]) == -1) abort(); /* Create a context with a separate stack which causes the function f to be call with the parameter 1. Note that the uc_link points to the main context which will cause the program to terminate once the function return. */ uc[1].uc_link = &uc[0]; uc[1].uc_stack.ss_sp = st1; uc[1].uc_stack.ss_size = sizeof st1; makecontext(&uc[1], (void(*)(void)) f, 1, 1); /* Similarly, but 2 is passed as the parameter to f. */ uc[2].uc_link = &uc[0]; uc[2].uc_stack.ss_sp = st2; uc[2].uc_stack.ss_size = sizeof st2; makecontext(&uc[2], (void(*)(void)) f, 1, 2); /* Start running. */ alarm(3); currThreadNum = 0; swapcontext(&uc[0], &uc[1]); return 0; } ```

רמז: שימו לב כיצד האות `SIGALRM` והמטפל שלו משמשים כמנגנון תזמון קדימותי המבצע החלפת הקשרים בין שני התהליכונים המדומים כל 3 שניות.

פתרון: התוכנית מדגימה מימוש של **תזמון קדימותי (preemptive)** עבור שני **תהליכונים (threads)** ברמת המשתמש. היא עושה זאת באמצעות שימוש במנגנון ה**הקשרים (contexts)** של C (ספריית `ucontext.h`) וב**אותות (signals)**. 1. **אתחול ב-`main`**: הפונקציה הראשית מגדירה שני הקשרים, `uc[1]` ו-`uc[2]`. כל הקשר מוגדר להריץ את הפונקציה `f` עם פרמטר אחר (1 ו-2, בהתאמה) ועם מחסנית נפרדת. בנוסף, היא מתקינה **מטפל אותות** (`handler`) עבור האות `SIGALRM`. 2. **התחלת הריצה**: התוכנית מפעילה שעון מעורר לשלוש שניות (`alarm(3)`) ומיד לאחר מכן מבצעת **החלפת הקשר** ראשונה באמצעות `swapcontext(&uc[0], &uc[1])`. פעולה זו שומרת את ההקשר של `main` ב-`uc[0]` ומתחילה להריץ את ההקשר `uc[1]`, כלומר, מתחילה את ריצת תהליכון 1. 3. **הפונקציה `f`**: כל תהליכון מריץ את הפונקציה `f` בלולאה אינסופית. בכל איטרציה, הפונקציה מדפיסה את מספר התהליכון המזהה שלה ומשהה את ריצתו לשנייה אחת (`sleep(1)`). 4. **מטפל האותות (`handler`)**: זהו ה**מתזמן** של המערכת. כל 3 שניות, שעון המעורר מצלצל והאות `SIGALRM` נשלח לתהליך. מערכת ההפעלה עוצרת את התהליכון הנוכחי ומריצה את הקוד של המטפל. המטפל קובע מחדש את שעון המעורר ל-3 שניות נוספות, מזהה איזה תהליכון רץ, מדפיס הודעת החלפה, ומבצע `swapcontext` כדי לעצור את התהליכון הנוכחי (ולשמור את מצבו) ולהמשיך את ריצת התהליכון השני מהנקודה בה עצר. **פלט התוכנית:** התוכנית תרוץ בלולאה אינסופית ותיצור דפוס חוזר: * תהליכון 1 ירוץ במשך כ-3 שניות ויספיק להדפיס את ההודעה "in thread 1" שלוש פעמים. * לאחר 3 שניות, יופעל מטפל האותות, שידפיס הודעה על החלפה מ-1 ל-2. * תהליכון 2 יתחיל לרוץ למשך כ-3 שניות וידפיס את ההודעה "in thread 2" שלוש פעמים. * לאחר 3 שניות נוספות, יופעל שוב מטפל האותות, שידפיס הודעה על החלפה מ-2 ל-1. * המחזור יחזור על עצמו. הפלט ייראה כך (התוכנית לעולם לא תסיים): in thread 1 in thread 1 in thread 1 in signal handler: switching from 1 to 2 in thread 2 in thread 2 in thread 2 in signal handler: switching from 2 to 1 in thread 1 ...