2011-09-08 18 views
10

मुझे पता है कि आधुनिक सीपीयू क्रम से निष्पादित हो सकते हैं, हालांकि वे हमेशा विकिपीडिया द्वारा वर्णित परिणामों में सेवानिवृत्त होते हैं।ऑर्डर निष्पादन और मेमोरी बाड़ से बाहर

"अन्य निर्देश तैयार कर रहे हैं के साथ समय में, तो फिर से आदेश अंत में परिणाम यह जाहिर होता है कि निर्देश के रूप में सामान्य प्रोसेस किया गया बनाने के लिए।" स्लॉट "ओडर प्रोसेसर में से इन भरने"

अब मल्टीकोर प्लेटफ़ॉर्म का उपयोग करते समय मेमोरी बाड़ की आवश्यकता होती है, क्योंकि ऑर्डर निष्पादन के कारण, x का गलत मान यहां मुद्रित किया जा सकता है।

Processor #1: 
while f == 0 
    ; 
print x; // x might not be 42 here 

Processor #2: 
x = 42; 
// Memory fence required here 
f = 1 

अब मेरी सवाल है, (मल्टीकोर प्रोसेसर मुझे लगता है के मामले में कोर) आदेश प्रोसेसर से बाहर के बाद से हमेशा में आदेश परिणाम रिटायर, तो क्या मेमोरी बाड़ की आवश्यकता है। मल्टीकोर प्रोसेसर के कोर न केवल अन्य कोरों से सेवानिवृत्त परिणाम देखता है या वे परिणाम भी देख रहे हैं जो उड़ान में हैं?

मैं उदाहरण मैं ऊपर दे दी है में मतलब है, जब प्रोसेसर 2 अंत में परिणाम संन्यास ले लेंगे, एक्स का परिणाम से पहले च आना चाहिए, है ना? मुझे पता है कि आदेश निष्पादन के दौरान यह एफx से पहले संशोधित हो सकता है लेकिन इसे x से पहले इसे सेवानिवृत्त नहीं किया होगा, है ना?

अब परिणाम और कैश समेकन तंत्र की इन-ऑर्डर सेवानिवृत्ति के साथ, आपको कभी भी x86 में मेमोरी बाड़ की आवश्यकता क्यों होगी?

+0

ध्यान दें कि मेमोरी बाड़ हमेशा सही कोड में जोड़े में आती है: जब दो धागे संवाद करते हैं, * प्रत्येक * थ्रेड को मेमोरी एक्सेस (= बाड़) के कुछ ऑर्डरिंग करना होता है। आम तौर पर, इन बाड़ों में से एक ने सेमेन्टिक्स जारी किया है, दूसरे ने अर्थशास्त्र हासिल किया है। अपने छद्म कोड में, प्रोसेसर # 2 को असाइनमेंट (रिलीज सेमेन्टिक्स) के बीच एक लेखन बाड़ निष्पादित करना चाहिए, और प्रोसेसर # 1 को लूप और 'प्रिंट' के बीच एक पठन बाड़ (अर्थशास्त्र प्राप्त करना) जोड़ना चाहिए। कुछ बाड़ विशिष्ट प्लेटफार्मों पर अनावश्यक हो सकती हैं, लेकिन किसी भी स्रोत कोड में दोनों बाड़ (जो नोप के लिए संकलित हो सकती है) होनी चाहिए। स्टोर बफर – cmaster

उत्तर

15

इस ट्यूटोरियल मुद्दों बताते हैं: http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-95-7.pdf

Fwiw, जहां स्मृति आदेश मुद्दों आधुनिक x86 प्रोसेसर पर होता है, कारण यह है कि जबकि 86 स्मृति स्थिरता मॉडल काफी मजबूत स्थिरता प्रदान करता है, स्पष्ट बाधाओं को पढ़ा संभालने के लिए आवश्यक कर रहे हैं लिखने के बाद स्थिरता। यह "स्टोर बफर" नामक किसी चीज़ के कारण है।

यह है कि, x86 अनुक्रमिक रूप से सुसंगत (अच्छा और आसान कारण है) को छोड़कर, लोड को पहले स्टोरों को फिर से व्यवस्थित किया जा सकता है। यही कारण है, प्रोसेसर अनुक्रम कार्यान्वित

store x 
load y 

तो प्रोसेसर बस इस रूप में

load y 
store x 

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

देखें http://download.intel.com/design/processor/manuals/253668.pdf

+2

+1, क्या आप कृपया स्टोर बफर को थोड़ा सा समझा सकते हैं और वे इस संदर्भ में क्यों महत्वपूर्ण हैं? –

+0

जैनब का उल्लेख करने के लिए – MetallicPriest

+0

