C ++ में रिमोट मेमोरी के लिए एक्सप्रेसिव स्मार्ट पॉइंटर्स बनाएं

नमस्कार, हेब्र!

आज हम C ++ में मेमोरी और पॉइंटर्स के साथ काम करने पर एक दिलचस्प अध्ययन का अनुवाद प्रकाशित कर रहे हैं। सामग्री थोड़ी अकादमिक है, लेकिन यह स्पष्ट रूप से गैलोविट्ज़ और विलियम्स की पुस्तकों के पाठकों के लिए रुचि होगी।

विज्ञापन का पालन करें!

स्नातक विद्यालय में, मैं वितरित डेटा संरचनाओं के निर्माण में लगा हूं। इसलिए, साफ और सुव्यवस्थित कोड बनाने के लिए मेरे काम में रिमोट पॉइंटर का प्रतिनिधित्व करने वाला अमूर्त अत्यंत महत्वपूर्ण है। इस लेख में, मैं बताऊंगा कि स्मार्ट पॉइंटर्स की आवश्यकता क्यों है, बताएं कि मैंने C ++ में अपनी लाइब्रेरी के लिए रिमोट पॉइंटर ऑब्जेक्ट्स कैसे लिखे, यह सुनिश्चित करें कि वे बिल्कुल नियमित C ++ पॉइंटर्स की तरह काम करते हैं; यह दूरस्थ लिंक ऑब्जेक्ट का उपयोग करके किया जाता है। इसके अलावा, मैं यह बताऊंगा कि किन मामलों में यह अमूर्तता इस साधारण कारण से विफल हो जाती है कि मेरा अपना पॉइंटर (अब तक) उन कार्यों का सामना नहीं करता है जो साधारण संकेत कर सकते हैं। मुझे उम्मीद है कि यह लेख उच्च स्तरीय अमूर्तताओं के विकास में शामिल पाठकों को दिलचस्पी देगा।

निम्न स्तर के एपीआई

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

void remote_read(void* dst, int target_node, int offset, int size); void remote_write(void* src, int target_node, int offset, int size); 

लक्ष्य नोड के साझा किए गए मेमोरी सेगमेंट में संकेतित ऑफसेट पर, remote_read इसमें से निश्चित संख्या में बाइट्स remote_read है, और remote_write एक निश्चित संख्या में बाइट्स लिखता है।

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

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

हटाए गए बिंदु

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

यदि हम मानते हैं कि हमारे पास ऊपर वर्णित लोगों के समान एक एपीआई होगा, तो मेमोरी में एक अद्वितीय स्थान दो "निर्देशांक" द्वारा इंगित किया जाएगा: (1) रैंक या प्रक्रिया आईडी और (2) इस रैंक के साथ प्रक्रिया द्वारा कब्जा किए गए दूरस्थ मेमोरी के साझा हिस्से के लिए किए गए ऑफसेट। । आप वहाँ नहीं रुक सकते और एक पूर्ण संरचना बना सकते हैं।

  template <typename T> struct remote_ptr { size_t rank_; size_t offset_; }; 

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

  template <typename T> T rget(const remote_ptr<T> src) { T rv; remote_read(&rv, src.rank_, src.offset_, sizeof(T)); return rv; } template <typename T> void rput(remote_ptr<T> dst, const T& src) { remote_write(&src, dst.rank_, dst.offset_, sizeof(T)); } 

ब्लॉक ट्रांसफर बहुत समान दिखते हैं, और यहां मैं उन्हें संक्षिप्तता के लिए छोड़ देता हूं। अब, मान पढ़ने और लिखने के लिए, आप निम्नलिखित कोड लिख सकते हैं:

  remote_ptr<int> ptr = ...; int rval = rget(ptr); rval++; rput(ptr, rval); 

यह मूल एपीआई से पहले से ही बेहतर है, क्योंकि यहां हम टाइप की गई वस्तुओं के साथ काम करते हैं। अब गलत प्रकार का मान लिखना या पढ़ना इतना आसान नहीं है या केवल एक वस्तु का एक हिस्सा लिखना है।

सूचक अंकगणित

