यह आलेख डेविड हॉवेल्स और पॉल ई। मैककेनी द्वारा व्यापक मार्गदर्शिका का आंशिक अनुवाद है, जिसे लिनक्स प्रलेखन (दस्तावेज / मेमोरी-बैरियर.टैक्स ऑनलाइन संस्करण ) के हिस्से के रूप में वितरित किया गया है।

कर्नेल / ड्राइवर डेवलपर्स के लिए पढ़ना चाहिए और एप्लिकेशन प्रोग्रामर के लिए बहुत जानकारीपूर्ण होना चाहिए।

एक सामान्य मेमोरी एक्सेस मॉडल।

निम्नलिखित सिस्टम मॉडल पर विचार करें:

: : : : : : +-------+ : +--------+ : +-------+ | | : | | : | | | | : | | : | | | CPU 1 |<----->| Memory |<----->| CPU 2 | | | : | | : | | | | : | | : | | +-------+ : +--------+ : +-------+ ^ : ^ : ^ | : | : | | : | : | | : v : | | : +--------+ : | | : | | : | | : | | : | +---------->| Device |<----------+ : | | : : | | : : +--------+ : : : 

प्रत्येक प्रोसेसर एक प्रोग्राम चलाता है जो मेमोरी एक्सेस ऑपरेशन का एक क्रम उत्पन्न करता है। अमूर्त प्रोसेसर में मेमोरी तक पहुंच को व्यवस्थित करने का एक कमजोर मॉडल है, ताकि वास्तव में एक्सेस संचालन यादृच्छिक क्रम में किया जा सके, यदि निष्पादन योग्य कोड में एम्बेडेड कारण-संबंधों का उल्लंघन नहीं किया जाता है। इसी तरह, संकलक उत्पन्न कोड को व्यवस्थित करने के लिए स्वतंत्र है, बशर्ते कि इस कोड के निष्पादन का परिणाम कार्यक्रम के स्रोत कोड से मेल खाता हो।

उपरोक्त आकृति में, प्रोसेसर द्वारा निष्पादित मेमोरी ऑपरेशन सिस्टम के अन्य घटकों द्वारा देखे जाते हैं, जैसे इस प्रोसेसर और सिस्टम के बीच की सीमाओं को पार करने वाले ऑपरेशन (धराशायी लाइनों द्वारा इंगित)।

बाहरी उपकरणों के साथ संचालन।

कई उपकरणों में मेमोरी में विशिष्ट पते वाले रजिस्टरों के सेट के रूप में एक नियंत्रण इंटरफ़ेस होता है; रजिस्टरों को नियंत्रित करने के लिए पहुंच का क्रम उचित संचालन के लिए महत्वपूर्ण है। उदाहरण के लिए, एक नेटवर्क एडेप्टर में आंतरिक रजिस्टर का एक सेट हो सकता है जो पता रजिस्टर (ए) और डेटा रजिस्टर (डी) के माध्यम से एक्सेस किया जाता है। आंतरिक कोड 5 को पढ़ने के लिए निम्नलिखित कोड का उपयोग किया जा सकता है:

  *A = 5; x = *D; 

यह कोड निम्नलिखित मेमोरी एक्सेस अनुक्रमों को स्पॉन कर सकता है:

 1  *A = 5, x =  *D 2 x =  *D,  *A = 5 

दूसरा अनुक्रम लगभग निश्चित रूप से गलत परिणाम लौटाएगा, क्योंकि पता रजिस्टर डेटा रजिस्टर को पढ़ने के बाद सेट किया जाएगा।

गारंटी।

प्रोसेसर कम से कम निम्नलिखित की गारंटी देता है:

• मेमोरी एक्सेस ऑपरेशन जो एक दूसरे पर निर्भर करते हैं, उसी प्रोसेसर के भीतर सही क्रम में किए जाते हैं। दूसरे शब्दों में, कोड के लिए
  
  

    Q = P; D = *Q; 

  
  प्रोसेसर निम्नलिखित मेमोरी एक्सेस ऑपरेशन उत्पन्न करेगा:
  
  

    Q =  P, D =  *Q 

  
  और केवल उसी क्रम में।
