פרק #4

4.1 מושג התהליך -

סרטון א'

4.1 מושג התהליך

הטקסט המוצג בסרטון א'

שאלה קטנה על החומר המוצג בסרטון א'

בתכנית מוגדר משתנה x, מערך שהוקצה דינאמית arr וכן פונק' f. האם הם חלק ממרחב הכתובות של התהליך שמריץ את התכנית?

מספרו של התהליך שמריץ את התכנית הוא 3879. האם מספר זה נשמר במרחב הכתובות של התהליך?

4.1 (המשך) יצירת וסיום תהליך, 4.2 מצבי תהליך -

סרטון ב'

4.1 (המשך) יצירת וסיום תהליך, 4.2 מצבי תהליך -

הטקסט המוצג בסרטון ב'

שאלה קטנה על החומר המוצג בסרטון ב'

תהליך P1 ממתין לקלט. מה מצבו?

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

הקלט של תהליך P1 הסתיים, אולם הוא טרם שב לרוץ במעבד (למה הוא טרם שב לרוץ)? מה מצבו?

תהליך P3 חילק באפס ועל כן הועף. האם משאביו ממוחזרים מידית? אם לא: מתי הם ימוחזרו? מה מצבו עד שמשאביו ממוחזרים?

4.3 גוש בקרת תהליך, 4.4 מתזמנים, 4.5 החלפת הקשר, 4.6 פעולות על תהליכים -

סרטון ג'

4.3 גוש בקרת תהליך, 4.4 מתזמנים, 4.5 החלפת הקשר, 4.6 פעולות על תהליכים -

הטקסט המוצג בסרטון ג'

שאלה קטנה על החומר המוצג בסרטון ג'

מה הקשר בין החלפת הקשר לבין ה: PCB?

תהליך P1 רץ במעבד. התקבלה פסיקה מהשעון, ובסופו של דבר המעבד עבר להריץ תהליך אחר P2. אייך קוראים לפונ' של מערכת ההפעלה שהחליטה ש: P2 יהיה התהליך שירוץ במעבד, (ולא תהליך אחר P3). מי הם התהליכים ביניהם על אותה פונ' לבחור?

4.6.2+4.6.3 המשתנה errno, הפונ': perror וכן: || לעומת |

סרטון ד'

4.6.2+4.6.3 המשתנה errno, הפונ': perror וכן: || לעומת |

הטקסט המוצג בסרטון ד'

תרגול קטן ובסיסי של החומר המוצג בסרטון ד'

ק"מ wait(NULL) מאפשרת לתהליך P1 (הורה) שייצר תהליך חדש P2 (ילד) לעצור, ולהמתין לסיום ילדו. נכיר אותה היטב בהמשך.

כתבו תכנית שמבצעת wait(NULL) בלי שהיא הולידה קודם ילד, ולכן ההמתנה של התכנית תכשל (כי אין ילד להמתין לו).
עתה הדפיסו את ערכו של errno, וכן זמנו: perror("xxx") ובדקו את הפלט.

שני אתגרים קטנים נוספים:

העזרו בפקודת ה: man כדי ללמוד מהם קובצי ה: include הדרושים עבור wait, errno, perror.

רמז: הקלידו ב: shell את הפקודה: man 2 wait

שאלה: מדוע יש צורך לכתוב את המספר 2 בפקודת ה: man? מה תפקידו?

4.6.3 ייצור תהליך באמצעות fork ומצב מרוץ בו תהליכים -

סרטונים ה' ו'

4.6.3 ייצור תהליך באמצעות fork ומצב מרוץ בו תהליכים -

הטקסט המוצג בסרטונים ה', ו'

תרגול קטן ובסיסי של החומר המוצג בסרטונים ה', ו'

כתבו תכנית בה תהליך הורה מוליד תהליך ילד באמצעות ק"מ: fork.
עתה ההורה בלולאה מציג את המספרים הטבעיים 1 עד 5 כל אחד בשורה נפרדת, הילד מציג את האותיות a עד e כל אחת בשורה נפרדת .

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

