जैसे ही मुझे लॉक-फ्री एल्गोरिदम में दिलचस्पी हुई, सवाल मुझे सताने लगा: कोड में "ऑर्डर बहाल करने" के लिए मेमोरी बैरियर्स की जरूरत कहां से आई?
निश्चित रूप से, एक विशिष्ट वास्तुकला के लिए मैनुअल के कई हजार पृष्ठों को पढ़ने के बाद, हमें इसका उत्तर मिलेगा। लेकिन यह उत्तर इस विशेष वास्तुकला के लिए उपयुक्त होगा। क्या कोई आम है? अंत में, हम चाहते हैं कि हमारा कोड पोर्टेबल हो। और C ++ 11 मेमोरी मॉडल एक विशिष्ट प्रोसेसर के लिए अनुरूप नहीं है।
सबसे स्वीकार्य सामान्य उत्तर मुझे श्री पॉल मैककेनी ने अपने 2010 के लेख, मेमोरी बैरियर्स: एक हार्डवेयर व्यू ऑफ़ सॉफ्टवेयर हैकर्स द्वारा दिया था । उनके लेख का मूल्य सामान्यता में है: उन्होंने कुछ सरलीकृत अमूर्त वास्तुकला का निर्माण किया, जिसके उदाहरण पर उन्होंने विश्लेषण किया कि स्मृति बाधा क्या है और इसे क्यों पेश किया गया था।
आम तौर पर, पॉल मैककेनी एक प्रसिद्ध व्यक्ति हैं। वह आरसीयू प्रौद्योगिकी के एक डेवलपर और सक्रिय प्रमोटर हैं, जो लिनक्स कर्नेल में सक्रिय रूप से उपयोग किया जाता है, और यह लिक्विड के नवीनतम संस्करण में भी लागू किया जाता है, क्योंकि सुरक्षित मेमोरी डीलक्लोलेशन के लिए एक और दृष्टिकोण (सामान्य तौर पर, मैं आरसीयू के बारे में अलग से बात करना चाहूंगा)। उन्होंने C ++ 11 मेमोरी मॉडल पर काम में भी भाग लिया।
लेख बड़ा है, मैं केवल पहले छमाही का अनुवाद देता हूं। मैंने खुद को कुछ टिप्पणियों को जोड़ने की अनुमति दी [जो पाठ में इस तरह से हाइलाइट की गई हैं] ।

मेमोरी बैरियर्स: सॉफ्टवेयर हैकर्स का एक हार्डवेयर व्यू

क्या सीपीयू डिजाइनरों ने मेमोरी बाधाओं को शुरू करने के लिए प्रेरित किया और इस तरह डेवलपर्स पर एक सुअर डाल दिया? संक्षिप्त उत्तर है: स्मृति अभिगम को बेहतर प्रदर्शन की अनुमति देता है, और सिंक्रनाइज़ेशन प्राइमेटिक्स [और लॉक-फ्री एल्गोरिदम, निश्चित रूप से] जैसी चीजों को "क्लीन" करने के लिए मेमोरी बैरियर की आवश्यकता होती है, जहां प्राइमरी की शुद्धता मेमोरी एक्सेस के आदेश पर निर्भर करती है।
एक विस्तृत जवाब के लिए सीपीयू कैश कैसे काम करता है, और इसे और बेहतर बनाने के लिए क्या आवश्यक है, इसकी अच्छी समझ की आवश्यकता है। इसलिए, आगे हम:

• कैश की संरचना पर विचार करें;
• हम वर्णन करते हैं कि कैसे कैश जुटना प्रोटोकॉल विभिन्न प्रोसेसर के लिए प्रत्येक मेमोरी सेल की दृश्यता सुनिश्चित करता है;
• विचार करें कि कैसे स्टोर बफ़र और अमान्य कतारें कैश को अधिकतम प्रदर्शन प्राप्त करने में मदद करती हैं।

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

कैश संरचना

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

