चित्रों में MMU (भाग 1)

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

वर्चुअल मेमोरी वाले सिस्टम में चार मुख्य गुण होते हैं:

1. उपयोगकर्ता प्रक्रियाएं एक दूसरे से अलग हो जाती हैं और, मरते हुए, पूरे सिस्टम को नहीं खींचती हैं
2. उपयोगकर्ता प्रक्रियाएँ भौतिक मेमोरी से अलग-थलग हैं, अर्थात, वे नहीं जानते कि आपके पास वास्तव में कितनी रैम है और यह किन पते पर स्थित है।
3. वर्चुअल मेमोरी के बिना ऑपरेटिंग सिस्टम की तुलना में ऑपरेटिंग सिस्टम बहुत अधिक जटिल है
4. आप पहले से कभी नहीं जान सकते कि अगले प्रोसेसर कमांड को निष्पादित करने में कितना समय लगेगा।

उपरोक्त सभी वस्तुओं के लाभ स्पष्ट हैं: लाखों टेढ़े-मेढ़े अनुप्रयोग प्रोग्रामर, ऑपरेटिंग सिस्टम के हजारों डेवलपर्स और एम्बेडरों की एक बेशुमार संख्या इस तथ्य के लिए आभासी स्मृति के लिए आभारी है कि वे अभी भी व्यवसाय में हैं।

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

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

MMU डिवाइस

अब चलो व्यापार के लिए नीचे उतरो। वर्चुअल मेमोरी सपोर्ट के बिना ऐसा प्रोसेसर कैसा दिखता है:

इस तरह के एक प्रोसेसर के लिए कार्यक्रम में उपयोग किए जाने वाले सभी पते वास्तविक हैं, "भौतिक", अर्थात्। प्रोग्रामर, प्रोग्राम को लिंक करते हुए, यह पता होना चाहिए कि रैम किस पते पर स्थित है। यदि आपके पास 640 kB RAM है, तो 0x02300000-0x0239FFFF पते पर मैप किया जाता है, तो आपके प्रोग्राम के सभी पते इस क्षेत्र में आने चाहिए।

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

यह व्यवस्था बहुत सुविधाजनक है - एमएमयू का उपयोग केवल तब किया जाता है जब प्रोसेसर मेमोरी तक पहुंचता है (उदाहरण के लिए, जब कैश की याद आती है), और शेष समय का उपयोग नहीं किया जाता है और ऊर्जा की बचत होती है। इसके अलावा, इस मामले में, एमएमयू का प्रोसेसर के प्रदर्शन पर लगभग कोई प्रभाव नहीं है।

यहाँ MMU के अंदर क्या होता है:

यह प्रक्रिया इस तरह दिखती है:

1. प्रोसेसर MMU इनपुट के लिए एक आभासी पता इनपुट करता है
2. यदि MMU को बंद कर दिया जाता है या यदि वर्चुअल पता अनट्रेंड एरिया में आता है, तो भौतिक पता बस वर्चुअल के बराबर हो जाता है
3. यदि MMU चालू होता है और वर्चुअल एड्रेस ब्रॉडकास्ट एरिया में आता है, तो एड्रेस ट्रांसलेट किया जाता है, यानी वर्चुअल पेज की संख्या को संबंधित भौतिक पेज की संख्या से बदल दिया जाता है (पेज के भीतर ऑफसेट समान है):
   
   • यदि वांछित वर्चुअल पेज नंबर के साथ रिकॉर्ड टीएलबी में है, तो भौतिक पेज नंबर उससे लिया जाता है
   • यदि टीएलबी में कोई आवश्यक प्रविष्टि नहीं है, तो आपको इसके लिए पृष्ठ तालिकाओं में देखना होगा कि ऑपरेटिंग सिस्टम अनारक्षित रैम क्षेत्र में स्थित है (ताकि पिछली मिस के प्रसंस्करण में कोई टीएलबी मिस न हो)। खोज को हार्डवेयर और सॉफ्टवेयर दोनों में लागू किया जा सकता है - एक पेज को गलती वाले अपवाद हैंडलर के माध्यम से। पाया गया प्रविष्टि टीएलबी में जोड़ा जाता है, जिसके बाद टीएलबी मिस होने वाली कमांड को फिर से निष्पादित किया जाता है।

