מערכות הפעלה

מערכות הפעלה

– זיכרון וירטואלי 10תרגול Linux-ב

מערכות הפעלה - תרגול 10 2(c) 2003 ארז חדד

(1תוכן התרגול )

-מבוא לזיכרון וירטואלי בLinux-זיכרון וירטואלי בIA32

סגמנטציה( דפדוףPaging)TLB

-ניהול זיכרון וירטואלי בLinuxשימוש מנוון בסגמנטציהמודל אחיד לטבלת דפיםמיקום מרחב הזיכרון של הגרעין-טיפול בTLB


(2תוכן התרגול )

-מרכיבי מערכת הזיכרון בLinuxתמונת עלניהול זיכרון לתהליךמאגרי הדפדוףטבלת המסגרותמטמון הדפים-טיפול בPage Fault

Demand PagingCopy On Write

מנגנון פינוי הדפים


)Linux )1מבוא לזיכרון וירטואלי ב-

במחשב יש בד"כ זיכרון פיזי ראשי )אלקטרוני( קטן בהרבהמהזיכרון הפיזי המשני )דיסק(

סדרי גודל: 3הבדל של MB לעומת GB מטרת מנגנון הזיכרון הוירטואלי היא לאפשר לכל תהליך

מרחב זיכרון פרטי שאינו מוגבל בגודל הזיכרון הראשי של המחשב

-בLinux 4 = 232 – מרחב זיכרון וירטואלי לכל תהליך בגודלGB כדי להשיג מטרה זו, מנצל מנגנון הזיכרון הוירטואלי את

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

תהליך שאינם בשימוש כרגעעקרון הלוקליות:יעילותו של מנגנון הזיכרון הוירטואלי נובעת מ

על-פני פרקי זמן קצרים, תהליך ניגש בד"כ רק לחלק קטן מאוד ממרחב הזיכרון העומד לרשותו


)Linux )2מבוא לזיכרון וירטואלי ב-

:ע"י אחסון רק החלק ה"פעיל" של מרחב הזיכרון של תהליךניתן להריץ יישום שדרישות הזיכרון שלו גדולות בהרבה מהזיכרון הפיזי ניתן להריץ מספר רב של יישומים כנ"ל באותו מחשב עם זיכרון פיזי קטן

יחסית החסרון של השיטה: הגדלה משמעותית של זמן הביצוע של

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

מנגנון זיכרון וירטואלי דורש תמיכה של החומרהתרגום בין כתובת לוגית לכתובת פיזיתזיהוי גישה לזיכרון וירטואלי שאינו מצוי בזיכרון הראשי


)IA32 )1ניהול זיכרון ב-

כזכור מתרגולים קודמים, על-מנת לגשת לזיכרון ישsegment:offset בפורמט כתובת לוגיתלספק

segment ביט המזהה "איזור זיכרון" של 16: מספר בן התהליך

offset ביט המזהה תא זיכרון מסוים באיזור 32: מספר בן הזיכרון המבוקש

כתובת כתובת לוגית זו עוברת תרגום בחומרה ל: כתובת תא בזיכרון הראשי )האלקטרוני( של פיזית

מנגנוןהמחשבסגמנטציה

מנגנון דפים

כתובת לוגיתsegment:offset

כתובת ליניארית ביט(32)

כתובת פיזית ביט(32/36)


)IA32 )2ניהול זיכרון ב-

:מודל הזיכרון הוא כדלקמן ביט, 32מוגדר מרחב זיכרון ליניארי - "שטוח" - במיעון

4GBכלומר בגודל עד היא כתובת תא במרחב זיכרון זההכתובת הליניארית מנגנון הדפים ממפה את המרחב הליניארי לאוסף דפים נפרד לכל

תהליך – כך מושגת ההפרדה בין איזורי הזיכרון של התהליכים

שהם סגמנטיםמעל מרחב זיכרון זה מוגדרת חלוקה ל ,"איזורי הזיכרון" שלמדנו עד כה

תיתכן חפיפה חלקית או מלאה בין סגמנטים לא נשתמש יותר במושג "איזור זיכרון" אלא במושג סגמנט, כדי לא

שנפגוש בהמשךLinuxלבלבל עם מושג איזור הזיכרון של


)IA32 )1סגמנטציה ב-

מתאר הסגמנט לכל סגמנט יש רשומה הקרויה(segment descriptor):ומכילה

כתובת הבסיס )הליניארית( של הסגמנט בכפולות של( 4גודל הסגמנטK)או בבתים סוג הסגמנט, לקביעת הרשאות הגישה

.לדוגמה: בסגמנט של קוד מותר לקרוא ולהריץ נתונים בלבדבסגמנט נתונים מותר לקרוא ולכתוב נתונים בלבד

,סוגים קיימים: קוד, נתוניםTSSמתרגול החלפת הקשר..( ועוד( DPL ערך – CPLמקסימלי לגישה לסגמנט

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

IA32ניהול זיכרון ב-



כל מתארי הסגמנטים מאוחסנים בטבלה הקרויהGDT )Global Descriptor Table( המוצבעת מרגיסטר מיוחד

gdtrהקרוי ( ערכו של רגיסטר סגמנטcs, ds… , נקרא )segment

selector-ומכיל שדה של אינדקס מתאר הסגמנט ב GDT התרגום מכתובת לוגית לליניארית הינו, לפיכך, פשוט

ביותר: המעבד שולף את כתובת הבסיס ממתאר הסגמנט offsetהמוצבע מרגיסטר הסגמנט ומוסיף לה את ערך ה-

-פעולה זו כרוכה בבדיקת הרשאות לפי סוג הפעולה והCPL ,ובבדיקת אי-גלישה מהסגמנט




כתובת כניסהבסיס

DPLסוגגודל

0x50x10000x33קוד

GDTזיכרון ליניארי

4K*נניח שגודל הסגמנט כתוב בכפולות של

0x1000

0x3fff

0x152:index=0x5

segment selector offset

0x1152

+



)IA32 )1ניהול דפים ב-

-מנגנון ניהול הדפים בIA32:הוא זה המאפשר יצירת מרחבי זיכרון שונים ובלתי תלויים זה בזהאי הגבלת הזיכרון הוירטואלי בגודל הזיכרון הראשי( טעינת קטעים מזכרון התהליך לפי הצורךpage fault )

לדפיםמרחב הזיכרון הוירטואלי של תהליך מחולק – קטעי זיכרון עוקבים בעלי גודל קבוע

4בד"כKB( כל דף יכול להמצא בזיכרון או במאגר דפדוףswap )

בדיסק




למסגרותהזיכרון הראשי )הפיזי( של המחשב מחולק בגודל דף

כאשר דף נמצא בזיכרון הראשי, הוא משובץ למסגרתכלשהי

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

"רק הדפים שנמצאים בשימוש התהליך "לאחרונה כך מושג אפקט הוירטואליות: הרצת מספר תהליכים עם

דרישת זיכרון כוללת או בנפרד גדולה מהזיכרון הראשי( טבלת הדפיםpage table) של כל תהליך מנהלת

את הדפים של התהליךהאם הדף נמצא בזיכרון ובאיזו מסגרת




:בתרגום כתובת ליניארית לכתובת פיזית המעבד מחשב תחילה באיזה דף נמצאת הכתובת

( offsetהליניארית ואת מרחקה מתחילת הדף )המעבד בודק בטבלת הדפים באיזה מסגרת נמצא הדף + הכתובת הפיזית היא כתובת תחילת המסגרתoffset

,אם הדף המכיל את הכתובת אינו נמצא בזיכרון הגורמת לגרעין page faultנוצרת חריגה מסוג

מערכת ההפעלה להביא את הדף לזיכרון בסיום הטיפול בפסיקה מבוצעת מחדש ההוראה שגרמה

לפסיקה



)IA32 )1טבלת הדפים ב- טבלת הדפים של תהליך מוצבעת מרגיסטר מיוחד בשםcr3 בתים עבור כל דף 4הטבלה אמורה להכיל כניסה בגודל