सीपीयू कैश लाइनों को कैश लाइनों के साथ डेटा का आदान-प्रदान करता है, जिसका आकार आमतौर पर दो की शक्ति है - 16 से 256 बाइट्स (सीपीयू पर निर्भर करता है)। जब प्रोसेसर पहली बार मेमोरी सेल को एक्सेस करता है, तो सेल कैश में नहीं होती है - इस स्थिति को मिस (कैश मिस या, अधिक सटीक रूप से, "स्टार्टअप" या "वार्मअप" कैश मिस) कहा जाता है। एक मिस का अर्थ है कि सीपीयू को सैकड़ों चक्रों तक इंतजार (स्टाल) करना पड़ता है जब तक कि डेटा मेमोरी से पुनर्प्राप्त नहीं हो जाता। अंत में, डेटा को कैश में लोड किया जाएगा, और इस पते पर बाद में एक्सेस करने से कैश में डेटा मिलेगा, जिससे सीपीयू पूरी गति से चलेगा।
कुछ समय के बाद, कैश भर जाएगा, और मिस करने के कारण नए अनुरोधित डेटा को जगह देने के लिए डेटा को कैश से बाहर निचोड़ा जाएगा। ऐसी मिसाइलों को क्षमता मिसेज कहा जाता है। इसके अलावा, कैश की भरमार होने पर भी भीड़ लग सकती है, क्योंकि यह हार्डवेयर में एक हैश टेबल के रूप में एक निश्चित बकेट आकार (या एक सेट , जैसा कि इसके सीपीयू डेवलपर्स इसे कहते हैं) में आयोजित किया जाता है।

दाईं ओर का आंकड़ा 256-बाइट कैश लाइन के साथ 2-साहचर्य (2-वे) कैश दिखाता है। लाइन खाली हो सकती है, जो तालिका में एक खाली सेल से मेल खाती है। बाईं ओर संख्याएं वे पते हैं जो सेल में हो सकते हैं। चूंकि लाइनें 256 बाइट्स द्वारा संरेखित की जाती हैं, पते के निचले 8 बिट्स शून्य हैं, और हैश फ़ंक्शन हैश तालिका में एक सूचकांक के रूप में अगले 4 बिट्स का चयन करता है। मान लीजिए कि प्रोग्राम कोड 0x43210E00 - 0x43210EFF पते पर स्थित है, और प्रोग्राम खुद पते 0x12345000 - 0x12345EFF पर डेटा एक्सेस करता है। अब उसे 0x12345F00 पते पर जाने दें। यह पता 0xF लाइन पर हैशेड है और इस लाइन के दोनों सेल खाली हैं, इसलिए 256 बाइट्स डेटा उनमें से एक में रखा जा सकता है। यदि प्रोग्राम 0x1233000 पर पहुंचता है, जिसका हैश 0x0 है, तो इसी 256-बाइट डेटा को 0x0 लाइन के सेल 1 (तरीका 1) में रखा जा सकता है। यदि प्रोग्राम 0x1233E00 (हैश = 0xE) पते पर पहुंचता है, तो नए 256 बाइट्स डेटा के लिए स्थान खाली करने के लिए लाइनों में से एक (तरीके) को कैश से बाहर धकेलना होगा। यदि आपको बाद में इस पुश किए गए डेटा तक पहुंच की आवश्यकता है, तो हमें एक मिस स्थिति मिलती है। इस तरह की गड़गड़ाहट को सहक्रियाशीलता मिस कहा जाता है
यह सब डेटा पढ़ने से संबंधित है, और लिखते समय क्या होगा? सभी सीपीयू डेटा के अनुरूप होना चाहिए, इसलिए लिखने से पहले, आपको अन्य सीपीयू के कैश से डेटा को हटाने (अमान्य) करने की आवश्यकता है। अमान्य होने के बाद ही प्रोसेसर सुरक्षित रूप से डेटा रिकॉर्ड कर सकता है। यदि डेटा सीपीयू कैश में है, लेकिन केवल पढ़ने के लिए है, तो इसे राइट मिस कहा जाता है। सीपीयू इस तरह के डेटा को अन्य प्रोसेसर के कैश में अमान्य कर देने के बाद ही सीपीयू इस डेटा को फिर से लिख (और पढ़) सकता है। इसके अलावा, अगर कुछ सीपीयू डेटा तक पहुंचने की कोशिश करते हैं, जबकि एक अन्य सीपीयू उन्हें लिखने के लिए अमान्य करता है, तो उसे संचार मिस नामक एक मिस प्राप्त होगी, क्योंकि यह स्थिति तब होती है जब डेटा का उपयोग संचार के लिए किया जाता है, जैसे कि , म्यूटेक्स या स्पिन-लॉक [अपने आप को म्यूटेक्स को संदर्भित करता है, न कि इसे संरक्षित करने वाले डेटा को; म्यूटेक्स किसी प्रकार का झंडा है] ।
जैसा कि आप देख सकते हैं, सभी सीपीयू के लिए डेटा सुसंगतता को प्रबंधित करने के लिए महान प्रयास किए जाने चाहिए। यह सब पढ़ने / अमान्य / लिखने के साथ, यह कल्पना करना आसान है कि डेटा खो जाएगा या (इससे भी बदतर) विभिन्न सीपीयू में उनके कैश में अलग-अलग डेटा होगा। इन समस्याओं को डेटा सुसंगतता प्रोटोकॉल द्वारा संबोधित किया जाता है।