4.6.5 דוגמה שנייה: ייצור כמה ילדים: fork, ps, kill -

סרטון ז'

4.6.5 דוגמה שנייה: ייצור כמה ילדים: fork, ps, kill -

הטקסט המוצג בסרטון ז'

תרגול קטן ובסיסי של החומר המוצג בסרטון ז'

כתבו תכנית המתנהלת בלולאה אינסופית. בכל סיבוב בלולאה התכנית קוראת מספר ומדפיסה את עשר כפולותיו הראשונות.
הריצו את התכנית מהטרמינל.

סיימו את הרצתה ע"י ש: (א) השהו אותה באמצעות z^, (ב) בדקו מה מספר התהליך, (ג) השתמשו בפקודת ה: shell שהינה: kill

4.6.6 דוגמה שלישית, בה ההורַה ממתינה לבנותיה (wait) -

סרטון ח'

4.6.6 דוגמה שלישית, בה ההורַה ממתינה לבנותיה (wait) -

הטקסט המוצג בסרטון ח'

תרגול קטן ובסיסי של החומר המוצג בסרטון ח'

כתבו תכנית המגדירה שני משתנים טבעיים (unsigned): num, sum ומאפסת אותם. עתה התכנית קוראת ערך לתוך num.

בשלב הבא התהליך מייצר ילד. הילד מחשב לתוך המשתנה sum את סכום מחלקיו של num ומציג זאת.
ההורה ממתין לילדו ואז מציג את ערכו של sum. איזה ערך יוצג? מדוע? מה אנו למדים מכך?

4.6.7 היבט צדדי של fork, שכפול חוצץ הפלט -

סרטון ט'

4.6.7 היבט צדדי של fork, שכפול חוצץ הפלט -

הטקסט המוצג בסרטון ט'

4.6.8 עוד כמה הערות על wait

4.6.9 ביצוע exec (אחרי fork) -

סרטון י'

4.6.9 ביצוע exec (אחרי fork) -

הטקסט המוצג בסרטון י'

תרגול קטן ובסיסי של החומר המוצג בסרטון י'

כתבו תכנית המקבלת באמצעות וקטור הארגומנטים שלוש מחרוזות:
(א) כזו הכוללת תו בודד שהינו סימן פעולה, ועשוי להיות +, -, *, / (ב) מספר אחד (ג) מספר שני.
התכנית ממירה את המחרוזות למספרים, מבצעת עליהם את הפעולה המבוקשת, ומציגה את התוצאה.
קמפלו את התכנית ושימרו את קובץ ההרצה בשם calc.

כתבו תכנית שניה המתגלגת בלולאה.

בכל סיבוב בלולאה, אם התכנית קוראת את הערך 0 היא מסיימת.

אם היא קוראת את הערך 1, היא קוראת אח"כ עוד שלוש מחרוזות: אותן שלוש מחרוזות שהתכנית calc מקבלת דרך וקטור הארגומנטים שלה.
אחרי קריאת שלוש המחרוזות התכנית מולידה ילד,

הילד מבצע exec לתכנית: calc תוך שהוא מעביר לה בוקטור הארגומנטים את המידע הדרוש לה.
ההורה מחכה לילדו (ופונה לסיבוב נוסף בלולאה).

תרגיל #1 בנושא fork, exec

4.7 שתוף פעולה בין תהליכים -

סרטון יא'

4.7 שתוף פעולה בין תהליכים -

הטקסט המוצג בסרטון יא'

4.8 סיגנלים (Signals) -

סרטון יב'

4.8 סיגנלים (Signals) -

הטקסט המוצג בסרטון יב'

4.8.1 רשימת סיגנלים חלקית, 4.8.2 שליחת סיגנל -

סרטון יג'

4.8.1 רשימת סיגנלים חלקית, 4.8.2 שליחת סיגנל -