במרחב הזיכרון של התהליך כניסה של דף שלא הוקצה לשימוש מכילה ערךNULL (0 )כל הביטים

4כדי למפותGB 4 בדפים שלKB צריך מיליון כניסות – גודל לכל תהליך4MBהטבלה יכול להגיע ל-

עם זאת, תהליך מנצל בדרך-כלל רק חלק מזערי ממרחבהזיכרון הוירטואלי – לא כדאי להחזיק את הטבלה כולה

הפתרון: להחזיק שתי רמות היררכיה )או יותר( בטבלה אם מוקצה דף חדש לשימוש התהליך, צריך להקצות, לפי הצורך, דפים

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



31 22 21 12 11 0

cr3

Page Directory

Page

DIRECTORY TABLE OFFSET

+

+

Page Table+


)IA32 )3טבלת הדפים ב-

:כל כניסה של דף בטבלת הדפים )בכל רמת היררכיה( מכילה ביטpresentמציין האם הדף נמצא בזיכרון :

מקביל לביטvalidמההרצאה ( ביטים כאשר 20מספר המסגרת בה מאוחסן הדף אם הוא בזיכרון

ביט(32הזיכרון הפיזי ממען ביטaccessed מודלק ע"י החומרה בכל פעם שמתבצעת גישה :

לכתובת בדף מקביל לביטreferenceמההרצאה

ביטdirtyמודלק ע"י החומרה בכל פעם שמתבצעת כתיבה לנתון בדף : מקביל לביטmodifiedמההרצאה

ביטread/write .קריאה וכתיבה1 = קריאה בלבד. 0: הרשאת גישה = ביטuser/supervisor .גישה אם 0: גישה מיוחסת = CPL < 3. 1 =

CPLגישה בכל ערך ועוד



TLB-ב IA32

כמקובל בארכיטקטורות חומרה רבות התומכות Translation ממומש IA32, גם ב-pagingב-

Lookaside Buffer )TLB(( זהו מטמוןcache של כניסות בטבלת הדפים הצמוד )

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

)חוסך את הגישה לזיכרון )כפול מספר רמות ההיררכיהלצורך חישוב

בכל החלפת הקשר )למעשה, בכל טעינת ערך חדש( אוטומטית של invalidation( מבוצעת פסילה )cr3ל-

של המעבדTLBתוכן ה-



)Linux )1ניהול זיכרון ב-

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

:משתמשת רק במינימום ההכרחי על-פי הגדרות החומרה בכל התהליכים מצביעים לאותם segment registersכל ה-

סגמנטים המכסים כולם אותו תחום – כל התחום הליניארי אי-תלות בחומרה: 1סיבה :Linux רצה גם בארכיטקטורות

חומרה אחרות שתומכות בדפים אבל לא בסגמנטציה פשטות: מימוש מנגנון שאינו מצריך עדכון 2סיבה :

segment registers בהחלפת הקשר או בגישה ממרחב הזיכרון של הגרעין לזה של תהליך



,למעשהLinux סגמנטים:4 מגדירה רק ( סגמנט קוד וסגמנט נתונים עבור הגרעיןDPL=0) סגמנט קוד וסגמנט נתונים עבור כל תהליכי המשתמש

(DPL=3) ההחלפה בין הסגמנטים )ברגיסטריםcs-לקוד ו ds, es, ss

user mode ו-kernel modeלנתונים( מתבצעת במעבר בין כל הסגמנטים, כאמור, מכסים את כל התחום

, גודל בדפים = 0x0הוירטואלי )כתובת בסיס = 0xfffff)

( כתובת לוגיתoffsetכתובת ליניארית = )בלבד כמו כן, מוגדר סגמנטTSS עבור כל אחד מהמעבדים

כפי שראינו בתרגול על החלפת הקשר



כאמור, מערכת הזיכרון הוירטואלי שלLinux מבוססת על דפים

Linux רמות של טבלת 3 מגדירה היררכיה כללית של דפים, הניתנת להתאמה לכל ארכיטקטורת חומרה