आइए एक साधारण उदाहरण का उपयोग करते हुए टीएलबी को देखें। मान लीजिए कि हमारे पास ए और बी दो प्रक्रियाएं हैं, उनमें से प्रत्येक अपने स्वयं के पते स्थान पर मौजूद है और शून्य से 0xFFFFFFFF तक के सभी पते इसके लिए उपलब्ध हैं। प्रत्येक प्रक्रिया का पता स्थान 256 बाइट्स के पृष्ठों में विभाजित है (मैंने यह संख्या छत से ली है - आमतौर पर पृष्ठ का आकार एक किलोबाइट से कम नहीं होता है), अर्थात। प्रत्येक प्रक्रिया के पहले पृष्ठ का पता शून्य है, दूसरा 0x100 है, तीसरा 0x200 है, और इसलिए अंतिम पेज 0xFFFFFF00 पर है। बेशक, इस प्रक्रिया को इसके लिए उपलब्ध सभी स्थान पर कब्जा करने की आवश्यकता नहीं है। हमारे मामले में, प्रक्रिया A में केवल दो पृष्ठ हैं, और प्रक्रिया B में तीन हैं। इसके अलावा, पृष्ठों में से एक दोनों प्रक्रियाओं के लिए आम है।

हमारे पास 1536 बाइट्स ऑफ फिजिकल मेमोरी भी हैं, जो 256 बाइट्स के छह पेजों में विभाजित हैं (वर्चुअल और फिजिकल मेमोरी का पेज साइज हमेशा एक जैसा होता है), और यह मेमोरी प्रोसेसर के फिजिकल एड्रेस स्पेस में एड्रेस 0x40000000 (खैर, यह इसी तरह से प्रोसेसर को मिलाया गया) से मैप की जाती है।



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

उसके बाद, ऑपरेटिंग सिस्टम प्रोसेस ए को निलंबित कर सकता है और प्रोसेस बी को शुरू कर सकता है। यह भौतिक पते 0x40000000 पर अपना पहला पेज लोड करेगा। हालाँकि, प्रक्रिया A के विपरीत, Process B की पहली कमांड अब TLB मिस नहीं होगी, क्योंकि TLB में शून्य वर्चुअल एड्रेस के लिए पहले से ही एक प्रविष्टि है। परिणामस्वरूप, प्रोसेस B प्रोसेस A को प्रोसेस करना शुरू कर देगा! दिलचस्प बात यह है कि यह ठीक इसी तरह से है कि ARM9 प्रोसेसर, जिसे व्यापक रूप से संकीर्ण घेरे में जाना जाता है, ने काम किया।

इस समस्या को हल करने का सबसे आसान तरीका संदर्भों को स्विच करते समय टीएलबी को अमान्य करना है, अर्थात, टीएलबी में सभी प्रविष्टियों को अमान्य के रूप में चिह्नित करें। यह एक अच्छा विचार नहीं है, जैसा कि:

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

अधिक जटिल तरीका सभी कार्यक्रमों को लिंक करना है ताकि वे प्रोसेसर के वर्चुअल एड्रेस स्पेस के विभिन्न हिस्सों का उपयोग करें। उदाहरण के लिए, प्रक्रिया ए निचले हिस्से (0x0-0x7FFFFFFF) पर कब्जा कर सकती है, और प्रक्रिया बी उच्चतम (0x80000000-0xFFFFFFFF) पर कब्जा कर सकती है। जाहिर है, इस मामले में, एक दूसरे से प्रक्रियाओं के अलगाव की कोई बात नहीं है, लेकिन यह विधि कभी-कभी एम्बेडेड सिस्टम में उपयोग की जाती है। सामान्य-उद्देश्य प्रणालियों के लिए, स्पष्ट कारणों के लिए, यह उपयुक्त नहीं है।