הטקסט המופיע בסרטון יג'

שאלה קטנה על החומר המוצג בסרטון יג'

מה ההבדלים בין הסיגנל SIGSTOP לסיגנל: SIGTSTP

דוגמה תכנותית ראשונה לתכנית השולחת סיגנל (לעצמה) -

סרטון יד'

דוגמה תכנותית ראשונה לתכנית השולחת סיגנל (לעצמה) -

הטקסט המופיע בסרטון יד'

4.8.3 תפיסת סיגנל -

סרטון טו'

4.8.3 תפיסת סיגנל -

הטקסט המוצג בסרטון טו'

תרגול קטן ובסיסי של החומר המוצג בסרטון טו'

כתבו תכנית בה תהליך קובע סיגנל הנדלר לסיגנל SIGINT בשם: catch_int.
בסיגנל הנדלר יש להדפיס את מספר התהליך שמבצע את הפונ'.
עתה ההורה: (א) מוליד ילד, (ב) מבצע sleep(3), (ג) שולח לילד את הסיגנל SIGINT

הילד: שולח להורה את הסיגנל SIGINT, (ב) הולך לשון לשלוש שניות.

שאלה: האם סדר הפלטים בתכנית יהיה זהה בכל הרצה או שמא יש אפשרות שבהרצה אחת יתקבל סדר אחד של הפלטים, ובהרצה שניה סדר אחר?

4.8.4 דוגמונת קצת צדדית: מכוון הקובץ, והסיגנל SIGCHLD -

סרטון טז'

תרגול קטן ובסיסי של החומר המוצג בסרטון טז'

נחזור לתכנית האחרונה שכתבם:

כתבו תכנית בה תהליך קובע סיגנל הנדלר לסיגנל SIGINT בשם: catch_int.
בסיגנל הנדלר יש להדפיס את מספר התהליך שמבצע את הפונ'.
עתה ההורה: (א) מוליד ילד, (ב) מבצע sleep(3), (ג) שולח לילד את הסיגנל SIGINT

הילד: שולח להורה את הסיגנל SIGINT, (ב) הולך לשון לשלוש שניות.

==

א. הוסיפו באבא פעולה ד' (אחרי שליחת הסיגנל לילד): pause.

הריצו את התכנית. בדקו מה קורה, והסבירו מדוע קורה מה שקורה.

ב. הוסיפו באבא (מעבר ל: pause) סיגנל הנדלר לסיגנל SIGCHLD בשם catch_child שלא עושה דבר.

הריצו את התכנית עתה . בדקו מה קורה, והסבירו מדוע קורה מה שקורה.

4.8.4 דוגמונת קצת צדדית: מכוון הקובץ, והסיגנל SIGCHLD -

הטקסט המוצג בסרטון טז'

4.8.5 תפיסת הסיגנל SIGCHLD -

סרטון יז'

4.8.5 תפיסת הסיגנל SIGCHLD -

הטקסט המוצג בסרטון יז'

תרגול קטן ובסיסי של החומר המוצג בסרטון יז'

כתבו תכנית בה תהליך ההורה מוליד שני ילדים, ואז הולך לשון לשניה אחת.
הילד הראשון שולח פלט: hi ומסיים.
הילד השני הולך לשון 3 שניות, שולח את הפלט bye ומסיים.

האב (אחרי שישן שניה אחת) מחכה לשני הילדים באמצעות wait, ומציג את ערך ההחזרה של wait (כלומר את מספרי התהליכים של הילדים).
עתה החליפו את wait ב: waitpid תוך שאתם מבקשים להמתין לכל ילד שהוא וכן: WNOHANG.

כמו קודם, האב יציג את ערך ההחזרה של waitpid
מה יהיה הפלט עתה?

מדוע?

4.8.6 חסימת סיגנלים (sigprocmask) -

סרטון יח'

4.8.6 חסימת סיגנלים (sigprocmask) -

הטקסט המוצג בסרטון יח'