קיימת הרמה הגבוהה ביותר נקראתPage Global Directory

)PGD(יש טבלה כזו לכל תהליך . הרמה האמצעית נקראתPage Middle Directory )PMD( הרמה התחתונה נקראתPage Table Entry )PTE( טבלאות נוספות בשתי הרמות הנמוכות מוקצות לפי הצורך

יחד עם הקצאת דפים חדשים לתהליך


GLOBALDIR MIDDLEDIR TABLE OFFSET

+

+

+

+

base register

Page Global Directory

Page Middle Directory

Page Table

Page



רמות של 3כיצד מתמפה היררכית Linux שראינו IA32 רמות טיפוסית של 2להיררכית

קודם?-הPGD-מתמפה ל Directory( 10)ביטים עליונים -הPMD ביטים: טבלה ברמת 0 מוגדרת כמכסה

PMD מוגדרת כמכילה כניסה אחת שנמצאת בזיכרון שמצביעה עליהPGDבאותו מקום כמו הכניסה ב-

-הPTE-מתמפה ל Table( 10)ביטים אמצעיים -4גודל דף מוגדר כKB( 12 ביטים נמוכים משמשים

(offsetכ-


(1מרחב הזיכרון של הגרעין )

הזיכרון שבשימוש גרעיןLinux לעולם אינו מפונה לדיסק (swapped)

זיכרון זה כולל את טבלאות הדפים של התהליכים מרחב הזיכרון של הגרעין ממופה לקטע קבוע של הזיכרון

הוירטואלי של כל תהליך באופן זה, הכתובת )הלוגית( של כל אוביקט בגרעין נשארת קבועה בכל

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

ביט( בלבד – ללא סגמנט32 )offsetפרמטרים מסוג מצביע המכילים קטע הזיכרון הליניארי המשמש את הגרעין הוא מהכתובת

0xc0000000 ומעלה )"הג'יגהבייט הרביעי"(, המוגדרת בקבועים PAGE_OFFSET-ו TASK_SIZE

קבועים אלו מוגדרים בקבצי הגרעיןinclude/asm-i386/page.h בהתאמהinclude/asm-i386/processor.hו-

Linuxניהול זיכרון ב-


(2מרחב הזיכרון של הגרעין )

3לפיכך, לרשות תהליך המשתמש עומדיםGB זיכרון וירטואלי להקצאה לשימוש

הגרעין מחזיק טבלת דפים משלו הקרויהKernel Master Page Global Directory

טבלה זו מתעדכנת בכל פעם שהגרעין מקצה ומשחרר דפים לשימושעצמו בלבד

אף תהליך לא משתמש בטבלה זו – תפקידה הוא לשמש כמקור ממנומתעדכנות טבלאות הדפים של תהליכי המשתמש בכל הנוגע לדפים

שבשימוש הגרעין על עדכון טבלאות הדפים של תהליכי המשתמש מתוך טבלת הדפים

של הגרעין נלמד בהמשך



Linux ב-TLBטיפול ב-

ישנם מצבים בהם גרעיןLinux מצליח להימנע מפסילת כל בעת ביצוע החלפת הקשר:TLBתוכן ה-

כאשר התהליך הבא לביצוע חולק את אותו מרחב זיכרון )אותן טבלאותדפים( יחד עם התהליך הקודם

כלומר, כאשר מדובר בשני חוטים של אותו יישום..( כאשר התהליך הבא לביצוע הוא חוט גרעיןkernel thread כמו )init או

ksoftirq_CPUn לתהליכי/חוטי גרעין אלו אין מרחב זיכרון משלהם – הם פועלים על מרחב

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

מאידך, ישנם מצבים בהם גרעיןLinux חייב לפסול בעצמו :TLBכניסות ב-

-כאשר מתבצע עדכון של רשומה בטבלת הדפים המופיעה גם בTLB ,כמו למשל בטעינת דף או בפינוי דף



)Linux )1מרכיבי מערכת הזיכרון ב-

בתרשים בהמשך מתוארים מרכיבי מנגנון ניהול הזיכרוןLinuxהוירטואלי ב-

דפים מועברים בין הזיכרון הראשי, שם הם מאוחסנים במסגרות, לבין swapהזיכרון המשני )דיסקים( שם הם מאוחסנים במאגרי דפדוף )

areasייעודיים או בקבצים ) הגרעין שומר במרחב הזיכרון שלו מבני נתונים עבור כל תהליך המתארים

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

-כזכור, דפי הגרעין לעולם לא מפונים לדיסק בLinux המסגרות הצבועות בפסים אפקיים כחולים שייכות למטמון

הדפיםפרטים בהמשך


)Linux )2מרכיבי מערכת הזיכרון ב-

טעינת דפים לזיכרון הראשי מבוצעת בפעולותDemand Paging

דפדוף על-פי דרישה המובעת באמצעותPage Fault פינוי דפים מבוצע בפעולותPage Frame Reclaiming

מחזור מסגרות – פעולה המבוצעת כברירה אחרונה כאשראין מספיק מקום פנוי בזיכרון הראשי

טבלאות הדפים מעודכנות להצביע על דף לפי מיקומוNULLוסוגו – בזיכרון, בדיסק או

אנו נסקור כל אחד מהמרכיבים שבתרשים בפירוטבהמשך


דיסקים

מבני הנתונים של הגרעין, כולל:מתארי זיכרון1.מתארי מרחבי זיכרון2.טבלת מסגרות + מטמון3.

דפיםטבלאות דפים4.

טבלתדפים

swap1מאגר דפדוף swap2מאגר דפדוף

bin/ls/קובץ home/eli/file1/קובץ

DemandPaging

זיכרון ראשי

PageFrame

Reclaiming


)Linux )1ניהול זיכרון תהליך ב-

כזכור, מרחב הזיכרון של תהליך כולל את מרחב הזיכרון של המיועד לשימוש קוד 3GB( ואת תחום הזיכרון של 1GBהגרעין )התהליך

3תהליך לא מקבל לשימושו את כל תחום הזיכרון שלGB מיד עם תחילת קיומו, אלא רק כמות התחלתית קטנה

-3בהמשך, מוקצה זיכרון נוסף לתהליך מתוך הGBלפי דרישתו איזורי זיכרון )הקצאת הזיכרון מבוצעת באמצעותMemory

Regions) איזורי זיכרון הם רצפים לא-חופפים של כתובות במרחב הזיכרון, שרק

