पेश है मोटे तौर पर फोरट्रान: क्या हम समानांतर होंगे?

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

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

समझने के लिए, बस एक सरल हैलो वर्ल्ड उदाहरण दें:

program hello write(*,*) "Hello world" end program hello 

दरअसल, सबसे आम कोड। बस -कोरे की (इंटेल कंपाइलर) के साथ इसे संकलित करने के बाद, हम प्रोग्राम की कई अलग-अलग प्रतियों से, या अलग-अलग Image'eys (छवियों) से, मोटे शब्दों में, "अभिवादन" देखेंगे। इसके अलावा, उनकी संख्या को नियंत्रित किया जा सकता है, उदाहरण के लिए –coarray-num-images = x स्विच, या FOR_COARRAY_NUM_IMAGES पर्यावरण चर के माध्यम से। यह स्पष्ट है कि निष्पादन किस तरीके से होता है, यह निर्धारित करने का एक तरीका है। आइए हमारे उदाहरण को जटिल करें:

 program hello_image write(*,*) "Hello from image ", this_image(), "out of ", num_images()," total images“ end program hello_image 

लॉन्च के बाद, हम कुछ इस तरह देखेंगे:

 Hello from image 1 out of 4 total images Hello from image 4 out of 4 total images Hello from image 2 out of 4 total images Hello from image 3 out of 4 total images 

जाहिर है, हमारे आवेदन को 4 बार (4 प्रतियां / छवि) चलाया गया था। मोटे के बारे में यह डेटा होने पर, हम, सिद्धांत रूप में, पहले से ही समानांतर अनुप्रयोग बनाने में सक्षम हैं।

यहां सिर्फ बहुत बेवकूफ हैं, क्योंकि मुख्य सवाल का कोई जवाब नहीं है - डेटा के बारे में क्या? इसके लिए एक बहुत ही सरल और स्पष्ट वाक्यविन्यास प्रस्तुत किया गया है:

 real, codimension[*] :: x real :: y[*] 

स्क्वायर कोष्ठक हमें बताते हैं कि हम मोटे का उपयोग करते हैं।
इस उदाहरण में, ये केवल स्केलर हैं जो अभी भी प्रोग्राम की प्रत्येक प्रति में उपलब्ध हैं। लेकिन अब हम इस स्केलर के मूल्य का उल्लेख उस प्रतिलिपि (छवि) में कर सकते हैं जिसकी हमें आवश्यकता है।

उदाहरण के लिए, y [2] लिखते हुए, हम चित्र 2 में y के मान की ओर मुड़ते हैं। यह डेटा के साथ "वास्तविक" समानांतर कार्य के लिए संभावनाओं को खोलता है।

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

 x = 42.0 

इस मामले में, हम छवि के लिए स्थानीय चर x के साथ काम कर रहे हैं।
जैसे ही वर्ग कोष्ठक हमारे कोड में दिखाई देते हैं, यह इस तथ्य का स्पष्ट संकेत है कि चर को किसी अन्य प्रोग्राम छवि में एक्सेस किया जा रहा है:

 x[3] = 42.0 !     42   3 x = x[1] !           1 x[i] = x[j] !     I      j 

मोटे के बारे में क्या अच्छा है, शुद्ध एमपीआई के विपरीत, हम संदेश भेजने या प्राप्त करने के बारे में परवाह नहीं करते हैं। यह सब कार्यान्वयन के कंधों पर है (जो पहले से ही एक ही एमपीआई का उपयोग करता है)। लेकिन हम "इससे ऊपर" हैं। इसके अलावा, कोड वितरित मेमोरी के साथ सिस्टम पर और साझा मेमोरी वाले सिस्टम पर दोनों काम करेगा। बस मोटे = साझा या मोटे = वितरित करने के लिए कुंजी बदलें।

चूंकि हमारे कार्यक्रम की विभिन्न प्रतियों में डेटा है, इसलिए यह मानना ​​तर्कसंगत है कि उन्हें सिंक्रनाइज़ करने के लिए साधन होना चाहिए। बेशक वे हैं। यह, उदाहरण के लिए, SYNC ALL निर्माण है, जो सभी छवियों को सिंक्रनाइज़ करता है। SYNC IMAGES () भी है, जो आपको केवल कुछ छवियों को सिंक्रनाइज़ करने की अनुमति देता है।

एक और उदाहरण:

 integer, codimension[*] :: fact integer :: i, factorial fact = this_image() SYNC ALL if ( this_image() == 1 ) then factorial = 1 do i = 1, num_images() factorial = factorial * fact[i] end do write(*, *) num_images(), 'factorial is ', factorial end if 

स्वाभाविक रूप से, यह तथ्य की गणना करने का सबसे तेज़ तरीका नहीं है, लेकिन यह अच्छी तरह से मोटे के साथ काम करने का सार दिखाता है।

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

नतीजतन, हमें एक बहुत प्रभावी उपकरण मिला - भाषा का एक हिस्सा जो आपको विभिन्न मेमोरी संगठन के साथ सिस्टम के समानांतर आवेदन बनाने की अनुमति देता है। स्वाभाविक रूप से, कॉइलर समर्थन और संकलक के कार्यान्वयन में मुख्य कठिनाई प्रदर्शन है। फिलहाल, यह अभी भी सबसे मजबूत बिंदु नहीं है ... लेकिन यहां विभिन्न कंपाइलरों के लिए काफी संभावनाएं हैं।

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