कैश मेमोरी का रहस्य, या 10 टीमों पर 1000 घड़ी चक्र खर्च करने का तरीका

प्रोसेसर कैश के बारे में बहुत कुछ लिखा गया है, जिसमें हैबे भी शामिल है , लेकिन सामान्य शब्दों में अधिक से अधिक। मैं आपके ध्यान में लाता हूं कि वास्तविक जीवन में कैश कैसे काम करता है।

एक उदाहरण के रूप में, मैं एक सिंगल-लेवल कैश के साथ और MMU के बिना 32-बिट हार्वर्ड RISC प्रोसेसर पर आधारित चिप पर एक साधारण प्रणाली ले जाऊंगा (ARM Cortex-R जैसी कुछ)। प्रोसेसर 32-बिट एएमबीए एएचबी बस प्रोसेसर आवृत्ति पर काम करने के माध्यम से बाहरी मेमोरी कंट्रोलर से जुड़ा हुआ है।



कमांड और डेटा कैश अलग-अलग हैं, प्रत्यक्ष मानचित्रण, आकार में प्रत्येक 16 किलोबाइट। कैश लाइन 32 बाइट्स लंबी होती है, यानी प्रत्येक कैश में 512 लाइनें होती हैं। आपको याद दिला दूं कि ऑफ़सेट कैश लाइन के अंदर बाइट के सीरियल नंबर को निर्धारित करता है, और इंडेक्स कैश में कैश लाइन की संख्या निर्धारित करता है। चूंकि कैश प्रत्यक्ष मानचित्रण है, इसलिए इसमें एक ही सूचकांक के साथ कई लाइनें नहीं हो सकती हैं, भले ही उनके पास अलग-अलग टैग हों।



यह समझने का सबसे आसान तरीका है कि यह सब कैसे काम करता है यह पता लगाने के लिए कि प्रोसेसर बिजली पर सही होने के बाद क्या करता है। मान लीजिए कि कैश चालू हैं और डिफ़ॉल्ट रूप से अक्षम हैं (जो कि खाली है), और किसी भी तरह से बाहरी मेमोरी में ऐसा प्रोग्राम था जो दो नंबर जोड़ता है:

         # इंटरप्ट वैक्टर की तालिका पता 0x0 से स्थित है
         _reset_vector:
 0x0000: जंप _start
         _interrupt1:
 0x0004: जंप _handler1
         _interrupt2:
 0x0008: जंप _handler2
 ...

         # मुख्य प्रोग्राम कोड पता 0x1234 से स्थित है
         _start:

         # R10 रजिस्टर करने के लिए मेमोरी से पहला ऑपरेंड लोड करें
 0x1234: Moveh R0, 0x1000 # लोड 0x1000 R0 में [31:16]
 0x1238: R10 लोड करें, [R0] # 0x10000000 से R10 में मान लोड करें

         # मेमोरी से दूसरे ऑपरेंड को रजिस्टर R11 में लोड करें
 0x123C: Moveh R1, 0x1001 # लोड 0x1001 R1 में [31:16]
 0x1240: R11 लोड करें, [R1] # 0x10010000 से R11 तक मान को लोड करें

         # ऑपरेंड जोड़ें और परिणाम को मेमोरी में लिखें
 0x1244: R2, R0, R1 जोड़ें
 0x1248: Moveh R3, 0x2000 # लोड 0x2000 R3 में [31:16]
 0x124C: R2, [R3] # को R2 को R3 के पते से सहेजें

         # प्रोसेसर बंद करो
 0x1250: पड़ाव 

चालू करने के बाद, प्रोसेसर रुकावट वेक्टर तालिका के पते के अनुरूप पते से कमांड निष्पादित करना शुरू कर देता है। यह पता आमतौर पर प्रोसेसर में हार्ड वायर्ड होता है। सामान्य मामले में, यह किसी भी चीज के बराबर हो सकता है, लेकिन सादगी के लिए हम मानते हैं कि यह शून्य के बराबर है।
इस प्रकार, हमारे कार्यक्रम की पहली कमांड - "जंप _start" - 0x0 पर स्थित है, और प्रोसेसर अपने पते को एक प्राथमिकता जानता है।