אליהם מותר לתהליך לגשת )וגם זה תחת הרשאות ספציפיות לכל איזור( ניתן להוסיף, להסיר, להגדיל ולהקטין איזורי זיכרון( 4כתובת התחלתית וגודל של איזור זיכרון הם כפולות של גודל דףKB ,)

מפני שיחידת ההקצאה הבסיסית של מנגנון הזיכרון הוירטואלי היא דף הקצאת איזור זיכרון לתהליך לא מוסיפה מיד דפים וכניסות בטבלת

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



הזיכרון שבשימוש הגרעין אינו מופיע כאיזור זיכרון, אבל מופיעבטבלאות הדפים

-מרחב הזיכרון של תהליך מוגדר בLinux באמצעות טבלת דפים וקבוצת איזורי זיכרון

איזורי הזיכרון קובעים איזה תת-תחומי כתובות נמצאים בשימוש( 3GBהתהליך )מתוך התחום של

טבלאות הדפים מציינות היכן )בזיכרון או בדיסק( נמצאים הדפיםשמכילים את הכתובות הנ"ל ואת הכתובות שבשימוש הגרעין

עם תחילת קיומו, תהליך מקבל מרחב זיכרון ובו קבוצההתחלתית של איזורי זיכרון

איזורים "סטנדרטיים" למערכותUNIX איזור אחד לקוד, אחד לנתונים :( ואחד heap(, אחד לערימה של הזיכרון הדינמי )dataסטטיים )

user modeלמחסנית איזורים נוספים: אחד לפרמטרים של שורת הפקודה, אחד למשתני

מערכת



במהלך ריצת התהליך, קבוצת איזורי הזיכרון במרחב הזיכרוןשל התהליך יכולה להשתנות

-איזור המחסנית בuser mode יכול לגדול עם הגידול במחסנית )אך לא לקטון(

)איזור הערימה יכול לגדול או לקטון לפי הצורך )הקצאה או שחרור טעינת / הסרת ספריות דינמיות והפעלה / סגירה של מנגנוני זיכרון

משותף הם דוגמאות למצבים של הוספה והסרה של איזורי זיכרון למז"מ של תהליך

מרחב זיכרון יכול להיות משותף למספר תהליכים שימושי במיוחד למימוש חוטים

עם זאת, יש לזכור שחוטים עדיין צריכים מחסניות נפרדות, המוקצות )לפיLinuxThreadsכאיזורי זיכרון נוספים במרחב הזיכרון המשותף )

מרחב זיכרון מפונה כאשר אינו בשימוש אף תהליך



בכל פעולה של טעינת התוכנה מחדש כדוגמתexecve)( ודומיה, מרחב הזיכרון מוחלף לחלוטין

)איזורי זיכרון + טבלאות דפים( שחרור מרחב הזיכרון הישן או התנתקות ממנו )אם הוא

משותף( והקצאת מרחב זיכרון חדש אם עובדים עםLinuxThreads חוטים הממומשים(

כתהליכים החולקים את אותו מרחב זיכרון(, אז ספריית וגורמת לכך שבנוסף )(execveהחוטים משנה את

( )(execveלפעולתה, שאר החוטים )פרט לזה שקרא ל-מופסקים, כך שמרחב הזיכרון משוחרר בעקבות הקריאה

)(execveל-



בשקף הבא מופיע תרשים המראה דוגמה למרחב יוצרת Linuxזיכרון של תהליך והאובייקטים ש-על-מנת לנהל את מרחב הזיכרון

מתאר הזיכרון מכיל מידע גלובלי על כל מרחב הזיכרוןמתאר איזור זיכרון מכיל מידע על איזור זיכרון ספציפי השדהmmap במתאר הזיכרון מצביע על רשימה מקושרת

של מתארי איזורי הזיכרון המוכלים במרחב הזיכרון השדהpgdבמתאר הזיכרון מצביע על שורש טבלת הדפים ,קוד( הסדר של סוגי איזורי הזיכרוןdata בדוגמה )וכו

שבתרשים אינו מחייב


environment

command linearguments

user modestack

heap

data

code

0x0

PAGE_OFFSET

vm_next

vm_end

vm_start

vm_mm

.

.

pgd

mmap

מתאר זיכרון(mm_struct)

מתאר איזור זיכרון(vm_area_struct)


(1מתאר הזיכרון של תהליך )

,כאמור( מתאר זיכרוןmemory descriptor) הוא רשומה ,המכילה מידע על מרחב הזיכרון של התהליך

רשומה מסוגmm_struct קובץ גרעיןinclude/linux/process.h

השדהmm במתאר תהליך מצביע על מתאר הזיכרון של התהליך

מתארי תהליכים, החולקים אותו מרחב זיכרון, מצביעים על אותו מתארזיכרון

לתהליך גרעין ערך שדהmm הוא NULL אין לו מרחב זיכרון משלו – והוא משתמש במרחב הזיכרון ובמתאר הזיכרון של תהליך משתמש

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

מקושרת

Linuxניהול זיכרון תהליך ב-



:להלן מספר שדות המופיעים במתאר הזיכרוןmmapמצביע לרשימת מתארי איזורי הזיכרון –

הרשימה של מתארי איזורי הזיכרון תמיד ממוינת לפי המיקום שלכל איזור בזיכרון

pgd-מצביע ל – Page Global Directory של מרחב הזיכרון )שורש טבלאות הדפים(

-זהו הערך הנטען לcr3בהחלפת הקשר mmlist מצביע קישור ברשימה הגלובלית של מתארי –

הזיכרוןrss מספר המסגרות שבשימוש מרחב זיכרון זה )דפים –

בזיכרון הראשי(total_vmסה"כ דפים באיזורי הזיכרון –




mm_users, mm_countמוני שיתוף של מרחב הזיכרון – mm_usersסופר כמה תהליכי משתמש חולקים את מרחב הזיכרון mm_count סופר כמה תהליכים )גרעין + משתמש( חולקים את

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

כאשרmm_users = 0 מפונים איזורי הזיכרון והטבלאות הממפות , אותם. מרחב הזיכרון )וטבלאות המיפוי של איזור הגרעין( מפונה

. mm_count = 0כאשר בהתאם למה שהוזכר בעבר, חוט/תהליך גרעין מנצל את מרחב

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

הוא בשימוש ע"י תהליך גרעין




הפונקציות הבאות המוגדרות בקובץ הגרעיןkernel/fork.c מטפלות במתאר הזיכרון של תהליך:

הקצאת מתאר זיכרון חדש מבוצעת בפונקציהmm_alloc)( שגם 1מאתחלת את מוני השיתוף ל-

( שיתוף מרחב זיכרוןclone)( מגדיל את )mm_users בפונקציה copy_mm)(

( סיום שימוש במרחב זיכרוןdo_exit)( או execve)( מפעיל את ) mm_users=0. אם 1 ב-mm_users המקטינה את )(mmputהפונקציה

מפונים איזורי הזיכרון והטבלאות הממפות אותם, ומופעלת הפונקציה mmdrop)( המקטינה את ,mm_count-שאז 0 ובודקת אם הוא 1 ב ,

מפונה מתאר הזיכרון לחלוטין



(1מתאר איזור זיכרון )

,מתאר איזור זיכרון לכל איזור זיכרון במרחב הזיכרון יש, כאמור(memory region object) שהוא רשומה המכילה מידע לגבי ,

איזור הזיכרון מתאר איזור הזיכרון אינו ניתן לשיתוף. אם לשני )או יותר( מרחבי זיכרון

שונים יש איזור זיכרון משותף, ייווצר בכל אחד מהם מתאר איזור זיכרון המצביע כל אחד לרצף הדפים המשותף

כל דף באיזור משותף מוגדר כדף משותף – יש לו כניסה בטבלת הדפיםבכל אחד ממרחבי הזיכרון החולקים בו

בדרך-כלל האיזור המשותף אף ממופה לתחומי כתובות שונים במרחביהזיכרון השונים

מתאר איזור הזיכרון הוא מסוג vm_area_struct קובץ גרעיןinclude/linux/mm.h



( 2מתאר איזור זיכרון )

:מספר שדות במתאר איזור הזיכרוןvm_mmמצביע למתאר הזיכרון של המרחב המכיל את האיזור – vm_startכתובת התחלה של איזור הזיכרון – vm_endכתובת אחת אחרי האחרונה של איזור הזיכרון – vm_next מצביע למתאר איזור הזיכרון הבא ברשימת האיזורים של –

המרחב המכיל את איזור הזיכרוןvm_page_prot ערכי ביטים שונים שיוצבו לכל הכניסות של הדפים –

באיזור. ראה בהמשךvm_flags:דגלים המציינים תכונות של האיזור, למשל –

VM_READ, VM_WRITE, VM_EXEC, VM_SHARED הרשאות: האם – מותר לקרוא/לכתוב/לבצע נתונים בדפים באיזור, האם מותר לשתף דפים

באיזור דגלים המציינים האם מותר לפנות את הדפים באיזור מהזיכרון למאגר

– אין לפנות את הדפים. VM_LOCKEDדפדוף ואיזה. לדוגמה – VM_EXECUTABLE הדפדוף הוא לקובץ ריצה –



( 3מתאר איזור זיכרון )

:דגלים המציינים התפתחות של איזור הזיכרוןVM_GROWSDOWN מציין שהאיזור גדל בכיוון הכתובות הנמוכות )אופייני למחסניות(,

VM_GROWSUPמציין גידול לכיוון הכתובות הגבוהות

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

איזור הזיכרון ,כזכורIA32 באמצעות הביט( מאפשרת ברמת דף r/w רק קריאה או )

(read מוגדר כ-executeקריאה וכתיבה ) "לפיכך, נקבעות הרשאות הדף לפי הרשאות האיזור לפי ה"אלגוריתם

הבא: מדליקים אתpresent כי כשדף מוקצה לראשונה, הוא בזיכרון( ואת(

user/supervisor)כי הדף אמור להיות נגיש לקוד תהליכי משתמש( אם יש הרשאתwrite באיזור, מדליקים את r/w)הכל מותר(



(4מתאר איזור זיכרון )

)מותר r/w, מכבים את execute או readאחרת, אם באיזור יש הרשאת 3.רק לקרוא(

presentאחרת )אין הרשאות(, מכבים את 4. לדף שכזה, אסור להתיר גישה, וכיבויpresent גורם לחריגת page fault

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

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

ישנם מצבים בדפים משותפים בהם הביטים מוצבים בכוונה לערך 3.(copy on writeשאינו מתאים להרשאות האיזור. פרטים בהמשך )

שיטת החישוב המדויקת של הרשאות דף מבוצעת דרך המערך 4.protection_arrayשממפה את הרשאות האיזור להרשאות דף ,

ומוצבת לדפים vm_page_protהתוצאה של החישוב נשמרת בשדה 5.באיזור עם הקצאתם



)Linux )1מאגרי דפדוף ב-

Linux מאגרי דפדוף ) מאפשרת הגדרה של מספרSwap Areas)אליהם מפונים דפים )מיפוי אנונימי( מהזיכרון הראשי

עדMAX_SWAPFILES )32(מאגרים ניתן להפעיל ולכבות מאגרי דפדוף באופן דינמי תוך כדי פעולת

המערכתעומס הדפים המפונים מחולק בין המאגרים

כל מאגר דפדוף הוא שטח דיסק המחולק ל( מגירותslots) ,( ומשמשת לאיחסון דף 4KBכאשר כל מגירה היא בגודל דף )

מהזיכרון הראשי המגירה הראשונה אינה משמשת לאחסון דפים – מכילה מידע ניהולי

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

לשפר את זמן הגישה


)Linux )2מאגרי דפדוף ב-