4.8.6 (המשך) חסימת סיגנלים (sigprocmask) - חידוד הנושא -

סרטון יט'

4.8.6 (המשך) חסימת סיגנלים (sigprocmask) - חידוד הנושא -

הטקסט המוצג בסרטון יט'

4.8.6 (המשך) חסימת סיגנלים (sigprocmask) - מגבלותיה של sigprocmask -

סרטון כ'

4.8.6 (המשך) חסימת סיגנלים (sigprocmask) - מגבלותיה של sigprocmask -

הטקסט המוצג בסרטון כ'

תרגול קטן ובסיסי בנושא חסימת סיגנלים

כתבו תכנית המגדירה סינגל הנדלר לסיגנל SIGINT בשם catch_int.
בסיגנל הנדלר חסמו את כל הסיגנלים הניתנים לחסימה.
מעבר לכך, בסיגנל הנדלר כללו לולאה אינסופית.
התכנית המרכזית (מחוץ לסיגנל הנדלר) בלולאה כל פעם תקרא מספר ותדפיס את ריבוע המספר, וזאת עד קבלת הערך אפס.

הריצו את התכנית. הקישו במקלדת c^ כדי להיכנס לסיגנל הנדלר. עתה הקישו שוב c^ או \^ (ששולח את הסיגנל SIGQUIT) או z^ (ששולח את הסיגנל SIGTSTP) וראו שהתכנית לא מגיבה להם (לא עפה, ולא עוצרת).
פתחו טרמינל נוסף. הקישו בו את הפקודה ps כדי ללמוד מה מספר התהליך של התכנית הסוררת שלכם.
עצרו את התכנית בעזרת פקודת ה: Shell שהינה: <kill -KILL <pid וששולחת את הסיגנל SIGKILL לתהליך.
כידוע, סיגנל זה לא ניתן לחסום כלל.

4.8.7 חסימת סיגנלים (sigaction) -

סרטון כא'

4.8.7 חסימת סיגנלים (sigaction) -

הטקסט המוצג בסרטון כא'

תרגול קטן ובסיסי בנושא חסימת סיגנלים באמצעות sigaction

כתבו תכנית המגדירה סינגל הנדלר לסיגנל SIGINT בשם catch_int. הפעם, עשו זאת באמצעות sigaction.

כל יתר התכנית נותר כמו שהיה בתכנית הקודמת:
בסיגנל הנדלר חסמו את כל הסיגנלים הניתנים לחסימה.
מעבר לכך, בסיגנל הנדלר כללו לולאה אינסופית.
התכנית המרכזית (מחוץ לסיגנל הנדלר) בלולאה כל פעם תקרא מספר ותדפיס את ריבוע המספר, וזאת עד קבלת הערך אפס.

הריצו את התכנית. הקישו במקלדת c^ כדי להיכנס לסיגנל הנדלר. עתה הקישו שוב c^ או \^ (ששולח את הסיגנל SIGQUIT) או z^ (ששולח את הסיגנל SIGTSTP) וראו שהתכנית לא מגיבה להם (לא עפה, ולא עוצרת).
פתחו טרמינל נוסף. הקישו בו את הפקודה ps כדי ללמוד מה מספר התהליך של התכנית הסוררת שלכם.
עצרו את התכנית בעזרת פקודת ה: Shell שהינה: <kill -KILL <pid וששולחת את הסיגנל SIGKILL לתהליך.
כידוע, סיגנל זה לא ניתן לחסום כלל.

4.8.8 חסימת סיגנלים - סיגנל תלוי - סיגנלים כקבוצה -

סרטון כב'

4.8.8 חסימת סיגנלים - סיגנל תלוי - סיגנלים כקבוצה -

הטקסט המוצג בסרטון כב'

4.8.9 יצירת timer באמצעות סיגנל -

סרטון כג'

4.8.9 יצירת timer באמצעות סיגנל -

הטקסט המוצג בסרטון כג'