• एक प्रोसेसर द्वारा निष्पादित मेमोरी के वर्गों को ओवरलैप करने के लिए लिखता है और पढ़ता है, उस प्रोसेसर के भीतर अपना क्रम बनाए रखता है। दूसरे शब्दों में, कोड के लिए
  
  

    a = *X; *X = b; 

  
  प्रोसेसर केवल निम्नलिखित मेमोरी एक्सेस अनुक्रम उत्पन्न करेगा:
  
  

    a =  *X,  *X = b 

  
  और कोड के लिए
  
  

    *X = c; d = *X; 

  
  - केवल यह:
  
  

     *X = c, d =  *X 

इसके अलावा:

• यह नहीं माना जाना चाहिए कि स्वतंत्र पढ़ने और लिखने के लिए मेमोरी एक्सेस ऑपरेशन किसी विशेष क्रम में उत्पन्न होंगे। दूसरे शब्दों में, कोड के लिए
  
  

    X = *A; Y = *B; *D = Z; 

  
  निम्नलिखित अनुक्रमों में से एक उत्पन्न किया जा सकता है:
  
  

   1 X =  *A, Y =  *B,  *D = Z 2 X =  *A,  *D = Z, Y =  *B 3 Y =  *B, X =  *A,  *D = Z 4 Y =  *B,  *D = Z, X =  *A 5  *D = Z, X =  *A, Y =  *B 6  *D = Z, Y =  *B, X =  *A 

• यह माना जाना चाहिए कि आसन्न और अतिव्यापी मेमोरी एक्सेस ऑपरेशन को संयुक्त किया जा सकता है या बिल्कुल भी प्रदर्शन नहीं किया जा सकता है। दूसरे शब्दों में, कोड के लिए
  
  

    X = *A; Y = *(A + 4); 

  
  निम्नलिखित अनुक्रमों में से एक उत्पन्न किया जा सकता है:
  
  

   1 X =  *A; Y =  *(A + 4); 2 Y =  *(A + 4); X =  *A; 3 {X, Y} =  {*A, *(A + 4) }; 

  
  और कोड के लिए
  
  

    *A = X; Y = *A; 

  
  - निम्न में से एक:
  
  

   1  *A = X; Y =  *A; 2  *A = Y = X; 

मेमोरी एक्सेस बाधाएं क्या हैं?

जैसा कि ऊपर दिखाया गया है, स्वतंत्र मेमोरी एक्सेस संचालन यादृच्छिक क्रम में किया जा सकता है, जो प्रोसेसर के बीच या प्रोसेसर और बाहरी डिवाइस के बीच बातचीत के लिए एक समस्या बन सकता है। कंपाइलर और प्रोसेसर को ऑर्डर रखने के लिए निर्देश देने के लिए एक तंत्र की आवश्यकता होती है।

मेमोरी एक्सेस बैरियर एक ऐसा तंत्र है। वे बाधा के दोनों ओर मेमोरी एक्सेस संचालन के आंशिक आदेश का नेतृत्व करते हैं।

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

बाधाओं की विविधता।

4 मुख्य प्रकार के अवरोध हैं:

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

और बाधाओं के निहित प्रकार के एक जोड़े:

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

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

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

क्या बाधाओं की गारंटी नहीं है।

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

डेटा निर्भरता बाधाओं।

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

  CPU 1 CPU 2 =============== =============== { A == 1, B == 2, C = 3, P == &A, Q == &C } B = 4; < > P = &B Q = P; D = *Q; 

कोड में, डेटा पर एक स्पष्ट निर्भरता है, और ऐसा लगता है कि अनुक्रम के अंत में Q या तो & A या & B के बराबर हो सकता है, और यह भी कि (Q == & A) का तात्पर्य (D == 1) है, और (Q == & B) ) का तात्पर्य (D == 4) है।

हालाँकि, CPU2 के दृष्टिकोण से, P को B से पहले अपडेट किया जा सकता है, जिसके परिणामस्वरूप (Q == & B) और (D == 2) (o_O) हो सकते हैं।

हालांकि ऐसा लग सकता है कि इस तरह का व्यवहार कारण-प्रभाव वाले रिश्तों का उल्लंघन है, या सुसंगतता की समस्या है, ऐसा नहीं है। यह व्यवहार कुछ प्रकार के प्रोसेसर पर देखा जाता है (उदाहरण के लिए, डीईसी अल्फा)।

स्थिति को ठीक करने के लिए, पते को पढ़ने और इस पते पर डेटा पढ़ने के बीच एक डेटा निर्भरता बाधा (या मजबूत) की आवश्यकता है:

  CPU 1 CPU 2 =============== =============== { A == 1, B == 2, C = 3, P == &A, Q == &C } B = 4; < > P = &B Q = P; <   > D = *Q; 

