कितने मेमोरी पते मेरे कंप्यूटर होल्ड में रैम कर सकते हैं?

कंप्यूटिंग अनुभव के सतह के स्तर को देखने के लिए इसे कुछ मजेदार लगता है, और अन्य दिनों में आंतरिक कामकाज में सही करने के लिए यह मजेदार है। आज हम कंप्यूटर मेमोरी की संरचना पर एक नज़र डाल रहे हैं और आप राम की छड़ी में कितना सामान पैक कर सकते हैं।

आज का प्रश्न और उत्तर सत्र सुपरयूज़र के सौजन्य से आता है - स्टैक एक्सचेंज का एक उपखंड, जो कि क्यू एंड ए वेब साइटों का एक समुदाय-संचालित समूह है।

प्रश्न

सुपरयूज़र रीडर जोहान स्मोहन इस बात से जूझ रहा है कि प्रोसेसर के प्रकार और मेमोरी साइज कुल मिलाकर कितने पते पर काम करते हैं। वह लिखता है:

32-बिट प्रोसेसर और 1 जीबी रैम के साथ कितने मेमोरी पते मिल सकते हैं और 64-बिट प्रोसेसर के साथ कितने?

मुझे लगता है कि यह कुछ इस तरह है:

1GB RAM को 32 बिट्स 4 बिट्स (?) द्वारा विभाजित किया गया है ताकि मेमोरी एड्रेस की संख्या प्राप्त हो सके?

मैंने विकिपीडिया पर पढ़ा कि एक 64 बिट प्रोसेसर की तुलना में 1 मेमोरी एड्रेस 32 बिट्स चौड़ा या 4 ऑक्टेट (1 ऑक्टेट = 8 बिट्स) होता है, जहाँ 1 मेमोरी एड्रेस या 1 पूर्णांक 64 बिट्स चौड़ा या 8 ऑक्टेट होता है। लेकिन यह नहीं पता कि मैं इसे सही तरीके से समझ पाया या नहीं।

ये प्रकार के प्रश्न हैं जो रात में जिज्ञासु को शांत रख सकते हैं। जोहान के प्रत्येक काल्पनिक सिस्टम के तहत कितने पते उपलब्ध हैं?

उत्तर

SuperUser योगदानकर्ता Gronostaj राम द्वारा विभाजित और उपयोग किए जाने के तरीके में कुछ अंतर्दृष्टि प्रदान करता है:

संक्षिप्त जवाब: उपलब्ध पतों की संख्या उन लोगों के बराबर है:

• बाइट्स में मेमोरी का आकार
• सबसे बड़ा अहस्ताक्षरित पूर्णांक जिसे CPU के मशीन शब्द में सहेजा जा सकता है

उपरोक्त उत्तर और स्पष्टीकरण:

मेमोरी में बाइट्स (B) होते हैं। प्रत्येक बाइट में 8 बिट (बी) होते हैं।

1 बी = 8 बी

1 जीबी रैम वास्तव में 1 GiB (जिबाइट, गीगाबाइट नहीं) है। अंतर यह है:

1 जीबी = 10 ^ 9 बी = 1 000 000 000 बी
1 GiB = 2 ^ 30 B = 1 073 741 824 B

स्मृति के हर बाइट का अपना पता होता है, चाहे वह सीपीयू मशीन शब्द कितना ही बड़ा क्यों न हो। उदाहरण के लिए। इंटेल 8086 सीपीयू 16-बिट था और यह बाइट्स द्वारा मेमोरी को संबोधित कर रहा था, इसलिए आधुनिक 32-बिट और 64-बिट सीपीयू करें। यह पहली सीमा का कारण है - आपके पास मेमोरी बाइट से अधिक पते नहीं हो सकते।

मेमोरी पता बस बाइट्स की एक संख्या है जो सीपीयू को मेमोरी की शुरुआत से उस तक पहुंचने के लिए छोड़ना पड़ता है जिसकी उसे तलाश है।

• पहले बाइट को एक्सेस करने के लिए 0 बाइट्स को छोड़ना पड़ता है, इसलिए पहले बाइट का पता 0 है।
• दूसरे बाइट को एक्सेस करने के लिए इसे 1 बाइट को छोड़ना पड़ता है, इसलिए इसका पता 1 है।
• (इत्यादि…)
• अंतिम बाइट का उपयोग करने के लिए, सीपीयू 1073741823 बाइट्स को छोड़ देता है, इसलिए इसका पता 1073741823 है।

अब आपको यह जानना होगा कि वास्तव में 32-बिट का क्या मतलब है। जैसा कि मैंने पहले उल्लेख किया है, यह एक मशीन शब्द का आकार है।

मशीन शब्द संख्याओं (रैम, कैश या आंतरिक रजिस्टरों में) को रखने के लिए उपयोग किए जाने वाले मेमोरी सीपीयू की मात्रा है। 32-बिट सीपीयू संख्या को धारण करने के लिए 32 बिट्स (4 बाइट्स) का उपयोग करता है। मेमोरी पते भी संख्याएँ हैं, इसलिए 32-बिट CPU पर मेमोरी एड्रेस में 32 बिट्स होते हैं।