तीसरा तरीका दूसरे का विकास है। कई प्रक्रियाओं के बीच वर्चुअल प्रोसेसर एड्रेस स्पेस के चार गीगाबाइट साझा करने के बजाय, इसे क्यों नहीं बढ़ाया जाए? 256 बार कहें? और प्रक्रिया अलगाव सुनिश्चित करने के लिए, यह सुनिश्चित करने के लिए कि हर प्रक्रिया में अभी भी चार गीगाबाइट रैम उपलब्ध है?
यह बहुत सरल निकला। आभासी पते को 40 बिट्स तक विस्तारित किया गया था, जिसमें प्रत्येक प्रक्रिया के लिए उच्चतम आठ बिट्स अद्वितीय थे और एक विशेष रजिस्टर में दर्ज किए गए - प्रक्रिया पहचानकर्ता (पीआईडी)। संदर्भ को स्विच करते समय, ऑपरेटिंग सिस्टम पीआईडी ​​को नए मूल्य के साथ अधिलेखित कर देता है (प्रक्रिया स्वयं अपने पीआईडी ​​को बदल नहीं सकती है)।
यदि हमारी प्रक्रिया A के लिए PID एक है, और Process B के लिए यह दो है, तो वर्चुअल पते जो प्रक्रियाओं के दृष्टिकोण से समान हैं, उदाहरण के लिए 0x00000100, क्रमशः प्रोसेसर के दृष्टिकोण से अलग होना चाहिए - 0x0100000100 और 0x0200000100।
जाहिर है, हमारे TLB में अब 24-बिट नहीं, बल्कि 32-बिट वर्चुअल पेज नंबर होने चाहिए। सुविधा के लिए, उच्च आठ बिट्स को एक अलग फ़ील्ड में संग्रहीत किया जाता है - एड्रेस स्पेस आइडेंटिफ़ायर (एएसआईडी)।

अब, जब प्रोसेसर MMU इनपुट के लिए एक वर्चुअल एड्रेस की आपूर्ति करता है, तो TLB को VPN और ASID के संयोजन का उपयोग करके खोजा जाता है, इसलिए प्रक्रिया B का पहला कमांड TLB के पिछले अमान्यकरण के बिना भी एक पेज त्रुटि का कारण होगा।



आधुनिक प्रोसेसर में, ASIDs अक्सर या तो आठ-बिट या 16-बिट होते हैं। उदाहरण के लिए, सभी ARM प्रोसेसर में MMUs के साथ ARM11, ASID आठ-बिट से शुरू होता है, और ARMv8 आर्किटेक्चर में 16-बिट ASID के लिए समर्थन जोड़ा जाता है।

वैसे, यदि प्रोसेसर वर्चुअलाइजेशन का समर्थन करता है, तो एएसआईडी के अलावा इसमें वीएसआईडी (वर्चुअल एड्रेस स्पेस आइडेंटिफिकेटर) भी हो सकता है, जो प्रोसेसर के वर्चुअल एड्रेस स्पेस को और विस्तारित करता है और उस पर चलने वाली वर्चुअल मशीन की संख्या होती है।

ASID को जोड़ने के बाद भी, ऐसी स्थितियाँ हो सकती हैं जब आपको एक या एक से अधिक रिकॉर्ड या पूरे TLB को अमान्य करने की आवश्यकता हो:

1. यदि कोई भौतिक पृष्ठ RAM से डिस्क पर लोड किया गया है - क्योंकि यह पृष्ठ पूरी तरह से अलग पते पर मेमोरी में वापस लोड किया जा सकता है, अर्थात, वर्चुअल पता नहीं बदलेगा, लेकिन भौतिक एक बदल जाएगा
2. यदि ऑपरेटिंग सिस्टम ने प्रक्रिया के पीआईडी ​​को बदल दिया है - क्योंकि एएसआईडी अलग होगा
3. यदि ऑपरेटिंग सिस्टम ने प्रक्रिया पूरी कर ली है