स्टेज 1. प्रोसेसर कमांड कैश में एक लाइन की तलाश करता है जिसमें 0x0 पते के साथ कमांड होती है। चूंकि कैश खाली है, प्रोसेसर के अंदर कैश नियंत्रक एक मिस को इंगित करता है और प्रोसेसर को तुरंत बंद कर देता है, साथ ही तथाकथित "रीड फट", जो बाहरी मेमोरी से डेटा पैकेट को पढ़ने का अनुरोध करता है। डेटा को कभी भी कैश शब्द में लोड नहीं किया जाता है - केवल पैकेट में, अन्यथा कैश में कोई मतलब नहीं है! डेटा पैकेट का आकार कैश लाइन की लंबाई के बराबर है। इस प्रकार, अनुरोध 8 घड़ी चक्र लेता है, क्योंकि हमारी प्रणाली में एएचबी बस प्रति घड़ी 32 से अधिक डेटा बिट्स को प्रसारित नहीं कर सकती है। आदर्श रूप से, मेमोरी कंट्रोलर तक पहुंचने के लिए अनुरोध को एक घड़ी चक्र की आवश्यकता होगी (यदि बस व्यस्त है एक और अनुरोध को संसाधित करने में, अधिक घड़ी चक्र की आवश्यकता होगी)। बाह्य मेमोरी के प्रकार के आधार पर, अनुरोध आने के तुरंत बाद नियंत्रक रीड डेटा को प्रसारित करना शुरू कर सकता है (यदि मेमोरी एसएसआरएएम है), या कुछ दर्जन घड़ी चक्र (एसडीआरएएम के मामले में) के बाद - इस समय को विलंबता कहा जाता है। मेमोरी कंट्रोलर से प्रोसेसर तक वापस जाने के लिए एक और घड़ी के लिए रीड डेटा की आवश्यकता होगी। नीचे चार घड़ी चक्रों की विलंबता के साथ बाह्य मेमोरी से कैश लाइन पढ़ने के समय आरेख हैं।



स्टेज 2. कैश नियंत्रक मेमोरी से लाइन बफर ("लाइन बफर") में आने वाले शब्दों को लिखता है, जिसका आकार कैश लाइन की लंबाई के बराबर है। जब लाइन बफ़र भर जाता है, तो इसकी सामग्री कमांड कैश की शून्य रेखा में संग्रहीत की जाएगी (चूंकि पता 0x0 पर 0 पर सूचकांक है)। हालांकि, प्रोसेसर बफर से कमांड को सीधे निष्पादित कर सकता है, इसलिए जैसे ही कमांड जो मिस का कारण बफर को लिखा गया है, कैश नियंत्रक तुरंत प्रोसेसर को अनलॉक करता है। चूंकि प्रोसेसर पिपलीलाइज्ड है, इसे पहले डीकोड होने से पहले मेमोरी से दूसरा इंस्ट्रक्शन चुनना होगा। इसे प्राप्त करने के लिए, दूसरी कमांड के पते की भविष्यवाणी की जाएगी, और सबसे अधिक संभावना है कि यह गलत तरीके से भविष्यवाणी की जाएगी, जिसके परिणामस्वरूप प्रोसेसर 0x4 पते से आदेशों का चयन करना जारी रखेगा। चूंकि दूसरा कमांड ("जंप _handler1") भी इस बिंदु पर बफर में होगा, कोई चूक नहीं होगी, और प्रोसेसर तीसरी कमांड ("जंप _handler2") का चयन करना शुरू कर देगा। यह तब तक जारी रहेगा जब तक कि प्रोसेसर यह नहीं समझ लेता कि उसने भविष्यवाणी में गलती की है और दूसरी कमांड को 0x1234 पर चुना जाना चाहिए।

स्टेज 3. जैसे ही प्रोसेसर स्पष्ट हो जाता है (और एक प्रोसेसर के साथ, कहते हैं, एक सात-चरण अनुदेश पाइप लाइन के बारे में सात घड़ी चक्र लेता है), यह तुरंत एक और कैश मिस का उत्पादन करेगा, इस बार कैश में एक लाइन की कमी के कारण 0x1234 (कमांड) चालें R0, 0x10000000 "), और यह एक नया" रीड फट "भेजेगा, जो कि रिटर्न पर, कैश की 145 वीं पंक्ति में संग्रहीत किया जाएगा (चूंकि पता 0x1220 पर इंडेक्स 0x91 = 145 है)। कार्यान्वयन के आधार पर, प्रोसेसर या तो लाइन की शुरुआत से कैश में डेटा लोड करना शुरू कर सकता है (यानी, पहले शब्द 0x1220, फिर 0x1224, 0x1228 और इसी तरह 0x123C तक), या उस शब्द से जो मिस (तथाकथित मोड) "क्रिटिकल शब्द पहले" - पहले शब्द 0x1234 के पते पर पढ़ा जाता है, फिर 0x1238, 0x123C, 0x1220, 0x1224, आदि) दोनों मामलों में, स्ट्रिंग पूरी तरह से किसी भी मामले में भरी हुई है, लेकिन पहले मामले में प्रोसेसर इंतजार करने के लिए पांच अतिरिक्त घड़ी चक्र खर्च करेगा। यह ध्यान दिया जाना चाहिए कि कई माइक्रोकंट्रोलर अभी भी "महत्वपूर्ण शब्द पहले" का समर्थन नहीं करते हैं, इसलिए सौभाग्य के साथ प्रोग्रामर प्रदर्शन में महत्वपूर्ण गिरावट प्राप्त कर सकता है।