कैश सुसंगतता प्रोटोकॉल

प्रोटोकॉल कैश लाइनों की स्थिति को नियंत्रित करता है, अखंडता सुनिश्चित करता है और डेटा हानि को रोकता है। दर्जनों राज्यों के साथ ऐसे प्रोटोकॉल बहुत जटिल हो सकते हैं, लेकिन हमारे उद्देश्यों के लिए यह MESI प्रोटोकॉल पर विचार करने के लिए पर्याप्त है, जिसमें 4 राज्य हैं।

MESI बताता है

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

MESI प्रोटोकॉल संदेश

एक राज्य से दूसरे में होने वाले कई बदलावों में सीपीयू के बीच सहभागिता की आवश्यकता होती है। यदि सभी सीपीयू एक साझा बस से जुड़े हैं, तो निम्न संदेश पर्याप्त हैं:

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

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

MESI राज्य आरेख

दाईं ओर आकृति में संक्रमण के निम्नलिखित अर्थ हैं:

• संक्रमण a (M -> E) : कैश लाइन को मेमोरी में वापस लिखा जाता है, लेकिन सीपीयू ने इसे कैश में छोड़ दिया और इसे बदलने का अधिकार है। इस परिवर्तन के लिए "राइटबैक" संदेश की आवश्यकता होती है।
• संक्रमण बी (ई -> एम) : सीपीयू कैश लाइन को लिखता है, जिसमें इसकी अनन्य पहुंच होती है। इस संक्रमण के लिए किसी संदेश की आवश्यकता नहीं है।
• संक्रमण c (M -> I) : CPU को "संशोधित" स्थिति में "रीड अमान्य" कैश लाइन संदेश प्राप्त होता है। सीपीयू को अपनी स्थानीय कॉपी को हटाना चाहिए और "रीड रिस्पांस" और "अमान्य स्वीकार" संदेशों के साथ प्रतिक्रिया करनी चाहिए। इस प्रकार, सीपीयू डेटा भेजता है और दिखाता है कि अब उसके पास घर पर इसकी प्रति नहीं है
• संक्रमण d (I -> M) : CPU डेटा पर एक रीड-मॉडिफ़ाइड-राइट-राइट (RMW) ऑपरेशन करता है जो कैश में नहीं है। यह "रीड अमान्य" सिग्नल का उत्सर्जन करता है, "रीड रिस्पांस" में डेटा प्राप्त करता है। सीपीयू संक्रमण को तभी पूरा करता है जब उसे सभी "अमान्य स्वीकार" प्रतिक्रियाएं मिलती हैं
• संक्रमण ई (एस -> एम) : सीपीयू डेटा पर एक रीड-मॉडिफाई-राइट (आरएमडब्ल्यू) ऑपरेशन करता है जो केवल-पढ़ने के लिए था। इसे "अमान्य" संकेत आरंभ करना चाहिए और तब तक प्रतीक्षा करना चाहिए जब तक कि यह "अमान्य स्वीकार" प्रतिक्रियाओं का पूरा सेट प्राप्त न कर ले
• संक्रमण f (M -> S) : कुछ अन्य प्रोसेसर डेटा पढ़ रहे हैं, और यह डेटा हमारे सीपीयू के कैश में है। नतीजतन, डेटा केवल-पढ़ने के लिए बन जाता है, जिससे मेमोरी में लेखन हो सकता है। यह संक्रमण एक रीड सिग्नल द्वारा ट्रिगर होता है। सीपीयू अनुरोधित डेटा वाले "रीड रिस्पांस" संदेश के साथ प्रतिक्रिया करता है।
• संक्रमण g (E -> S) : कुछ अन्य प्रोसेसर डेटा पढ़ रहे हैं, और यह डेटा हमारे सीपीयू के कैश में है। डेटा साझा हो जाता है और इसलिए केवल पढ़ने के लिए। संक्रमण "रीड" सिग्नल प्राप्त करके शुरू किया गया है। सीपीयू अनुरोधित डेटा वाले "रीड रिस्पांस" संदेश के साथ प्रतिक्रिया करता है।
• संक्रमण h (S -> E) : CPU तय करता है कि उसे कैश लाइन में डेटा लिखने की आवश्यकता है, और इसलिए एक "अमान्य" संदेश भेजता है। जब तक सीपीयू "अमान्य स्वीकार" प्रतिक्रियाओं का पूरा सेट प्राप्त नहीं करता है तब तक संक्रमण पूरा नहीं होता है। अन्य CPU "कैशबैक" कैशबैक लाइन को "राइटबैक" संदेश के साथ फेंकते हैं, ताकि हमारा सीपीयू इस डेटा को कैश करने वाला एकमात्र बन जाए।
• संक्रमण i (E -> I) : एक अन्य CPU हमारे CPU के स्वामित्व वाले डेटा पर RMW ऑपरेशन करता है, जिससे हमारा प्रोसेसर कैश लाइन को अमान्य कर देता है। संक्रमण संदेश "रीड अमान्य" के साथ शुरू होता है, हमारा सीपीयू "रीड रिस्पांस" और "अमान्य स्वीकार" संदेशों के साथ प्रतिक्रिया करता है।
• संक्रमण j (I -> E) : सीपीयू डेटा को नई कैश लाइन में सहेजता है और "रीड अमान्य" संदेश प्रसारित करता है। सीपीयू संक्रमण को तब तक पूरा नहीं कर सकता जब तक कि उसे "रीड रिस्पांस" और "अमान्य स्वीकार" का पूरा सेट प्राप्त न हो जाए। जैसे ही रिकॉर्डिंग पूरी हो जाती है, कैश लाइन संक्रमण (बी) के माध्यम से "संशोधित" स्थिति में प्रवेश करती है
• संक्रमण k (I -> S) : सीपीयू डेटा को एक नई कैश लाइन में लोड करता है। सीपीयू "रीड" संदेश भेजता है और "रीड रिस्पांस" प्राप्त करके संक्रमण को पूरा करता है
• संक्रमण l (S -> I) : एक अन्य CPU डेटा को कैश लाइन में संग्रहित करना चाहता है, जिसे केवल-पढ़ने की स्थिति है, चूंकि कुछ तीसरे CPU (या, उदाहरण के लिए, हमारा) डेटा हमारे साथ साझा करता है। संक्रमण "अमान्य" स्वीकार करने से शुरू होता है, और हमारा सीपीयू "अमान्य स्वीकार" के साथ प्रतिक्रिया करता है

