כמה כתובות זיכרון האם זיכרון RAM במחשב שלי להחזיק?

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

מפגש השאלות והתשובות של היום מגיע אלינו באדיבות SuperUser - חלוקה מחודשת של Stack Exchange, קיבוץ מונחה על ידי הקהילה של אתרי אינטרנט של Q & A.

השאלה

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

כמה כתובות זיכרון ניתן לקבל עם מעבד 32 סיביות ו 1GB RAM וכמה עם מעבד 64 סיביות?

אני חושב שזה משהו כזה:

1GB של RAM מחולק או 32 סיביות 4 סיביות (?) כדי לקבל את מספר כתובות זיכרון?

קראתי בוויקיפדיה כי 1 כתובות זיכרון הן 32 סיביות או 4 octets (1 octet = 8 סיביות), בהשוואה למעבד 64 סיביות שבו 1 כתובות זיכרון או מספר שלם אחד הוא 64 סיביות או 8 octets. אבל לא יודע אם הבנתי את זה נכון.

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

התשובה

SuperUser התורם Gronostaj מציע כמה תובנה כיצד RAM מחולק ומנוצל:

תשובה קצרה: מספר הכתובות הזמינות שווה לקטן מבין אלה:

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

תשובה ארוכה והסבר של האמור לעיל:

זיכרון מורכב של בתים (B). כל בייט מורכב מ -8 סיביות (b).

1 B = 8 b 

1 GB של RAM הוא למעשה 1 GiB (gibibyte, לא ג 'יגה). ההבדל הוא:

1 GB = 10 ^ 9 B = 1 000 000 000 B 1 GiB = 2 ^ 30 B = 1 073 741 824 B 

לכל בית זיכרון יש כתובת משלו, לא משנה כמה גדולה המילה מכונה CPU. למשל. מעבד Intel 8086 היה 16 סיביות והוא פונה בזיכרון של בתים, כך גם המעבדים המודרניים של 32 סיביות ו- 64 סיביות. זו הסיבה לגבול הראשון - לא ניתן לקבל יותר כתובות מאשר בתים של זיכרון.

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

• כדי לגשת לבית הראשון יש לדלג 0 בתים, אז כתובת בית הראשון הוא 0.
• כדי לגשת לבית השני יש לדלג 1 בתים, ולכן הכתובת שלה היא 1.
• (וכן הלאה… )
• כדי לגשת לבית האחרון, CPU מדלג על 1073741823 בתים, כך שכתובתו היא 1073741823.

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

המילה Machine היא כמות הזיכרון המשמשת את ה- CPU כדי להחזיק מספרים (ב- RAM, מטמון או רישומים פנימיים). מעבד 32 סיביות משתמש ב- 32 סיביות (4 בתים) כדי להחזיק מספרים. כתובות זיכרון הן גם מספרים, כך שבמעבד של 32 סיביות, כתובת הזיכרון מורכבת מ -32 סיביות.

עכשיו לחשוב על זה: אם יש לך קצת, אתה יכול לשמור שני ערכים על זה: 0 או 1. הוסף עוד אחד ויש לך ארבעה ערכים: 0, 1, 2, 3. על שלושה סיביות, אתה יכול לשמור שמונה ערכים : 0, 1, 2 ... 6, 7. זוהי למעשה מערכת בינארית וזה עובד ככה:

בינארי עשרוני 0 0000 1 0001 2 0010 3 0011 4 0100 5 0101 6 0110 7 0111 8 1000 9 1001 10 1010 11 1011 12 1100 13 1101 14 1110 15 1111 

זה עובד בדיוק כמו תוספת רגילה, אבל הספרה המקסימלית היא 1, לא 9. עשרוני 0 הוא 0000, אז אתה מוסיף 1 ולקבל 0001, להוסיף אחד שוב ויש לך 0010. ללא שם: מה שעולה כאן כמו עם עשרוני 09 והוספת אחת: תשנה את 9 עד 0 ותגדיל את הספרה הבאה.

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

 11111111 = 255 + 1 ----------- 100000000 = 0 (9 סיביות כאן, אז 1 הוא trimmed) 

• עבור 1 bit הערך הגדול ביותר הוא 1,
• 2 סיביות - 3,
• 3 סיביות - 7,
• 4 סיביות - 15

המספר הגדול ביותר האפשרי הוא תמיד 2 ^ N-1, כאשר N הוא מספר הביטים. כפי שאמרתי קודם, כתובת זיכרון היא מספר ויש לה גם ערך מקסימלי. לכן גודל המכונה של מכונה הוא גם מגבלה על מספר כתובות זיכרון זמין - לפעמים המעבד שלך פשוט לא יכול לעבד מספרים גדולים מספיק כדי לטפל בזיכרון יותר.

אז על 32 סיביות אתה יכול לשמור מספרים מ 0 עד 2 ^ 32-1, וזה 4 294 967 295. זה יותר מאשר את הכתובת הגדולה ביותר 1 GB RAM, אז במקרה הספציפי שלך RAM יהיה הגורם המגביל.

מגבלת ה- RAM עבור מעבד 32 סיביות היא תיאורטית 4 GB (2 ^ 32) ו 64-bit מעבד זה 16 EB (exabytes, 1 EB = 2 ^ 30 GB). במילים אחרות, מעבד 64 סיביות יכול כתובת האינטרנט כולו ... 200 פעמים;) (מוערך על ידי wolframAlpha).

