मेमोरी संगठन

पिछले सप्ताह के दौरान, उन्होंने दो बार लोगों को समझाया कि स्मृति के साथ काम x86 में कैसे आयोजित किया गया था, तीसरी बार समझाने के लिए नहीं, उन्होंने यह लेख लिखा था।

और इसलिए, स्मृति के संगठन को समझने के लिए, आपको कुछ बुनियादी अवधारणाओं को जानना होगा, जैसे रजिस्टर, स्टैक, और इसी तरह। मैं अपनी उंगलियों पर भी यह समझाने की कोशिश करूंगा, लेकिन बहुत संक्षेप में क्योंकि यह इस लेख के लिए विषय नहीं है। तो चलिए शुरू करते हैं।

जैसा कि आप जानते हैं, प्रोग्रामर जब प्रोग्राम लिखते हैं, तो वह किसी भौतिक पते के साथ काम नहीं करता है, लेकिन केवल एक तार्किक के साथ। और फिर अगर वह असेंबलर में प्रोग्रामिंग कर रहा है। उसी सी में, प्रोग्रामर से मेमोरी सेल पहले से ही अपनी सुविधा के लिए, पॉइंटर्स द्वारा छिपाए जाते हैं, लेकिन यदि आप मोटे तौर पर एक पॉइंटर का उपयोग करते हैं, तो यह मेमोरी के तार्किक पते का एक और प्रतिनिधित्व है, और जावा में कोई पॉइंटर्स नहीं हैं, यह वास्तव में एक महत्वपूर्ण भाषा है। हालांकि, एक सक्षम प्रोग्रामर को यह जानने से नहीं रोका जाएगा कि स्मृति को सामान्य स्तर पर कैसे व्यवस्थित किया जाता है। सामान्य तौर पर, मैं प्रोग्रामर से बहुत दुखी हूं जो नहीं जानते कि मशीन कैसे काम करती है, आमतौर पर ये जावा प्रोग्रामर और अन्य php लोग होते हैं जो बेसबोर्ड के नीचे योग्यता रखते हैं।

ठीक है, दुख के बारे में पर्याप्त है, चलो व्यापार के लिए नीचे उतरो।
32-बिट प्रोसेसर के प्रोग्राम मोड के पता स्थान पर विचार करें (64 बिट्स के लिए, सभी सादृश्य द्वारा)
इस मोड के एड्रेस स्पेस में 2 ^ 32 मेमोरी सेल होंगे, जिनकी संख्या 0 से 2 ^ 32-1 तक होगी।
प्रोग्रामर इस मेमोरी के साथ काम करता है, अगर उसे एक वैरिएबल को परिभाषित करने की आवश्यकता होती है, तो वह सिर्फ यह कहता है कि एड्रेस के साथ मेमोरी सेल में ऐसा और ऐसा डेटा टाइप होगा, जबकि प्रोग्रामर को खुद नहीं पता होगा कि यह सेल किस नंबर पर कुछ लिखेगा। :
int data = 10;
कंप्यूटर इसे इस तरह से समझेगा: आपको स्टॉप की संख्या के साथ कुछ सेल लेने और इसमें पूर्णांक 10 डालने की आवश्यकता है। इसके अलावा, आप सेल 18894 का पता भी नहीं जान पाएंगे, यह आपसे छिपा होगा।

सब कुछ ठीक होगा, लेकिन सवाल यह उठता है कि कंप्यूटर इस मेमोरी सेल को कैसे देखता है, क्योंकि हमारी मेमोरी अलग हो सकती है:
स्तर 3 कैश
स्तर 2 कैश
1 कैश स्तर
मुख्य स्मृति
हार्ड ड्राइव

ये सभी अलग-अलग यादें हैं, लेकिन कंप्यूटर आसानी से ढूंढता है जिसमें हमारा एक अंतर डेटा चर है।
यह समस्या प्रोसेसर के साथ ऑपरेटिंग सिस्टम द्वारा हल की गई है।
आगे का सारा लेख इस पद्धति के विश्लेषण के लिए समर्पित होगा।

X86 आर्किटेक्चर स्टैक का समर्थन करता है।

एक स्टैक प्लेटों के ढेर के सिद्धांत द्वारा आयोजित रैम का एक निरंतर क्षेत्र है, आप स्टैक के बीच से प्लेट नहीं ले सकते हैं, आप केवल शीर्ष ले सकते हैं और एक प्लेट डाल सकते हैं, आप केवल स्टैक के शीर्ष पर भी जा सकते हैं।
स्टैक के साथ काम करने के लिए प्रोसेसर में, विशेष मशीन कोड आयोजित किए जाते हैं, जिनमें से कोडांतरक mnemonics इस तरह दिखते हैं:

धक्का देना
स्टैक पर ऑपरेंड को धक्का देता है

