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

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

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

प्रश्न

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

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

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

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

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

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

उत्तर

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

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

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

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

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

1 बी = 8 बी 

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

1 GB = 10 ^ 9 B = 1 000 000 000 B 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 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 छंटनी की जाती है) 

• 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 बार संबोधित कर सकता है?) (अनुमानित byWolframAlpha).

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

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

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

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

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

पेजिंग

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

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

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

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

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

विभाजन

खैर, यह एक पेजिंग के समान है। इसका उपयोग इंटेल 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 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 बाइट्स था).

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

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

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