תרגול vm Flashcards
מהי פרגמנטציה חיצונית ופנימית
חיצונית
בזבוז בהסתכלות מבחוץ
על מקטעי הזכרון יש חורים
פנימית
לדוגמה קומפיילר מיישר את כל הבקשות לגודל של מכפלה מסויימת
ואז נוצר בזבוז פנימי בתוך כל בלוק
מהו
MMU
רכיב חומרה בתוך המעבד
אשר אחראי לתרגום כתובת וירטואלית לפיזית
Memory management unit
מה זה אומר מרחב זכרון של תהליך
כל תהליך חי בבועה משל עצמו
וחושב שהוא התהליך היחידי שרץ על הזכרון במחשב
מה זה
swapping
מערכת ההפעלה מעבירה זכרון לדיסק
ככה נוצר אשליה לתהליך שהוא יכול לגשת להשתמש ביותר זכרון ממש שיש בכל המחשב
הסבר את היתרונות הבאים של זכרון וירטואלי
Demanded pagin
Deduplication
Cow
לא באמת מקצים את הזכרון עד לגישה הראשונה אליו
Lazy allocation בתכלס
אם יש כמה תהליכים אשר משתמשים באותו הזכרון לקריאה בלבד כמו libc אין צורך לשכפל את הזכרון
בעת fork לדוגמה כל הזכרון מסומן כקריאה בלבד לשני התהליכים ואז הראשון שרוצה להשתמש בו גורם להעתקה שלו ברקע
מה זה דף ומה זה מסגרת
דף בזכרון וירטואלי
מסגרת בפיזי
שניהם 4k
מסגרת ב32ביט
כמה דפים יכולים להיות לכל מרחב וירטואלי
בIA32
מליון בערך
המרחב שאפשר לגשת אליו הוא 2 בחזקת 32
גודל כל דף הוא 4 קילו שזה 2 בחזקת 12
זה חלקי זה נקבל מליון
כמה ביטים צריך בשביל לסמן את מספר הדף
בia32
אם יש מליון דפים
שזה 2 בחזקת 20 אז צריך 20 ביטים
איך עובד המיפוי ברמת הביטים
בין זכרון וירטואלי לפיזי
בia32
20 הביט העליונים יהיו לסימון מספר המסגרת
אמרנו שיש מליון לכן 20
ו12 הביטים התחתונים יסמנו את ההיסט בתוך המסגרת כי היא בגודל 4 קילו בייט לכן 12
איך ממופה ההיסט ומספר הדף למסגרת
בia32
ההיסט זהה לא צריך תרגום
המספר דף למסגרת בטבלת הדפים
למה אי אפשר
או לא פיזבילי
לעשות טבלת דפים לינארית
כלומר מערך אחד לאחד
כי בפועל התהליכים לרוב הם קטנים ולא ניגשים לכל מרחב הזכרון שלהם
כמו כן לכל דף נצטרך לשמור את מספר הדף ועוד סיבות בקרה מה שיגרום לגודל של
4 מגה ב32 ביט
ו512 גיגה ב64 ביט
וזה לכל תהליך
הסבר את הרעיון הכללי של טבלת דפים הררכית
נקודת ההנחה היא שרוב התהליכים לא משתמשים בכל הזכרון שלהם ואפילו רק בחלק קטן ממנו
לכן נוסיף עוד שכבת אבסטרקציה
נחלק את הדפים לבלוקים
עם 1024 כניסות בכל אחד
ותהיה טבלה שתסמן האם בלוק מוקצה או לא
כמה כניסות לכל בלוק בטבלת דפים
Ia32
1024
בלוק הוא בעצמו מסגרת לכן בגודל 4 קילו
וזה חלקי 4 בייט של כל כניסה
לכן 1024
PGD ראשי תיבות
Page global directory
מהו pgd
טבלת הדפים ההירכית
מסמנת לכל בלוק האם מוקצה או לא מוקצה
בתוך כל בלוק יהיה מיפוי של הדפים המוקצים
אם לא אז יש במקום שלה null
אם כן יהיה מצביע לטבלת דפים בבלוק
PDE
PTE
Pde page directory entry
Pte page table entry
רשומות בטבלה ההיררכית שה pde מצביע עליה
רגיסטר
Cr3
מצביע לשורש טבלת הדפים של התהליך הנוכחי
כתובת פיזית
אחרת רקורסיה אינסופית
איך מתבצע תרגום מכתובת וירטואלית לפיזית בטבלת דפים היררכית
Ia32
יש 32 ביט של כתובת
ה12 התחתונים הם הoffset שנשמר זהה
אנחנו יודעים להגיע לpgd בעזרת cr3
ה10 העליונים יסמנו את הכניסה בpgd
לפיהם נוכל לדעת מה הכתובת של הpage table של הבלוק הזה
כעת ניקח את ה10 ביטים הבאים והם יהיו
האינדקס בתוך הpage table
כעת הגענו למסגרת הפיזית ונשתמש בoffset
מה גודל של כל כניסה בטבלת הדפים
Ia32
32 ביט
20 לסימון המסגרת
12 לבקרה
מהו ביט 0 בכל PTE
זהו ביט הpresent
הוא מסמן האם הדף נמצא בזכרון הפיזי 1
או לא 0
מה זה אומר שביט
Present=0
אם כל הביטים הם 0 אז הדף לא ממופה כלל
אם לפחות אחד הביטים הוא לא 0 אז הדף דופדף לדיסק ובpte יהיה את הכתובת שלו בswap area
ביט בקרה
Accessed
מודלק כל פעם שיש גישה לדף
מכובים באופן מחזורי
כדי לאכוף פינוי דפים לדיסק
ביט בקרה dirty
מודלק בכל פעם שיש כתיבה לנתון בדף
משמש את מערכת ההפעלה כדי לדעת שיש מידע שצריך להכתב לדיסק
ביט בקרה
Read/write
0 קריאה בלבד
1 קריאה וכתיבה
ביט בקרה
User/supervisor
0 גישה לקוד הגרעין בלבד
1 גישה לכל תהליך
Tlb ראשי תיבות
Translation lookaside buffer
איפה נשמר הtlb
בזכרון ייעודי ומהיר בתוך המעבדחלק מהmmu
למה צריך את הtlb
בממוצע כחצי מהפקודות ניגשות לזכרון
וכל אחת מהם דורשת חיפוש בכל היררכית הדפים
עי שמירה של טבלה קטנה עם התרגומים האחרונים נחסוך הרבה בקשות לזכרון בתקווה
מה מכילה כל רשומה בtlb
מספר דף
מספר מסגרת
ביטי בקרה
Acecced,dirty…
מה קורה לתוכן הtlb בעת שינוי cr3
פסילה של כל תוכן הtlb
Tlb flush
איך מערכת ההפעלה שומרת על נכונות הtlb
מתי
אם הגרעין מוחק כניסה בטבלת הדפים כדי למפות אותה לדיסק
הוא חייב גם למחוק אותה מהtlb כי הוא עדיין מצביע למסגרת שכבר מופתה החוצה
בעת החלפת הקשר cr3 משתנה
אחרת התהליך החדש עלול לגשת למסגרות של התהליך הקודפ
מתי לינוקס לא תפסול את תוכן הtlb?
ולמה זה כדאי
כדי למנוע פגיעה בביצועים!
אם החלפת ההקשר היא בין שתי חוטים של אותו תהליך מרחב הזכרון נשאר כשהיה ואפשר לשמור אותו
אם החלפת ההקשר היא לתהליך גרעין
משום שאין לגרעין טבלת דפים משלו אין להם מרחב זכרון משלם והם עובדים כל מרחב הזכרון של הגרעין
יכול להיות שתהליך ביקש עדכון מהקרנל למבנה נתונים שלו לדוגמה קידום הseek
מה החלק של מה בתרגום הדפים
מה החלק התוכנתי בכל התהליך
בעצם כל התהליך למעט page fualt הוא תהליך חומרתי
Tlb and page walk
בכמה ביטים משתמשים באמת מתוך ה64 בx64
ומה גודל מרחב הזכרון לכל תהליך
48 ביטים
256 טרה
מה גודל מרחב הזכרון הפיזי ב
X64
האם הוא שווה לגודל מרחב הזכרון הוירטואלי
52 ביטים
בעוד שהווירטואלי הוא רק 40
מה גודל כניסה בטבלת הדפים ב
X64
מספר מסגרת מכיל 40 ביטים כגודל הדף המקסימלי
ההסבר לא הכי משכנע אבל לא נורא
12 ביטים לדגלים
קיבלנו 52
אבל ליישור לחזקת 2 נקבל 64 ביטים
כלומר 8 בתים
כמה כניסות pte בכל מסגרת
ב64
כמה ביטים צריך בשביל לייצג אותו
512
כלומר 9 ביטים לייצוג
4 אלף חלקי 8 גודל כל כניסה
ולוג של גל זה יתן 9
גודל דף סטדנרטי ב
64
גם 4k
כמה רמות תרגום ב
X64
וכמה ב
32
ב32
יש 2 רמות תרגום
ב64
יש 4 רמות
איך ממופים הביטים שאיתם מתרגמים כתובת וירטואלית לפיזית ב
64
ה12 התחתונים הם offset בדומה ל32
ומשם למעלה יש 4 רמות של אינדוקס כשבכל אחד יש 9 ביטים לכל אינדקס כי אמרנו שיש 512 כניסות
נשארו ביטים 48 עד 63 שאינם בשימוש
מה זה דפים גדולים
האם גם ב32 וגם ב64
רק ב64
הרעיון הוא להשתמש בפחות רמות של תרגום ולנצל את זה בשביל להוסיף עוד לoffset
כך שבמקום 4k שמיוצג עי 12 ביטים נוכל להשתמש בביטים שהיו של התרגום
מסתבר שלפי ההרצאה אפשר גם ב32
מה היתרונות והחסרות של דפים גדולים
יתרונות
אלו יתרונות שנובעים מכך שיש פחות דפים
משפרים ביצועים מבחינת זה שהם מקטינים את כמות התרגומים
מגדילים את יעילות הtlb
מקצרים את הpage walk
חסרונות
פרגמנטציה פנימית יכולה להיות
פרגמנטציה חיצונית ומחסור בזכרון רציף אם משתמשים גם בדפים קטנים וגם בגדולים
פוגעים בביצועים מבחינת latency
כי לדוגמה pagefualt יהיה ארוך יותר כי יותר מידע צריך להטען מהדיסק
מהו מנגנון
Read ahead
לינוקס מזהה גישה סדרתית לדיסק וטוענת מבעוד מועד את הדפים הבאים כדי לחסוך שגיאות דף
האם דפים גדולים חוסכים לנו את כמות שגיאות הדפים בגישה סדרתית?
לא
בגלל מנגנון read ahead אנחנו מקבלים זאת בכל מקרה
האם זהו יתרון שדפים גדולים מורידים את מספר חריגות הדפים
לאו דווקא
לדוגמה שירות אינטרנט שרגיש לדיליי יפגע מאוד אם הוא יצטרך לחכות יותר זמן לטעינה של הדף הגדול
לאיזה 2 חלקים מפוצל מרחב הזכרון
ואיך הם מתחלקים בין תהליכים
החצי העליון
מרחב זכרון של הגרעין
נשאר זהה בין כל התהליכים
החצי התחתון
מרחב זכרון של המשתמש
משתנה כל פעם בין תהליכים
האם מרחב הזכרון של המשתמש ושל הגרעין יכולים לדופדף לדיסק
רק המשתמש
המרחב זכרון של הגרעין לעולם לא ימופה לדיסק
מה זה אומר שמרחב הזכרון של הגרעין נשאר זהה בין כל התהליכים
הכתובות הווירטואליות של כל אובייקט בגרעין נשארת קבועה בין כל התהליכים
מהו memory descriptor
איך קוראים למבנה שמייצג אותו
מתאר הזכרון של התהליך
מיוצג על ידי מבנה mm_struct
איפה שמור מתאר מרחב הזכרון
בpcb
תחת שדה
mm
מה אפשר להגיד על חוטים ומתאר memeory descriptor
זהה בין החוטים
מה יהי ערך מתאר הזכרון של חוט גרעין
Null
בכמה מילים מה זה חוט גרעין
חוט שרץ בהרשאה 0
נגיש רק למרחב הגרעין מהתהליך שרץ לפניו
רגיסטר הcr3 נשאר כשהיה בתהליך שרץ לפניו
הסבר כל שדות במרחב הזכרון של התהליך
mm_user כמה תהליכי משתמש חולקים את מרחב הזכרון
כאשר מגיע ל0 מערכת ההפעלה מפנה את המחסנית ערימה וקוד וכל מה שקשור למשתמש מהזכרון כי אין עוד משתמשים
mm_count כמה תהליכי משתמש וחוטי גרעין חולקים את מרחב הזכרון - כל תהליכי המשתמש נספרים כאחד ביחד
כאשר מגיע ל0 מערכת ההפעלה מפנה את כל מרחב הזכרון - גם את טבלת הדפים כי גם אין חוטי גרעין שמשתמשים בו
Mmlist
מצביע לרשימה גלובלית לרשימה של כל מרחבי הזיכרון
Pgd כתובת של טבלת הדפים
זה גם מה שיטען לcr3 בעת זימון התהליך
Mmap
Rss מספר המסגרות בשימוש
Total_vm מספר הדפים המוקצים
בשדות מתאר מרחב הזכרון
מה אפשר להגיד על היחס בין
Rss total_vm
Rss
קטן או שווה ל
Total_vm
בגלל
Deamand pagin
מה זה איזור זכרון
איך נקרא באנגלית
איך מגיעים אליו
Virtual memory regions
מתאר את האיזורים בזכרון כמה מחסנים ערימה text וכו
אפשר להגיע אליו דרך שדה הmmap בתוך בmm בpcb
יוביל אותנו לרשימה מקושרת של vm_area_struct שיכילו את המידע על האיזורים
איזה שדות יש בvm_area_struct
vm_start and end
התחלה ואחת אחרי אחרונה של איזור הזכרון
Vm_next
מצביע לערל הבא ברשימה של המבנים
Vm_mm
מצביע בחזרה לmm בpcb
Vm_page_prot
ערכי ביטים שונים שנכניס לכניסות של הדפים השייכים לאיזור זה
Vm_flag
מכיל דגלים בשביל שהגרעין ידע מה חוקי לעשות עם אותו איזור זכרון
Vm_ read/write/exec
Vm_may read/write… האם מותר להדליק
Vm_shared האם לשתף עם תהליך הבן
Vm_locked אסור לעשות לזה swap
איך מייצרים איזור זכרון חדש?
קריאת מערכת
Mmap
איזה איזורי זכרון יש לכל תהליך
איזור לקוד code/text
נתונים סטטים data
Heap
Stack
מה קורה אם לmalloc אין מספיק זכרון פנוי בערימה
היא פונה לקראית מערכת brk
בתכלס מאחורה
היא משתמשת ב
Sbrk להקצאות קטנות
וmmap להקצאות גדולות
לפי הקבוע MMAP_THreshould
באיזה קריאות מערכת free משתמשת כדי לעשות מניפולציות לגודל הערימה
Brk and munmap
הסבר על קריאת המערכת sbrk
מה מקבלת מה מחזירה ומה מטרתה
מגדילה ומקטינה את הערימה
אם מקבלת 0 מחזירה את ראש הערימה הנוכחית
איזה סוגים של איזור זכרון יש?
2
מגובה קובץ
איזור שמכיל מידע שמקורו בקובץ
כתיבה וקריאה אליו תדרוש קריאה וכתיבה מהקובץ
אנונימי
איזור זכרון שלא קשור לקובץ אלא לזיכרון הדינאמי של התהליך
האם אפשר לפנות איזורי זכרון אנונימים לדיסק
כן
מה סוג איזורי הזכרון
ערימה
מחסנית
קוד
קוד הוא מגובה קובץ
כי מתאים לקובץ הבינארי של התוכנית
אי אפשר לכתוב אליו לכן לא יהיה dirty
מחסנית וערימה אנונימים
איך קריאות המערכת
Clone
Execv
משפיעות על מרחב הזכרון
Clone
מייצרת עוד חוט
מגדילה את mm_users ב1
Execv
טוענת תהליך חדש ולכן משחררת את מרחב הזכרון הקודם (מקטינה את המונים)
הסבר בקצרה על cow
מנגנון עצל להקטין את זמן ביצוע fork
הוא פורס את ההעתקה היקרה של מרחב הזכרון של התהליך לתשלומים קטנים בעתיד בעלות של דף
בכל פעם שתהליך ירצה לכתוב בפעם הראשונה
Cow הסבר באופן מפורט
אחרי fork
כל pte שהצביע על מסגרת
יורד מהרשאות r\w 1
ל0
עכשיו 2 התהליכים מצביעים על אותם מסגרות עם r/w0
ומספר ההצבעות על המסגרת (המונה) עלה ל2
התהליך הראשון מבין שניהם שירצה לכתוב יקבל שגיאת דף
והמסגרת תועתק
כעת בשתי המסגרות המונה הצבעות הוא 1
ועכשיו לתהליך הראשון שניסה לכתוב r/w=1
לשני הוא עדיין 0
כשהוא ירצה לכתוב הוא גם יקבל שגיאת דף ורק ישתנה הערך מ0 ל1 בלי העתקות
האם cow תמיד עדיף לנו
לא
אם עשינו פורק ואז execv אז כמובן
אבל אם שתי התהליכים משתמשים בכל הזכרון סתם עלה לנו הרבה זמן יקר של שגיאות דפים ועדכון הpte בתהליך האב לrw=0
במנגנוןcow
אחרי שתהליך מנסה לכתוב לאיזור מוגן שrw=0
איך מערכת ההפעלה יודעת שזה cow ולא סתם מקום שאסור לכתוב אליו?
בודק שהדף שייך לאיזור זכרון מותר לכתיבה
לפי VM_WRITE
במתאר האיזור
איך עובד מנגנון
Demanedpaging
כאשר משתמש קןרא ל
Mmap
רק רשימת האיזורים מתעדכנת תחילה
מסמנים בpte present=0
כי עדיין לא מצביע למסגרת אמיתית
רק בנסיון הגישה הראשון נקבל page fault
אם זה זכרון מגובה קובץ הקובץ יטען מהדיסק
אם אנונימי
וקריאה את מצביעים כל הzeropage
אם כתיבה אז מקצים מסגרת ומאפסים אותה
Minor and majoe page fault
Minor
לא ניגש לדיסק
לגן לא חוסמת
רלוונטי לזכרון ממופה אנונימי
Major
חוסמת כי צריך לטעון מהדיסק
רלוונטי למגובה קובץ
הסבר על
Zero page
דף מלא באפסים
לקריאה בלבד
בעת קריאה לזכרון אנונימי בפעם הראשונה הוא יוצבע לכאן
מה קורה לאחר איפול בחריגת
הדף
ואיך קוראים לפונק הטיפול בשגרה
Do_page_fault()
הפקודה מבוצעת
מחדש
אם הטיפול לא הרג את התהליך
מהם 2 הסיבות לקבל page fault
גישה לדף שאינו נמצא בזכרון
Present ==0
גישה לא חוקית
שאינה לפי ההרשאות בpage table
לדוג כתיבה לדף של קריאה בלבד
מתי page fault
היא שגיאה
מתי באחד מהם יש החרגה קלה
כשמשתמש מנסה לגשת לזכרון של הגרעין
הפעולה לא מורשית לפי הרשאות האיזור כמו כתיבה לאיזור הקוד
גישה לכתובת שאיזה מוקצית לאיזור זכרון
חריג אחד הוא גלישה קלה מהמחסנית שזה מתאפשר עד 32 בתים
איך החומרה מעבירה לגרעין את הכתובת הוירטואלית שגרמה לחריגת דף
רגיסטר cr2
מה קורה אם חריגת דף היא שגיאה
במצב משתמש ובמצב גרעין
מצב משתמש נקבל
Sigsegv
אם בגרעין נקבל אופססס ונקווה שלא יקרוס כלום
מהי לוקאליות בזמן
ובמרחב
בזמן
גישה לאותה כתובת בזמנים סמוכים
לדוגמה תוכנית שעורכת קוד ותוכנית אחרת שמהדרת אותו
במרחב
אם ניגשנו לכתובת אחת סביר שניגש גם לכתובות הקרובות אליה לדוגמה קריאה רציפה של מערך
מתי נכתב לדיסק באמת המידע בלינוקס
Write back
בלינוקס המידע יכתב
כאשר הזכרון ישוחרר
עם קריאת מערכת munmap
או בעת קריאת מערכת מפורשת
msync
איך נקרא המנגנון שדוחה את הכתיבות לדיסק
Write back
למה לינוקס משתמשת בעקרון הwrite back
בתקווה לחסוך כתיבה של ערכי בניים
לא בטוח שיהיו
מה החיסרון של write back
אין אמינות לכתיבת המידע
המידע בזכרון יכול ללכת לאיבוד והמידע לא באמת יכתב לדיסק
לאיפה readhead קורא את הדפים
מה החסרונות של read ahead
המנגנון חוזה שתהיה קריאה מסגרות הבאות והוא טוען אותם למטמון הדפים
לא בטוח שנצטרך את הדפים הבאים שיקראו לכן יכול להיות בזבוז
זה גם יכול לחנוק את המערכת אם היא כבר ממש עמוסה
מה עושה מערכת ההפעלה אם חסר זכרון
למסגרות ממפות קובץ
ולמסגרות אנונימיות
למסגרות ממופות קובץ הגרעין יפנה אותן לקובץ שהן הגיעו ממנו
למסגרות אנונימיות הגרעין יפנה לswap area
מהי טבלת המסגרות
איזה שדות יש בכל רשומה
באיזה שדה משתמש cow
מערך עם כניסה לכל מסגרת בזיכרון הפזי
לכל כניסה יש מספר שדות
Refcount - כמה מרחבי זיכרון מצביעים אל המסגרת
Cow משתמש בשדה זה
Mapping
מצביע לinode אם זה קובץ
Null אם אנונימי
Index
היסט מתחילת הקובץ אם זה מגובה קובץ
Null אם אנונימי
Flags
דגלים כמו dirty
וactive, refrenced שמיוצגים עי 2 ביטים
Nexthash prevHash קודמים והבאים ברשימת ההתנגשות ברשימת הערבול
האם לינוקס תפנה מיד מסגרת שבטלת המסגרות שלה
Refcount==0
לא
לינוקס לא ממהרת לפנות ותפנה רק כאשר יהיה חייב כי אין מקום
מי ממומש תוכנתי ומי חומרתי
בטבלת ערבול המסגרות
וטבלת ערבול הדפים
שניהם תוכנתי
מתי לינוקס משתמשת בטבלת המסגרות
ומתי בטבלת ערבול הדפים
המסגרות
כאשר צריך לפנות דף מלוכלך לדיסק לינוקס בודקת קודם כל בטבלת המסגרות את המיקום של הדף בדיסק
דפים
כאשר צריך לקרוא דף מהדיסק
לינוקס בודקת קודם אם הדף כבר לא נמצא כבר בטבלת ערבול הדפים
בקצרה מה מטרת
טבלת המסגרות
וטבלת ערבול הדפעם
מסגרות
לדעת מה השימוש של כל מסגרת
כמה משתמשים
ועל איזה קובץ מצביעה
ואיזה חלק היא שלו
ערבול דפים
כדי לחפש מה המסגרת של דף מסויים
מהם 2 הדרכים לגשת למידע מהדיסק
2 פקודות שונות
ומה ההבדל בינהם
אחת זה
Read write sys calls
מביאה את המידע למטמון הדפים
מעתיקה את המידע הרלוונטי לחוצץ של
המשתמש
Mmap
קריאת המערכת יוצרת איזור חדש
כאשר ננסה לגשת למידע תהיה חריגת דף שתעדכן את טבלת הדפים להצביע למסגרות של מטמון הדפים
בפקודה mmap
איך מייצרים אנונימי
ואיך מגובה קובץ
מגובה קובץ
fd=fd of an open file
אנונימי
fd=-1
מה ההבדל בין
Mmap
ל
Read
מבחינת חריגות דף
Read
מקצה פעם אחת מקום לחוצץ של המשתמש ואז יכולה להשתמש בו שוב ושוב
לעומת זאת mmap
תקבל חריגת דף על כל מסגרת שהיא תנסה לקרוא וכל פעם נצטרך להקצות עוד דף בשביל המסגרת הבאה
ולכן בקבצים גדולים כמות חריגות הדף בread היא זניחה
מהי מגבלת גודל קובץ ב64
שצריך להטען בmmap
לפי גודל מרחב הזכרון של המשתמש
128 טרה
מתי עדיף להתשמש בread על פני mmap
כשאר קוראים מספר קטן של בתים מקובץ עדיף להשתמש בread
יתרונות בשימוש
Mmap
בקריאת קובץ
לא צריך להשתמש בחוצצים להעתיק מידע שקיים כבר במטמון הדפים
אינטואיטיבי למתכנת כי מתנהג כמו קובץ
חוסך בזמן וזיכרון
וקריאת המידע נעשית רק בעת נסיון הקריאה של המשתמש שעלול להיות גם החסרון שלה מול read בקריאות קטנות
איזה סוגי מיפויים יש לmmap מבחינת מי רשאי לגשת
זכרון פרטי
MAP_private
יש במטמון הדפים עותק יחיד של המידע מוגן בcow
כולם מצביעים לעותק הזה
אם מישהו רוצה לכתוב אליו המידע יועתק והוא יוכל לכתוב אליו בצד
הכתיבה לא תכתב לדיסק
זה טוב לדוגמה בשיתוף של ספריות בין תהליכים
מיפוי משותף
MAP_Shared
מטמון הדפים מחזיק עותק בודד של המידע
כתיבה מצד תהליך אחד רלוונטית לכולם
כתיבות יגעו בסוף לדיסק
PFRA
מה ראשי תיבות
Page frame reclamation
איזה תהליכים יעדיפו מטמון דפים גדול ואיזה קטן
מטמון דפים קטן יתן יותר מקום לזכרון אנונימי לצורכי התהליכים
לכן תוכניות שקוראות הרבה מהדיסק דוןקא יעדיפו מטמון דפים גדול
ותוכניות חישביות יעדיפו קטן
מה עלול לקרות במצב קיצון של מטמון דפים קטן
איך נקרא המצב
Trashing
המערכת מבלה את רוב הזמן שלה במענה לחריגות דף
מה מגבלת הגודל למטמון הדפים
בלינוקס אין חסם על גודל מטמון הדפים
כל בקשה להוסיף למטמון הדפים תענה בחיוב
איך עובד בקצרה מנגנון שחרור מסגרות
על טבלת מטמון הדפים
אם אין עוד מסגרות פנויות
רק מסגרות שכתבו אליהן dirty יכתבו מחדש לדיסק
מסגרות אנונימיות יעברו לswap area
תפונה גם אם נקיה וגם אם מלוכלכת כי בשימוש של תהליך
Pfra מפנה מסגרת של תהליך משתמש וגם של הגרעין?
רק של משתמש
כמה מאגרי דפדוף יש?
ולמה
יש הרבה
כך אפשר לכתוב באופן מקבילי לדיסק לכמה מאגרי דפדוף במקביל
האם ניתן לשנות את מספר מאגרי הדפדפוף
כן
אפשר לכבות ולהדליק מאגרי דפדוף תוך כדי ריצה
איך בנויים מאגרי דפדוף
כל מאגר דפדוף מחולק למגירות slots
כל מגירה בגול מסגרת 4k
המגירה הראשונה מכילה מטהדאטה כל המאגר
אלגוריתם הדפדוף מנסה שהמגירות יהיו רציפות
מה זה seek latency
הדילאיי שלוקח עד שהזרוע המגנטית של הדיסק זזה למידע
מתי pfra מתחיל לפעול
יש כמות מוגדרת של מסגרות פנויות
Min low high
מתחיל לעבוד low ברקע
בmin בחזית
בhigh מפסיק לעבוד
מה זה אומר pfra רץ ברקע ובחזית
איפה ברקע יעיל בדכ
יעיל בעיקר במרובות מעבדים
ברקע זה אומר אסינכרוני
הגרעין מעיר חוט מיוחד בשם
kswapd
שמריץ את
Pfra
אם הוא לא מספיק מהיר אז נריץ ישירות את pfra כלומר בחזית
למה מוגדר רף min
כי pfra בעצמו דורש זיכרון ואם לא יהיה מספיק בשביל להריץ אותו הקרנל יכול לקרוס
איזה עקרונות מרכזיים
Pfra
מממש
מה הוא מעדיף
מעדיף לפנות מסגרות לא מוצבעות או נקיות
כי לא דורשות כתיבה לדיסק
החלפה של מסגרות קרות יותר (דיברנו על זה פעם)
מפנה מסגרות משותפות מכל מרחבי הזכרון המצביעים עליה בבת אחת אחרת היא עדיין תשאר שם
האם יכול להיות מסגרת אנונימית לא מוצבעת
כי מסגרת אנונימית לא מוצבעת זה אומר שהתהליך שהתשמש בה נסגר ואז היא הייתה אמורה להמחק
מתי לדוגמה עדיף לשחרר לדפדף מסגרת אנונימית על פני מסגרת לא מוצבעת
אם יש תהליך שעורך קוד ואחריו תהליך שמקמפל אותו חבל סתם לדפדף את הקוד החוצה כי עוד רגע נצטרך לטעון אותו שוב לזיכרון
איך נקבעת רמת הפעילות של מסגרת
AR
00
10
01
11
בבינארי
A active bit
R is the frame refrenced
בכל פרק זמן מסויים מערכת ההפעלה תכבה את הביט A במסגרות כדי לא להסתכל אחורה מדיי
מהי inactive list
And
Inactive list
לא פעילות
כל המסגרות עם רמת פעילות
0 או 1
פעילות
2 או 3
Pfra תפנה קודם לא פעילות
האם הקצאת משתנים לוקאלים על המחסנית היא עצלה?
בקורס לא
מה מטרת מטמון הדפים
לחסוך קריאות לדיסק
שומר עותק של מסגרות פיזיות בזכרון ועושה עליהן מניפולציות
אם פתחתי קובץ עם mmap private
ואז עשיתי לקובץ write
האם נראה את זה עכשיו באיזור של הmmap
לא מוגדר טוב בלינקוס
מה כודלו
Tlb l1
Tlb l2
Tlb l3
32/64/128
~1500
Not exists
Page reclamation algorithms
איזה יש מה כל אחד עושה
Belady
אופטימלי באופן תיארוטי כי לא בטוח שיצליח לחזור את העתיד
שמוציא את הדפים שניגשו אליהם לפני הכי הרבה זמן
Lru least reaet used
עוד אלגוריתם לא פרקטי במציאות
משתמש בעקרון הלוקאליות אבל דורש עדכון לא פרקטי של מבני הנתונים של מערכת. הפעלה בכל גישה
Clock
פרקטי lru
שומר ביט לכל דף
של האם ניגשנו אליו לאחרונה
מתאפס כל כמה שניות
עובר על כל הדפים בסדר של שעון מהאחרון שניגנו אליו וכל פעם מאפס את הביט של האם ניגשנו ואם הוא כבר מאופס מפנה אותו
Nru not recently used
Lru מתוכחם
מעדיף לשמור דפים שrefrenced
מעדיף דפים מלוכלכים כי כבד להוציא אותם
סדר ההוצאה שלו
Refrenced זה הכי חשוב
ואז חשוב האם מלולכך או לא
מה יש כיום בtlb מודרנים?
אפשר גם לשמור pid לכל רשומה
אבל גם הכמות שלהם מוגבלת
ככה לא צריך למחוק הכל כל פעם
האם יש לכל היותר tlb אחד לכל המערכת?
יש אחד לכל ליבה
מה זה
Tlb shootdown
בגלל שיש tlb לכל core מערכת ההפעלה צריכה לשמור עליהם מעודכנים
לדוגמה שליבה מסוימת משנה הרשאות גישה למסגרת
Pte prefetching
Cpu קורא מידע מה
זכרון
בגודל של 8 כתובות בכל פעם
32 או 64 בתים
ולכן הוא כבר שומר את
התרגומים של 7 הכותבות הבאות במטמון l2 או l3
נסיון של ניחוש לפי עקרון הלוקאליות שנצטרך בtlb כבר את הרשומות הבאות
מה גודל כניסה pte
ב32
ו64
4 בתים
8 בתים