पॉप ऑपरेंड
स्टैक के ऊपर से मान खींचता है और इसे अपने ऑपरेंड में डालता है

मेमोरी में स्टैक ऊपर से नीचे की ओर बढ़ता है, जिसका अर्थ है कि जब आप इसमें कोई मूल्य जोड़ते हैं, तो स्टैक के शीर्ष का पता कम हो जाता है, और जब आप इसमें से निकालते हैं, तो स्टैक के शीर्ष का पता बढ़ जाता है।

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

आइए अधिक विस्तार से विचार करें मुख्य कार्यक्रम रजिस्टर। इनमें आठ 32-बिट सामान्य-उद्देश्य रजिस्टर शामिल हैं: EAX, EBX, ECX, EDX, EBP, ESI, EDI, ESP
डेटा को रजिस्टर में रखने के लिए, या डेटा को मेमोरी सेल में रजिस्टर से हटाने के लिए, मूव कमांड का उपयोग किया जाता है:

चाल बाज, १०
नंबर 10 को ईगल रजिस्टर में लोड करता है।

मूव डेटा, ईबेक्स
डेटा मेमोरी लोकेशन में ईबेक्स रजिस्टर में निहित संख्या को कॉपी करता है।

ईएसपी रजिस्टर में स्टैक के शीर्ष का पता होता है।
सामान्य प्रयोजन रजिस्टर के अलावा, मुख्य कार्यक्रम रजिस्टर में छह 16-बिट सेगमेंट रजिस्टर शामिल हैं: सीएस, डीएस, एसएस, ईएस, एफएस, जीएस, ईएफएलएजीएस, ईआईपी
EFLAGS बिट्स को दर्शाता है, तथाकथित झंडे, जो प्रोसेसर की स्थिति को दर्शाते हैं या पिछले कमांड की प्रगति को दर्शाते हैं।
ईआईपी रजिस्टर में अगले कमांड का पता होता है जिसे प्रोसेसर द्वारा निष्पादित किया जाएगा।
मैं FPU रजिस्टरों को पेंट नहीं करूंगा, क्योंकि हमें उनकी आवश्यकता नहीं होगी। इसलिए, रजिस्टरों और स्टैक के बारे में हमारी छोटी विषयांतरता, हम स्मृति के संगठन में वापस जाते हैं।

जैसा कि आपको याद है, लेख का उद्देश्य तार्किक स्मृति को भौतिक स्मृति में बदलने के बारे में बात करना है, वास्तव में अभी भी एक मध्यवर्ती चरण है और पूर्ण श्रृंखला इस तरह दिखती है:

तार्किक पता -> रैखिक (आभासी) -> भौतिक

संपूर्ण रैखिक पता स्थान खंडित है। प्रत्येक प्रक्रिया के पता स्थान में कम से कम तीन खंड होते हैं:
कोड खंड। (हमारे कार्यक्रम से आदेश हैं जिन्हें निष्पादित किया जाएगा।)
डेटा खंड। (इसमें डेटा है, अर्थात, चर)
स्टैक सेगमेंट जो मैंने ऊपर लिखा था।

रेखीय पते की गणना सूत्र द्वारा की जाती है:

रैखिक पता = खंड का आधार पता (चित्र में यह खंड की शुरुआत है) + ऑफसेट

कोड खंड

कोड खंड का आधार पता सीएस रजिस्टर से लिया गया है। कोड सेगमेंट के लिए ऑफसेट मूल्य EIP रजिस्टर से लिया जाता है, जो निर्देश के पते को संग्रहीत करता है, जिसके बाद इस कमांड के आकार से EIP मान बढ़ाया जाता है। यदि कमांड 4 बाइट्स पर कब्जा कर लेता है, तो ईआईपी मूल्य 4 बाइट्स से बढ़ जाता है और अगले निर्देश को इंगित करेगा। यह सब एक प्रोग्रामर की भागीदारी के बिना स्वचालित रूप से किया जाता है।
हमारी मेमोरी में कई कोड सेगमेंट हो सकते हैं। हमारे मामले में, वह अकेला है।

डेटा खंड

डेटा को डीएस, ईएस, एफएस, जीएस में रजिस्टरों में लोड किया जाता है
इसका मतलब है कि डेटा सेगमेंट 4x तक हो सकता है। हमारी तस्वीर में वह अकेला है।
डेटा खंड के भीतर ऑफसेट निर्देश के ऑपरेंड के रूप में निर्दिष्ट किया गया है। डिफ़ॉल्ट रूप से, डीएस रजिस्टर बिंदुओं वाले खंड का उपयोग किया जाता है। दूसरे सेगमेंट में प्रवेश करने के लिए यह आवश्यक है कि इसे सीधे सेगमेंट रिप्लेसमेंट प्रीफिक्स कमांड में दर्शाया जाए।