מתאר מאגר לכל מאגר דפדוף מחזיק הגרעין בזיכרון רשומת(Swap Area Descriptor) מסוג swap_info_struct

קובץ גרעיןinclude/linux/swap.h:מספר שדות המופיעים ברשומת מתאר המאגר

swap_device, swap_file מזהי ההתקן בו נמצא מאגר הדפדוף )יכול – להיות קובץ או התקן חומרה(

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

maxגודל מאגר הדפדוף בדפים – כל מתארי המאגרים שבשימוש המערכת נמצאים במערך

swap_info קובץ גרעיןinclude/linux/swap.h


)Linux )3מאגרי דפדוף ב- דף זיכרון השמור במאגר דפדוף מזוהה בפשטות

באמצעות מספר הכניסה של מאגר הדפדוף במערך swap_info:מספר המגירה במאגר הדפדוף +

מזהה הדף הפיזי )הצירוף שלעיל נקראSwapped-Out Page Identifier)

כאשר דף מפונה לדיסק, מוצב ערך זה בכניסה בטבלתהדפים שהצביעה לדף

( הוא גם המקום של הביט 0 )שערכו 0ביטPresent בכניסה בטבלת הדפים – כך מסמנים לחומרה שהדף אינו הזיכרון

מספר המגירה במאגר מספר המאגר 0017831


Linuxטבלת המסגרות ב- גרעיןLinux מחזיק מערך עם כניסה לכל מסגרת בזיכרון

הראשי של המחשב המערך נקראmem_map וכל כניסה היא מסוג struct page

קובץ גרעיןinclude/linux/mm.h:מספר שדות חשובים בכל כניסה

count( מונה שימוש – reference counter של הדף שבמסגרת: כמה ), 0מרחבי זיכרון מצביעים לדף זה כשהוא בזיכרון. אם ערך המונה הוא

המסגרת פנויהmapping, index, next_hash, pprev_hash ,משמשים במטמון הדפים –

כפי שנראה מידlruמשמש למנגנון פינוי הדפים. פרטים בהמשך – flags:דגלים המתארים את מצב הדף שבמסגרת, כגון –