इस मामले में, तीसरा परिणाम ((Q == & B) और (D == 2) असंभव है।

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

निर्भरता प्रबंधन के लिए बाधाएं।

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

  q = &a; if (p) q = &b; <   > x = *q; 

इस उदाहरण में बाधा का वांछित प्रभाव नहीं होगा, क्योंकि वास्तव में (पी) और (x = * q) के बीच कोई डेटा निर्भरता नहीं है, लेकिन एक नियंत्रण निर्भरता है। प्रोसेसर परिणाम की भविष्यवाणी करने की कोशिश कर सकता है।
इस स्थिति में वास्तव में क्या आवश्यक है:

  q = &a; if (p) q = &b; < > x = *q; 

एसएमपी के मामले में बाधाएं।

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

एक लेखन अवरोधन में हमेशा डेटा निर्भरता अवरोधक, रीड बैरियर या सामान्यीकृत मेमोरी एक्सेस बैरियर के रूप में एक जोड़ी होनी चाहिए। इसी तरह, डेटा निर्भरता अवरोध और रीड बैरियर में राइट बैरियर या सामान्यीकृत मेमोरी एक्सेस बैरियर के रूप में एक जोड़ी होनी चाहिए:

  CPU 1 CPU 2 =============== =============== a = 1; < > b = 2; x = b; < > y = a; 

या:

  CPU 1 CPU 2 =============== =============================== a = 1; < > b = &a; x = b; <   > y = *x; 

एक रीडिंग बैरियर हमेशा मौजूद होना चाहिए, एकमात्र सवाल यह है कि आदिम को किस तरह की ताकत का चयन करना चाहिए।

नोट: लिखने की बाधा से पहले ऑपरेशन लिखें आमतौर पर रीड बैरियर या डेटा निर्भरता के दूसरी तरफ रीड ऑपरेशंस को जोड़ा गया है और इसके विपरीत:

  CPU 1 CPU 2 =============== =============== a = 1; }---- --->{ v = c b = 2; } \ / { w = d < > \ < > c = 3; } / \ { x = a; d = 4; }---- --->{ y = b; 

बाधाओं के साथ मेमोरी एक्सेस संचालन के उदाहरण।

पहला: लिखने की बाधाएं लिखने के संचालन में एक आंशिक क्रम का परिचय देती हैं। घटनाओं के निम्नलिखित अनुक्रम पर विचार करें:

  CPU 1 =======================  A = 1  B = 2  C = 3 < >  D = 4  E = 5 

यह क्रम एक क्रम में मेमोरी कोऑरेन्सेस सपोर्ट सिस्टम तक पहुँचता है, जो कि बाकी सिस्टम रिकॉर्ड्स के एक अनऑर्डिनेटेड सेट के रूप में देख सकता है {रिकॉर्ड ए, रिकॉर्ड बी, रिकॉर्ड सी}, रिकॉर्ड के एक अनऑर्डेड सेट से पहले होने वाले {RECORD D, RECORD E}:

  +-------+ : : | | +------+ | |------>| C=3 | } /\ | | : +------+ }----- \ ----->   | | : | A=1 | } \/    | | : +------+ } | CPU 1 | : | B=2 | } | | +------+ } | | wwwwwwwwwwwwwwww } <---      | | +------+ }  ,      | | : | E=5 | }    ""    | | : +------+ } ,    | |------>| D=4 | } | | +------+ +-------+ : : | | ,     |    CPU 1 V 

दूसरा: डेटा-निर्भरता बाधाएं डेटा-निर्भर रीड ऑपरेशंस में आंशिक ऑर्डर करना शुरू करती हैं। घटनाओं के निम्नलिखित अनुक्रम पर विचार करें:

  CPU 1 CPU 2 ======================= ======================= { B = 7; X = 9; Y = 8; C = &Y }  A = 1  B = 2 < >  C = &B  X  D = 4  C ( &B)  *C ( B) 

बाधाओं के बिना, सीपीयू 2 सीपीयू 1 के लेखन अवरोध के उपयोग के बावजूद, सीपीयू 1 द्वारा उत्पन्न घटनाओं का किसी भी क्रम में निरीक्षण कर सकता है:

  +-------+ : : : : | | +------+ +-------+ |   | |------>| B=2 |----- --->| Y->8 | |  | | : +------+ \ +-------+ | CPU 2 | CPU 1 | : | A=1 | \ --->| C->&Y | V | | +------+ | +-------+ | | wwwwwwwwwwwwwwww | : : | | +------+ | : : | | : | C=&B |--- | : : +-------+ | | : +------+ \ | +-------+ | | | |------>| D=4 | ----------->| C->&B |------>| | | | +------+ | +-------+ | | +-------+ : : | : : | | | : : | | | : : | CPU 2 | | +-------+ | |   ---> | | B->7 |------>| |  B | +-------+ | | | : : | | | +-------+ | |   ---> \ | X->9 |------>| |   \ +-------+ | |  B ----->| B->2 | +-------+ +-------+ : : 

