परमाणु संचालन

यह दिलचस्प हो गया कि वास्तव में संचालन की परमाणुता कैसे प्राप्त की जाती है। कौन परवाह करता है - बिल्ली में आपका स्वागत है।


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

1. एलएल / एससी

LL / SC कमांड के उदाहरण:
ldl_l / stl_c और ldq_l / stq_c (अल्फा), lwarx / stwcx (PowerPC), ll / sc (MIPS), और ldrex / strex (ARM 6 और ऊपर)।
कमांड जोड़े में दिए गए हैं, क्योंकि पहला ऑपरेंड के वर्तमान मूल्य को एक रजिस्टर या अन्य नियंत्रित स्थान पर लोड करता है, दूसरा ऑपरेंड में नए मूल्य को संग्रहीत करता है यदि ऑपरेंड 1 और 2 के बीच के अंतराल के लिए नहीं बदला है। साथ में, वे यह सुनिश्चित करते हैं कि उनके बीच के सभी कमांड ऑपरेन्ड के उसी संस्करण के साथ काम करते हैं जो एलएल का उपयोग करके लोड किया गया था। उदाहरण के लिए, lwarx / stwcx (PowerPC) युग्म लें:

void atomic_incr(int * operand, int incr) { asm volatile ( "loop:\n\t" /* repeat until this succeeds */ "lwarx 6,0,%0\n\t" /* reserve the operand */ "add 6,6,%1\n\t" /* add incr to it */ "stwcx. 6,0,%0\n\t" /* put the sum back, and release it */ "bne- loop" /* start-over on failure */ : : "r" (operand), "r" (incr) : "r6" ); } 

यहां से कोड लिया जाता है।
ऑपरेंड से डेटा 6 वें रजिस्टर में लोड किया जाता है और इसे (ऑपरेंड) आरक्षित किया जाता है। फिर 6 वीं रजिस्टर में हमें ऑपरेंड और इंक्री का योग मिलता है। अंत में, हम रजिस्टर में प्राप्त राशि को ऑपरेंड में अनलोड करते हैं और इसे जारी करते हैं। यदि ऑपरेंड के आरक्षण और रिलीज़ के बीच के अंतराल में इसका मूल्य वर्तमान ऑपरेशन के अलावा कहीं और बदल दिया जाएगा (भले ही वही मूल्य जो पहले से ही ऑपरेंड में संग्रहीत किया गया था), तो हमें एक त्रुटि मिलेगी। यह 5 वीं पंक्ति की जांच करता है, एक त्रुटि के मामले में फिर से ऑपरेशन शुरू करता है।

2. कैस

ऑपरेशन का सिद्धांत सरल है - हम देखते हैं कि ऑपरेंड में क्या मूल्य संग्रहीत है। यदि यह वही है जो हम उम्मीद करते हैं, तो हम इसे एक नए में बदल देंगे।
एल्गोरिथ्म:

 int compare_and_swap (int* reg, int oldval, int newval) { int old_reg_val = *reg; if (old_reg_val == oldval) *reg = newval; return old_reg_val; } 