תרגול קטן ובסיס בנושא יצירת timer באמצעות סיגנל

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

שלב ב'
הוסיפו לתכנית מרכיב נוסף: קבעו סיגנל הנדלר גם לסיגנל SIGINT. בסיגנל הנדלר זה כבו את הטיימר.
הריצו את התכנית עתה. בדקו שאם לא הקשתם c^ אזי אחרי חמש שניות נשלח הסיגנל SIGALRM והתכנית מסתיימת.
אם, לעומת זאת, בפרק הזמן של 5 השנ', המשתמש הקיש c^ אזי הטיימר כובה, ולכן התכנית אינה מסתיימת (היא ממשיכה בלולאה האינסופית).
סיימו את התכנית ע"י הקשת \^ בטרמינל (ששולח לתהליך את הסיגנל SIGQUIT).

4.8.9 (המשך) יצירת timer באמצעות סיגנל - דוגמה מורכבת יותר -

סרטון כד'

4.8.9 (המשך) יצירת timer באמצעות סיגנל - דוגמה מורכבת יותר -

הטקסט המוצג בסרטון כד'

4.8.10 הסיגנלים GIGUSR1, SIGUSR2 -

סרטון כה'

4.8.10 הסיגנלים GIGUSR1, SIGUSR2 -

הטקסט המוצג בסרטון כה'

(וכן סעיף 4.8.11 - כללים לכתיבת טפלית סיגנל)

תרגילון קטן ובסיסי בנושא SIGUSR1, SIGUSR2

כתבו תכנית בה תהליך קובע signal handler לסיגל SIGUSR1.

בסיגנל הנדלר רק נשלחת הודעה: תהליך מספר ... קיבל את הסיגנל SIGUSR1.

עתה התהליך מוליד ילד.

כל אחד משני התהליכים הולך לשון פרק זמן מקרי של לכל היותר 5 שנ', ועת מתעורר שולח למשנהו את הסיגנל הנ"ל.

4.8.12 סיגנלים וקבוצת תהליכים -

סרטון כו'

4.8.12 סיגנלים וקבוצת תהליכים -

הטקסט המוצג בסרטון כו'

תרגיל #2 בנושא סיגנלים

4.9 צינור (pipe)

4.9.1 מבוא ל'צינור' (pipe)

4.9.2 מערך המתארים (file descriptors) של תהליך -

סרטון כז'

4.9 צינור (pipe)

4.9.1 מבוא ל'צינור' (pipe)

4.9.2 מערך המתארים (file descriptors) של תהליך -

הטקסט המוצג בסרטון כז'

תרגילון קטן ובסיסי בנושא שימוש בצינור ב: Shell של יוניקס

כתבו תכנית א' המגרילה שני מספרים שלמים בתחום 0 עד 9, ומציגה אותם על המסך הן לפלט הסטנדרטי, והן לקובץ השגיאה הסטנדרטי.

שמרו את קובץ ההרצה בשם gen2nums.

כתבו תכנית ב' הקוראת שני מספרים מהקלט הסטנדרטי, ומציגה את סכום.

שמרו את קובץ ההרצה בשם sum.

הריצו את שתי התכניות עם פייפ ב: shell, כך שהפלט של תכנית א' יהיה הקלט של תכנית ב'

4.9 מבוא ל'צינור' (pipe) המשך - קריאה וכתיבה מ\על קובץ באמצעות פונ' הספריה של שפת סי, לעומת באמצעות קריאות מערכת (system calls) -

סרטון כח'

4.9 מבוא ל'צינור' (pipe) המשך - קריאה וכתיבה מ\על קובץ באמצעות פונ' הספריה של שפת סי, לעומת באמצעות קריאות מערכת (system calls) -

הטקסט המוצג בסרטון כח'

תרגילון קטן ובסיסי בנושא קריאה וכתיבה מקבצים

באמצעות פונ' הספריה של שפת סי, לעומת: באמצעות ק.מ. של יוניקס