सूचक अंकगणित सबसे महत्वपूर्ण तकनीक है जो एक प्रोग्रामर को स्मृति में मूल्यों के संग्रह का प्रबंधन करने की अनुमति देता है; अगर हम स्मृति में वितरित कार्य के लिए एक कार्यक्रम लिख रहे हैं, तो संभवतः हम मूल्यों के बड़े संग्रह के साथ काम करने जा रहे हैं।
डिलीट पॉइंटर को एक मतलब से बढ़ाना या घटाना क्या है? हटाए गए बिंदुओं के अंकगणित को साधारण बिंदुओं के अंकगणित के रूप में विचार करना सबसे सरल विकल्प है: पी + 1 बस मूल रैंक के साझा सेगमेंट में पी के बाद अगले sizeof(T) -लॉन्ग मेमोरी को इंगित करता है।

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

इस तरह से सूचक अंकगणित को लागू करना सरल है, और इसमें केवल सूचक ऑफसेट को बदलना शामिल है।

  template <typename T> remote_ptr<T> remote_ptr<T>::operator+(std::ptrdiff_t diff) { size_t new_offset = offset_ + sizeof(T)*diff; return remote_ptr<T>{rank_, new_offset}; } 

इस मामले में, हमारे पास वितरित मेमोरी में डेटा सरणियों तक पहुंचने का अवसर है। इसलिए, हम यह प्राप्त कर सकते हैं कि SPMD प्रोग्राम की प्रत्येक प्रक्रिया उस एरे में अपने वेरिएबल पर राइट या रीड ऑपरेशन करेगी, जिसमें रिमोट पॉइंटर को निर्देशित किया गया है [2]।

 void write_array(remote_ptr<int> ptr, size_t len) { if (my_rank() < len) { rput(ptr + my_rank(), my_rank()); } } 

अन्य संचालकों को लागू करना भी आसान है, साधारण सूचक अंकगणित में किए गए अंकगणितीय कार्यों के पूर्ण सेट के लिए सहायता प्रदान करना।

Nullptr का चयन करें

नियमित पॉइंटर्स के लिए, nullptr वैल्यू NULL , जिसका अर्थ आमतौर पर #define को 0x0 तक कम करना है, क्योंकि मेमोरी में इस सेक्शन का उपयोग करने की संभावना नहीं है। दूरस्थ पॉइंटर्स के साथ हमारी योजना में, हम या तो एक विशिष्ट सूचक मान को nullptr रूप में चुन सकते हैं, इस प्रकार इस स्थान को अप्रयुक्त मेमोरी में बना सकते हैं, या एक विशेष बूलियन सदस्य शामिल कर सकते हैं जो इंगित करेगा कि क्या सूचक शून्य है। इस तथ्य के बावजूद कि अप्रयुक्त मेमोरी में एक निश्चित स्थान बनाना सबसे अच्छा तरीका नहीं है, हम यह भी ध्यान में रखेंगे कि जब केवल एक बूलियन मान जोड़ते हैं, तो रिमोट पॉइंटर का आकार अधिकांश संकलक के दृष्टिकोण से दोगुना हो जाएगा और संरेखण बनाए रखने के लिए 128 से 256 बिट तक बढ़ जाएगा। यह विशेष रूप से अवांछनीय है। मेरे पुस्तकालय में, मैंने मान 0 nullptr रूप में {0, 0} , को 0 की रैंक के साथ 0 की एक ऑफसेट nullptr ।

nullptr लिए अन्य विकल्पों को चुनना संभव हो सकता है जो बस के रूप में भी काम करेंगे। इसके अलावा, कुछ प्रोग्रामिंग वातावरणों में, जैसे कि यूपीसी, संकीर्ण बिंदुओं को लागू किया जाता है जो प्रत्येक में 64 बिट्स में फिट होते हैं। इस प्रकार, उन्हें विनिमय के साथ परमाणु तुलनात्मक संचालन में उपयोग किया जा सकता है। एक संकीर्ण सूचक के साथ काम करते समय, आपको समझौता करना पड़ता है: या तो ऑफसेट पहचानकर्ता या रैंक पहचानकर्ता को 32 बिट्स या उससे कम में फिट होना चाहिए, और यह स्केलेबिलिटी को सीमित करता है।

हटाए गए लिंक

पायथन जैसी भाषाओं में, ब्रैकेट स्टेटमेंट __setitem__ और __getitem__ को कॉल करने के लिए सिंटैक्टिक शुगर के रूप में कार्य करता है, इस पर निर्भर करता है कि आप ऑब्जेक्ट पढ़ते हैं या इसे लिखते हैं। C ++ में, operator[] यह नहीं बताता कि कोई वस्तु किस श्रेणी की है और क्या लौटा मूल्य तुरंत पढ़ने या लिखने के अंतर्गत आएगा। इस समस्या को हल करने के लिए, C ++ डेटा संरचनाएं कंटेनर में निहित मेमोरी की ओर इशारा करते हुए लिंक लौटाती हैं, जिसे लिखा या पढ़ा जा सकता है। operator[] std::vector लिए कार्यान्वयन std::vector कुछ इस तरह लग सकता है।

  T& operator[](size_t idx) { return data_[idx]; } 