अब इस बारे में सोचें: यदि आपके पास एक बिट है, तो आप इस पर दो मान बचा सकते हैं: 0 या 1. एक और बिट जोड़ें और आपके पास चार मान हैं: 0, 1, 2, 3. तीन बिट्स पर, आप आठ मानों को सहेज सकते हैं : 0, 1, 2… 6, 7. यह वास्तव में एक बाइनरी सिस्टम है और यह इस तरह काम करता है:

बाइनरी दशमलव
0 0000
१ ०००१
२ ००१०
३ ००११
4 0100
5 0101
6 0110
7 0111
8 1000
९ १००१
10 1010
११ १०१ १
12 1100
१३ ११०१
१४ १११०
१५ ११११

यह बिल्कुल सामान्य जोड़ की तरह काम करता है, लेकिन अधिकतम अंक 1 है, न कि 9. दशमलव 0 है 0000 , तो आप 1 जोड़ें और प्राप्त करें 0001 , एक बार फिर से जोड़ें और आपके पास है 0010 । यहाँ क्या हुआ दशमलव के साथ होने जैसा है 09 और एक जोड़ना: आप 9 से 0 बदलते हैं और अगले अंक बढ़ाते हैं।

ऊपर दिए गए उदाहरण से आप देख सकते हैं कि हमेशा एक अधिकतम मूल्य होता है जिसे आप संख्या में बिट्स की निरंतर संख्या के साथ रख सकते हैं - क्योंकि जब सभी बिट्स 1 होते हैं और आप 1 से मूल्य बढ़ाने की कोशिश करते हैं, तो सभी बिट्स 0 हो जाएंगे, इस प्रकार ब्रेकिंग नंबर। इसे पूर्णांक ओवरफ़्लो कहा जाता है और यह उपयोगकर्ताओं और डेवलपर्स दोनों के लिए कई अप्रिय समस्याओं का कारण बनता है।

11111111 = 255
+ 1
-----------
  100000000 = 0 (9 बिट यहाँ, इसलिए 1 छंटनी की गई है)

• 1 बिट के लिए सबसे बड़ा मूल्य 1 है,
• 2 बिट्स - 3,
• 3 बिट्स - 7,
• 4 बिट्स - 15

सबसे बड़ी संभव संख्या हमेशा 2 ^ N-1 होती है, जहां N बिट की संख्या होती है। जैसा कि मैंने पहले कहा, एक मेमोरी एड्रेस एक संख्या है और इसका अधिकतम मूल्य भी है। यही कारण है कि मशीन शब्द का आकार उपलब्ध मेमोरी पतों की संख्या के लिए भी एक सीमा है - कभी-कभी आपका सीपीयू अधिक संख्याओं को संसाधित नहीं कर सकता है ताकि अधिक मेमोरी को संबोधित किया जा सके।

इसलिए 32 बिट्स पर आप नंबर 0 से 2 ^ 32-1 तक रख सकते हैं, और यह 4 के 294 967 295 हैं। यह 1 जीबी रैम में सबसे बड़े पते से अधिक है, इसलिए आपके विशिष्ट मामले में रैम की मात्रा सीमित कारक होगी।

32-बिट सीपीयू के लिए रैम की सीमा सैद्धांतिक रूप से 4 जीबी (2 ^ 32) है और 64-बिट सीपीयू के लिए यह 16 ईबी (एक्साबाइट, 1 ईबी = 2 ^ 30 जीबी) है। दूसरे शब्दों में, 64-बिट सीपीयू पूरे इंटरनेट ... 200 बार;) (द्वारा अनुमानित) को संबोधित कर सकता है वोल्फरम अल्फा ).

हालांकि, वास्तविक-जीवन ऑपरेटिंग सिस्टम में 32-बिट सीपीयू 3 गीगाबाइट रैम के बारे में पता कर सकते हैं। ऑपरेटिंग सिस्टम की आंतरिक वास्तुकला की वजह से - कुछ पते अन्य उद्देश्यों के लिए आरक्षित हैं। आप इस तथाकथित के बारे में अधिक पढ़ सकते हैं विकिपीडिया पर 3 जीबी बैरियर । आप इस सीमा को उठा सकते हैं भौतिक पता एक्सटेंशन .

मेमोरी एड्रेसिंग के बारे में बोलते हुए, कुछ चीजें हैं जिनका मुझे उल्लेख करना चाहिए: अप्रत्यक्ष स्मृति , विभाजन तथा पेजिंग .

अप्रत्यक्ष स्मृति

जैसा कि @Daniel R Hicks ने एक अन्य उत्तर में बताया, OSes वर्चुअल मेमोरी का उपयोग करते हैं। इसका अर्थ यह है कि अनुप्रयोग वास्तव में वास्तविक मेमोरी पतों पर काम नहीं करते हैं, लेकिन ओएस द्वारा प्रदान किए गए हैं।