MESI प्रोटोकॉल उदाहरण

आइए देखें कि कैश के लिए मेमोरी की सीधी मैपिंग के साथ 4-प्रोसेसर सिस्टम के उदाहरण का उपयोग करते हुए MESI कैश लाइन के संदर्भ में कैसे काम करता है। पता 0 पर डेटा स्मृति में है। निम्न तालिका डेटा परिवर्तन को दर्शाती है। पहला कॉलम ऑपरेशन की क्रम संख्या है, दूसरा ऑपरेशन करने वाले प्रोसेसर की संख्या है, तीसरा ऑपरेशन है, अगले चार कॉलम प्रत्येक सीपीयू की कैश लाइन की स्थिति (मेमोरी एड्रेस / स्टेट के रूप में) हैं, अंतिम कॉलम हैं मेमोरी में सही डेटा होता है (V) या नहीं (I)।

सबसे पहले, CPU की कैश लाइनें "अमान्य" स्थिति में हैं, और मेमोरी में सही डेटा है। जब सीपीयू 0 पता 0 पर डेटा पढ़ता है, तो सीपीयू 0 की कैश लाइन "साझा" स्थिति में जाती है और मेमोरी के अनुरूप होती है। सीपीयू 3 पता 0 पर डेटा भी पढ़ता है, ताकि कैश लाइनें दोनों सीपीयू के कैश में "साझा" स्थिति में जाएं, लेकिन अभी भी मेमोरी के साथ संरेखित हैं। इसके बाद, CPU 0 पता 8 पर डेटा लोड करता है, जो कैश लाइन को भीड़ देता है और इसमें नया डेटा डालता है (पते 8 पर पढ़ें)। इसके बाद, सीपीयू 2 पता 0 पर डेटा पढ़ता है, लेकिन फिर पता चलता है कि इसे (आरएमडब्ल्यू ऑपरेशन) लिखने की आवश्यकता है, इसलिए यह सुनिश्चित करने के लिए "रीड अमान्य" सिग्नल का उपयोग करता है कि यह डेटा की एक अनन्य प्रतिलिपि है। "रीड अमान्य" सिग्नल सीपीयू 3 कैश लाइन को अमान्य करता है (हालांकि इसका डेटा अभी भी मेमोरी के अनुरूप है)। सीपीयू 2 फिर लिखता है, जो आरएमडब्ल्यू ऑपरेशन का हिस्सा है, जो कैश मोड को "संशोधित" स्थिति में रखता है। मेमोरी में डेटा अब अप्रचलित है। सीपीयू 1 एक परमाणु वृद्धि करता है और डेटा प्राप्त करने के लिए पढ़े गए अमान्य सिग्नल का उपयोग करता है। यह CPU 2 कैश से डेटा प्राप्त करता है, और CPU 2 में ही डेटा अक्षम होता है। नतीजतन, सीपीयू 1 की कैश लाइन में डेटा "संशोधित" स्थिति में है और अभी भी मेमोरी के साथ संरेखित नहीं है। अंत में, सीपीयू 1 पता 8 पर डेटा पढ़ता है, जो कैश लाइन को मेमोरी ("राइटबैक" संदेश का उपयोग करके) में फ्लश करता है।