कैस एक्सटेंशन - डबल तुलना और स्वैप ( CAS2 )। दो स्वतंत्र चर की ओर संकेत क्रमशः एक के बजाय, दो अपेक्षित मान और प्रत्येक चर के लिए दो नए मान दिए जाते हैं।
लेकिन एलएल / एससी की तुलना में टीमों का यह समूह अधिक "कमजोर" है, क्योंकि स्थिति संभव है:
प्रारंभिक शर्तें: तुलना_और_स्वाप (reg, 5, 7) और * reg = 5;
1) int old_reg_val = * reg; (old_reg_val = 5)
2) एक और ऑपरेशन * रेग = 42 करता है; funny_stuff; * रेग = 5;
3) यदि (old_reg_val == oldval) - कथन सत्य है, हालाँकि चर के मान में दो परिवर्तन हुए हैं। यही है, एक बदलाव हुआ है, लेकिन हमारे ऑपरेशन को इसके बारे में नहीं पता है। इस स्थिति को ABA समस्या कहा जाता है ।
इस समस्या के लिए कई वर्कअराउंड हैं। मुझे डबल-वर्ड तुलना-और-स्वैप दिलचस्प (अक्सर डबल तुलना और स्वैप के साथ भ्रमित) का उपयोग करने की विधि मिली।
एक उदाहरण:

 /* double-compare-and-swap: atomically sets the two-word data at address @mem * to the two-word value of @new if value at @mem * equals @old * @mem: pointer to value * @old: old value * @new: new value * * returns: 0 on failure, non-zero on success */ static inline char DWCAS(volatile DWORD *mem, DWORD old, DWORD new) { char r = 0; unsigned long old_h = old >> SHIFT, old_l = old; unsigned long new_h = new >> SHIFT, new_l = new; __asm__ __volatile__("lock; " CMPXCHGxB " (%6);" "setz %7; " : "=a" (old_l), "=d" (old_h) : "0" (old_l), "1" (old_h), "b" (new_l), "c" (new_h), "r" (mem), "m" (r) : "cc", "memory"); return r; } 

यहां से कोड लिया जाता है।
उपसर्ग "लॉक;" का अर्थ है कि मेमोरी एक्सेस बस का उपयोग केवल कमांड द्वारा किया जा सकता है।
प्रेषित शब्द में आवश्यक मान के साथ मेमोरी के लिए एक सूचक होता है और एक एबीए नंबर होता है जो प्रत्येक ऑपरेशन के साथ बदलता है (मैंने इसे पेटेंट में से एक में देखा था)।

3. सरल परमाणु संचालन।

यह आमतौर पर जोड़ या वृद्धि है।
आदेशों के उदाहरण: addl (i386), xaddl (x86)।
यहाँ विकिपीडिया से परमाणु परिवर्धन को लागू करना है:

 void atomic_add(int * operand, int incr) { asm volatile ( "lock; xaddl %1, (%0)\n" // add incr to operand : // no output : "r" (operand), "r" (incr) ); } 

कुछ आर्किटेक्चर पर, "लॉक;" उपसर्ग की जरूरत नहीं है। एक उदाहरण इटेनियम पर बढ़ रहा है ( यहाँ से लिया गया है ):

 void atomic_oneup(int * operand) { uint64_t res; // this MUST be 64 bits asm volatile ( "fetchadd4.rel %0=%1,%2" : "=r" (res) : "m" (*operand), "i" (1) : "memory" ); } 

वैसे, वेतन वृद्धि, कमी, + =, - = C ++ में परमाणु (कम से कम x86 और x86_64 पर) हैं। कोई उपसर्ग "लॉक" नहीं है, इसलिए कोई परमाणु भी नहीं है। सी ++ 11 में परमाणु संचालन दिखाई दिया।

 int a =0; ++a; 

के लिए संकलित करता है

 c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) 83 45 fc 01 addl $0x1,-0x4(%rbp) 

वेतन वृद्धि के लिए सबल होगा।

निष्कर्ष

प्रश्न: यह हर छात्र को पता है! इसके बारे में क्यों लिखें?
A: मैं सोच रहा था कि यह कैसे काम करता है। मैंने केवल कल्पना की थी कि कुछ प्रकार के ताले थे। मुझे उम्मीद है कि यह किसी और के लिए दिलचस्प था।

प्रश्न: लेख में बहुत सारी त्रुटियां और गलतियां हैं।
एक: लिखें, मैं ख़ुशी से इसे ठीक कर दूंगा।

प्रश्न: क्या? पहले से ही एक निष्कर्ष? लेख ही कहाँ है? MSI , कैश कोहरेंस और %_with_smart_words% कहां हैं?
A: मैंने गहरी खुदाई नहीं की। मुझे उम्मीद है कि इन विषयों को जानने वाले लोग इस बारे में लिखेंगे।

UPD: सुधार के लिए धन्यवाद lesha_penguin और TheShade ।