כתבו תכנית המשתמשת בפונ' הספריה של שפת סי (בפרט במשתנים מטיפוס * FILE ).

התכנית מקבלת דרך וקטור הארגומנטים שם של קל קובץ קלט, ושם של קובץ פלט.

היא קוראת את קובץ הקלט תו אחר תו. כל תו שהינו אות לטינית קטנה או גדולה היא כותבת על קובץ הפלט. כל תו שאינו אות ואינו white space היא כותבת על הפלט הסטנדרטי, וכל white space היא כותבת הן על הקובץ והן על הפלט הסטנדרטי.

כתבו אותה תכנית, הפעם באמצעות ק.מ. של יוניקס (בפרט עם משתנים מטיפוס int שישמרו את מתארי הקבצים).

4.9.3 - ייצור צינור, 4.9.4 קריאה וכתיבה מ\על צינור -

סרטון כט'

4.9.3 - ייצור צינור, 4.9.4 קריאה וכתיבה מ\על צינור -

הטקסט המוצג בסרטון כט'

4.9.5 - קריאה וכתיבה מ\על צינור באמצעות פונ' הספריה של שפת סי

- (scanf, printf,...)

סרטון ל'

תרגילון קטן ובסיסי בנושא ייצור צינור, כתיבה עליו וקריאה ממנו באמצעות ק.מ. של יוניקס

כתבו תכנית בה תהליך האב מייצר צינור, ואז מוליד ילד. הילד כותב לצינור את המחרוזת: "hi, bye, die", האב קורא מהצינור את המחרוזת ומציג אותה על הפלט הסטנדרטי.

4.9.5 - קריאה וכתיבה מ\על צינור באמצעות פונ' הספריה של שפת סי

- (scanf, printf,...)

הטקסט המוצג בסרטון ל'

תרגילון קטן ובסיסי בנושא ייצור צינור, כתיבה עליו וקריאה ממנו באמצעות פונ' הספריה של שפת סי

כתבו תכנית בה תהליך האב מייצר צינור, ואז מוליד ילד. הילד כותב לצינור באמצעות fprintf (או עדיף: fputs) את המחרוזת: "hi, bye, die", האב קורא מהצינור באמצעות fgets את המחרוזת, ומציג אותה על הפלט הסטנדרטי.

4.9.6 - קריאה וכתיבה מ\על צינור באמצעות ק'\כ' מהקלט\פלט הסטנדרטיים -

סרטון לא'

4.9.6 - קריאה וכתיבה מ\על צינור באמצעות ק'\כ' מהקלט\פלט הסטנדרטיים -

הטקסט המוצג בסרטון לא'

תרגילון קטן ובסיסי בנושא ייצור צינור, כתיבה עליו וקריאה ממנו באמצעות פונ' הספריה של שפת סי הכותבות\קוראות על\ה הפלט\הקלט הסטנדרטי

כתבו תכנית בה תהליך האב מייצר צינור, ואז מוליד ילד. הילד כותב לפלט הסטנדרטי באמצעות puts את המחרוזת: "hi, bye, die", האב קורא מהקלט הסטנדרטי באמצעות fgets(..., stdin) את המחרוזת, ומציג אותה על הפלט הסטנדרטי.

4.9.6 (המשך)- קריאה וכתיבה מ\על צינור באמצעות ק'\כ' מהקלט\פלט הסטנדרטיים

ובתוספת exec -

סרטון לב'

4.9.6 (המשך)- קריאה וכתיבה מ\על צינור באמצעות ק'\כ' מהקלט\פלט הסטנדרטיים

ובתוספת exec -

הטקסט המוצג בסרטון לב'

תרגילון קטן ובסיסי בנושא ייצור צינור, כתיבה עליו וקריאה ממנו באמצעות פונ' הספריה של שפת סי הכותבות\קוראות על\ה הפלט\הקלט הסטנדרטי + exec