उपरोक्त उदाहरण में, सीपीयू 2, B == 7 का मान रखता है, इस तथ्य के बावजूद कि C पढ़ने के बाद * C (जो कि B को वापस करना चाहिए)।
हालाँकि, यदि C और पढ़ने के बीच डेटा निर्भरता का अवरोध है, तो CPU 2 पर * C (i. B) को पढ़ सकते हैं।

  CPU 1 CPU 2 ======================= ======================= { B = 7; X = 9; Y = 8; C = &Y }  A = 1  B = 2 < >  C = &B  X  D = 4  C (gets &B) <   >  *C (reads B) 

चित्र इस तरह दिखता है:

  +-------+ : : : : | | +------+ +-------+ | |------>| B=2 |----- --->| Y->8 | | | : +------+ \ +-------+ | CPU 1 | : | A=1 | \ --->| C->&Y | | | +------+ | +-------+ | | wwwwwwwwwwwwwwww | : : | | +------+ | : : | | : | C=&B |--- | : : +-------+ | | : +------+ \ | +-------+ | | | |------>| D=4 | ----------->| C->&B |------>| | | | +------+ | +-------+ | | +-------+ : : | : : | | | : : | | | : : | CPU 2 | | +-------+ | | | | X->9 |------>| | | +-------+ | | ,   --> \ ddddddddddddddddd | |  ,  \ +-------+ | |  C   ----->| B->2 |------>| |  +-------+ | | : : +-------+ 

तीसरा: रीड बैरियर आंशिक रूप से स्ट्रीमलाइन को पढ़ता है। घटनाओं के निम्नलिखित अनुक्रम पर विचार करें:

  CPU 1 CPU 2 ======================= ======================= { A = 0, B = 9 }  A=1 < >  B=2  B  A 

बाधाओं के बिना, सीपीयू 2 सीपीयू 1 के लेखन अवरोध के उपयोग के बावजूद, सीपीयू 1 द्वारा उत्पन्न घटनाओं का किसी भी क्रम में निरीक्षण कर सकता है:

  +-------+ : : : : | | +------+ +-------+ | |------>| A=1 |------ --->| A->0 | | | +------+ \ +-------+ | CPU 1 | wwwwwwwwwwwwwwww \ --->| B->9 | | | +------+ | +-------+ | |------>| B=2 |--- | : : | | +------+ \ | : : +-------+ +-------+ : : \ | +-------+ | | ---------->| B->2 |------>| | | +-------+ | CPU 2 | | | A->0 |------>| | | +-------+ | | | : : +-------+ \ : : \ +-------+ ---->| A->1 | +-------+ : : 

हालाँकि, यदि B पढ़ने और CPU 2 पर A पढ़ने के बीच एक अवरोध है,

  CPU 1 CPU 2 ======================= ======================= { A = 0, B = 9 }  A=1 < >  B=2  B < >  A 

सीपीयू 1 द्वारा प्रदान किया गया आंशिक आदेश सीपीयू 2 को सही ढंग से देखेगा:

  +-------+ : : : : | | +------+ +-------+ | |------>| A=1 |------ --->| A->0 | | | +------+ \ +-------+ | CPU 1 | wwwwwwwwwwwwwwww \ --->| B->9 | | | +------+ | +-------+ | |------>| B=2 |--- | : : | | +------+ \ | : : +-------+ +-------+ : : \ | +-------+ | | ---------->| B->2 |------>| | | +-------+ | CPU 2 | | : : | | | : : | |    -> \ rrrrrrrrrrrrrrrrr | |     \ +-------+ | |   B ---->| A->1 |------>| |   CPU 2 +-------+ | | : : +-------+ 

पढ़ने और अटकलों को लोड करने में बाधाएं।

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

ऐसा हो सकता है कि रीड वैल्यू की जरूरत न हो - उदाहरण के लिए, अगर रीड कमांड से पहले जंप कमांड का सामना करना पड़ता है। ऐसे मामलों में, रीड वैल्यू को खारिज या कैश किया जाएगा।