यहां सबसे महत्वपूर्ण तथ्य यह है कि हम टाइप T& की एक इकाई लौटाते हैं, जो एक कच्चा सी ++ लिंक है जिसके द्वारा आप लिख सकते हैं, और टाइप T की इकाई नहीं, जो केवल स्रोत डेटा के मूल्य का प्रतिनिधित्व करता है।

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

 template <typename T> struct remote_ref { remote_ptr<T> ptr_; operator T() const { return rget(ptr_); } remote_ref& operator=(const T& value) { rput(ptr_, value); return *this; } }; 

इस प्रकार, हम अपने रिमोट पॉइंटर को नई शक्तिशाली विशेषताओं के साथ समृद्ध कर सकते हैं, जिसकी उपस्थिति में इसे साधारण बिंदुओं की तरह ही डीरेल किया जा सकता है।

 template <typename T> remote_ref<T> remote_ptr<T>::operator*() { return remote_ref<T>{*this}; } template <typename T> remote_ref<T> remote_ptr<T>::operator[](ptrdiff_t idx) { return remote_ref<T>{*this + idx}; } 

इसलिए अब हमने पूरी तस्वीर दिखा दी है कि आप रिमोट पॉइंटर्स को सामान्य रूप से कैसे उपयोग कर सकते हैं। हम ऊपर दिए गए सरल प्रोग्राम को फिर से लिख सकते हैं।

 void write_array(remote_ptr<int> ptr, size_t len) { if (my_rank() < len) { ptr[my_rank()] = my_rank(); } } 

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

रनटाइम पर उत्पन्न होने वाली लागत (या इसके अभाव में!)

हालांकि, इस तरह के उच्च-स्तरीय अमूर्त उपयोग के लिए हमें क्या लागत आएगी? हर बार जब हम मेमोरी एक्सेस करते हैं, तो हम डेरेफेरिंग विधि को कॉल करते हैं, मध्यवर्ती ऑब्जेक्ट को लौटाते हैं जो पॉइंटर को लपेटता है, फिर हम रूपांतरण ऑपरेटर या असाइनमेंट ऑपरेटर को कॉल करते हैं जो मध्यवर्ती ऑब्जेक्ट को प्रभावित करता है। रनटाइम पर इसका क्या खर्च होगा?

यह पता चला है कि यदि आप पॉइंटर और रेफरेंस क्लासेस को ध्यान से देखते हैं, तो रनटाइम के दौरान इस एब्स्ट्रैक्शन के लिए कोई ओवरहेड नहीं होगा - आधुनिक C ++ कंपाइलर इन इंटरमीडिएट ऑब्जेक्ट्स और मेथड कॉल को आक्रामक एम्बेडिंग से संभालते हैं। मूल्यांकन करने के लिए कि इस तरह की अमूर्तता की कीमत क्या होगी, हम एक साधारण उदाहरण कार्यक्रम संकलित कर सकते हैं और जाँच सकते हैं कि असेंबली यह देखने के लिए जाएगी कि रनटाइम में कौन सी वस्तुएं और विधियाँ मौजूद होंगी। उदाहरण के रूप में यहां वर्णित पेड़-आधारित कटौती के साथ दूरदराज के remote_read और remote_write वर्गों के साथ संकलित किया गया है, आधुनिक संकलक पेड़-आधारित कटौती को कई remote_read और remote_write [4] से कम करते हैं। कोई वर्ग विधि नहीं कहलाती है, कोई संदर्भ वस्तु रनटाइम पर मौजूद नहीं है।

डेटा संरचना पुस्तकालयों के साथ सहभागिता

अनुभवी C ++ प्रोग्रामर याद रखें कि मानक C ++ टेम्प्लेट लायब्रेरी बताता है: STL कंटेनरों को कस्टम C ++ एलोकेटर्स का समर्थन करना चाहिए। आवंटनकर्ता आपको मेमोरी आवंटित करने की अनुमति देते हैं, और फिर इस मेमोरी को हमारे द्वारा बनाए गए पॉइंटर्स के प्रकारों का उपयोग करके संदर्भित किया जा सकता है। क्या इसका मतलब यह है कि आप बस एक "दूरस्थ आवंटनकर्ता" बना सकते हैं और इसे एसटीएल कंटेनरों का उपयोग करके दूरस्थ मेमोरी में डेटा स्टोर करने के लिए कनेक्ट कर सकते हैं?

