🎖️ 🖇️ 🤴🏻 सरल बहु-थ्रेडेड डेटा एक्सेस प्रकार और परमाणु चर 🔯 🎈 🔘

अलेक्जेंडर सैंडलर द्वारा पोस्ट, मूल लेख (23 दिसंबर, 2008)

परिचय

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

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

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

व्यावहारिक रूप में, परमाणु चर दो या दो से अधिक थ्रेड्स से एक साधारण चर तक पहुंचने की समस्या का सबसे अच्छा समाधान है।

परमाणु चर कैसे काम करते हैं

वास्तव में, बहुत सरल है। इंटेल x86 और x86_64 प्रोसेसर के आर्किटेक्चर (जैसे अन्य आधुनिक प्रोसेसर आर्किटेक्चर के विशाल बहुमत) के पास किसी भी मेमोरी एक्सेस ऑपरेशन के दौरान एफएसबी को ब्लॉक करने के निर्देश हैं। FSB का अर्थ है फ्रंट साइड बस। यह बस है जिसे प्रोसेसर रैम के साथ संचार करने के लिए उपयोग करता है। अर्थात्, FSB को अवरुद्ध करने से किसी भी अन्य प्रोसेसर (कोर) और इस प्रोसेसर पर चलने वाली प्रक्रिया को रैम तक पहुंचने से रोका जा सकेगा। और यह वही है जो हमें परमाणु चर को लागू करने की आवश्यकता है।

लिनक्स कर्नेल में परमाणु चर का व्यापक रूप से उपयोग किया जाता है, लेकिन किसी कारण से किसी ने उन्हें मानव उपयोगकर्ता मोड के लिए लागू करने की जहमत नहीं उठाई। जीसीसी से पहले 4.1.2।

परमाणु चर आकार सीमा

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

व्यवहार में, पूर्णांक 1, 2, 4 और 8 बाइट्स तक पहुँचने पर आप FSB को ब्लॉक कर सकते हैं। जीसीसी परमाणु ऑपरेशनों को लगभग पारदर्शी, लंबे, और लंबे लंबे (और उनके अहस्ताक्षरित समकक्षों) के साथ करने की अनुमति देता है।

आवेदन के विकल्प

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

decrement_atomic_value(); if (atomic_value() == 0) fire_a_gun();

एक परमाणु चर के मूल्य की कल्पना करें 1. क्या होता है यदि दो धागे एक ही समय में छद्म सी के इस हिस्से को निष्पादित करने की कोशिश करते हैं?

चलो हमारे मॉडलिंग में वापस आते हैं। यह संभव है कि थ्रेड 1 लाइन 1 चलाएगा और रुक जाएगा, जबकि थ्रेड 2 लाइन 1 चलाएगा और रनिंग लाइन 2 जारी रखेगा। बाद में, थ्रेड 1 जाग जाएगा और लाइन 2 को निष्पादित करेगा।

जब ऐसा होता है, तो थ्रेड्स में से कोई भी फायर_a_gun () प्रक्रिया (पंक्ति 3) शुरू नहीं करेगा। जाहिर है, यह एक गलत व्यवहार है, और अगर हम म्यूटेक्स या स्पिन लॉक का उपयोग करके कोड के इस हिस्से की रक्षा करते, तो ऐसा नहीं होता।

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

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

वास्तव में ...

कुछ सरल विशेषताएं हैं जो यह काम करती हैं। सबसे पहले, बारह (हाँ, बारह - 12) कार्य हैं जो परमाणु परिवर्धन, प्रतिस्थापन और तार्किक परमाणु या, और, एक्सोर और नंद बनाते हैं। प्रत्येक ऑपरेशन के लिए दो कार्य हैं। एक जो परिवर्तन होने से पहले चर का मान लौटाता है, और दूसरा वह परिवर्तन के बाद चर का मान लौटाता है।

यहाँ वास्तविक कार्य हैं:

 type __sync_fetch_and_add (type *ptr, type value); type __sync_fetch_and_sub (type *ptr, type value); type __sync_fetch_and_or (type *ptr, type value); type __sync_fetch_and_and (type *ptr, type value); type __sync_fetch_and_xor (type *ptr, type value); type __sync_fetch_and_nand (type *ptr, type value);