निम्नलिखित उदाहरण पर विचार करें:

  CPU 1 CPU 2 ======================= =======================  B  }  , ,  }      A 

जो निम्नलिखित कमांड उत्पन्न कर सकते हैं:

  : : +-------+ +-------+ | | --->| B->2 |------>| | +-------+ | CPU 2 | : :| | +-------+ | |   , ---> --->| A->0 |~~~~ | |     +-------+ ~ | |   A : : ~ | | : :| | : : ~ | |     --> : : ~-->| |     : : | |    : : +-------+ 

दूसरे रीड ऑपरेशन से पहले एक रीड बैरियर या डेटा निर्भरता रखना

  CPU 1 CPU 2 ======================= =======================  B   < >  A 

उपयोग किए गए अवरोध के प्रकार के आधार पर, पहले पढ़े गए मूल्य की समीक्षा करने के लिए प्रोसेसर को मजबूर करें। यदि पहले पढ़ा गया मेमोरी क्षेत्र नहीं बदला है, तो मूल्य का उपयोग किया जाएगा:

  : : +-------+ +-------+ | | --->| B->2 |------>| | +-------+ | CPU 2 | : :| | +-------+ | |   , ---> --->| A->0 |~~~~ | |     +-------+ ~ | |   A : : ~ | | : :| | : : ~ | | : : ~ | | rrrrrrrrrrrrrrrr~ | | : : ~ | | : : ~-->| | : : | | : : +-------+ 

हालाँकि, यदि मेमोरी प्रोसेसर को किसी अन्य प्रोसेसर द्वारा अधिलेखित किया गया था, तो पहले पढ़ा गया मान छोड़ दिया जाएगा और रीड कमांड फिर से जारी की जाएगी:

  : : +-------+ +-------+ | | --->| B->2 |------>| | +-------+ | CPU 2 | : :| | +-------+ | |   , ---> --->| A->0 |~~~~ | |     +-------+ ~ | |   A : : ~ | | : :| | : : ~ | | : : ~ | | rrrrrrrrrrrrrrrrr | | +-------+ | |    ---> --->| A->1 |------>| |     +-------+ | | : : +-------+ 

कोर में स्पष्ट बाधाएं।

लिनक्स में विभिन्न प्रकार के अवरोध हैं जो विभिन्न स्तरों पर काम करते हैं:

• संकलक बाधाएँ।
• प्रोसेसर की बाधाएं।
• I / O लिखने की बाधाएं स्मृति (MMIO) में मैप की गईं।

संकलक बाधाएँ।

स्पष्ट कंपाइलर बैरियर कंपाइलर को बैरियर के एक तरफ से दूसरे तक मेमोरी एक्सेस के संचालन को रोकने से रोकता है:

  barrier(); 

यह केवल संकलक स्तर की बाधा है।

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

प्रोसेसर की बाधाएं।

निम्नलिखित 8 फ़ंक्शन लिनक्स में प्रोसेसर बाधाओं का प्रतिनिधित्व करते हैं:

      SMP ===================== ======================= ===========================   mb() smp_mb()  wmb() smp_wmb()  rmb() smp_rmb()    read_barrier_depends() smp_read_barrier_depends() 

, , .

: , (, a[b] b, — a[b]), .

, SMP- , .

: SMP- SMP-, .

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

I / O लिखने की बाधाएं स्मृति (MMIO) में मैप की गईं।

निम्नलिखित कार्य मेमोरी इनपुट / आउटपुट क्षेत्र में लिखने में बाधा है:

  mmiowb(); 

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

प्रोसेसर कैश के प्रभाव।

, , .

, ; , :

  <--- CPU ---> : <-----------  -----------> : +--------+ +--------+ : +--------+ +-----------+ | | | | : | | | | +--------+ |  | | | : |  | | | | | | CPU |--->| |----->| CPU |<-->| | | | | | | | : | | | |--->|  | | | | | : | | | | | | +--------+ +--------+ : +--------+ | | | | : |  | +--------+ : |  | : | - | +--------+ +--------+ +--------+ : +--------+ |  | | | | | | | : | | |  | | | |  | | | : |  | | |--->| -| | CPU |--->| |----->| CPU |<-->| | |  | | | | | : | | | | | | | | | | : | | | | +--------+ +--------+ +--------+ : +--------+ +-----------+ : : 

, , - , , .

, , - . , . , - .

, , , .