PG_locked מציין שהמסגרת נעולה עקב פעולת פינוי/הבאת דף שעדיין לא – הסתיימה

PG_referenced, PG_active, PG_lru, PG_dirty, PG_launder משמשים – למנגנון פינוי הדפים. פרטים בהמשך


)Linux )1מטמון הדפים ב-

כפי שכבר הוזכר, מערכת ההפעלה מפנה וטוענת דפים שלמרחבי זיכרון של תהליכים במסגרת פעולת מנגנון הזיכרון

הוירטואלי ,עם זאתLinux טוענת ומפנה דפים בין הדיסק לזיכרון גם

בשביל פעולת מערכת הקבצים: ,כאשר תהליך פותח קובץ לעבודהLinux טוענת דפים המכילים מידע

מהקובץ ומשתמשת בהם כחוצצים לשיפור הביצועים בקריאות וכתיבות – קריאות מהזיכרון וכתיבות לזיכרון מתבצעות מהר יותר מאשר

בעבודה ישירה עם הדיסק בנקודות זמן שונות, נכתבים דפי החוצצים בחזרה לקובץ בדיסק כדי

לעדכן אותו-התקני חומרה בLinux מהווים חלק ממערכת הקבצים, ולכן

העבודה מולם מתבצעת בצורה דומה



( מטמון הדפיםPage Cache) הוא המנגנון המרכזי לכל Linuxלטעינת ופינוי דפים בין הזיכרון לדיסק ב-

מטרה שהיאמטמון הדפים ממומש בתוך טבלת המסגרות

דפים מוכנסים ומוסרים במטמון באופן דינמי, ובהתאם לכךהמסגרות שלהם

דוגמאות לדפים שאינם במטמון: דפים של הגרעין, דפיםשאינם מיועדים לפינוי, ועוד

,גם דפים הניתנים לפינוי יכולים להצטרף ולצאת מהמטמוןכפי שנראה בהמשך



:דף המכיל מידע מהדיסק, יכול להכיל סוגים שונים של מידעקטע של קובץ: קוד מתוכנית טעונה, נתונים מקובץ נתונים

דף כזה נקרא( ממופה לקובץfile mapped)( דף זיכרון של תהליך שנשמר בדיסק במאגר דפדוף כלשהוswap

area) דף כזה נקרא( ממופה אנונימיanonymous mapped)

!דפים של קוד במרחב זיכרון תהליך, כמו גם דפים שימו לב המכילים נתונים מקבצים, אינם מטופלים כמו דפים של נתונים

או מחסנית של תהליך, בכך שהם מפונים אל הקבצים מהם נטענו ולא אל מאגר דפדוף כללי כלשהו

בהתאם לסוג המידע המוכל בדף, משתנה הטיפול בדףבטעינה ופינוי

טעינה ופינוי לקובץ מסוים או למאגר דפדוף



בהתאם לכך, שדהmapping ברשומת מסגרת של דף במטמון הדפים, מצביע לאובייקט ניהול המכיל מידע

ופונקציות לטיפול בדף שבמסגרת )פינוי וטעינה( אם הדף ממופה לקובץ, אובייקט הניהול מקושר לקובץ

המתאים אם הדף ניתן לדפדוף וממופה אנונימי )ומיועד לפיכך למאגרי

(swap cacheמטמון הדפדוף )דפדוף(, אובייקט הניהול הוא שהוא אובייקט מיוחד עבור דפים כאלו

שדהindex ברשומת מסגרת כל דף במטמון הדפים מציין את המיקום הפיזי של הדף במאגר המידע בדיסק

( עבור מידע מקובץ, את ההיסט מתחילת הקובץoffset) עבור דף מזכרון תהליך, את מזהה הדף הפיזי )כלומר מצביע

למגירה(



מטמון הדפים מכילhash-table המתרגם צירוף של (mapping+index )( לכתובת מסגרת )אם יש כזו

של האוביקט indexהמכילה את הדף במיקום mapping

כל המסגרות שמתאימות לאותוhash מקושרות ברשימה pprev_hash ו-next_hashכפולה מעגלית דרך השדות

ברשומת המסגרת-הhash table שימושי במיוחד עבור מנגנון הדפדוף, כפי

שנראה בהמשך הפונקציות/מאקרו הבאות, המוגדרות בקבצי הגרעין

mm/filemap.c-ו include/linux/pagemap.h-קשורות ל ,hash table:

page_hash)(-פונקצית ה – hash



find_get_page)( מקבלת – mapping+index ומחזירה מצביע אם אין(NULLלמסגרת המכילה את הדף המתאים )או

add_to_page_cache)( הוספת מסגרת + מיקום פיזי )מגירה או – hash-tableבקובץ( למטמון וכך גם ל-

שדה( מבחינת מונה השימוש של מסגרתcount או )(, מטמון הדפים נחשב swap_mapמגירה )מונה

כמרחב זיכרון נפרד המשתמש בדף המאוחסן בה כאשר מסגרת או מגירה בשימוש מטמון הדפים, מוגדל

מבוצעת עם ניתוק 1. הקטנת המונה ב-1המונה ב-המסגרת או המגירה מהמטמון

-המטרה: למנוע שיבוש במיפוי הhash-table באמצעות הקצאה מחדש של המסגרת/מגירה עד להוצאת הדף

מהמטמון


(1הקשר בין מסגרת למגירה )

הקשר בין מסגרת ומגירה, המכילות את אותו דף ממופהאנונימי, הינו דינמי:

דף המצוי במגירה יכול להטען לכל מסגרת פנויה שתוקצה בעת הצורך דף מפונה למגירה בדיסק רק לאחר שכל מרחבי הזיכרון השותפים בו

מצביעים על המגירה בדיסק – והקשר הקיים בין המסגרת למגירה ניתן לניתוק

Linux:מאפשרת קישור דינמי גם בכיוון ההפוך לאחר שדף נטען לזיכרון וכל מרחבי הזיכרון מצביעים למסגרת, ניתן

לשחרר את המגירה ולנתק את הקשר הקייםבעת הכנת דף לפינוי, מקצים לו מסגרת חדשה אם אין לו

מטמון הדפדוף )בתוך מטמון הדפים( מחזיק את הקשר ביןהמגירה והמסגרת של אותו דף, כל עוד קשר זה מתקיים

)ומסמן בכך את קיום הקשר(כאשר הקשר ניתק, המסגרת מוצאת ממטמון הדפים

וגם מונה השיתוף של המגירה מוקטן..

Linuxמטמון הדפים ב-



בתרשים בהמשך מוצגת דוגמה לתהליך פינוי דף ממופהאנונימי למסגרת

S1-ו S2 הם שני מרחבי זיכרון שלהם דף משותף P המצוי בתחילה , הינו מטמון הדפיםPC( במסגרת בזיכרון. 1)שלב

הערך הכתוב במשבצת של המסגרת שלP ושל המגירה של P בכל (swap_map או countהשלבים הינו מונה השיתוף )

במסגרת פינוי דפים, מבוצע מעבר על הטבלאות שלS1 והגרעין (:2 )שלב Pמחליט לפנות את

הדףP שדה( אינו במטמון הדפים mapping במסגרת מצביע על NULL )ולכן:

מוקצית מגירה עבורP המסגרת והמגירה שלP מקושרות למטמון הדפים )עדכון מוני השיתוף, עדכון