दुर्भाग्य से, नहीं। संभवतः, प्रदर्शन कारणों से, C ++ मानक को अब कस्टम संदर्भ प्रकारों के लिए समर्थन की आवश्यकता नहीं है, और C ++ मानक लाइब्रेरी के अधिकांश कार्यान्वयन में वे वास्तव में समर्थित नहीं हैं। इसलिए, उदाहरण के लिए, यदि आप GCC से libstdc ++ का उपयोग करते हैं, तो आप कस्टम पॉइंटर्स का सहारा ले सकते हैं, लेकिन आपके लिए केवल सामान्य C ++ लिंक उपलब्ध हैं, जो आपको दूरस्थ मेमोरी में STL कंटेनरों का उपयोग करने की अनुमति नहीं देता है। कुछ उच्च-स्तरीय सी ++ टेम्पलेट लाइब्रेरी, उदाहरण के लिए, एजेंसी , जो कस्टम पॉइंटर प्रकार और संदर्भ प्रकारों का उपयोग करते हैं, में एसटीएल से कुछ डेटा संरचनाओं के अपने स्वयं के कार्यान्वयन होते हैं जो वास्तव में आपको दूरस्थ संदर्भ प्रकारों के साथ काम करने की अनुमति देते हैं। इस मामले में, प्रोग्रामर को एक प्रकार के आवंटनकर्ता, पॉइंटर्स और लिंक बनाने के लिए रचनात्मक दृष्टिकोण में अधिक स्वतंत्रता मिलती है, और, इसके अलावा, डेटा संरचनाओं का एक संग्रह प्राप्त करता है जो स्वचालित रूप से उनके साथ उपयोग किया जा सकता है।

व्यापक संदर्भ

इस लेख में, हमने कई व्यापक और अभी तक हल नहीं की गई समस्याओं का समाधान किया है।

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

नोट

[१] यूपीसी में, पॉइंटर्स में एक चरण होता है जो यह निर्धारित करता है कि पॉइंटर को एक के बाद एक बढ़ाकर क्या रैंक दिया जाएगा। चरणों के कारण, वितरित सरणियों को संकेत में समझाया जा सकता है, और उनमें वितरण पैटर्न बहुत भिन्न हो सकते हैं। ये विशेषताएं बहुत शक्तिशाली हैं, लेकिन वे एक नौसिखिए उपयोगकर्ता को जादुई लग सकते हैं। हालांकि कुछ यूपीसी इक्के वास्तव में इस दृष्टिकोण को पसंद करते हैं, एक अधिक उचित ऑब्जेक्ट-ओरिएंटेड दृष्टिकोण पहले एक साधारण रिमोट पॉइंटर क्लास लिखना है और फिर यह सुनिश्चित करना है कि डेटा विशेष रूप से इसके लिए डिज़ाइन किए गए डेटा संरचनाओं के आधार पर आवंटित किया गया है।

[२] HPC में अधिकांश एप्लिकेशन SPMD की शैली में लिखे गए हैं, इस नाम का अर्थ है "एक कार्यक्रम, विभिन्न डेटा।" SPMD API एक फ़ंक्शन या वैरिएबल my_rank() प्रदान करता है जो प्रोग्राम को निष्पादित करने वाली प्रक्रिया को एक अद्वितीय रैंक या आईडी बताता है, जिसके आधार पर यह फिर मुख्य प्रोग्राम से शाखा कर सकता है।

[३] यहाँ दूरस्थ सूचक वर्ग का उपयोग करते हुए SPMD शैली में एक सरल पेड़ की कमी लिखी गई है। कोड को मेरे सहयोगी एंड्रयू बेल्ट द्वारा लिखित एक कार्यक्रम के आधार पर रूपांतरित किया गया है।

  template <typename T> T parallel_sum(remote_ptr<T> a, size_t len) { size_t k = len; do { k = (k + 1) / 2; if (my_rank() < k && my_rank() + k < len) { a[my_rank()] += a[my_rank() + k]; } len = k; barrier(); } while (k > 1); return a[0]; } 

[४] उपरोक्त कोड का संकलित परिणाम यहां पाया जा सकता है ।