अवांछित रिकॉर्डिंग डाउनटाइम

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

स्टोर बफ़र्स

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

स्टोर फॉरवर्डिंग

पहली समस्या, का उल्लंघन कहा जाता है यह देखने के लिए अपने स्वयं के अखंडता (स्वयं स्थिरता), निम्नलिखित कोड पर विचार करें:

1 a = 1; 2 b = a + 1; 3 assert( b == 2 ); 

चर "a" और "b" का प्रारंभिक मान 0. है। चर "a" प्रोसेसर 1 के कैश में है, और चर "b" प्रोसेसर 0 की कैश में है।
ऐसा लगता है, यह assert कैसे काम कर सकता है? हालांकि, अगर किसी ने दिखाए गए आर्किटेक्चर के साथ एक प्रोसेसर को लागू किया है, तो वह आश्चर्यचकित हो जाएगा। इस तरह की प्रणाली संभावित रूप से घटनाओं के निम्नलिखित अनुक्रम का उत्पादन कर सकती है:

• 1. CPU 0 a = 1 निष्पादित करना शुरू करता है
• 2. सीपीयू 0 "कैश" में है या नहीं, और क्या नहीं है, यह देखने के लिए देखता है - मिस
• 3. इसलिए, "0" के साथ कैश लाइन पर विशेष अधिकार प्राप्त करने के लिए सीपीयू 0 "रीड अमान्य" संकेत भेजता है।
• 4. सीपीयू 0 अपने स्टोर बफर को "ए" लिखता है
• । CPU 1 को "रीड अमान्य" संदेश मिलता है और "कैश" और "कैशलेस" लाइन को हटाकर कैश लाइन भेजकर इसका जवाब देता है।
• 6. सीपीयू 0 b = a + 1 निष्पादित करना शुरू करता है
• 7. सीपीयू 0 सीपीयू 1 से प्रतिक्रिया प्राप्त करता है, जिसमें पुराना, शून्य "ए" मूल्य भी होता है, और इसके कैश में लाइन डालता है
• 8. CPU 0 अपने कैश से "a" लोड करता है - मान शून्य लोड किया जाता है
• 9. सीपीयू स्टोर बफर में संग्रहीत कैश पर लिखने के लिए एक अनुरोध निष्पादित करता है, कैश लाइन के लिए "a" = 1 मान लिखता है
• 10. सीपीयू 0 को शून्य में जोड़ता है, जिसे पहले "ए" के रूप में पढ़ा जाता है, और परिणाम को कैश लाइन "बी" में संग्रहीत करता है (जो, जैसा कि हम याद करते हैं, सीपीयू 0 के कब्जे में है)
• 11. CPU 0 assert(b == 2) निष्पादित करता assert(b == 2) और एक त्रुटि फेंकता है - assert ट्रिगर होता है