עם זאת, במערכות ההפעלה האמיתית מערכות 32-bit CPUs יכול כתובת על 3 GiB של RAM. זה בגלל הארכיטקטורה הפנימית של מערכת ההפעלה - כמה כתובות שמורות למטרות אחרות. אתה יכול לקרוא עוד על זה שנקרא 3 מחסום GB על ויקיפדיה. תוכל להרים את המגבלה הזו באמצעות הרחבת כתובת פיזית.

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

זיכרון וירטואלי

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

טכניקה זו מאפשרת למערכת ההפעלה להעביר נתונים מסוימים מ RAM ל שנקרא דף (Windows) או החלפת (* NIX). HDD הוא כמה magnitudes לאט יותר מאשר RAM, אבל זה לא בעיה רצינית עבור גישה לנתונים לעתים נדירות וזה מאפשר OS לספק יישומים יותר RAM ממה שאתה באמת מותקן.

החלפה

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

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

תארו לעצמכם ספר מלא במילות 4 אותיות. נניח שיש 1024 מספרים בכל דף. כדי לענות על מספר, אתה צריך לדעת שני דברים:

• מספר העמוד שבו מודפסת המילה.
• איזו מילה בדף זה היא זו שאתה מחפש.

עכשיו זה בדיוק איך מודרני x86 CPUs לטפל בזיכרון. זה מחולק ל 4 דפי KiB (1024 מכונת מילים כל) ודפים אלה יש מספרים. (דפים למעשה יכול להיות גם 4 MiB גדול או 2 MiB עם PAE). כאשר אתה רוצה כתובת תא זיכרון, אתה צריך את מספר הדף ואת כתובת בדף זה. שים לב כי כל תא זיכרון הוא הפניה בדיוק זוג אחד של מספרים, זה לא יהיה המקרה עבור פילוח.

פילוח

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

דוגמה:

נניח שיש לנו 8 בייטים של זיכרון, כל אפסים מחזיקים למעט בית 4 אשר שווה ל 255.

איור עבור דגם זיכרון שטוח:

 _____ | 0 | | 0 | | 0 | | 255 | 0 | | 0 | | 0 | | 0 | ----- 

איור עבור זיכרון מעומעם עם דפי 4 בתים:

 PAGE0 _____ | 0 | | 0 | | 0 | PAGE1 | 255 _____ ----- | 0 | | 0 | | 0 | | 0 | ----- 

איור עבור זיכרון מקוטע עם מקטעים של 4 בתים שונו ב- 1:

 SEG 0 _____ SEG 1 | 0 | _____ SEG 2 | 0 | | 0 | _____ SEG 3 | 0 | | 0 | | 0 | _____ SEG 4 | 255 | 255 | 255 | 255 _____ SEG 5 ----- | 0 | | 0 | | 0 | | 0 | _____ SEG 6 ----- | 0 | | 0 | | 0 | | 0 | _____ SEG 7 ----- | 0 | | 0 | | 0 | | 0 | _____ ----- | 0 | | 0 | | 0 | | 0 | ----- ----- ----- ----- 

כפי שאתה יכול לראות, בית 4 יכול להיות מטופל בארבע דרכים: (פונה 0)

• קטע 0, קיזוז 3
• מקטע 1, קיזוז 2
• קטע 2, קיזוז 1
• קטע 3, לקזז 0

זה תמיד אותו תא זיכרון.

ביישומים אמיתיים מקטעים מועברים על ידי יותר מ 1 בתים (עבור 8086 זה היה 16 בתים).

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

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

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