क्या तालमेल को कैश नहीं करता है यह सुनिश्चित करता है कि x86 में रीड-आफ-लिखने की स्थिरता है? – MetallicPriest

7

में धारा 8.2 स्मृति बाड़ सुनिश्चित करता है कि बाड़ से पहले चर के सभी परिवर्तनों, अन्य सभी कोर करने के लिए दिखाई दे रहे हैं, ताकि सभी कोर डेटा की तारीख को देखने के लिए ऊपर एक है।

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

सर्वव्यापक 86/64 सहित कुछ आर्किटेक्चर,, एक निर्देश कभी कभी "पूर्ण बाड़" कहा जाता है सहित कई स्मृति बाधा निर्देश प्रदान करते हैं। एक पूर्ण बाड़ सुनिश्चित करता है कि बाड़ से पहले सभी लोड और स्टोर ऑपरेशंस बाड़ के बाद जारी किए गए किसी भी लोड और स्टोर से पहले किए गए होंगे।

यदि कोई डेटा डेटासेट पर पुराने डेटा के साथ काम करना शुरू कर रहा था, तो यह कभी भी सही परिणाम कैसे प्राप्त कर सकता है? इससे कोई फर्क नहीं पड़ता कि अंतिम परिणाम प्रस्तुत किया जाना था-अगर सभी सही क्रम में किए गए थे।

कुंजी संग्रह बफर, जो कैश और सीपीयू के बीच बैठता है में है, और यह करता है:

दूरदराज के सीपीयू को

स्टोर बफर अदृश्य

स्टोर बफर की अनुमति देता है याद करने के लिए लिखते हैं और/या कैश अनुकूलन इंटरकनेक्ट करने के लिए बचाया जा पहुँचता

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

संपादित करें:

कोड आपको एक उदाहरण के रूप में इस्तेमाल के लिए, विकिपीडिया इस कहते हैं:

एक स्मृति बाधा च को प्रोसेसर # 2 के असाइनमेंट से पहले डाला जा सकता है यह सुनिश्चित करें कि के नए मूल्य एक्स एफ के मूल्य में परिवर्तन से पहले अन्य प्रोसेसर या पर दृश्यमान है।

2

बस स्पष्ट क्या पिछले जवाब में निहित है बनाने के लिए, यह सही है, लेकिन स्मृति से अलग है पहुँचता:

सीपीयू आदेश से बाहर निष्पादित कर सकते हैं, हालांकि वे हमेशा परिणाम रिटायर in- आदेश शिक्षा का

सेवानिवृत्ति स्मृति पहुंच निष्पादित से अलग है, स्मृति का उपयोग अनुदेश सेवानिवृत्ति के लिए एक अलग समय में पूरा कर सकते हैं।

प्रत्येक कोर के रूप में अगर यह की अपनी स्मृति तक पहुँचता है सेवानिवृत्ति पर होते कार्य करेगा, लेकिन अन्य कोर अलग अलग समय पर उन पहुंच देख सकते हैं।

(x86 और एआरएम पर, मुझे लगता है कि केवल स्टोर ही इसके अधीन हैं, लेकिन उदाहरण के लिए, अल्फा स्मृति से पुराना मान लोड कर सकता है। X86 एसएसई 2 में सामान्य x86 व्यवहार से कमजोर गारेनटेस के साथ निर्देश हैं)।

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

+1

आउट-ऑफ-ऑर्डर सेवानिवृत्ति के लिए सैद्धांतिक प्रस्ताव हुए हैं ताकि 1k निर्देश आउट-ऑफ-ऑर्डर विंडो के साथ मेमोरी विलंबता को छिपाना संभव हो, बिना किसी अव्यवहारिक 1k प्रविष्टियों को सामान्य आरओबी स्केल किए। विशेष रूप से, किलो-निर्देश प्रोसेसर। Google ने इस लिंक को कुछ यादृच्छिक साइट पर पेपर पाया: http://cgi.di.uoa.gr/~halatsis/Advanced_Comp_Arch/General_presentations/ACM_online-Seminars/Valero/kilo-Instruction.pdf। और https://www.csl.cornell.edu/~martinez/doc/taco04.pdf भी। –

+1

और बीटीडब्ल्यू, एक एकल कोर अपनी याददाश्त के उपयोग को क्रम में देखता है, लेकिन उन्हें सेवानिवृत्ति के लिए इंतजार नहीं करना पड़ता है। स्टोर-फ़ॉरवर्डिंग स्टोर को रिटायर होने के इंतजार किए बिना हाल ही में संग्रहीत डेटा तक पहुंचने के लिए लोड को संभव बनाता है और (इसके बाद उसके बाद) L1D कैश को प्रतिबद्ध करता है। http://blog.stuffedcow.net/2014/01/x86-memory-disambiguation/ –

संबंधित मुद्दे