समस्या यह है कि हमारे पास "क" की दो प्रतियां हैं - एक कैश में और दूसरी स्टोर बफर में।

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

बफ़र और मेमोरी बैरियर लिखें

एक अन्य समस्या को देखने के लिए, वैश्विक मेमोरी ऑर्डर का उल्लंघन, निम्नलिखित उदाहरण पर विचार करें, जिसमें चर "a" और "b" का प्रारंभिक मान 0 है:

 1 void foo() 2 { 3 a = 1; 4 b = 1; 5 } 6 7 void bar() 8 { 9 while ( b == 0 ) continue; 10 assert( a == 1 ); 11 } 

सीपीयू 0 को foo() और सीपीयू 1 bar() । मान लीजिए कि "ए" वाली मेमोरी केवल सीपीयू 1 के कैश में है, और सीपीयू 0 "बी" वाली मेमोरी का मालिक है। तब क्रियाओं का निम्नलिखित क्रम संभव है:

• 1. CPU 0 a=1 करता a=1 । "ए" के लिए कैश लाइन सीपीयू 0 के कैश में नहीं है, इसलिए सीपीयू 0 अपने लेखन बफर में "ए" नए मूल्य को रखता है और "रीड अमान्य" सिग्नल का उत्सर्जन करता है।
• 2. CPU 1 निष्पादित होता है while (b==0) continue , लेकिन "b" इसके कैश में नहीं है, इसलिए यह "रीड" संदेश भेजता है
• 3. सीपीयू 0 b = 1 करता है। वह पहले से ही अपने कैश में "b" का मालिक है, अर्थात्, संबंधित कैश लाइन "अनन्य" या "संशोधित" स्थिति में है - इसलिए उसे बिना किसी को बताए अपने कैश में नए "b" मान को बचाने का हर अधिकार है
• 4. सीपीयू 0 संदेश "पढ़" प्राप्त करता है और प्रतिक्रिया में नवीनतम मूल्य "बी" के साथ एक कैश लाइन प्रसारित करता है, साथ ही इस लाइन को अपने कैश में "साझा" स्थिति में स्थानांतरित करता है।
• 5. सीपीयू 1 "बी" के साथ कैश लाइन प्राप्त करता है और इसे अपने कैश में डालता है
• 6. सीपीयू 1 अब पूरा while (b == 0) continue , क्योंकि यह देखता है कि b == 1 , और अगले निर्देश के साथ आगे बढ़ें
• 7. सीपीयू 1 assert(a == 1) निष्पादित करता है। चूंकि सीपीयू 1 पुराने मूल्य "ए" के साथ काम करता है, इसलिए शर्त पूरी नहीं की जाती है
• 8. सीपीयू 1 संदेश "रीड अमान्य" प्राप्त करता है और एक कैश लाइन "सीपीयू 0" के साथ प्रसारित करता है, साथ ही इस लाइन को अपने कैश में अमान्य करता है। लेकिन बहुत देर हो गई
• 9. सीपीयू 0 "के साथ" कैश लाइन प्राप्त करता है और बफर से लिखता है (स्टोर बफर को इसके कैश में फ्लश करता है)

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

 1 void foo() 2 { 3 a = 1; 4 smp_mb(); 5 b =1; 6 } 7 8 void bar() 9 { 10 while ( b == 0 ) continue; 11 assert( a == 1 ); 12 } 

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

जैसा कि आप देख सकते हैं, यहां तक ​​कि सहज रूप से सरल चीजें सिलिकॉन में कई जटिल चरणों का नेतृत्व करती हैं।

एक रिकॉर्डिंग अनुक्रम में अवांछित डाउनटाइम

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

अमान्य कतार

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

अवैध कतारों और विकलांगता की पुष्टि

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

अमान्य कतारों और स्मृति बाधाओं