यह MMU के बारे में कहानी को पूरा कर सकता है, अगर एक बारीकियों के लिए नहीं। तथ्य यह है कि एमएमयू के अलावा, प्रोसेसर और रैम के बीच कैश मेमोरी भी है।

जो लोग भूल गए हैं कि कैश मेमोरी क्या है और यह कैसे काम करती है, यहां और वहां ज्ञान को ताज़ा कर सकती है।

एक उदाहरण के लिए हम 64 बाइट्स में कैशे की लाइन (या आप की तरह - कैशे की एक लाइन) के आकार के साथ एक किलोबाइट के आकार में दो-चैनल (2-वे) कैश लेंगे। अब यह मायने नहीं रखता है कि यह कमांड कैश, डेटा कैश या संयुक्त कैश है या नहीं। चूंकि मेमोरी पेज का आकार 256 बाइट्स होता है, इसलिए प्रत्येक पेज पर चार कैश लाइनें रखी जाती हैं।

चूंकि कैश प्रोसेसर और एमएमयू के बीच है, इसलिए यह स्पष्ट है कि केवल वर्चुअल एड्रेस इंडेक्सिंग और टैग तुलना के लिए उपयोग किए जाते हैं (भौतिक पते केवल एमएमयू के आउटपुट में दिखाई देते हैं)। अंग्रेजी में, इस तरह के कैश को वर्चुअली इंडेक्सेड, वर्चुअली टैगेड कैश (VIVT) कहा जाता है।

VIVT कैश में ओमोनिमा चेसिस में परजीवी

वास्तव में, समस्या क्या है? एक और उदाहरण पर विचार करने का समय आ गया है। समान दो प्रक्रियाएँ A और B लें:

1. मान लें कि प्रक्रिया A को पहले निष्पादित किया गया है। निष्पादन के दौरान, एक-एक करके, इस प्रक्रिया के लिए आदेशों या डेटा वाली पंक्तियों को कैश मेमोरी (लाइनें 0-4) में लोड किया जाता है।
2. ऑपरेटिंग सिस्टम प्रोसेस A को रोकता है और प्रोसेस B को कंट्रोल ट्रांसफर करता है।
3. सिद्धांत रूप में, इस समय, प्रोसेसर को प्रोसेस बी के पहले पृष्ठ से पहली पंक्ति को कैश में लोड करना चाहिए और वहां से कमांड निष्पादित करना शुरू करना चाहिए। वास्तव में, प्रोसेसर कैश इनपुट के लिए एक आभासी पता 0x0 भेजता है, जिसके बाद कैश जवाब देता है कि इसे कुछ भी लोड करने की आवश्यकता नहीं है, क्योंकि वांछित लाइन पहले से ही कैश है।
4. प्रोसेस B, प्रक्रिया A के कोड को खुश करने के लिए शुरू होता है।

रुको, आप कहते हैं, हमने सिर्फ ASID को TLB में जोड़कर इस समस्या को हल किया है? और हमारे पास जो कैश है वह MMU तक है - जब कोई कैश मिस नहीं होता है, तो हम MMU को भी नहीं देखते हैं, और हमें नहीं पता कि ASID क्या है।



यह VIVT कैश के साथ पहली समस्या है - तथाकथित होमोनियम, जब एक ही वर्चुअल एड्रेस को विभिन्न भौतिक पते पर मैप किया जा सकता है (हमारे मामले में, वर्चुअल एड्रेस 0x00000000 को प्रक्रिया A के लिए भौतिक पते 0x40000500 पर मैप किया जाता है और प्रोसेस B के लिए 0x40000000)।

समलैंगिकों की समस्या को हल करने के लिए कई विकल्प हैं:

