‫שבוע ‪#05‬‬ ‫פרק‪Memory Management :‬‬ ‫ניהול הזיכרון‬ ‫קורס מערכות הפעלה ב'‬ ‫מכללת הדסה ‪ /‬מכללה חרדית‬ ‫צבי מלמד‬ ‫‪[email protected]‬‬ ‫הרצאות הקורס מבוססות במידה רבה ביותר על ההרצאות של ד"ר יורם ביברמן‬ ‫© כל הזכויות שמורות לד"ר יורם ביברמן ולצבי מלמד‬ ‫©צבי מלמד‬ ‫‪1‬‬ ‫ניהול זיכרון‬ ‫•‬ ‫המטרות שדיברנו עליהם בעבר‪ ,‬ובפרט בפרק הקודם‪:‬‬ ‫– שיפור ניצולת המעבד‬ ‫– שיפור התגובתיות למשתמש‬ ‫•‬ ‫הפתרון )באופן הכי כללי(‬ ‫– ריבוי תוכניות שרצות במקביל‬ ‫•‬ ‫מה שזה מצריך‪:‬‬ ‫– שהתוכניות האילו תמצאנה בזיכרון בו‪-‬זמנית‬ ‫•‬ ‫דרושות – שיטות לניהול הזיכרון ‪memory management scheme‬‬ ‫•‬ ‫אולי יותר מכל מרכיב אחר – שיטות לניהול הזיכרון תלויות בתמיכה בחומרה‪.‬‬ ‫– במלים אחרות‪ :‬יחסי הגומלין בין מבנה החומרה למערכת ההפעלה מאוד‬ ‫משמעותיים בהקשר של ניהול הזיכרון‬ ‫©צבי מלמד‬ ‫‪2‬‬ ‫עולם היהדות‬ ‫• מהדר )בהלכה‪ ,‬בכשרות‪(...‬‬ ‫• כורך )מצה ומרור‪(...‬‬ ‫• טוען )בבית הדין הרבני‪(...‬‬ ‫©צבי מלמד‬ ‫‪3‬‬ ‫ניהול הזיכרון ‪ -‬רקע‬ ‫• התוכניות – נמצאות על הדיסק )או התקן לא‪-‬נדיף אחר(‬ ‫• בכדי להריץ – התוכנית צריכה להיטען לזיכרון‬ ‫• הזכרנו אזורים שונים בזיכרון‪:‬‬ ‫– טקסט‪/‬קוד – פקודות התוכנית‬ ‫– נתונים )‪ (data‬ו‪ – bss-‬נתונים גלובליים וסטטיים‪ ,‬מאותחלים‬ ‫ובלתי מאותחלים‬ ‫– מחסנית‪ ,‬ערימה – הזיכרון "הדינמי"‬ ‫©צבי מלמד‬ ‫‪4‬‬ ‫התהליך‬ ‫• לכל תהליך מרחב כתובות‬ ‫)‪ (address space‬שלו –‬ ‫אליהן‪ ,‬ורק אליהן‪ ,‬הוא רשאי‬ ‫לפנות‬ ‫תזכורת – מהמצגת על‬ ‫תהליכים‬ ‫©צבי מלמד‬ ‫‪5‬‬ ‫מרחב הכתובות )‪ (address space‬של התהליך‬ ‫‪.1‬‬ ‫‪.2‬‬ ‫‪.3‬‬ ‫‪.4‬‬ ‫‪.5‬‬ ‫‪.6‬‬ ‫‪ - text segment‬פקודות התכנית )בשפת מכונה( = ]בד"כ מוגן מפני‬ ‫כתיבה[‬ ‫‪ - Stack‬מחסנית )פרמטרי התוכנית‪ ,‬קריאות לפונקציות ומשתנים‬ ‫לוקליים(‬ ‫‪ heap‬ערמה )להקצאה דינאמית(‬ ‫‪ – data section‬משתנים סטטיים וגלובליים‬ ‫‪ (block started by symbol) bss‬משתנים גלובליים וסטטיים‬ ‫שאינם מאותחלים )וע"כ אינם נשמרים בקובץ המכיל את התכנית(‬ ‫מידע נוסף על התהליך )רשימת קבצים שפתח‪ ,‬עדיפות‪ ,‬זמן ריצה‪,‬‬ ‫מצב האוגרים ב‪ context switch-‬האחרון‪] - ( .. ,‬מתוחזק על ידי‬ ‫מערכת ההפעלה[‬ ‫תזכורת – מהמצגת על‬ ‫©צבי מלמד‬ ‫תהליכים‬ ‫‪6‬‬ ‫ניהול הזיכרון ‪ -‬רקע‬ ‫•‬ ‫ביצוע תוכנית – רצף של ביצוע פקודות‬ ‫•‬ ‫ביצוע פקודה כולל מספר שלבים‪ ,‬שבעיקרם קריאת נתונים מהזיכרון )ותלוי‬ ‫בפקודה‪ ,‬אולי גם כתיבה לזיכרון(‬ ‫– )‪ – Program Counter = PC (aka instruction pointer‬משמש לאיתור‬ ‫מיקום הפקודה הבאה לביצוע )כתובתה בזיכרון(‬ ‫– ‪ – Instruction Register = IR‬מכיל את הפקודה ה"נוכחית"‬ ‫– פענוח הפקודה‬ ‫– קריאת הארגומנטים מהזיכרון )במידת הצורך(‬ ‫– אחסון תוצאת הפקודה בזיכרון‬ ‫•‬ ‫כל הקריאות והכתיבות לזיכרון מתבצעות על גבי ה‪BUS-‬‬ ‫– )‪ BUS, USB‬הזה‪ ,‬האם יש קשר ביניהם חוץ מפרמוטצית האותיות‪(?...‬‬ ‫©צבי מלמד‬ ‫‪7‬‬ ‫ניהול הזיכרון ‪ -‬רקע‬ ‫•‬ ‫לא נתעניין בנתונים שנמצאים בכתובות השונות‪ ...‬אלא בעיקר רק בכתובות‬ ‫עצמן‪ ,‬זאת אומרת‪ ,‬באיזה כתובת נמצא הנתון‬ ‫•‬ ‫מרחב הכתובות ‪ address space‬של ‪ – P‬אוסף כל הכתובות שאליהן עשוי המעבד‬ ‫לפנות כאשר הוא מריץ תהליך מסוים ‪P‬‬ ‫•‬ ‫כתובת סמלית ‪ – symbolic address‬הסמל בתוכניתנו שמייצג כתובת‬ ‫– ההכרזה‬ ‫;‪int num‬‬ ‫;‪num = 17‬‬ ‫– הגדירה כתובת סמלית – ‪.num‬‬ ‫– אם נבחן את התוכנית – את פקודות התוכנית‪ ,‬לא נראה בפקודה ‪ num‬אלא‬ ‫התיחסות לכתובת כלשהי‪ ,‬שהיא הכתובת בזיכרון שהוקצתה למשתנה ‪num‬‬ ‫– באופן דומה‪ ,‬אם השתמשנו ב‪ goto my_label-‬או אפילו‪ ...‬זימון לפונקציה‬ ‫©צבי מלמד‬ ‫‪8‬‬ ‫שאלה של ניסוח‬ ‫• מרחב הכתובות ‪ address space‬של ‪– P‬‬ ‫האם היינו הך?‬ ‫– אוסף כל הכתובות שאליהן עשוי המעבד לפנות כאשר הוא‬ ‫מריץ תהליך מסוים ‪P‬‬ ‫– אוסף כל הכתובות שאליהן עשוי לפנות התהליך בזמן הריצה?‬ ‫©צבי מלמד‬ ‫‪9‬‬ ‫ניהול הזיכרון ‪ -‬רקע‬ ‫• הגדרנו משתנים בתכניתנו‬ ‫;‪double my_double‬‬ ‫;‪long int to_long‬‬ ‫• הקומפיילר מחליט וקובע‪:‬‬ ‫– כמה בתים להקצות למשתנה – כלומר‪ ,‬לכתובת הסמלית‬ ‫– קביעות אודות הכתובת הפיזית שתכיל את המשתנה בזמן‬ ‫הריצה‬ ‫– מה תהיה כתובת התווית או הפונקציה‬ ‫• אבל – הקומפיילר איננו הקובע היחיד‪ ,‬וגם לא הפוסק האחרון‬ ‫• אז מה בעצם קובע הקומפיילר‪ ,‬ומה קובעים "השחקנים" האחרים‬ ‫אודות הכתובת של משתנה או תווית?‬ ‫©צבי מלמד‬ ‫‪10‬‬ ‫קביעת הכתובת ‪Absolute Code‬‬ ‫שיטה א'‪ :‬קוד מוחלט – ‪absolute code‬‬ ‫– אם המהדר יודע באילו בכתובות בזיכרון תהיה התוכנית בזמן‬ ‫שתורץ‪ ,‬הוא יכול לקבוע גם את הכתובת הפיזית המוחלטת‬ ‫והסופית של המשתנה‪.‬‬ ‫– יתרון ‪:‬‬ ‫• טעינת מהירה של התוכנית – לא צריך לחשב כתובות‬ ‫• ריצה מהירה )אותה סיבה(‬ ‫– חיסרון‪ :‬הקומפיילר צריך לדעת משהו דיי דראסטי‪ ...‬באיזה‬ ‫כתובת תשכון התוכנית‬ ‫– קבצי ‪ .com‬של ‪ DOS‬עבדו כך‬ ‫©צבי מלמד‬ ‫‪11‬‬ ‫קביעת הכתובת ‪Relocatable Code -‬‬ ‫שיטה ב'‪ :‬קוד בר‪-‬הזזה – ‪relocatable code‬‬ ‫– המהדר לא יודע לאיזה כתובת התוכנית תיטען בזיכרון‬ ‫– אבל – הוא יודע‪ :‬אחרי שהתוכנית תיטען לכתובת מסוימת‬ ‫בזיכרון‪, ,‬היא לא תזוז משם עד סיום ריצתה )אפילו אם עוד‬ ‫תוכניות רצות במקביל(‬ ‫כיצד זה עובד?‬ ‫– המהדר קובע כתובת יחסית ביחס לכתובת בסיס כלשהי‬ ‫– כאשר ה‪) Loader-‬טוען( טוען את התוכנית לזיכרון‪:‬‬ ‫• הוא יודע "לאן הוא טוען"‬ ‫• יבצע המרה של הכתובות היחסיות לכתובות המוחלטות‬ ‫• )"הניתנות להזזה" ‪ - relocatable addresses‬מה משתמע?(‬ ‫©צבי מלמד‬ ‫‪12‬‬ ‫כתובת יחסית‪ ,‬בסיס ומוחלטת‬ ‫כתובת יחסית‬ ‫כתובת יחסית‬ ‫כתובת יחסית‬ ‫כתובת יחסית‬ ‫כתובת בסיס‬ ‫‪+‬‬ ‫כתובת יחסית‬ ‫כתובת יחסית‬ ‫כתובת יחסית‬ ‫כתובת מוחלטת‬ ‫©צבי מלמד‬ ‫‪13‬‬ ‫קביעת הכתובת ‪Relocatable Code -‬‬ ‫‪2404‬‬ ‫‪+‬‬ ‫‪12000‬‬ ‫‪14404‬‬ ‫• משתנה שכתובתו היחסית ‪ 2404‬נטען לכתובת מוחלטת ‪.14404‬‬ ‫• זאת כתובתו הסופית של המשתנה‪.‬‬ ‫• איזו‪/‬כמה עבודה הצטרך הטוען לבצע?‬ ‫• מאזן רווח והפסד‪:‬‬ ‫‪ +‬יותר עבודה בזמן הטעינה‬ ‫– גמישות במיקום הפיזי של התוכנית בזיכרון‬ ‫©צבי מלמד‬ ‫‪14‬‬ ‫קביעת הכתובת ‪ -‬שיטה שלישית‬ ‫• נקודת המוצא‪ :‬גם לאחר שטענו את התוכנית לזיכרון‪ ,‬הכתובות‬ ‫עלולות להתחלף‬ ‫– נהוגה במערכות ריבוי‪-‬תוכניות בסיסיות‬ ‫– התוכנית עשויה להיות משוחלפת לדיסק ‪ swap out‬או ‪roll out‬‬ ‫• למה?‬ ‫– הגיעה תוכנית חדשה בעדיפות גבוהה יותר‪ ...‬אין מקום לשתיהן‬ ‫בזיכרון‬ ‫• אז מה קורה‪...‬‬ ‫– כאשר התוכנית מוחזרת לזיכרון המחשב – היא מוחזרת‬ ‫לכתובת כלשהי )ובד"כ לא הכתובת שהייתה בה קודם(‬ ‫– לכן – גם הטוען – אינו קובע שום דבר סופי ואולטימטיבי‬ ‫©צבי מלמד‬ ‫‪15‬‬ ‫קביעת הכתובת ‪ -‬שיטה שלישית‬ ‫• במצב כזה –הכתובות היחסיות אינן מומרות בכתובות מוחלטות‬ ‫בשלב הטעינה הראשונה או בשלב הטעינה החוזרת‬ ‫• בכל פעם שהמעבד פונה לכתובת כלשהי – הוא יציין את הכתובת‬ ‫היחסית‪ .‬באותו רגע‪ ,‬ובתוקף לאותה פעולה‪/‬פניה בלבד תתבצע‬ ‫ההמרה לכתובת פיזית )מוחלטת(‬ ‫• האם זה יאט את ריצת התוכנית?‬ ‫©צבי מלמד‬ ‫‪16‬‬ ‫קביעת הכתובת ‪ -‬שיטה שלישית‬ ‫• עלול היה להאט את התוכנית‪ ,‬לולא הייתה לזה תמיכה בחומרה‬ ‫• ‪ Memory Management Unit – MMU‬מבצעת באופן‬ ‫"אוטומטי" את ההמרה הזאת‬ ‫• משתמשת ברגיסטר‪Base-Register :‬‬ ‫• תוכנו של הרגיסטר הזה – שונה מתהליך לתהליך‪,‬‬ ‫– ולכן מתקבלות כתובות פיזיות שונות עבור אותן כתובות‬ ‫יחסיות‬ ‫– נשמר‪ :‬מרחבי זיכרון נפרדים לכל תהליך‬ ‫• מי יהיה אחראי לעדכן את הרגיסטר הזה?‬ ‫• איך נבטיח שמישהו "אחר" לא ישנה את ערכו – בשוגג או בזדון?‬ ‫©צבי מלמד‬ ‫‪17‬‬ ‫קביעת הכתובת ‪ -‬שיטה שלישית‬ ‫• מאזן רווח והפסד‬ ‫‪ +‬אפילו עוד יותר גמישות במרחב הפיזי של התוכנית‬ ‫• קודם זה איפשר‪ :‬מספר תוכניות ירוצו במקביל‬ ‫• עכשיו בנוסף‪ :‬התוכנית יכולה להיות להיות מוצאת‬ ‫מהזיכרון לפרקי זמן מסוימים‪ ,‬ולהמשיך את ריצתה אחר‬ ‫כך‪ ,‬מאותו מקום‬ ‫– חישוב נוסף בכל פניה לזיכרון‬ ‫– האטה )פוטנציאלית??(‬ ‫תוספת חומרה‪ ,‬שמבצעת את ההמרה – חיבור לאוגר בכל פנייה‬ ‫©צבי מלמד‬ ‫‪18‬‬ ‫טעינת תוכנית – זמנים אופיינים‬ ‫• זמן חיפוש בדיסק – )‪15 msec (milliseconds‬‬ ‫• זמן חביון ‪8 msec – context switch latency time‬‬ ‫• קצב העברת נתונים‪100MB/Sec :‬‬ ‫• נניח שגודל תוכנית הוא ‪  1MB‬זמן ההעברה שלו‪10 msec :‬‬ ‫• סה"כ‪ :‬בערך ~ ‪33msec‬‬ ‫• חריץ הזמן צריך להתייחס לגדלים האילו‬ ‫©צבי מלמד‬ ‫‪19‬‬ ‫שיחלוף ‪ – swapping -‬בעיה פוטנציאלית‬ ‫• ‪ P1‬ממתין לקלט )שיקרא לתוך החוצצים שלו(‬ ‫• ה‪ disk-controller -‬קורא עבורו נתונים מהדיסק‬ ‫• בטרם הסתיימה הפעולה‪ P1 ,‬שוחלף ואת מקומו בזיכרון תפס ‪P2‬‬ ‫• בקר‪-‬הדיסק יודע שעליו להעביר את המידע לכתובות אילו‪ ....‬אבל‬ ‫המידע הזה הוא ‪.passé‬‬ ‫אבחנות ופתרון אפשרי‪:‬‬ ‫• ‪ ‬צרה צרורה‪...‬‬ ‫• ‪ ‬הקלט יתבצע לחוצץ של מערכת ההפעלה ורק כאשר ‪ P1‬יורץ שוב‬ ‫)‪ (swapped in‬נעביר את הנתונים למקום הדרוש בזיכרון‬ ‫©צבי מלמד‬ ‫‪20‬‬ ‫קביעת הכתובת )‪ – (address binding‬שיטה רביעית‬ ‫•‬ ‫נקודת המוצא‪:‬‬ ‫– התוכנית איננה בהכרח רציפה בזיכרון או נטענת במלואה לזיכרון!‬ ‫– מקובלת במערכות של זיכרון מדומה ‪virtual memory‬‬ ‫– הקלה בדרישה הקודמת‪ :‬התוכנית יכלה אמנם לרוץ פעם כשהיא שוכנת‬ ‫באזור א' ופעם אחרת באזור ב' – אבל הייתה חייבת להיות בזיכרון‬ ‫במלואה וברציפות‪.‬‬ ‫•‬ ‫הרעיון המרכזי‪:‬‬ ‫– אם התוכנית היא ספר אנחנו קוראים דף בכל נקודת זמן‬ ‫– בכל פעם נטען לזיכרון רק חלק מהתוכנית – דף אחד‬ ‫– כל עוד התוכנית פונה לכתובת חוקית בדף שנמצא בזיכרון – אשרינו וטוב‬ ‫לנו‬ ‫– אם התוכנית פונה לכתובת חוקית אבל בדף שאיננו בזיכרון‪ ,‬נצעק גוואלט‪...‬‬ ‫©צבי מלמד‬ ‫‪21‬‬ ‫קביעת הכתובת )‪ – (address binding‬שיטה רביעית‬ ‫• הרעיון המרכזי )המשך(‪:‬‬ ‫– לא נצעק גוואלט‪ ...‬ולא באמת ניבהל‪.‬‬ ‫– תופעל רוטינה‪/‬טיפול בשם ‪) page-fault‬חריגת‪-‬דף או שגיאת‪-‬‬ ‫דף(‪ .‬הדף שמכיל את הכתובת הדרושה‪ ,‬יטען לזיכרון‬ ‫– לאן בזיכרון? ‪ ‬למקום פנוי‪...‬‬ ‫– ולכן – התוכנית איננה רציפה בזיכרון אלא מפוזרת על פני‬ ‫מקטעים שונים‬ ‫– אם קודם היה דרוש לנו אוגר בסיס אחד לכל תהליך‪ ,‬עכשיו‬ ‫דרוש לנו )מין של‪ (...‬אוגר בסיס‪ ,‬לכל דף של התוכנית‪.‬‬ ‫• טעינת התוכנית היא דינמית ומתבצעת על ידי ‪relocatable linking‬‬ ‫‪loader‬‬ ‫©צבי מלמד‬ ‫‪22‬‬ ‫קביעת הכתובת – שיטה רביעית‪ :‬זיכרון‬ ‫מדומה‬ ‫• השיטה נקראת זיכרון מדומה‪ ,‬ווירטואלי‪ ,‬למראית עין‪...‬‬ ‫– זיכרון הדיסק למראית עין מתפקד כמו הזיכרון הראשי‪.‬‬ ‫כלומר‪ ,‬הדיסק הוא הרחבה ‪ extension‬של הזיכרון הראשי‬ ‫– הזיכרון של התוכנית הוא רק למראית עין שלם ורציף אבל‬ ‫התוכנית למעשה מפוזרת באזורים שונים בזיכרון‬ ‫• טעינת התוכנית היא דינמית ומתבצעת על ידי ‪relocatable linking‬‬ ‫‪loader‬‬ ‫• התכונות הווירטואליות הנ"ל מסייעות לנו גם בכריכה דינמית של‬ ‫ספריות משותפות‬ ‫©צבי מלמד‬ ‫‪23‬‬ ‫‪shared library linking‬‬ ‫• התכונות הווירטואליות הנ"ל מסייעות לנו גם בכריכה דינמית של ספריות‬ ‫משותפות‬ ‫• ניתן לכרוך פונקציה בשני אופנים‪:‬‬ ‫א‪ .‬כריכה סטאטית – קוד הפונקציה מוסף לקובץ הבינארי של התוכנית‪.‬‬ ‫– הקובץ גדל בהתאמה‪.‬‬ ‫– אין אבחנה מהו מקור הפונקציה – קוד המקור שלנו או מספריה‬ ‫ב‪ .‬כריכה דינאמית – במקום להוסיף את קוד הפונקציה מוסף ‪ – stub‬בדל‪ ,‬שארית‪,‬‬ ‫של הפונקציה האמתית‪.‬‬ ‫– הבדל )כמו בדל סיגריה( – ‪ stub‬הזה מאפשר למערכת ההפעלה לאתר את ה‬ ‫הפונקציה הדרושה )שנמצאת ב‪ DLL -‬או ‪(Shared-Library‬‬ ‫– הקובץ גדל במידה זניחה בלבד‬ ‫– בזמן הריצה מוחזק בזיכרון עותק אחד של הפונקציה הזאת שמשמש‬ ‫תהליכים מרובים‬ ‫– ‪ ‬זמן טעינת התוכנית מתקצר מאוד‬ ‫©צבי מלמד‬ ‫‪24‬‬ ‫הקצאת זיכרון רציפה‬ ‫‪contiguous memory allocation‬‬ ‫• מערכות ריבוי תוכניות בסיסיות שטוענות תכניות בשלמותן‬ ‫לזיכרון‬ ‫• זיכרון ראשי מכיל‬ ‫– מערכת הפעלה‪ ,‬תוכניות שירות שנלוות לה‪.‬‬ ‫– תוכניות המשתמשים‪ :‬במרחב הזיכרון שאיננו שייך למערכת‬ ‫ההפעלה‬ ‫• החלפת הקשר )בין היתר( טוענת את ה‪base/relocation register-‬‬ ‫• כל כתובת לוגית שמייצר המעבד מוספת לערכו על מנת לקבל את‬ ‫הכתובת הפיזית בזיכרון‬ ‫• בדיקת חריגה‪ :‬השוואה לאוגר‪-‬הגבול ‪limit-register‬‬ ‫©צבי מלמד‬ ‫‪25‬‬ ‫עד כאן יום א' ‪15.4.2012‬‬ ‫הקצאת זיכרון רציפה‬ ‫המערכת הזאת‪:‬‬ ‫•‬ ‫מספקת הגנה בפני תוכנית‬ ‫משתמשים שמנסות לגשת לאזור‬ ‫שאסור להן‬ ‫•‬ ‫מאפשר לשנע‪/‬לנייד תוכניות‬ ‫לכתובת התחלה כלשהי על פי‬ ‫הצורך‬ ‫•‬ ‫מאפשרת לזיכרון של מערכת‬ ‫ההפעלה )שנמצא אקטיבית‬ ‫בזיכרון( להשתנות באופן דינמי‬ ‫)לגדול ‪ /‬לקטון(‬ ‫©צבי מלמד‬ ‫‪26‬‬ ‫הקצאת הזיכרון‬ ‫•‬ ‫כיצד יוקצה הזיכרון לתוכניות המשתמשים? )אופן ההקצאה(‬ ‫•‬ ‫פתרון א'‪:‬‬ ‫– נחלק את הזיכרון ל‪ n-‬חלקים‪.‬‬ ‫– החלקים – לא בהכרח בעלי גודל שווה‬ ‫– כל תהליך יקבל את החלק )הקטן ביותר( שבו הוא יכול להסתפק‬ ‫– תוצאה‪:‬‬ ‫• קל למימוש‬ ‫• לכל היותר ‪ n‬תהליכים במקביל )‪ n‬נקבע מראש(‬ ‫• מגבלה על גודל תהליך – כגודל החלק הגדול שקבענו‬ ‫• ‪ ‬לא משתמשים בזה‬ ‫©צבי מלמד‬ ‫‪27‬‬ ‫הקצאת הזיכרון‬ ‫•‬ ‫כיצד יוקצה הזיכרון לתוכניות המשתמשים? )אופן ההקצאה(‬ ‫•‬ ‫פתרון ב'‪:‬‬ ‫– מערכת ההפעלה מנהלת טבלה של שטחי הזיכרון הפנויים ‪ /‬התפוסים‬ ‫– חור )‪ – (hole‬שטח זיכרון פנוי‪ .‬מאפיינים‪ :‬כתובת התחלה וגודל‬ ‫– כשצריך לטעון )‪ (load‬תהליך או לשחלף )‪ – (swap in‬נחפש עבורו חור‬ ‫"מתאים" )‪ (fit‬ורק אם מצאנו חור כזה הפעולה תתבצע‪.‬‬ ‫©צבי מלמד‬ ‫‪28‬‬ ‫הקצאת זיכרון רציפה‬ ‫• כאשר תהליך מסוים מגיע )בקשה להטען( מערכת ההפעלה מחפשת‬ ‫עבורו חור "מתאים" )מספיק גדול(‬ ‫• התהליך נטען בשלמותו לזיכרון רק אם נמצא חור מתאים כזה‪ ,‬ואז‬ ‫הוא מתחיל לרוץ‬ ‫• תהליך ששוחלף לדיסק – באופן דומה – יכול לחזור לרוץ רק אם‬ ‫נמצא עבורו חור גדול דיו‬ ‫©צבי מלמד‬ ‫‪29‬‬ ‫הקצאת זיכרון רציפה – דוגמא‬ ‫• נניח זיכרון בגודל ‪ 5‬יח'‬ ‫• א‪ .‬הגיע ‪ P1‬בגודל ‪ ,2‬והוכנס ל‪0, 1:‬‬ ‫• ב‪ .‬הגיע ‪ P2‬בגודל ‪ ,2‬והוכנס ל‪2, 3 :‬‬ ‫• ג‪ .‬הגיע ‪ P3‬בגודל ‪  3‬עליו להמתין‬ ‫• ד‪ P1 .‬סיים‪ ,‬ושיחרר את יח' ‪ .0, 1‬עדיין לא ניתן להריץ את ‪P3‬‬ ‫– למרות ‪-‬יש דיי מקום עבורו‪ ,‬אבל‪ ,‬המקום הזה איננו רציף‬ ‫• ה‪ .‬נניח שעכשיו מגיע ‪ P4‬בגודל ‪ 2‬יח' – האם נאפשר לו לרוץ?‬ ‫©צבי מלמד‬ ‫‪30‬‬ ‫הקצאת זיכרון רציפה – דוגמא‬ ‫• ה‪ .‬נניח שעכשיו מגיע ‪ P4‬בגודל ‪ 2‬יח' – האם נאפשר לו לרוץ?‬ ‫• תשובה‪:‬‬ ‫– לפי שיקול דעת – מדיניות‪ ...‬אלגוריתם‬ ‫)‪ – (i‬נקבע שלא ניתן להריץ תהליך חדש עד ש‪ P3 -‬יורץ‬ ‫)‪ – (ii‬נאפשר ל‪ P4 -‬לרוץ‬ ‫– ה‪ :tradeoff -‬ניצולת המערכת מול הרעבה )של ‪(p3‬‬ ‫©צבי מלמד‬ ‫‪31‬‬ ‫הקצאת זיכרון רציפה – שיפורים‬ ‫• כאשר תהליך משחרר זיכרון – לבדוק האם הזיכרון סמוך לחור –‬ ‫ואם כן לאחד אותם‬ ‫• מעת לעת לבצע איחוי ‪ defragmentation‬של הזיכרון כדי לאחד‬ ‫חורים‬ ‫– האיחוי – מחייב הזזת תהליכים בזיכרון‬ ‫©צבי מלמד‬ ‫‪32‬‬ ‫הקצאת זיכרון רציפה‬ ‫• השאלה‪ :‬מהו החור המתאים‬ ‫– באופן ספציפי‪ :‬נתונה קבוצת חורים‪ ,‬ובקשה לזיכרון רציף‬ ‫בגודל ‪ n‬תאים‪ .‬איזה חור יוקצה לבקשה?‬ ‫• תשובות אפשריות‪:‬‬ ‫‪– First Fit‬‬ ‫‪– Best Fit‬‬ ‫‪– Worst Fit‬‬ ‫©צבי מלמד‬ ‫‪33‬‬ ‫הקצאת הזיכרון‬ ‫• ‪ : First-Fit‬מחפשים ברשימת החורים‪ ,‬עד שמוצאים את הראשון‬ ‫המתאים )כלומר שהוא מספיק גדול(‪.‬‬ ‫– החלק שאיננו מוקצה הופך להיות "חור" )קטן יותר כמובן(‬ ‫• ‪ : Best-Fit‬מחפשים את החור הכי קטן שיכול להתאים לדרישה‪.‬‬ ‫– השארית – בד"כ תהיה חור במידה קטנה מדי לשימוש‬ ‫– לתחזק את הרשימה ממוינת )זירוז החיפוש(‬ ‫• ‪ :Worst-Fit‬מחפשים את החור הגדול ביותר במערכת‪.‬‬ ‫– מגדיל את הסבירות שהשארית תהייה שמישה‪ .‬מקטין את‬ ‫הבזבוז‬ ‫• מה עדיף?‬ ‫©צבי מלמד‬ ‫‪34‬‬ ‫הקצאת זיכרון רציפה – מה עדיף?‬ ‫• איך נדע?‬ ‫– מעקב אחרי שימוש וסימולציות‬ ‫• ‪ First-Fit‬או ‪ best-fit‬טובים יותר מבחינת זמן וניצולת הזיכרון‬ ‫מאשר ‪Worst-Fit‬‬ ‫• ניצולת זיכרון – שניהם דומים‬ ‫• זמן חיפוש – ‪ first-fit‬עדיף‬ ‫©צבי מלמד‬ ‫‪35‬‬ ‫‪Internal & External Fragmentation‬‬ ‫קיטוע חיצוני ופנימי‬ ‫• כל שלושת השיטות סובלות מקיטוע חיצוני ‪(external‬‬ ‫)‪:fragmentation‬‬ ‫– עם הזמן נוצרים יותר ויותר שטחי זיכרון קטנים ולא‬ ‫שימושיים‬ ‫– מחוץ לשטחים המוקצים לתוכנית – לכן נקרא קיטוע חיצוני‬ ‫• כלל ה‪50% -‬‬ ‫– שטחם של החורים הלא שמישים מגיע לכדי מחציתם של שטחי‬ ‫הזכרון השמישים )= שליש מנפח הזיכרון(‬ ‫– ‪ deframentation‬פותר את בעית הקיטוע החיצוני – במחיר‬ ‫השקעת עבודה לא מבוטלת‬ ‫©צבי מלמד‬ ‫‪36‬‬ ‫‪Internal Fragmentation‬‬ ‫קיטוע פנימי‬ ‫• הקצאת הזכרון איננה ביחידות של "בתים בודדים" )או בדיוק בכמות‬ ‫הנדרשת( – אלא בגושים בגודל ‪ X‬בתים‪.‬‬ ‫• ‪ ‬לכל תהליך מוקצה יותר ממה שדרוש לו בפועל‬ ‫• לא רק ההקצאה הראשונית – אלא בקשות חוזרות להקצאת זיכרון‬ ‫דינמית‪.‬‬ ‫• בממצע – בזבוז של חצי‪-‬בלוק לכל בקשה‪/‬הקצאה‬ ‫• החלק הלא מנוצל "מבוזבז"‬ ‫• בזבוז פנימי לתהליך – ולכן נקרא ‪internal fragmentation‬‬ ‫©צבי מלמד‬ ‫‪37‬‬ ‫חלוקה לדפים ‪Paging‬‬ ‫• במערכות של ‪:virtual memory‬‬ ‫– התוכנית הראשית איננה נטענת לזיכרון בשלמותה‬ ‫– איננה שוכנת בכתובות רציפות בזיכרון‬ ‫• כיצד זה מתבצע?‬ ‫©צבי מלמד‬ ‫‪38‬‬ ‫חלוקה לדפים – ‪Paging‬‬ ‫• קיים הזיכרון הפיזי והזיכרון הלוגי‬ ‫• השאלה‪ :‬כיצד לטעון את הזיכרון הלוגי בזיכרון הפיזי‪.‬‬ ‫– כבר הסכמנו שהתוכנית )הזיכרון הלוגי( יכולה להטען במרוצת‬ ‫חייה‪/‬ריצתה לאזורים שונים בזיכרון הפיזי‪ ,‬וגם‪ ,‬לא חייבת לשכון‬ ‫באופן רצוף‪.‬‬ ‫• נחלק אם כן‪ ,‬גם את הזיכרון הפיזי וגם את הזיכרון הלוגי לחלקים שווי‬ ‫גודל‬ ‫– החלקים בזיכרון הפיזי – נקרא להם ‪) frames‬מסגרות(‬ ‫– החלקים בזיכרון הלוגי – נקרא להם ‪) pages‬דפים(‬ ‫– דף לוגי ‪ page‬כלשהו יטען למסגרת ‪ frame‬פיזית כלשהי ‪ -‬שפנויה‬ ‫ברגע הטעינה‬ ‫– טבלת הדפים תחזיק את המידע – עבור כל דף לוגי מספר ‪ ,#i‬באיזה‬ ‫מסגרת פיזית הוא משוכן כרגע )או‪ :‬האם הדף נמצא בזיכרון(‬ ‫©צבי מלמד‬ ‫‪39‬‬ ‫חלוקה לדפים – ‪Paging‬‬ ‫©צבי מלמד‬ ‫‪40‬‬ ‫חלוקה לדפים – ‪Paging‬‬ ‫• גודל אופייני לדף‪ 2) 2^12 :‬בחזקת ‪ (4096 = 12‬בתים‬ ‫– קיימת שונות רבה‬ ‫• נתייחס לכתובת הדף כמורכבת משני חלקים‪:‬‬ ‫– מספר הדף ‪page-number‬‬ ‫– הסטה בתוך הדף ‪page-offset‬‬ ‫אינדקס לטבלת הדפים‬ ‫הסטה בתוך הדף‬ ‫©צבי מלמד‬ ‫‪41‬‬ ‫חלוקה לדפים – ‪Paging‬‬ ‫• טבלת הדפים דומה‬ ‫לאוגר בסיס ‪ +‬הזזה‬ ‫• במקום אוגר בסיס‬ ‫אחד – טבלה של‬ ‫בסיסים‬ ‫©צבי מלמד‬ ‫‪42‬‬ ‫‪ – Paging‬דוגמא‬ ‫•‬ ‫כתובת פיזית בת ‪ 5‬סיביות‬ ‫•‬ ‫כלומר‪ ,‬מרחב הזיכרון – ‪ 32‬בתים‬ ‫•‬ ‫גודל מסגרת ‪ 4 = frame‬בתים )‪(22‬‬ ‫•‬ ‫מספר מסגרות‪8 :‬‬ ‫•‬ ‫כתובת בתוך המסגרת‪ 2 :‬סיביות‬ ‫•‬ ‫כתובת המסגרת‪ 3 :‬סיביות‬ ‫•‬ ‫הכתובת הלוגית‪011 01 :‬‬ ‫)עשרוני‪ ,13 :‬תוכן‪ :‬האות ‪(n‬‬ ‫•‬ ‫מיפוי לדף לוגי מספר ‪ ,3‬ששוכן‬ ‫במסגרת מספר ‪2‬‬ ‫©צבי מלמד‬ ‫‪43‬‬ ‫מודל מופשט של זיכרון ווירטואלי‬ process X process Y page 1 page 2 page 3 ‫טבלת‬ ‫הדפים של‬ X ‫תהליך‬ page 4 frame 1 frame 2 frame 3 page 5 frame 4 page 6 frame 5 page 7 frame 6 page 8 frame 7 frame 8 frame 9 frame 10 44 page 1 ‫זיכרון פיזי‬ ‫©צבי מלמד‬ ‫טבלת‬ ‫הדפים של‬ Y ‫תהליך‬ page 2 page 3 page 4 page 5 page 6 page 7 page 8 ‫זיכרון דפים – דוגמא עם כתובות בייצוג עשרוני‬ ‫•‬ ‫•‬ ‫•‬ ‫•‬ ‫•‬ ‫•‬ ‫נניח שמרחב הזיכרון של התהליך = כלומר‪ ,‬הזיכרון הלוגי הוא בגודל‬ ‫‪10,000‬‬ ‫ייצוג כתובת בזיכרון הלוגי‪ 4 :‬ספרות עשרוניות‬ ‫נניח גודל דף )= גודל מסגרת( = ‪ .100‬כלומר‪ ,‬כתובת בתוך הדף ‪ 2‬ספרות‬ ‫עשרוניות )החל מ‪ 00-‬ועד ‪(99‬‬ ‫כמות הדפים‪ ,100 :‬ולכן דרושות ‪ 2‬ספרות לייצג את מספר הדף )החל מ‪-‬‬ ‫‪ 00‬ועד ‪(99‬‬ ‫נניח זיכרון פיזי בגודל ‪ .100,000‬כלומר כתובת זיכרון פיזי היא ‪ 5‬ספרות‬ ‫עשרוניות‪ .‬הזיכרון הפיזי מכיל ‪ 1000‬מסגרות‪ ,‬ולכן כתובת מסגרת היא ‪3‬‬ ‫ספרות עשרוניות )החל מ‪ 000-‬ועד ‪(999‬‬ ‫ולכן‪ ,‬טבלת הדפים שמתרגמת מכתובת דף לכתובת מסגרת תכיל ‪100‬‬ ‫כניסות )תאים( בהתאם ל‪ 100-‬דפים‪ ,‬וכל תא יכיל ‪ 3‬ספרות בכדי להצביע‬ ‫על המסגרת המתאימה‬ ‫©צבי מלמד‬ ‫‪45‬‬ ‫זיכרון דפים – דוגמא עם כתובות בייצוג עשרוני‬ ‫זיכרון לוגי בגודל ‪10,000‬‬ ‫כתובת‪ 4 :‬ספרות עשרוניות‬ ‫גודל דף – ‪100‬‬ ‫זיכרון לוגי בגודל ‪100,000‬‬ ‫כתובת‪ 5 :‬ספרות עשרוניות‬ ‫גודל מסגרת ‪100 -frame‬‬ ‫כתובת ‪00000‬‬ ‫’‪‘M‬‬ ‫טבלת דפים בגודל ‪100‬‬ ‫)כלומר‪ 100 :‬כניסות‪/‬כתובות(‬ ‫כל כתובת‪ 2 :‬ספרות עשרוניות‬ ‫’‪‘M‬‬ ‫כתובת ‪5012‬‬ ‫כתובת ‪34512‬‬ ‫‪345‬‬ ‫כתובת ‪99999‬‬ ‫כתובת ‪50‬‬ ‫©צבי מלמד‬ ‫‪46‬‬ ‫חלוקה לדפים – ‪Paging‬‬ ‫משמעויות‪/‬תכונות נוספות של שימוש בדפים‪:‬‬ ‫א‪ -‬קל להזיז דפים בזיכרון‬ ‫ב‪ -‬אין קיטוע חיצוני‬ ‫ג‪ -‬הקיטוע הפנימי הוא מינימלי – בערך חצי דף לתהליך‬ ‫ד‪ -‬כאשר טוענים תהליך ששוחלף‪ ,‬יש לטעון גם את טבלת הדפים שלו‬ ‫)אם גם היא שוחלפה(‬ ‫ה‪ -‬קיים אוגר ייעודי – ‪Page-Table Base Register – PTBR‬‬ ‫שמצביע על כתובתה של טבלת הדפים בזיכרון‪ .‬צריך לעדכן את‬ ‫כתובתה של טבלת הדפים )אם היא שוחלפה לכתובת חדשה(‬ ‫‪ ‬כתוצאה מ‪ -‬ד' ‪ +‬ה' ‪ ‬זמן החלפת הקשר עולה‬ ‫©צבי מלמד‬ ‫‪47‬‬ ‫קביעת גודל הדף‬ ‫• האם נרצה דפים גדולים או קטנים?‬ ‫• מהם השיקולים בעד ‪ /‬נגד ?‬ ‫©צבי מלמד‬ ‫‪48‬‬ ‫קביעת גודל הדף‬ ‫א‪ -‬דפים קטנים‬ ‫‪ ‬קיטוע פנימי קטן‬ ‫‪ ‬טבלת דפים גדולה‬ ‫‪ ‬מעלה את ה‪ overhead-‬של ‪) page-swap‬קריאה‪/‬כתיבה( לדיסק‬ ‫בגלל שמרכיב הזמן כולל גורם קבוע של הזזת ראשים ו‪-‬‬ ‫‪ – context-switch latency‬ומעבירים יחסית מעט נתונים(‬ ‫ב‪ -‬משמעויות נוספות שעוד נכיר בהמשך‪...‬‬ ‫• גודל מקובל של דפים‪ 12-13) 4KB-8KB :‬סיביות(‬ ‫• סולאריס‪ :‬תומכת בדפים בשני גדלים‪8KB, 4MB :‬‬ ‫• לינוקס‪ :‬גודל דף‪) 4KB :‬הפקודה‪( getconf PAGE_SIZE :‬‬ ‫• ‪ :Windows‬גודל דף ‪4KB‬‬ ‫©צבי מלמד‬ ‫‪49‬‬ (‫ )שקף גיבוי‬Free frames before/after allocation 50 ‫©צבי מלמד‬ ‫‪TLB - Translation Look-aside Buffer‬‬ ‫• פניה לזיכרון בתוכנית‪:‬‬ ‫– המעבד יוצר כתובת לוגית‬ ‫– בעזרת טבלת הדפים )שנמצאת בעצמה בזיכרון( מתרגמים את‬ ‫הכתובת הלוגית לכתובת פיזית‬ ‫– הפניה לזיכרון בתוכנית(‬ ‫– ‪ ‬שתי פניות לזיכרון בשביל פניה אחת בתוכנית – כפול זמן‬ ‫• בעייתי! מה גם שמלכתחילה הפניה לזיכרון היא צוואר‬ ‫בקבוק )ביחס לזמני הריצה של המעבד(‬ ‫• פתרון‪TLB :‬‬ ‫©צבי מלמד‬ ‫‪51‬‬ ‫גישות לפתרון בעיות גישה לזיכרון‬ ‫• הבעיות הכרוכות בטבלת הדפים‪:‬‬ ‫א‪ -‬גישה כפולה לזיכרון )מהירות(‬ ‫ב‪ -‬גודל טבלת הדפים )= מספר הדפים ‪ X‬גודל כתובת(‬ ‫• בעיות של גישה לזיכרון נפתרות בדרך כלל על ידי שילוב של שתי‬ ‫גישות‪:‬‬ ‫‪.I‬‬ ‫‪) CACHING‬זיכרון מטמון(‬ ‫‪) Indirection .II‬מיעון עקיף(‬ ‫©צבי מלמד‬ ‫‪52‬‬ ‫‪TLB - Translation Look-aside Buffer‬‬ ‫•‬ ‫•‬ ‫•‬ ‫•‬ ‫שתי פניות לזיכרון בשביל פניה אחת בתוכנית – כפול זמן‬ ‫פתרון‪TLB :‬‬ ‫– זיכרון מטמון‪ ,‬מהיר‪ ,‬יקר‪ ,‬קטן שנמצא על המעבד עצמו‬ ‫– אין צורך לגישה דרך ה‪BUS-‬‬ ‫– מכיל חלק מטבלת הדפים‬ ‫בכדי למצוא כניסה בטבלת הדפים – ראשית נחפש את הכניסה ב‪TLB-‬‬ ‫– אם הצלחנו – מה טוב‪ = Hit ) TLB Hit – ...‬פגיעה(‬ ‫– אם לא הצלחנו‪TLB-Miss :‬‬ ‫• נפנה לטבלת הדפים בזיכרון‬ ‫• נטען את הכניסה הדרושה ל‪TLB-‬‬ ‫‪ – Hit-Ratio‬אחוז ההצלחה בחיפוש ערך ב‪cache/TLB-‬‬ ‫©צבי מלמד‬ ‫‪53‬‬ TLB - Translation Look-aside Buffer CPU p 20 o 10 9 f – ‫המסלול המהיר‬ TLB-Hit 1 Physical Addresses 16 10 9 Virtual Addresses ? Key Value p f f p TLB Page Table 54 o ‫©צבי מלמד‬ –‫המסלול האיטי‬ TLB-Miss ‫‪Paging H/W‬‬ ‫• זיכרון אסוציאטיבי –‬ ‫– כשניתנת ל‪ TLB-‬כתובת‬ ‫מסוימת שדרושה )מספר‬ ‫דף(‪ ,‬מתבצעת במקביל‬ ‫השוואה לכל הכתובות‬ ‫ששמורות אצלו – האם‬ ‫הכתובת שניתנה זהה לאחת‬ ‫מהן‬ ‫• נמצאה התאמה?‬ ‫– כן ‪ ‬תוכן הזיכרון "מוצג"‬ ‫ומשתמשים בו‬ ‫– לא ‪ ‬נדלק ביט ‪TLB-‬‬ ‫‪MISS‬‬ ‫©צבי מלמד‬ ‫‪55‬‬ ‫‪TLB - Translation Look-aside Buffer‬‬ ‫• נניח‪:‬‬ ‫– מרחב כתובת של ‪ 32‬סיביות )‪(4GB‬‬ ‫– דף בגודל ‪ 4096) 2^12‬בתים(‬ ‫– מספר הכניסות בטבלת הדפים‪ = 2^20 :‬מיליון‬ ‫– מספר הכניסות ב‪ – TLB-‬בד"כ בתחום‪64-1024 :‬‬ ‫• מדוע אם כן ה‪ TLB-‬עוזר לנו?‬ ‫– עקרון הלוקליות‪ :‬בנקודות זמן סמוכות התוכנית פונה לכתובות‬ ‫סמוכות‪ ,‬או למספר מצומצם של כתובות סמוכות‪ ,‬שנמצאות במספר‬ ‫מצומצם של דפים‬ ‫– עקרון זה תורם להגדלת ה‪hit-ratio -‬‬ ‫• ‪ – TLB-Reach‬כמות הכתובות שניתן להגיע אליהן בעזרת ה‪TLB-‬‬ ‫– ככל שהדפים גדולים יותר – ה‪ TLB-Reach -‬גדול יותר‬ ‫©צבי מלמד‬ ‫‪56‬‬ ‫‪TLB - Translation Look-aside Buffer‬‬ ‫• באחריות החומרה ‪ -‬הטיפול ב‪) TLB -‬הוספת כניסה שלא נמצאה‬ ‫בו לתוך ה‪ TLB-‬ובמידת הצורך‪ ,‬פינוי כניסה אחרת(‬ ‫• באחריות מערכת ההפעלה – לעדכן את ה‪ TLB-‬כאשר מוציאים דף‬ ‫לדיסק‪ ,‬או מזיזים דף בזיכרון‪ ,‬או תהליך סיים לרוץ )ודפיו התפנו‬ ‫כולם(‬ ‫• בזמן החלפת הקשר – יש לנקות את ה‪TLB-‬‬ ‫– אלא אם כן ה‪ TLB -‬מחזיק את מספר התהליך‪ ,‬ואז הוא יכול‬ ‫להחזיק כתובות של מספר תהליכים בו זמנית‬ ‫©צבי מלמד‬ ‫‪57‬‬ memory access time calculation ...‫נניח‬ • • • • • 58 TLB Hit Ratio = 80% TLB Search = 20 nsec (nano-seconds) Memory access time = 100 nsec (register access time = 0.5 nsec [the main CPU cycle] effective memory access time ‫זמן הגישה לזיכרון בפועל‬ ‫ נ"ש‬100 :‫ללא טבלת דפים‬ ‫ נ"ש‬200 :TLB ‫עם טבלת דפים ללא‬ : TLB+ ‫טבלת דפים‬ 0.80*(20+100) + 0.20*(20+100+100) = 140 nsec – ‫ נ"ש‬122 :‫ נקבל‬:hit ratio= 98% ‫חישוב דומה עבור‬ (0.98*120+0.02*220) ‫©צבי מלמד‬ • • • • ‫‪memory access time calculation‬‬ ‫• החישוב הנ"ל תיאורטי במקצת‪.‬‬ ‫• באופן מעשי ה‪ TLB-‬נמצא כזיכרון מטמון על ה‪CPU-‬‬ ‫• כאשר יש לנו ‪ TLB-Hit‬זמן הגישה לזיכרון הוא מחזור אחד‪ ,‬שכן‬ ‫המידע מה‪ TLB-‬מגיע במרוצת מחזור השעון של המעבד‬ ‫• כאשר יש לנו ‪ TLB-Miss‬זמן הגישה הוא כפול )שתי גישות(‬ ‫©צבי מלמד‬ ‫‪59‬‬ ‫טבלת הדפים והגנות )‪(protection‬‬ ‫• הגנה על הזיכרון מושגת בין‪ ,‬היתר‪ ,‬באמצעות טבלת הדפים‪.‬‬ ‫• בכל כניסה מסומנים מספר ביטים )לצד מספר המסגרת שאליה‬ ‫ממופה הדף(‪:‬‬ ‫– הדף לקריאה‪ ,‬או לכתיבה‪ ,‬או לביצוע )מכיל קוד(‬ ‫– מותרת פניה לדף במצב משתמש או רק במצב גרעין‬ ‫– האם הדף וולידי )בתוקף( – נכלל במרחב הכתובות של התהליך‬ ‫)בלינוקס יתכנו חורים במרחב הכתובות(‬ ‫– האם הדף בזיכרון או בדיסק‬ ‫©צבי מלמד‬ ‫‪60‬‬ ‫מבנה טבלת הדפים‬ ‫• כתובת ‪ 32 -‬סיביות או ‪ 64‬סיביות‬ ‫• נניח – ‪ 32‬סיביות‪ ,‬וגודל דף‪ 2^12 :‬בתים‪  .‬מספר דפים ~מיליון‬ ‫• גודל הטבלה‪) :‬בהנחה‪ 4 ,‬בתים לכל כניסה(‪ 1024 ≈ 4MB :‬דפים‬ ‫• הקצאת גודל זיכרון כזה‪ ,‬ושיהיה רציף – אילוץ קשה‬ ‫– מה גם‪ ...‬שלעתים קרובות חלקים גדולים ממרחב הכתובות‬ ‫כלל אינם בשימוש‬ ‫• השאיפה‪:‬‬ ‫– לארגן את הטבלה בדרך אחרת‪ ,‬חלופית‪.‬‬ ‫– נכיר מספר גישות לכך‬ ‫©צבי מלמד‬ ‫‪61‬‬ ‫מבנה טבלת הדפים‬ ‫• גישה א'‪:‬‬ ‫– להפוך את הטבלה לעץ בעל שתיים או יותר רמות‬ ‫– גישה שכיחה‪ ,‬מקובלת גם בלינוקס – ‪two level paging‬‬ ‫– ‪ 20‬הביטים של "כתובת הדף" מחולקים לשתי קבוצות של ‪ 10‬ביטים‪:‬‬ ‫• ‪ – 10 MS-Bits‬הכניסה בטבלה החיצונית‬ ‫• הטבלה החיצונית מכילה ‪ 2^10‬כניסות‬ ‫• ‪ – 10 LS-Bits‬ה‪ offset -‬בתוך הטבלה החיצונית‪ ,‬משמשת‬ ‫במצביע לטבלה הפנימית‪.‬‬ ‫• בטבלה הפנימית‪ :‬כל כניסה היא בת ‪10‬סיביות שמתאימה ל‪-‬‬ ‫"‪10‬הסיביות הנמוכות" של כתובת הדף‬ ‫• גישה זאת מקובלת במעבדי ‪Pentium‬‬ ‫• גישה זאת נקראת‪) forward-mapped page table:‬תרגום חופשי‪:‬‬ ‫"טבלת דפים עם מיפוי קדימה"(‬ ‫©צבי מלמד‬ ‫‪62‬‬ ‫טבלת הדפים בעלת ‪ 2‬רמות‬ ‫©צבי מלמד‬ ‫‪63‬‬ ‫דוגמא – טבלת מיפוי בשתי רמות‬ ‫מיפוי בשתי רמות מזיכרון‬ ‫ סיביות‬20 ‫ווירטואלי של‬ ‫ סיביות‬16 ‫לזיכרון פיזי של‬ CPU p1 p2 20 PTBR 16 o 10 + Virtual Addresses 1 page table p1 f + p2 First-Level Page Table 64 Physical Addresses ‫©צבי מלמד‬ Second-Level Page Table Memory f 16 o 10 ‫”‪can we use “forward mapped page table‬‬ ‫?‪for 64 bit addressing‬‬ ‫• השיטה איננה יעילה‪/‬סבירה עבור כתובות של ‪ 64‬ביט‪ ...‬בגלל ריבוי‬ ‫הרמות‪.‬‬ ‫• נכיר שיטות אחרות‬ ‫©צבי מלמד‬ ‫‪65‬‬