ये ऐसे फ़ंक्शंस हैं जो बदलने से पहले एक वैरिएबल का मान लौटाते हैं। दूसरी ओर, निम्न कार्य, परिवर्तन करने के बाद एक चर का मान लौटाते हैं।

 type __sync_add_and_fetch (type *ptr, type value); type __sync_sub_and_fetch (type *ptr, type value); type __sync_or_and_fetch (type *ptr, type value); type __sync_and_and_fetch (type *ptr, type value); type __sync_xor_and_fetch (type *ptr, type value); type __sync_nand_and_fetch (type *ptr, type value);

प्रत्येक अभिव्यक्ति का प्रकार निम्न में से एक हो सकता है:

 int unsigned int long unsigned long long long unsigned long long

ये तथाकथित अंतर्निहित फ़ंक्शन हैं, जिसका अर्थ है कि आपको उनका उपयोग करने के लिए किसी भी हेडर फ़ाइलों को शामिल करने की आवश्यकता नहीं है।

यह कार्रवाई में देखने का समय है

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

स्रोत कोड

 #include <stdio.h> #include <pthread.h> #include <unistd.h> #include <stdlib.h> #include <sched.h> #include <linux/unistd.h> #include <sys/syscall.h> #include <errno.h> #define INC_TO 1000000 //  ... int global_int = 0; pid_t gettid( void ) { return syscall( __NR_gettid ); } void *thread_routine( void *arg ) { int i; int proc_num = (int)(long)arg; cpu_set_t set; CPU_ZERO( &set ); CPU_SET( proc_num, &set ); if (sched_setaffinity( gettid(), sizeof( cpu_set_t ), &set )) { perror( "sched_setaffinity" ); return NULL; } for (i = 0; i < INC_TO; i++) { // global_int++; __sync_fetch_and_add( &global_int, 1 ); } return NULL; } int main() { int procs = 0; int i; pthread_t *thrs; //    procs = (int)sysconf( _SC_NPROCESSORS_ONLN ); if (procs < 0) { perror( "sysconf" ); return -1; } thrs = malloc( sizeof( pthread_t ) * procs ); if (thrs == NULL) { perror( "malloc" ); return -1; } printf( "Starting %d threads...\n", procs ); for (i = 0; i < procs; i++) { if (pthread_create( &thrs[i], NULL, thread_routine, (void *)(long)i )) { perror( "pthread_create" ); procs = i; break; } } for (i = 0; i < procs; i++) pthread_join( thrs[i], NULL ); free( thrs ); printf( "  ,  global_int value : %d\n", global_int ); printf( "  : %d\n", INC_TO * procs ); return 0; }

36 और 37 की पंक्तियों पर ध्यान दें। केवल वेरिएबल को बढ़ाने के बजाय, मैं बिल्ट-इन फ़ंक्शन का उपयोग करता हूं __ Sync_fetch_and_add () । इस कोड का निष्पादन स्पष्ट रूप से अपेक्षित परिणाम देता है - अर्थात, Global_int का मूल्य 4,000,000 है, जैसा कि अपेक्षित है (मशीन में प्रोसेसर की संख्या एक मिलियन से गुणा की जाती है - मेरे मामले में यह क्वाड-कोर मशीन है)। याद रखें, जब मैंने कोड का यह टुकड़ा चलाया था, तो लाइन 36 को छोड़कर , परिणाम 1,908,090 था, न कि 4,000,000, जैसा कि हमें उम्मीद थी।

सावधानियों

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

निष्कर्ष

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

अनुवादक का नोट

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

मैं ध्यान देता हूं कि इस समय परमाणु चर:

मानकों में वर्णित C11 (पी। 7.17) और C ++ 11 (पृष्ठ 29) - उनके कार्यान्वयन ज्यादातर मामलों में उपलब्ध हैं (हालांकि C11 के लिए अभी भी समस्याएं हैं);
बूस्ट के रूप में बूस्ट के लिए वर्णित और कार्यान्वित किया गया। परमाणु (हालांकि, यह कार्यान्वयन 1.50 को बढ़ावा देने में कभी शामिल नहीं किया गया था);
इंटेल थ्रेडिंग बिल्डिंग ब्लॉक में लागू किया गया।

सरल बहु-थ्रेडेड डेटा एक्सेस प्रकार और परमाणु चर