1. कैश को फ्लश करें (कैश फ्लश, यानी, मेमोरी में वापस कैश की बदली हुई सामग्री लिखें) और संदर्भ स्विच करते समय कैश को अमान्य करें (अर्थात, लाइनों को अमान्य के रूप में चिह्नित करें)। यदि हमारे पास कमांड और डेटा का एक अलग कैश है, तो कमांड कैश को अमान्य करने के लिए पर्याप्त सरल है (अर्थात, सभी लाइनों को खाली के रूप में चिह्नित करें), क्योंकि कमांड कैश केवल-प्रोसेसर के लिए पढ़ा जाता है और इसे फ्लश करने का कोई मतलब नहीं है
2. ASID को कैश टैग में जोड़ें
3. हर बार जब हम कैश में जाते हैं, तब MMU से संपर्क करें, और न केवल तब जब कोई गलती होती है - तो हम ASID के साथ PID की तुलना करने के लिए मौजूदा तर्क का उपयोग कर सकते हैं। विदाई, ऊर्जा की बचत और गति!

आपको कौन सा विकल्प पसंद है? मैं शायद दूसरे के बारे में सोचूंगा। ARM9 और VIVT कैश के साथ कुछ अन्य प्रोसेसर में, एक तीसरा लागू किया जाता है।

VIVT कैश में समानार्थी

यदि कैश में होमोन्मेस एकमात्र समस्या थी, तो प्रोसेसर डेवलपर्स दुनिया के सबसे खुशहाल लोग होंगे। एक दूसरी समस्या है - समानार्थी शब्द, उपनाम, जब कई आभासी पते एक ही भौतिक पते पर मैप किए जाते हैं।
चलो अपनी मेढ़ों की प्रक्रियाओं ए और बी पर वापस जाते हैं मान लीजिए कि हमने समलैंगिकों की समस्या को कुछ सभ्य तरीके से हल किया है, क्योंकि कैश को हर बार फ्लैश करना वास्तव में बहुत महंगा है!
तो:

