std :: परमाणु | तुलना_exchange_weak बनाम तुलना_exchange_strong

Question

मैं अभी भी अनिश्चित हूं अगर मुझे समझ में नहीं आ रहा है या दस्तावेज़ीकरण स्पष्ट रूप से तैयार नहीं किया गया है।

bool atomic_compare_exchange_weak(volatile A* object, C * expected, C desired); 
bool atomic_compare_exchange_weak(A* object, C * expected, C desired); 
bool atomic_compare_exchange_strong(volatile A* object, C * expected, C desired); 
bool atomic_compare_exchange_strong(A* object, C * expected, C desired); 
bool atomic_compare_exchange_weak_explicit(volatile A* object, C * expected, C desired, memory_order success, memory_order failure); 
bool atomic_compare_exchange_weak_explicit(A* object, C * expected, C desired, memory_order success, memory_order failure); 
bool atomic_compare_exchange_strong_explicit(volatile A* object, C * expected, C desired, memory_order success, memory_order failure); 
bool atomic_compare_exchange_strong_explicit(A* object, C * expected, C desired, memory_order success, memory_order failure); 
bool A::compare_exchange_weak(C & expected, C desired, memory_order success, memory_order failure) volatile; 
bool A::compare_exchange_weak(C & expected, C desired, memory_order success, memory_order failure); 
bool A::compare_exchange_strong(C & expected, C desired, memory_order success, memory_order failure) volatile; 
bool A::compare_exchange_strong(C & expected, C desired, memory_order success, memory_order failure); 
bool A::compare_exchange_weak(C & expected, C desired, memory_order order = memory_order_seq_cst) volatile; 
bool A::compare_exchange_weak(C & expected, C desired, memory_order order = memory_order_seq_cst); 
bool A::compare_exchange_strong(C & expected, C desired, memory_order order = memory_order_seq_cst) volatile; 
bool A::compare_exchange_strong(C & expected, C desired, memory_order order = memory_order_seq_cst); 

टिप्पणी: निम्नलिखित अंश नवीनतम मसौदा (N3126, खंड 29.6) से लिया गया है कमजोर तुलना और विनिमय संचालन नकली तौर पर विफल हो सकता है, है कि, झूठी वापसी करते हुए छोड़ने मेमोरी की सामग्री द्वारा इंगित की गई है कि ऑपरेशन ऑब्जेक्ट जैसा ही है और ऑपरेशन के बाद अपेक्षित के समान ही है। [नोट: यह नकली विफलता के कार्यान्वयन को व्यापक मशीनों की श्रेणी पर तुलना-और-विनिमय के कार्यान्वयन को सक्षम बनाता है, उदाहरण के लिए, लोडरॉक स्टोर-सशर्त मशीनें। नकली विफलता का परिणाम है कि कमजोर की लगभग सभी उपयोग तुलना-और-विनिमय लूप में होंगे।

तो, इसका क्या अर्थ है? सबसे पहले, यह 'असफल' असफल हो सकता है ?! ऐसा क्यों करता है और वे 'मई' को कैसे परिभाषित करते हैं? दूसरा, मुझे नहीं पता क्यों, लेकिन मुझे अभी भी पता नहीं है कि "_strong" और "_weak" प्रत्यय वाले कार्यों के बीच क्या अंतर है।

आशा है कि कोई भी मदद कर सके;) सर्वश्रेष्ठ संबंध।

संपादित करें: यही कारण है कि मैं libstdc में ++ पाया देता है - जैसे कार्यान्वयन (atomic_0.h):

bool compare_exchange_weak(
    __integral_type& __i1, 
    __integral_type __i2, 
    memory_order __m1, 
    memory_order __m2 
) 
{ 
    __glibcxx_assert(__m2 != memory_order_release); 
    __glibcxx_assert(__m2 != memory_order_acq_rel); 
    __glibcxx_assert(__m2 <= __m1); 
    return _ATOMIC_CMPEXCHNG_(this, &__i1, __i2, __m1); 
} 

bool compare_exchange_strong(
    __integral_type& __i1, 
    __integral_type __i2, 
    memory_order __m1, 
    memory_order __m2 
) 
{ 
    __glibcxx_assert(__m2 != memory_order_release); 
    __glibcxx_assert(__m2 != memory_order_acq_rel); 
    __glibcxx_assert(__m2 <= __m1); 
    return _ATOMIC_CMPEXCHNG_(this, &__i1, __i2, __m1); 
} 

Answer 1

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

अधिक जानकारी के लिए, उदाहरण देखें

http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-95-7.pdf

अध्याय 12 और परिशिष्ट सी http://kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html

Answer 2

नोट में एक सुराग देता है, LL/SC आर्किटेक्चर का जिक्र है। विकिपीडिया आलेख से:

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

एलएल/एससी के वास्तविक कार्यान्वयन हमेशा सफल नहीं होते हैं यदि प्रश्न में स्मृति स्थान के लिए कोई समवर्ती अपडेट नहीं हैं। एक संदर्भ स्विच, एक और लोड-लिंक, या यहां तक ​​कि (कई प्लेटफॉर्म पर) एक और लोड या स्टोर ऑपरेशन के बीच दो असाधारण घटनाओं के बीच कोई असाधारण घटनाएं, स्टोर-सशर्त को असफल रूप से असफल होने का कारण बनती हैं।

डालूँगा/एससी चिप्स compare_exchange डालूँगा/एससी के मामले में लागू किया जाएगा, जो नकली तौर पर असफल हो सकता है, इसलिए compare_exchange_strong जरूरतों अतिरिक्त भूमि के ऊपर विफलता के मामले में पुन: प्रयास करने पर

। compare_exchange_strong और compare_exchange_weak प्रदान करने से प्रोग्रामर यह तय करने की अनुमति देता है कि वे लाइब्रेरी को नकली असफलताओं को संभालने के लिए चाहते हैं (इस मामले में वे compare_exchange_strong का उपयोग करेंगे या यदि वे इसे अपने कोड में संभालना चाहते हैं (इस मामले में वे compare_exchange_weak का उपयोग करेंगे)