चरण 4. भले ही "महत्वपूर्ण शब्द पहले" समर्थित हो या न हो, तीन सही आदेशों को तुरंत कैश में लोड किया जाएगा ("R1, 0x10010000" को सम्मिलित करने के लिए)। जब कतार "लोड R10, [R0]" कमांड पर पहुंचती है, तो प्रोसेसर एक डेटा कैश मिस (आखिरकार, डेटा कैश खाली है - सभी पिछले जोड़तोड़ कमांड कैश के साथ हुआ) का पता लगाएगा और एक अन्य रीड रीड भेजेगा, जिसे शून्य लाइन पर लिखा जाएगा (चूंकि 0x10000000 पते पर सूचकांक 0 है)। यदि प्रोसेसर पर्याप्त स्मार्ट और स्मार्ट है (और अधिकांश प्रोसेसर, छात्र शिल्प की तुलना में थोड़ा अधिक जटिल है, तो इसके लिए पर्याप्त स्मार्ट हैं), वह समझ जाएगा कि "R10 लोड, [R0]" के बाद कमांड इसके बारे में स्वतंत्र है और इसे एक साथ निष्पादित किया जा सकता है। कैश में डेटा की प्रतिलिपि बनाना। उसके बाद, प्रोसेसर 0x1240 पर एक कमांड का चयन करना चाहेगा और हमें एक और "रीड फट" मिलेगा, जो लटकाएगा, क्योंकि बस अभी भी डेटा कैश से पिछले अनुरोध पर कब्जा कर लिया जाएगा। बेशक, जितनी जल्दी या बाद में कमांड "लोड R11, [R1]" निर्देश कैश में समाप्त हो जाएगा, और प्रोसेसर तुरंत डेटा कैश का एक नया मिस ढूंढेगा, जो इसके अलावा कैश से 0x4000 टैग (0x10000000 और 0x10010000 पते के बाद से) से टैग के साथ पहले से लोड लाइन मिटा देगा टैग के साथ - क्रमशः 0x04000 और 0x04800, और दोनों का सूचकांक शून्य है)।

चरण 5. अंत में, प्रोसेसर "स्टोर आर 2, [आर 3]" कमांड निष्पादित करेगा, जो डेटा कैश का एक और मिस होगा और परिणामस्वरूप, एक और "रीड फट" होगा, और इसके अलावा कैश से टैग 0,004800 टैग के साथ लाइन को मिटा देगा। टैग 0x08000 के साथ एक पंक्ति। इसके अलावा, आपको यह याद रखने की ज़रूरत है कि यह कमांड बाहरी मेमोरी के लिए कुछ भी नहीं लिखेगा, क्योंकि यह केवल कैश में लिखा जाएगा! जब तक प्रोग्रामर स्पष्ट रूप से अपडेट की गई कैश लाइन को मेमोरी (यानी, कैश लाइन फ्लश बना), या जब तक लाइन को दूसरी लाइन द्वारा कैश से बाहर नहीं निकालता है, तब तक कोई "राइट फट" नहीं होगा। उदाहरण के लिए, यदि "रुक" कमांड के बजाय "लोड r4, [0x8000]" कमांड था, तो पढ़ने की प्रक्रिया इस तरह दिखाई देगी:



अंत में, मैं यह कहना चाहूंगा: कैश के गलत उपयोग से संबंधित त्रुटियों को महीनों तक खोजा जा सकता है। कंपाइलर्स जो वाष्पशील और मेमोरी को कैश करते हैं, जो कॉमरेड वॉन न्यूमैन की पूर्वधारणा के विपरीत हैं, खुद को बदल रहे हैं, इस बात के गवाह हैं। कैश की "पारदर्शिता" एक मिथक है जो केवल वैक्यूम PHP का उपयोग करके गोलाकार प्रोग्रामर के लिए उपयुक्त है। इसलिए, यदि आपके प्रोसेसर में कैश है, तो इसे नुकसान के रास्ते से बंद कर दें!