mapping-ו index)במסגרת -הטבלה בS1 עוברת להצביע על המגירה של P מזהה הדף הפיזי מוצב(

בטבלה, עדכון מוני השיתוף(P!עדיין לא מפונה פיזית מהזיכרון




בהמשך, מבוצע מעבר גם על הטבלאות שלS2 ושוב הגרעין מחליט (:3 )שלב Pלפנות את

כעת, הדףP:כבר במטמון הדפים ולכן P עוברת להצביע על המגירה של S2הטבלה ב-1.

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

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

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

תיאום בין מרחבי הזיכרון המשתמשים בדף אין צורך לעדכן את כל טבלאות הדפים המתייחסות לאותו דף בבת

אחתניתן לדחות את פעולת הפינוי הפיזי ככל הרצויהדף מפונה פיזית פעם אחת, ולמקום אחד בדיסק



(4הקשר בין מסגרת למגירה ) בטעינת דף מתבצעות הפעולות בסדר הפוך בקירוב, תוך

שימוש במטמון הדפים בטעינת דף למרחב זיכרון מסוים, בודקים אם הדף כבר נטען

:)(find_get_pageלמסגרת בזיכרון באמצעות אם כן, רק מעדכנים את טבלת הדפים ומוני השיתוףאחרת, טוענים את הדף לזיכרון ומכניסים אותו למטמון הדפים

גם טעינת דף משותף מתבצעת בצורה הדרגתית תוך שמירהעל תיאום בין התהליכים

הדף נטען פעם אחת בלבד ולמסגרת אחת בלבדהתמונה הכללית דומה מאוד עבור דפים ממופים לקובץ

ההבדל העיקרי הוא שהמיקום של הדף בדיסק הוא קבוע, ולכןאין צורך "להקצות מגירה" בפינוי לדיסק הדף נמצא במטמון הדפים כל עוד הוא בזיכרון, כי אינו מנותק מהמיקום

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

המיקום לפי מקום הדף באיזור הזיכרון הממופה לקובץ, ולכן שומרים NULLבטבלת הדפים כשהדף מפונה



2

S1

S2

PC

מאגר דפדוף

זיכרון ראשי 1P

2

S1

S2

PC

מאגר דפדוף


2

P

1

S1

S2

PC

מאגר דפדוף


3

P

S1

S2

PC

מאגר דפדוף

זיכרון ראשי 4

2

P


Linuxפינוי דפים ב-

-כפי שכבר הוזכר קודם, פינוי דפים בLinux מתבצע כפעולה של חוסר ברירה

Linuxנוטה לנצל את הזיכרון הראשי ככל האפשר מבלי לפנות דפים כלל מוגדר סף "קריטיות" של כמות מינימלית של מסגרות שחייבת להשאר

פנויה – לצורך הפעלת אלגוריתמים של פינוי זיכרון( למעשה, הזיכרון הראשי מחולק למתחמי זיכרוןMemory Zones שבמתאר )

(, ובכל אחד מהם pages_lowשל כל אחד מהם מוגדר סף קריטי מינימלי )מתבצע פינוי מסגרות בנפרד

( לכל מתחם זיכרון מוגדר גם סף עליוןpages_high שמעבר לו אין צורך ,)לבצע פינוי מסגרות

מחזור מסגרות )מנגנון פינוי הדפים, הקרוי מנגנוןPage Frame Reclaiming) מופעל בקריאה לפונקציה ,try_to_free_pages)(

המקבלת כפרמטר מצביע למתאר מתחם הזיכרון המיועד לפינוי קובץ גרעיןmm/vmscan.c


אלגוריתם פינוי הדפים

פינוי דפים מהזיכרון לדיסק הינו מנגנון בעל שלושה:Linuxמרכיבים ב-

דירוג דינמי של רמת הפעילות של כל דף במסגרת בזיכרון 1.)שאינו שייך לגרעין(

כאשר עולה הצורך בפינוי זיכרון:מעבר על רשימת המסגרות בעלות ה"פעילות הנמוכה 2.

ביותר" ופינוי המסגרות שאינן בשימוש מרחבי זיכרון של תהליכים

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

תהליכי משתמש: כאשר מאותרת כניסה השייכת לאיזור זיכרון ומצביעה למסגרת הניתנת לפינוי ובעלת פעילות "נמוכה", מבוצע פינוי של הדף ממרחב הזיכרון הנבדק

פינוי דף ממרחב זיכרון יחיד, בהתאם לשיטה שהודגמה קודם


Linuxפינוי דפים ב-

הפעלת הפונקציהtry_to_free_pages)( מבוצעת במקרים הבאים:

כאשר מתעורר חוט גרעין מיוחד הקרויkswapd" או( swapper בודק ,)"את כמות המסגרות הפנויה ומגלה שהגיעה לסף הנמוך או עברה אותו,

. הפונקציה מופעלת שוב )(try_to_free_pagesומפעיל כתוצאה את ושוב עד שכמות המסגרות הפנויות עוברת את הסף העליון )כדי למנוע

(thrashingסחרור – ( חוט גרעין זהpid=0-רץ בעדיפות נמוכה ומנצל לפיכך את ה )idle time

)זמן ללא פעילות תהליכים( לפעולות ארוכות של פינוי הזיכרון, כך שכשתהליכי משתמש חוזרים לרוץ, יש להם יותר זיכרון זמין – שיפור ביצועי

המערכת )כאשר הקצאת מסגרת חדשה נכשלת )בעקבות הגעה לסף הקריטי

kswapdמתבצעת הפעלה ישירה של הפונקציה או שמעירים את


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