ढेर खंड

उपयोग किए गए स्टैक सेगमेंट को एसएस रजिस्टर के मूल्य द्वारा निर्धारित किया जाता है।
इस खंड के भीतर ऑफसेट ईएसपी रजिस्टर द्वारा दर्शाया गया है, जो आपको याद करते हुए स्टैक के शीर्ष पर इंगित करता है।
स्मृति में सेगमेंट एक-दूसरे को ओवरलैप कर सकते हैं, इसके अलावा, सभी सेगमेंट का आधार पता मेल खा सकता है, उदाहरण के लिए, शून्य पर। इस तरह के एक पतित मामले को स्मृति का रैखिक प्रतिनिधित्व कहा जाता है। आधुनिक प्रणालियों में, स्मृति को आमतौर पर इस तरह से व्यवस्थित किया जाता है।

अब एक खंड के आधार पते की परिभाषा पर विचार करें, मैंने लिखा है कि वे रजिस्टरों में निहित हैं एसएस, डीएस, सीएस, लेकिन यह पूरी तरह से सच नहीं है, उनमें कुछ 16-बिट चयनकर्ता शामिल हैं, जो खंडों के एक निश्चित विवरण को इंगित करता है जिसमें आवश्यक पता पहले से ही संग्रहीत है।

यह चयनकर्ता जैसा दिखता है, उसके तेरह बिट्स में डिस्क्रिप्टर तालिका में डिस्क्रिप्टर इंडेक्स होता है। यह गणना करना मुश्किल नहीं होगा कि तालिका में वर्णनकर्ताओं की अधिकतम संख्या 2 ^ 13 = 8192 है।
सामान्य तौर पर, दो प्रकार के डिस्क्रिप्टर टेबल होते हैं: जीडीटी और एलडीटी। पहले को ग्लोबल डिस्क्रिप्टर टेबल कहा जाता है, यह हमेशा सिस्टम में केवल एक होता है, इसका शुरुआती पता, या इसके शून्य डिस्क्रिप्टर का पता 48-बिट सिस्टम रजिस्टर GDTR में संग्रहीत होता है। और जिस समय से यह प्रणाली शुरू होती है, तब तक यह नहीं बदलता है और स्वैप में भाग नहीं लेता है।
लेकिन विवरणकर्ताओं के मूल्य भिन्न हो सकते हैं। यदि चयनकर्ता में TI बिट शून्य है, तो प्रोसेसर बस GDT में जाता है और इंडेक्स द्वारा वांछित डिस्क्रिप्टर की खोज करता है, जिसकी मदद से वह इस सेगमेंट तक पहुंचता है।
अब तक, सब कुछ सरल था, लेकिन अगर टीआई 1 है तो इसका मतलब है कि एलडीटी का उपयोग किया जाएगा। इन तालिकाओं में से कई हैं, लेकिन चयनकर्ता जिसे LDTR सिस्टम रजिस्टर में लोड किया गया है, जो कि GDTR के विपरीत बदल सकता है, फिलहाल इसका उपयोग किया जाएगा।
चयनकर्ता इंडेक्स एक ऐसे डिस्क्रिप्टर की ओर इशारा करता है जो अब सेगमेंट के आधार पते को इंगित नहीं करता है, लेकिन उस मेमोरी को जिसमें स्थानीय डिस्क्रिप्टर टेबल संग्रहीत है, अधिक सटीक रूप से इसका शून्य तत्व है। खैर, फिर सब कुछ जीडीटी के साथ ही है। इस प्रकार, ऑपरेशन के दौरान, स्थानीय तालिकाओं को आवश्यकतानुसार बनाया और नष्ट किया जा सकता है। LDT में अन्य LDT के लिए विवरण नहीं हो सकते हैं।
तो हम जानते हैं कि प्रोसेसर डिस्क्रिप्टर को कैसे मिलता है, और देखें कि चित्र में इस डिस्क्रिप्टर में क्या निहित है:
डिस्क्रिप्टर्स में 8 बाइट्स होते हैं।
बिट्स 15-39 और 56-63 में इस खंड के विवरणकर्ता द्वारा वर्णित एक रेखीय आधार पता होता है। मुझे एक रैखिक पता खोजने के लिए हमारे सूत्र की याद दिलाएं:

रैखिक पता = आधार पता + ऑफसेट

इस सरल ऑपरेशन के साथ, प्रोसेसर वांछित रैखिक मेमोरी पते तक पहुंच सकता है।
डिस्क्रिप्टर के अन्य बिट्स पर विचार करें, सेगमेंट सीमा या सीमा बहुत महत्वपूर्ण है, इसमें 0-15 से 20-बिट मान और 48-51 बिट्स हैं। सीमा खंड के आकार को निर्धारित करती है। डेटा और कोड सेगमेंट के लिए, अंतराल में स्थित सभी पते उपलब्ध हैं:

[बेस; आधार + सीमा)

55 जी-बिट्स (ग्रैन्युलैरिटी) के आधार पर, सीमा को बाइट्स में एक शून्य बिट मूल्य पर मापा जा सकता है और फिर अधिकतम सीमा 1 एमबी होगी, या 1 के मूल्य पर, सीमा को पृष्ठों द्वारा मापा जाता है, जिनमें से प्रत्येक 4 केबी है। और ऐसे सेगमेंट का अधिकतम आकार 4GB होगा।
स्टैक सेगमेंट के लिए, सीमा सीमा में होगी:

(आधार + सीमा; क्रिया)

वैसे, मुझे आश्चर्य है कि डिस्क्रिप्टर में आधार और सीमा इतनी क्यों फट गई है। तथ्य यह है कि x86 प्रोसेसर विकसित रूप से विकसित हुए और 286x विवरणकों के समय कुल 8 बिट्स थे, उच्चतम 2 बाइट्स आरक्षित थे, ठीक है, बाद के प्रोसेसर मॉडल में, विवरणकर्ता भी थोड़ी गहराई में वृद्धि के साथ बढ़ गए, लेकिन पिछड़ी संगतता को बनाए रखने के लिए, हमें संरचना को छोड़ना होगा क्योंकि यह है ।
"वर्टेक्स" पते का मान 54 डी बिट पर निर्भर करता है, यदि यह 0 है, तो वर्टेक्स 0xFFF (64kb-1) है, यदि D बिट 1 है, तो वर्टेक्स 0xFFFFFFFF (4GB-1) है
41-43 बिट्स के साथ, खंड प्रकार एन्कोडेड है।
000 - डेटा खंड, केवल पढ़ा
001 - डेटा खंड, पढ़ना और लिखना
010 - स्टैक सेगमेंट, केवल पढ़ा
011 - स्टैक सेगमेंट, पढ़ना और लिखना
100 - कोड सेगमेंट, केवल निष्पादन
101- कोड खंड, पढ़ना और निष्पादन
110 - दास कोड खंड, केवल निष्पादन
111 - दास कोड खंड, निष्पादन और केवल पढ़ा

44 एस बिट्स यदि 1 के बराबर है तो हैंडल रैम के वास्तविक सेगमेंट का वर्णन करता है, अन्यथा एस बिट्स का मूल्य 0 है।

सबसे महत्वपूर्ण बिट उपस्थिति की 47 वीं पी बिट है। यदि बिट 1 है, तो इसका मतलब है कि खंड या स्थानीय डिस्क्रिप्टर तालिका रैम में भरी हुई है, यदि यह बिट 0 है, तो इसका मतलब है कि यह खंड रैम में नहीं है, यह हार्ड डिस्क पर है, एक बाधा उत्पन्न होती है, प्रोसेसर का एक विशेष मामला चल रहा है, एक विशेष केस हैंडलर लॉन्च किया गया है। जो हार्ड डिस्क से वांछित सेगमेंट को मेमोरी में लोड करता है, यदि P बिट 0 है, तो डिस्क्रिप्टर के सभी फ़ील्ड अपना अर्थ खो देते हैं और उनमें सेवा की जानकारी संग्रहीत करने के लिए स्वतंत्र हो जाते हैं। हैंडलर पूरा होने के बाद, P बिट 1 पर सेट हो जाता है, और डिस्क्रिप्टर फिर से एक्सेस हो जाता है, जिसका सेगमेंट पहले से ही मेमोरी में है।

यह तार्किक पते के रैखिक में रूपांतरण को समाप्त करता है, और मुझे लगता है कि यह ब्रेक के लायक है। अगली बार मैं रेखीय से भौतिक में रूपांतरण का दूसरा भाग बताऊंगा।
और मुझे यह भी लगता है कि किसी फ़ंक्शन के लिए तर्क पारित करने के बारे में, और मेमोरी में वेरिएबल रखने के बारे में यह थोड़ी सी बात है, ताकि वास्तविकता के साथ किसी प्रकार का संबंध हो, क्योंकि मेमोरी में वेरिएबल रखना पहले से ही प्रत्यक्ष है, कुछ आपको काम से निपटना है, और न केवल क्या एक सिस्टम प्रोग्रामर के लिए कुछ सैद्धांतिक निर्माण। लेकिन यह समझने के बिना कि स्मृति कैसे काम करती है, यह समझना असंभव है कि ये बहुत चर स्मृति में कैसे संग्रहीत किए जाते हैं।
सामान्य तौर पर, मुझे आशा है कि यह तब तक दिलचस्प था जब तक हम फिर से नहीं मिलते।