כתבו תכנית א' המגרילה שני מספרים שלמים בתחום 0 עד 9, ומציגה אותם על המסך הן לפלט הסטנדרטי, והן לקובץ השגיאה הסטנדרטי.

שמרו את קובץ ההרצה בשם gen2nums.

כתבו תכנית ב' הקוראת שני מספרים מהקלט הסטנדרטי, ומציגה את סכום.

שמרו את קובץ ההרצה בשם sum.

כתבו תכנית ג' המקצה צינור, ומייצרת ילד. עתה:

א. הילד דואג לכך שפלט שנשלח ל: stdout יגיע לצינור, ואז עושה exec לתכנית gen2nums.

ב. ההורה דואג לכך שקלט שמתקבל מ: stdin יגיע מהצינור, ואז עושה exec לתכנית sum

הריצו, כמובן, את תכנית ג'.

תרגיל #3 בנושא: pipe

4.10 תור (FIFO) הקרוי גם: צינור משוים (Named Pipe) -

סרטון לג'

4.10 תור (FIFO) הקרוי גם: צינור משוים (Named Pipe) -

הטקסט המופיע בסרטון לג'

תרגול קטן ובסיסי בנושא תור הודעות

צרו דרך ה: shell תור הודעות.

כתבו תכנית א' אשר בלולאה מגרילה מספרים בתחום 0 עד 9 עד הגרלת הערך אפס, כותבת אותם על הפלט הסטנדרטי וכן שולחת אותם דרך התור.

כתבו תכנית ב' אשר קוראת מהתור מספרים עד eof ומציגה אותם על הפלט הסטנדרטי

4.11 תור הודעות (Message Queue) -

חלק א' - הקדמה וייצור התור -

סרטון לד'

4.11 תור הודעות (Message Queue) -

חלק א' - הקדמה וייצור התור -

הטקסט המוצג בסרטון לד'

4.11 תור הודעות (Message Queue) -

חלק ב' - 4.11.3 - 4.11.1 - שליחת וקבלת הודעות (שתי תכניות נפרדות) -

סרטונים לה' + לו' -

4.11 תור הודעות (Message Queue) -

חלק ב' - 4.11.3 - 4.11.1 - שליחת וקבלת הודעות (שתי תכניות נפרדות) -

הטקסט המוצג בסרטונים לה' + לו'

תרגול קטן ובסיסי של תור הודעות

כתבו שתי תכניות המתקשרות דרך תור הודעות. תכנית א' תייצר אותו, תכנית ב' תתחבר לתור הקיים.

עתה תכנית ב' מגרילה מספר בתחום 0 עד 9 ושולחת אותו לתכנית א' (שתי התכניות מציגות את המספר).

עתה, תכנית א' מגרילה מספר בתחום 0 עד 9, מוסיפה אותו למספר שהיא קיבלה מתכנית ב', ושולחת אותו דרך תור ההודעות לתכנית ב' (שתי התכניות מציגות את המספר החדש).

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

זו שהקצתה את התור גם משחררת אותו.

חשבו האם קיימים מצבי מרוץ במערכת

4.11 תור הודעות (Message Queue) -

חלק ג' - 4.11.4 דוגמה שניה לשימוש בתור הודעות

4.11 תור הודעות (Message Queue) -

חלק ג' - 4.11.5 דוגמה שלישית:

שרת בדיקת ראשוניות למספר לקוחות, המחזיק תור הודעות, בו מועבר struct -

סרטון לז'

4.11 תור הודעות (Message Queue) -

חלק ג' - 4.11.5 דוגמה שלישית:

שרת בדיקת ראשוניות למספר לקוחות, המחזיק תור הודעות, בו מועבר struct -

הטקסט המוצג בסרטון לז'

4.11 תור הודעות (Message Queue) -

חלק ג' - 4.11.6 דוגמה שלישית:

תכנית הלקוח בשרת לבדיקת ראשוניות (כפי שהוצג מעל) -

סרטון לח'

4.11 תור הודעות (Message Queue) -

