תרגול 8 הרצאה 6.7 סנכרון Flashcards
מה מבטיח
mutex
condition varibales
mutex
אטומיות - כשנבצע קטע קוד קריטי לא יהיה אף חוט אחר שיריץ את אותו הקוד קריטי עד שנסיים
לא מביטחים סדר, יכול להיות שנתחיל את הקוד ויהיה 100 החלפות הקשר עד שנסיים
condition varibales
מבטיחים סדר
What is the futex system?
It is by the kernel to implement the primitive mutex and conditional variables
מהו תור מקבילי
ואיך צריך להגן עליו בעבודה עם חוטים
תור
שאפשר להכניס ולהוציא ממנו איברים
שאם התור ריק פעולת ההוצאות תמתין עד שיכנס איבר חדש
צריך כם להגן עם מנעולים וגם להבטיח סדר
מנעולים כדי שלא יהיו 2 חוטים שיכניסו או יוציאו בו זמנית
וסדר כדי להבטיח שחוט שרוצה להוציא איבר יעשה זאת רק אחרי שחוט אחר הכניס איבר והתור לא ריק
למי מיועד כל תהליכי הסנכון שאנחנו מדברים עליהם
חוטים או תהליכים
גם וגם
כזכור גם לתהליכים יכול להיות זכרון משותף כמו שלמדנו עם הקריאות מערכת הנכונות לא בחומר
האם אפשר לממש מנעולים בעזרת חומרה או בעזרת תוכנה
עקרונית אפשר בעזרת תכונה אבל זה מאוד מסובך ומועד לטעויות
לכן מסתמכים על החומרה - המעבדים היום כולם תומכנים במנגנונים כאלה
כמו שהגרין מבטל חריגות בזמן נעליה
מה המשתמש יעשה?
יבטל סיגנלים
איזה פקודות מעבד תומכות באטומיות כדי לממש מנעולים
xchg - מחלפיה שתי משתנים
cas - compere and swap מעבירים לה 2 ערכים אם הם שווים אז שמים בראשון את הערך החדש טוב לIF
tas - test and set - בודק משתנה ושם בוא 1
מתי משתמשים בspin ומתי בblock
ספין רק כאשר ההמתנה תהיה הרבה יותר קצרה מזמן החלפת ההקשר
אחרת נחסום וניתן להקשר להתחלף
מה הערך של סמפור אומר עליו
אם הערך חיובי
זה סופר את כמות המשאבים שיש לנו
לדוגמה כמות האיברים בתור
אם הערך שלילי
זה סופר את כמות המשימות שממתינות למאשבים לדוגמה כמות התהליכים שרוצים לקבל איבר מהתור
הסבר על הממשק עם סמפורים באופן תיאורתי
s = semaphore
wait(s)
value – כלומר מוריד אחד מהמשאבים
אם הערך נהיה שלילי נכנסים להמתנה
אם עדיין חיובי אז בעצם קיבלנו משאב ולא נכנס להמתנה
signal(s)
value ++
אם ההוספה עכשיו הפכה את הערך ל0 או שנשאר שלילי זה אומר שיש מישהו שמחכה מעירים אחד מהממתינים ובעצם נותנים לו את המשאב
הסבר על הממשק של סמפורים מבחינת פונק
סמפור הוא אובייקט של הגרעין
מדברים איתו ב
sem_wait() - wait
sem_post() - singal
sem_close()….
sem_getvalue()
.
.
.
מה זה סמפור עם ערך מקסימלי 1
זה הופך להיות ספיןלוק
בעקרון - לא במציאות
מה ההבדל בין ספיןלוק לסמפור מבחינת הסיבוך שלהם
ספיןלוק הוא הרבה יותר פשוט
הוא חלק מהמימוש של הסמפור
האם שגרת הטיפול תוותר אי פעם כל המעבד
לדוגמה wait
לא
האם פסיקת חומרה יכולה לחתוך
טיפול בחריגה
קריאת מערכת
פסיקת חומרת אחרת?
כן היא תחתוך הכל
האם יכול להיות ששגרת הטיפול בפסיקת חומרה תייצר חריגה או תקרא לקריאת מערכת
רק במקרה אחד וזה
Page fault
מה ההבדל בין פסיקת תוכנה לחומרה
תן דוגמה לכל אחד
פסיקת תוכנה (חריגה)
נוצרת עי המשתמש לדוגמה על חלוקה ב0
פסיקת חומרה
היא אסינכרונית
ומגיעה מהתקן חומרה חיצוני
כמו פסיקת שעון
מה זה מסלול בקרה בגרעין
רצף פקודות שהגרעין מבצע בשביל לטפל ב
קריאות מערכת
פסיקות חומרה
פסיקות תוכנה
איזה מסלולים יכולים להחתך במערכת מרובת מעבדים
כל המסלולים יכולים להחתך עם כולם
אם הגרעין ניתן להפקעה
במערכת מעבד יחיד מי יכול לחתוך את הבאים
קריאת מערכת או חריגה
פסיקת חומרה
קריאת מערכת או חריגה
כל מסלול בקרה אחר יכול לחתוך
פסיקת חומרה
יכולה להחתך רק עי פסיקת חומרה אחרת
למעט חריגת דף
מה אפשר להגיד שקריאת מערכת וחריגות לעולם לא עושים
לעולם לא יגרמו לעוד חריגה
מה פסיקת חומרה לעולם לא תעשה
לא תקרא לקריאת מערכת
חוץ
מחריגת דף לא תגרום לעוד חריגה
איך להגן על מבנה הנתונים שלי מפני חיתוכים של מסלולי בקרה
במערכת חד מעבדית וגם במרובה
במעבד יחיד
אם לא נגיש לפסיקות חומרה
ונגיש לחריגות או קריאות מערכת
מספיק מנעל סמפור
בשני המעבדים
אם נגיש לפסיקות חומרה
אז במערכת עם מעבד אחד מספיק לנטרל את פסיקות החומרה
ואילו במעבד מרובה מעבדים צריך גם להשתמש במנעול spinlock
מה הבעיה בשימוש במנעולים בטיפול פסיקות חומרה במעבד יחיד
יכול להיות מצב שמסלול בקרה אחד נועל מנעול ואז מגיע פסיקה שניה שרוצה להשתמש במנעול הזה אז היא ממתינה ש, האחת תסתיים אבל היא לעולם לא תסתיים בגלל שהיא מחכה שתים תסתיים
מה זה אומר נטרול פסיקות מקומיות
ואיך זה מתבצע
ומה חשוב לעשות ולמה
זה אומר שאנו מכבים פסיקות תוכנה במעבד מסויים בודד ולא בכולם
מכבים את דגל if ברגיסטר הדגלים rflags
If==00
חשוב לגבות את תוכן הדגל לפני הקטע הקריטי ולטעון אותו בחזרה לאחריו
יכול להיות שלא היה דלוק לפני
זה פותר בעיות במקרים של טיפול מקונן בפסיקות
מהי הפונקציה
schedule_tick()
שגרת הטיפול בפסיקת שעון
דוגמה למבנה נתונים שנגיש גם עי קריאות מערכת וגם מפסיקות חומרה
תור הריצה
Runqueue
נגיש לקריאות מערכת כמו wait אשר מוציאה תהליך בן מהתור
ונגיש לפסיקות שעון שיכולות לשנות את המיקום של התהליך בתור
למה בשגרת הטיפול במערכת מרובת ליבות נעדיף להשתמש ב
Spinlock
ולא במנעול סמפור
Spinlock
משתמש בbusy wait
אשר יעלה יותר במקרים של המתנה מהירה מאוד כי כך נחסכת התקורה של יציאה וכניסה מהמתנה
הוגנות
לא יהיה מצב שתהליך מקבל פסיקת חומרה היא לא מצליחה לתפוס מנעול ואז התהליך יצא להמתנה על משהו שלא הוא גרם
מה טקטיקות ההגנה של מבני נתונים אשר נגישים לקריאות מערכת וחריגות
או להשאיר את מבנה הנתונים במצב תקין לפני קריאה ל
Schedule()
צריך גם לוודא בחזרה שלא שונה עי מסלול בקרה אחר
לא אפשרי בדרך כלל
או שימוש בסמפורים כדי להבטיח אטומיות בגישה למבנה הנתונים
דוגמה לשימוש בסמפורים להגנת מסנה נתונים שנגיש לקריאות מערכת וחריגות
Read()
מחזיקה מנעול לכל קובץ שעליו היא עובדת
אם תהליך ינסה לרכוש את המנעול והוא יהיה כבר נעול זה יכניס אותו לתור ההמתנה
האם
Mutex
מבטיח סדר?
לא
CREW ראשי תיבות
ואיך נקרא בעברית
Concurrent readers, exclusive writer
זאת בעיית הקוראים כותבים
האם CREW מתייחס רק לקבצים
לא
לכל משאב שיש כמה גורמים שרוצים לקרוא ולכתוב אליו
מה העקרון המנחה בCERW שהיינו רוצים שיהיה
לאפשר להרבה לקרוא תוך כדי
אבל אם מישהו אחד רוצה לכתוב אי אפשר לקרוא או לכתוב איתו ביחד
האם סמפורים משתמשים בBUSY WAITING
כן לחלק קריטי קטן אבל
וזה הגיוני כי אמרנו שהם משתמשים בSPIN LOCK בשביל המימוש שלהם
מהו חוק אמדל
מוצא חסם עליון לכמה אפשר למהר תהליך בעזרת מקבול
מחשב בהיתן כמות מסויימת של ליבות את המקסימום שאפשר להגיל
יש נוסחא לזה
מה הממשק לניהול משתני תנאי
פונק
חלק מpthreads
pthread_cond_init
מאתחל משתנה תנאי
מקבל מצביע למשתנה תנאי
ואת ההגדרות שלו
pthread_cond_wait
מקבל את משתנה התנאי
ומנעול
משחרר את המנעול
ונכנס להמתנה על המשתנה תנאי
בחזרה מהמתנה החוט יעבור להמתין על המנעול שהעביר
משחרר מענול - רוכש את משתנה התנאי - רוכש שוב את המנעול
pthread_cond_signal
ישחרר חוט כלשהו שממתין
לא בהכרח הוגן
pthread_cond_broadcar
ישחרר את כל החוטים הממתינים
אחרי זה ינסו לתפוס את המנעול
pthread_cond_destroy
משחרר את משתנה התנאי
יכשל אם יש עדיין חוטים הממתינים למשתנה תנאי
מה קורה אם שלחתי במשתנה תנאי
signal
או
brodcast
ואין מי שממתין
ילך לאיבוד
במימוש שלנו למשנתנה תנאי מה עלול לקרות בעייתי
איך פותרים
יכול להיות שתהליך יקבל סינגל משתנה תנאי
יתעורר
ועד שהוא ירכוש את המנעול יהיה מהר תהליך אחר שיתפוס אותו ישנה את הערך של המבנה שהוא רוצה ואז ישחרר
ואז התהליך שלנו יכרוש את המנעול אבל לא בטוח שהוא ירצה בכלל לעשות משהו כי יכול להיות שהמבנה נתונים השתנה כך שהוא מעדיף לחכות
הפתרון הוא בדיקה של התנאי שאנחנו רוצים אחרי נעילת המנעול ואם לא מתקיים לדוגמה אין לי איברים בתור אז נצא שוב להמתנה
איזה גרסה לא חוסמת יש לנסיו קבלת סמפור
sem_trywait
אם לא יכול אז לא יחסום ויכשל
איך אפשר לקרוא את ערך הסמפור_
sem_getvalue
במה שונה סמפור בינארי ממנעול
בסמפור כל אחד יכול לשלוח סיגנל גם אם לא עשה עליו המתנה לפי
במנעולים רק הרוכש יכול לשחרר