1. सबसे पहले, प्रोसेस ए को निष्पादित किया जाता है - लाइन्स A0 - A3 और जनरल लाइन 0 को एक के बाद एक कैश में लोड किया जाता है (याद रखें कि ए और बी प्रक्रियाओं में एक पेज आम है)
2. फिर ऑपरेटिंग सिस्टम, फ्लैश कैश नहीं, संदर्भ स्विच करता है
3. प्रोसेस बी चलना शुरू हो जाता है। लाइनों B0 - B7 को कैश में लोड किया जाता है।
4. अंत में, प्रोसेस बी कॉमन लाइन को संदर्भित करता है। 0. यह लाइन पहले से ही प्रोसेस ए द्वारा कैश में लोड की गई है, लेकिन प्रोसेसर को इसके बारे में पता नहीं है, क्योंकि यह कैश में एक अलग वर्चुअल एड्रेस के तहत दिखाई देता है (मुझे याद है कि VIVT कैश में कोई भौतिक पते नहीं हैं
5. एक कैश मिस होता है। वर्चुअल एड्रेस 0x00000200 को फिजिकल एड्रेस 0x40000200 पर ट्रांसलेट किया जाता है, और जनरल लाइन 0 को कैश में लोड किया जाता है। इसका स्थान आभासी पते से निर्धारित होता है - और पता 0x00000200 सूचकांक 0 (बिट्स 8-6) और टैग 0x1 (बिट्स 31-9) से मेल खाता है।
6. चूंकि इंडेक्स 0 के साथ सेट में दोनों चैनल पहले से ही कब्जे में हैं, इसलिए आपको पहले से लोड की गई लाइनों (A0 या B0) में से एक को बाहर फेंकना होगा। LRU (कम से कम हाल ही में प्रयुक्त) एल्गोरिथ्म का उपयोग करते हुए, कैश लाइन A0 को फेंकता है और इसके स्थान पर जनरल लाइन 0 को जोड़ता है।

नतीजतन, भौतिक स्मृति का एक ही टुकड़ा दो अलग-अलग स्थानों में कैश में है। अब, यदि दोनों प्रक्रियाएं अपनी प्रतिलिपि बदलती हैं, और फिर इसे स्मृति में रखना चाहती हैं, तो उनमें से एक को आश्चर्य होगा।
स्पष्ट रूप से, यह समस्या केवल डेटा कैश के लिए या संयुक्त कैश के लिए प्रासंगिक है (फिर से, कमांड कैश केवल-पढ़ने के लिए है), लेकिन होमोनिम्स समस्या की तुलना में इसे हल करना अधिक कठिन है:

1. सबसे आसान तरीका है, जैसा कि हमने पहले ही पता लगाया है, कैश को हर बार संदर्भ को स्विच करने के लिए फ्लश करना है (वैसे, समानार्थी का मुकाबला करने के लिए, समलैंगिकों के विपरीत, आपको कैश को अमान्य करने की आवश्यकता नहीं है)। हालाँकि, सबसे पहले, यह महंगा है, और दूसरी बात, यह मदद नहीं करेगा अगर प्रक्रिया अपने पते के स्थान में एक ही भौतिक पृष्ठ की कई प्रतियां रखना चाहती है
2. आप हार्डवेयर में समानार्थक शब्द पहचान सकते हैं:
   
   • या, प्रत्येक मिस के साथ, पूरे कैश के माध्यम से चलाएं, प्रत्येक टैग के लिए पते का अनुवाद करें और प्राप्त किए गए भौतिक पतों की तुलना उस पते के प्रसारण के दौरान प्राप्त किए गए जो मिस का कारण बने (और जीवित मृत को ईर्ष्या करें!)
   • या प्रोसेसर के लिए एक नया ब्लॉक जोड़ें जो रिवर्स ट्रांसलेशन करेगा - भौतिक पते का वर्चुअल में रूपांतरण। उसके बाद, प्रत्येक मिस के लिए, उस पते का अनुवाद करें जो इसके कारण था, और फिर इस भौतिक पते को आभासी में बदलने के लिए रिवर्स अनुवाद का उपयोग करें और कैश में सभी टैग के साथ तुलना करें। हंसमुख होकर, आप बेहतर तरीके से कैश फ्लश करेंगे!
3. तीसरा तरीका पर्यायवाची शब्दों के पर्यायवाची से बचना है। उदाहरण के लिए, साझा किए गए पृष्ठों का उपयोग न करें। या, प्रोग्राम को साझा किए गए पते स्थान पर फिर से लिंक करना शुरू करें।

जुटना और VIVT कैश

लेकिन यह सब नहीं है! हम अपने स्वयं के एल 1 कैश के साथ मल्टी-कोर प्रोसेसर के युग में रहते हैं, जो असंगत बनने का प्रयास करते हैं। कैशे प्रोटोकॉल का आविष्कार कैश असंगति का मुकाबला करने के लिए किया गया था। हालांकि, यह बुरा है: प्रोटोकॉल बाहरी बस की निगरानी करते हैं, और इस पर पते क्या हैं? शारीरिक! और कैश वर्चुअल का उपयोग करता है।

फिर यह कैसे पता करें कि किस कैश लाइन को मेमोरी में तत्काल लिखा जाना चाहिए, क्योंकि यह पड़ोसी प्रोसेसर के लिए इंतजार कर रहा है? लेकिन किसी भी तरह से। शायद यह एक अलग लेख के लिए एक विषय है।

VIVT कैश के फायदे

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

लगभग बीस साल पहले अधिक प्लसस थे। VIVT कैश उन दिनों सक्रिय रूप से उपयोग किया जाता था जब एक बाहरी MMU को एक अलग चिप के रूप में उपयोग किया जाता था। इस तरह के एमएमयू तक पहुंच प्रोसेसर के समान चिप पर स्थित एमएमयू की तुलना में अधिक समय लेती है। लेकिन चूंकि एमएमयू तक पहुंच केवल कैश मिस के मामले में आवश्यक थी, इसने हमें स्वीकार्य सिस्टम प्रदर्शन सुनिश्चित करने की अनुमति दी।

क्या करें?

, VIVT- (, - — ). : - - MMU. , , . . — .