מסגרות במטמון הדפים: active_list רשימת מסגרות הדפים ה"פעילים", כלומר דפים שניגשו –

אליהם "לאחרונה"inactive_list רשימת מסגרות הדפים ה"לא-פעילים", כלומר דפים –

שלא נגשו אליהם "זמן מה"active_list, inactive_list הם שמות המשתנים הגלובליים המצביעים

mm/page_alloc.cלראשי הרשימות, המוגדרים בקובץ הגרעין הרשימות לא-חופפות, ומסגרות מועברות בין הרשימות כפי שנראה

בהמשךמסגרת מוספת לרשימה דרך ראש הרשימה הדגלPG_lru דולק ברשומת מסגרת הנמצאת באחת מהרשימות )לא

מסגרת השייכת לגרעין, למשל( הקישור של מסגרת לאחת הרשימות הוא באמצעות השדהlru ברשומת

המסגרת הדגלPG_active דולק רק בכל רשומת מסגרת השייכת לרשימה

active_list


בחירת דפים לפינוי

הדגלPG_referenced ברשומת מסגרת מציין שבוצעה גישה לדף במסגרת זו

-דגל זה משמש ליצירת שתי הזדמנויות למסגרת להשאר בactive_list מתוך active_listאבל גם שתי מדרגות למסגרת על-מנת להכנס ל-

inactive_listה- הפונקציהmark_page_accessed)( ,המופעלת לציון גישה למסגרת ,

, מדליקה את active_listמבצעת כדלקמן: אם המסגרת ב-PG_referenced אחרת, אם .PG_referenced .כבוי, מדליקה אותו

ומכניסה את המסגרת PG_referencedאחרת, מכבה את active_listל-

קובץ גרעיןmm/filemap.c הפונקציהrefill_inactive)( המופעלת לעדכון ,inactive_list מפעם

מסוף הרשימה )מסגרות active_listלפעם, עוברת על כל המסגרות ב- דלוק, מכבה אותו ומכניסה את PG_referencedותיקות ביותר(: אם . אחרת, מעבירה את המסגרת active_listהמסגרת מחדש ל-

דולקPG_referenced עם דגל inactive_listל- קובץ גרעיןmm/vmscan.c


בחירת דפים לפינוי

הפונקציהmark_page_accessed)( מופעלת עבור דף כלשהו כאשר:

בכל פעם שדף זה נטען מהדיסק בכל פעם שהגרעין מגלה שביטaccessed של דף זה בטבלת הדפים

מכובהaccessedדלוק – אז גם הביט -פינוי הדפים מבוצע החל מסוף רשימת הinactive_list-האלגוריתם המתקבל הוא קירוב לLRU אלגוריתם" :

ההזדמנות השלישית??"

PG_referenced=0PG_active=0




add_to_page_cache)(

refill_inactive)(

mark_page_accessed)(


)(try_to_free_pagesהפונקציה

פונקציה זו מנסה לפנותSWAP_CLUSTER_MAX )32( מסגרות במתחם זיכרון נתון

קוד עקרוני של הפונקציה בשקף הבא בכישלון0 בהצלחה, 1מחזירה

הפונקציה קוראת לפונקצית פינוי המסגרותshrink_caches)( ( על-מנת לגרום priorityבמספר רמות עולות של עדיפות )

לפינוי כמות המסגרות הדרושהshrink_caches)( מחזירה בכל פעם את מספר המסגרות שנותרו

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

על-מנת )(out_of_memoryבזיכרון(, הפונקציה קוראת ל-להרוג תהליך משתמש )ואת שותפיו למרחב הזיכרון( ולקחת

את מרחב הזיכרון שלו( אם אין תהליכי משתמש, המערכת מושבתת בהודעת שגיאהkernel

oops)


)(try_to_free_pagesהפונקציה תהליך המשתמש שמועדף כקורבן הוא כזה שאמור להביא "מקסימום תועלת

במינימום נזק": הרבה מסגרות במרחב הזיכרון, מעט זמן ריצה )לא הספיק - פחות חשוב..(, ללא זכויות nice > 0הרבה..(, עדיפות נמוכה מהרגיל )

superuser שוב, פחות חשוב( וללא גישה לחומרה )כדי שלא ישבש את פעולת( המערכת(

0הריגת תהליך משתמש נחשבת ככישלון – מוחזר:קוד הפונקציה

int priority = DEF_PRIORITY; /* 6 */int nr_pages = SWAP_CLUSTER_MAX; /* 32 */..do {

nr_pages = shrink_caches)classzone, priority, gfp_mask, nr_pages(;if )nr_pages <= 0(

return 1;} while )--priority(;out_of_memory)(;return 0;


פונקציות פינוי המסגרות

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

מותנה בכך שעדיין לא הושגה כמות המסגרות הפנויות הנדרשת:

הפעלת פונקציות לצמצום גודל מטמוני זיכרון )פרט למטמון הדפים(1.

, inactive_list על-מנת להגדיל את ה-)(refill_inactiveהפעלת 2. על-מנת לנסות לשחרר מסגרות )(shrink_cacheואחריה קריאה ל-

inactive_listמה-צמצום מטמונים של מערכת הקבצים, בתקווה שזה יגרום לשחרור 3.

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

לפנות מתוך היעד המקוריshrink_caches)(-ו shrink_cache)( מוגדרות בקובץ הגרעין

mm/vmscan.c


פונקציות פינוי המסגרות

הפונקציהshrink_cache)(( מקבלת כפרמטרים את העדיפות priority ,)(nr_pages( וכמות יעד של מסגרות לפינוי )classzoneמתחם הזיכרון )

:פעולת הפונקציה היא אלגוריתם השחרור כפי שהוזכר קודם-מתחילה לסרוק מסגרות החל מסוף הinactive_list:מנסה לפנות רק מסגרות

הנמצאות במתחם המבוקש( שעדיין לא פונו ממטמון הדפיםcount > 0)( שאינן בשימוש תהליכי משתמשcount = 1)

:לכל מסגרת מתאימה( אם המסגרת בתהליך כתיבה לדיסקPG_launderממתינה לסיום הכתיבה ,)דולק דגל( "אם המסגרת "מלוכלכתPG_dirty ,יוזמת התחלת כתיבה של המסגרת ,)דולק

PG_dirty ומכבה את PG_launderמדליקה את

שחרור המסגרת מתבטא


Linux ב-Page Faultטיפול ב-

מערכות הפעלה

Documents

Transcript of מערכות הפעלה