यह तकनीक ऑपरेटिंग सिस्टम को रैम से कुछ डेटा को तथाकथित पेजफाइल (विंडोज) या स्वैप (* NIX) में स्थानांतरित करने की अनुमति देती है। HDD RAM की तुलना में कुछ कम धीमी है, लेकिन यह शायद ही कभी एक्सेस किए गए डेटा के लिए एक गंभीर समस्या नहीं है और यह OS को आपके द्वारा वास्तव में स्थापित किए गए अनुप्रयोगों से अधिक RAM प्रदान करने की अनुमति देता है।

पेजिंग

अब तक हम जो बात कर रहे थे उसे फ्लैट एड्रेसिंग स्कीम कहा जाता है।

पेजिंग एक वैकल्पिक संबोधन योजना है जो अधिक मेमोरी को संबोधित करने की अनुमति देती है जो आप आमतौर पर फ्लैट मॉडल में एक मशीन शब्द के साथ कर सकते हैं।

4-अक्षरों के शब्दों से भरी किताब की कल्पना कीजिए। बता दें कि प्रत्येक पेज पर 1024 नंबर हैं। एक नंबर को संबोधित करने के लिए, आपको दो बातें जाननी होंगी:

• उस शब्द को मुद्रित करने वाले पृष्ठ की संख्या।
• उस पृष्ठ पर कौन सा शब्द है जिसे आप खोज रहे हैं

अब यह ठीक है कि आधुनिक x86 CPU स्मृति को कैसे संभालते हैं। इसे 4 KiB पृष्ठों (प्रत्येक में 1024 मशीन शब्द) में विभाजित किया गया है और उन पृष्ठों की संख्याएँ हैं। (वास्तव में पेज 4 MiB बड़े या 2 MiB भी हो सकते हैं पीएई )। जब आप मेमोरी सेल को संबोधित करना चाहते हैं, तो आपको उस पेज में पेज नंबर और एड्रेस की आवश्यकता होती है। ध्यान दें कि प्रत्येक मेमोरी सेल को एक जोड़ी संख्याओं द्वारा संदर्भित किया जाता है, जो कि विभाजन के मामले में नहीं होगा।

विभाजन

खैर, यह एक पेजिंग के समान है। इसका उपयोग इंटेल 8086 में किया गया था, सिर्फ एक उदाहरण के लिए। पतों के समूहों को अब मेमोरी सेगमेंट कहा जाता है, न कि पेज। अंतर खंडों को ओवरलैप कर सकता है, और वे बहुत ओवरलैप करते हैं। उदाहरण के लिए 8086 पर 4096 विभिन्न खंडों से अधिकांश मेमोरी सेल उपलब्ध थे।

एक उदाहरण:

मान लें कि हमारे पास 8 बाइट्स की मेमोरी है, 4 जी बाइट को छोड़कर सभी ज़ीरो जो 255 के बराबर है।

फ्लैट मेमोरी मॉडल के लिए चित्रण:

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

पृष्ठांकित स्मृति के लिए चित्रण 4-बाइट पृष्ठों के साथ:

PAGE0
 _____
| 0 |
| 0 |
| 0 | पृष्ठ 1
| 255 | _____
 ----- | 0 |
        | 0 |
        | 0 |
        | 0 |
         -----

खंडित स्मृति के लिए चित्रण 4-बाइट सेगमेंट के साथ 1 द्वारा स्थानांतरित:

सेग ०
 _____ SEG १
| 0 | _____ SEG 2
| 0 | | 0 | _____ SEG 3
| 0 | | 0 | | 0 | _____ SEG 4
| 255 | | 255 | | 255 | | 255 | _____ सेगमेंट 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 बाइट्स था)।

विभाजन के बारे में क्या बुरा है, यह जटिल है (लेकिन मुझे लगता है कि आप पहले से ही जानते हैं कि;) क्या अच्छा है, यह है कि आप मॉड्यूलर प्रोग्राम बनाने के लिए कुछ चतुर तकनीकों का उपयोग कर सकते हैं।

उदाहरण के लिए, आप कुछ मॉड्यूल को एक सेगमेंट में लोड कर सकते हैं, फिर दिखाते हैं कि यह सेगमेंट वास्तव में छोटा है (सिर्फ मॉड्यूल को पकड़ने के लिए पर्याप्त छोटा है), फिर पहले सेगमेंट को चुनें जो उस छद्म से छोटा नहीं है और अगला लोड करता है मॉड्यूल, और इतने पर। मूल रूप से, इस तरह से आपको क्या मिलता है यह चर आकार के पृष्ठ हैं।

---

स्पष्टीकरण में कुछ जोड़ना है? टिप्पणियों में ध्वनि बंद। अन्य टेक-सेवी स्टैक एक्सचेंज उपयोगकर्ताओं से अधिक जवाब पढ़ना चाहते हैं? पूरी चर्चा धागा यहाँ देखें .