חלק ג' - 4.11.6 דוגמה שלישית:

תכנית הלקוח בשרת לבדיקת ראשוניות (כפי שהוצג מעל) -

הטקסט המוצג בסרטון לח'

תרגיל #4 בנושא: צינור משוים ותור הודעות

תור הודעות בתחביר POSIX (במקום בתחביר XSI/IPC)

4.12 זיכרון משותף (shared Memory) -

חלק א' -

סרטונים לט' + מ'

4.12 זיכרון משותף (shared Memory) -

חלק א' -

הטקסט המוצג בסרטונים לט' + מ'

ועוד כמה הערות שלא מוזכרות בסרטונים

(בפרט: על ז"מ בתחביר POSIX)

4.13 תושבת (Socket)

4.13.1 - רקע -

סרטון מא'

4.13 תושבת (Socket)

4.13.1 - רקע -

הטקסט המוצג בסרטון מא'

4.13 תושבת (Socket)

4.13.2-14.13.4 - תכנית הלקוח -

סרטונים מא', מב'

4.13 תושבת (Socket)

4.13.2-14.13.4 - תכנית הלקוח -

הטקסט המוצג בסרטונים מא', מב'

(וכן עוד כמה הערות)

4.13 תושבת (Socket)

4.13.5-14.13.6 - תכנית השרת (ללקוח בודד) -

סרטונים מג', מד'

4.13 תושבת (Socket)

4.13.5-14.13.6 - תכנית השרת (ללקוח בודד) -

הטקסט המוצג בסרטונים מג', מד'

4.13 תושבת (Socket)

4.13.7 - תכנית שרת (המטפל במספר לקוחות במקביל) -- ק.מ. select -

סרטון מה'

4.13 תושבת (Socket)

4.13.7 - תכנית שרת (המטפל במספר לקוחות במקביל) -- ק.מ. select -

הטקסט המוצג בסרטון מה'

4.13 תושבת (Socket)

4.13.7 (המשך) - תכנית שרת (המטפל במספר לקוחות במקביל) -

סרטון מו'

4.13 תושבת (Socket)

4.13.7 (המשך) - תכנית שרת (המטפל במספר לקוחות במקביל) -

הטקסט המוצג בסרטון מו'

4.13 תושבת (Socket)

4.13.7 (המשך) - תכנית הלקוחות (בשרת המטפל במספר לקוחות במקביל) -

סרטון מז'

4.13 תושבת (Socket)

4.13.7 (המשך) - תכנית הלקוחות (בשרת המטפל במספר לקוחות במקביל) -

הטקסט המוצג בסרטון מז'

4.13 תושבת (Socket)

4.13.8 תושבת לתקשורת בין תהליכים הרצים באותה מערכת

4.14 קריאה לשגרה מרוחקת

Remote Procedure Call (RPC)

הקדמה, וסעיף 14.1: תכניתונת בשפת rpcgen -

סרטון מח'

4.14 קריאה לשגרה מרוחקת

Remote Procedure Call (RPC)

הקדמה, וסעיף 4.14.1: תכניתונת בשפת rpcgen -

הטקסט המוצג בסרטון מח'

4.4.14 קריאה לשגרה מרוחקת

Remote Procedure Call (RPC)

4.14.2: הפונ' שהשרת מעמיד לרשות הלקוחות -

סרטון מט'

4.4.14 קריאה לשגרה מרוחקת

Remote Procedure Call (RPC)

4.14.2: הפונ' שהשרת מעמיד לרשות הלקוחות -

הטקסט המוצג בסרטון מט'

4.14 קריאה לשגרה מרוחקת

Remote Procedure Call (RPC)

4.14.3: תכנית הלקוח -

סרטון נ'

4.14 קריאה לשגרה מרוחקת

Remote Procedure Call (RPC)

4.14.3: תכנית הלקוח -

הטקסט המוצג בסרטון נ'

4.15 כלים לתקשורת בין תהליכים במערכת הפעלה חלונות