मान लें कि प्रोसेसर कतार अनुरोधों को अमान्य करते हैं और तुरंत जवाब देते हैं। यह दृष्टिकोण कैश अमान्यकरण विलंब को कम करता है, लेकिन मेमोरी बाधा को तोड़ सकता है, जिसे हम निम्नलिखित उदाहरण में देखेंगे।
चर "ए" और "बी" को शुरू में शून्य होने दें और "ए" "साझा" स्थिति (जो कि केवल-पढ़ने के लिए) में दोनों प्रोसेसरों के कैश में है, और "बी" सीपीयू 0 (अर्थात, कैश लाइन) के अधिकार में है "विशेष" या "संशोधित"। मान लीजिए सीपीयू 0 foo() और सीपीयू 1 bar() करता है bar() :

 1 void foo() 2 { 3 a = 1; 4 smp_mb(); 5 b = 1; 6 } 7 8 void bar() 9 { 10 while (b == 0) continue; 11 assert(a == 1); 12 } 

संचालन का क्रम निम्नानुसार हो सकता है:

• 1. CPU 0 a=1 करता a=1 । संबंधित कैश लाइन केवल सीपीयू 0 के कैश में पढ़ी जाती है, इसलिए प्रोसेसर अपने स्टोर बफर में "ए" नया मूल्य डालता है और एक संदेश "अमान्य" भेजता है, ताकि सीपीयू 1 "कैशे लाइन को" के साथ "" फ्लश कर दे।
• 2. CPU 1 निष्पादित होता है while(b == 0) continue , लेकिन "b" इसके कैश में नहीं है। इसलिए, यह एक "पढ़ा" संदेश भेजता है
• 3. सीपीयू 1 सीपीयू 0 से "अमान्य" प्राप्त करता है, इसे अपनी अमान्य कतार में संग्रहीत करता है, और तुरंत प्रतिक्रिया करता है
• 4. सीपीयू 0 को सीपीयू 1 से एक प्रतिक्रिया मिलती है, इसलिए यह smp_mb() (लाइन 4) को निष्पादित करने के लिए स्वतंत्र है और इसके मूल्य बफर में नए मूल्य "a" को कैश में डाल दिया है।
• 5. सीपीयू 0 b=1 करता है। यह पहले से ही "बी" के साथ कैश लाइन का मालिक है, इसलिए यह अपने कैश में नए "बी" मूल्य को बचाता है
• 6. सीपीयू 0 एक "रीड" सिग्नल प्राप्त करता है और एक कैश वैल्यू को एक नए मान "बी" के साथ प्रोसेसर 1 तक पहुंचाता है, साथ ही इस लाइन को "साझा" के रूप में चिह्नित करता है।
• 7. सीपीयू 1 "बी" के साथ कैश लाइन प्राप्त करता है और इसे अपने कैश में डालता है
• 8. अब CPU 1 पूरा कर सकता है while(b == 0) continue और कार्यक्रम की अगली पंक्ति पर जाता है
• 9. सीपीयू 1 assert(a == 1) निष्पादित करता है। पुराने मूल्य "ए" के कैश में होने के कारण, आग लगना और एक अपवाद फेंकता है
• अपवाद के बावजूद, सीपीयू 1 कतार में रखे "अमान्य" संदेश को निष्पादित करता है और, देरी के साथ, कैश लाइन "" को अमान्य करता है

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

बाधाओं को पढ़ें और लिखें

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

 1 void foo() 2 { 3 a = 1; 4 smp_wmb(); //   5 b = 1; 6 } 7 8 void bar() 9 { 10 while (b == 0) continue; 11 smp_rmb(); //   11 assert(a == 1); 12 } 

कुछ आर्किटेक्चर में विविध बाधाओं का एक बड़ा समूह है, लेकिन चर्चा किए गए तीन विकल्पों को समझना सिद्धांत में स्मृति बाधाओं को पेश करने के लिए पर्याप्त है।

अनुवादक के बाद

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

आइए संक्षेप में बताने का प्रयास करते हैं।
तो, हमारे पास कैश / मेमोरी - रीडिंग (लोड) और राइटिंग (स्टोर) के साथ बातचीत करने वाले प्रोसेसर के दो ऑपरेशन हैं। दो ऑपरेशन हमें एक साथ चार अलग-अलग मेमोरी बैरियर देते हैं:

 op1; // store  load barrier ; // memory fence op2; // store  load 

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

आगे

इसलिए हमने देखा कि मेमोरी बाधाएं कहां से आईं। हमने सीखा कि वे एक आवश्यक बुराई हैं। हमने उन्हें किसी तरह कोड में व्यवस्थित करने का भी प्रयास किया।

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