ओपनएचएमपीपी

ओपनएचएमपीपी (एचएमपीपी) हाइब्रिड मल्टीकोर पैरेलल प्रोग्रामिंग के लिए) - विषम कंप्यूटिंग के लिए प्रोग्रामिंग मानक। कंपाइलर निर्देशों के एक सेट के आधार पर, स्टैंडर्ड एक प्रोग्रामिंग मॉडल है जिसे GPGPU से जुड़ी जटिलता के बिना हार्डवेयर त्वरक को संभालने के लिए डिज़ाइन किया गया है। निर्देशों पर आधारित यह दृष्टिकोण लागू किया गया है क्योंकि वे एक एप्लिकेशन कोड और हार्डवेयर एक्सेलेरेटर (HWA) के उपयोग के बीच एक ढीले रिश्ते को सक्षम करते हैं।

परिचय

ओपनएचएमपीपी निर्देश-आधारित प्रोग्रामिंग मॉडल हार्डवेयर त्वरक पर गणनाओं को ऑफलोड करने और हार्डवेयर मेमोरी से/से डेटा आंदोलन को अनुकूलित करने के लिए एक सिंटैक्स प्रदान करता है।

यह मॉडल CAPS (एम्बेडेड और सुपरस्केलर प्रोसेसर के लिए कंपाइलर और आर्किटेक्चर) द्वारा शुरू किए गए कार्यों पर आधारित है, जो कंप्यूटर विज्ञान और नियंत्रण में अनुसंधान के लिए राष्ट्रीय संस्थान, फ्रेंच नेशनल सेंटर फॉर साइंटिफिक रिसर्च, रेन्नेस विश्वविद्यालय 1 और INSA का एक सामान्य प्रोजेक्ट है। रेन्नेस।

ओपनएचएमपीपी अवधारणा

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

ओपनएचएमपीपी कोडलेट अवधारणा

एक कोडलेट में निम्नलिखित गुण होते हैं:

1. यह एक शुद्ध कार्य है.
   • इसमें स्थैतिक चर या अस्थिर चर वैरिएबल घोषणाएं शामिल नहीं हैं और न ही किसी वैश्विक वैरिएबल का संदर्भ है, सिवाय इसके कि इन्हें एचएमपीपी निर्देश "निवासी" द्वारा घोषित किया गया हो।
   • इसमें अदृश्य बॉडी (जिसे इनलाइन नहीं किया जा सकता) के साथ कोई फ़ंक्शन कॉल शामिल नहीं है। इसमें पुस्तकालयों और सिस्टम फ़ंक्शंस जैसे मॉलोक, प्रिंटफ़, का उपयोग शामिल है ...
   • प्रत्येक फ़ंक्शन कॉल को एक स्थिर शुद्ध फ़ंक्शन (कोई फ़ंक्शन पॉइंटर्स नहीं) को संदर्भित करना चाहिए।
2. यह कोई मान नहीं लौटाता (सी (प्रोग्रामिंग भाषा) में शून्य फ़ंक्शन या फोरट्रान में एक सबरूटीन)।
3. तर्कों की संख्या निश्चित की जानी चाहिए (अर्थात यह C में stdarg.h की तरह एक विविध फ़ंक्शन नहीं हो सकता है)।
4. यह पुनरावर्ती नहीं है.
5. इसके मापदंडों को गैर-एलियास्ड माना जाता है (अलियासिंग (कंप्यूटिंग) और सूचक उपनाम देखें)।
6. इसमें कॉलसाइट निर्देश (यानी किसी अन्य कोडलेट के लिए आरपीसी) या अन्य एचएमपीपी निर्देश शामिल नहीं हैं।

ये गुण सुनिश्चित करते हैं कि एक कोडलेट सुदूर प्रणाली संदेश को HWA द्वारा दूरस्थ रूप से निष्पादित किया जा सकता है। यह RPC और इससे संबंधित डेटा स्थानांतरण अतुल्यकालिक हो सकते हैं।

कोडलेट आरपीसी

एचएमपीपी सिंक्रोनस और एसिंक्रोनस आरपीसी प्रदान करता है। एसिंक्रोनस ऑपरेशन का कार्यान्वयन हार्डवेयर पर निर्भर है।

सिंक्रोनस बनाम एसिंक्रोनस आरपीसी

एचएमपीपी मेमोरी मॉडल

एचएमपीपी दो एड्रेस स्पेस पर विचार करता है: होस्ट प्रोसेसर एक और एचडब्ल्यूए मेमोरी।

एचएमपीपीपी मेमोरी मॉडल

निर्देश अवधारणा

ओपनएचएमपीपी निर्देशों को एप्लिकेशन स्रोत कोड में जोड़े गए "मेटा-सूचना" के रूप में देखा जा सकता है। वे सुरक्षित मेटा-जानकारी हैं यानी वे मूल कोड व्यवहार को नहीं बदलते हैं। वे किसी फ़ंक्शन के दूरस्थ निष्पादन (आरपीसी) के साथ-साथ एचडब्ल्यूए मेमोरी में/से डेटा के स्थानांतरण को संबोधित करते हैं।

नीचे दी गई तालिका ओपनएचएमपीपी निर्देशों का परिचय देती है। ओपनएचएमपीपी निर्देश विभिन्न आवश्यकताओं को संबोधित करते हैं: उनमें से कुछ घोषणाओं के लिए समर्पित हैं और अन्य निष्पादन के प्रबंधन के लिए समर्पित हैं।

	Control flow instructions	Directives for data management
Declarations	codelet group	resident map mapbyname
Operational Directives	callsite synchronize region	allocate release advancedload delegatedstore

निर्देशों के सेट की अवधारणा

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

लेबल दो प्रकार के होते हैं:

• एक कोडलेट से संबंधित। सामान्य तौर पर, इस प्रकार के लेबल वाले निर्देश केवल एक कोडलेट के प्रबंधन तक सीमित होते हैं (इसे कोडलेट के समूह से अलग करने के लिए दस्तावेज़ के शेष भाग में स्टैंड-अलोन कोडलेट कहा जाता है)।
• कोडलेट्स के समूह से जुड़ा एक। इन लेबलों को इस प्रकार नोट किया गया है: "<LabelOfGroup>", जहां "LabelOfGroup" उपयोगकर्ता द्वारा निर्दिष्ट नाम है। सामान्य तौर पर, जिन निर्देशों पर इस प्रकार का लेबल होता है, वे पूरे समूह से संबंधित होते हैं। समूह की अवधारणा समस्याओं के एक वर्ग के लिए आरक्षित है जिसके प्रदर्शन को प्राप्त करने के लिए पूरे एप्लिकेशन में डेटा के विशिष्ट प्रबंधन की आवश्यकता होती है।

ओपनएचएमपीपी निर्देश सिंटैक्स

नोटेशन को सरल बनाने के लिए, एचएमपीपी निर्देशों के सिंटैक्स का वर्णन करने के लिए नियमित अभिव्यक्तियों का उपयोग किया जाएगा।

सिंटैक्स निर्देशों के विवरण के लिए नीचे दिए गए रंग सम्मेलन का उपयोग किया जाता है:

• आरक्षित एचएमपीपी कीवर्ड हरा;
• व्याकरण के वे तत्व जिन्हें एचएमपीपी कीवर्ड में अस्वीकार किया जा सकता है वे लाल;
• उपयोगकर्ता के वेरिएबल काले रंग में रहते हैं।

सामान्य वाक्यविन्यास

OpenHMPP निर्देशों का सामान्य सिंटैक्स है:

• सी भाषा के लिए:

#pragma hmpp <grp_label> [कोडलेट_लेबल]? निर्देश_प्रकार [,directive_parameters]* [&]

• फोरट्रान भाषा के लिए:

!$hmpp <grp_label> [कोडलेट_लेबल]? निर्देश_प्रकार [,directive_parameters]* [&]

कहाँ:

• <grp_label>: कोडलेट्स के समूह का नामकरण करने वाला एक विशिष्ट पहचानकर्ता है। ऐसे मामलों में जहां एप्लिकेशन में कोई समूह परिभाषित नहीं है, यह लेबल आसानी से छूट सकता है। कानूनी लेबल नाम को इस व्याकरण का पालन करना चाहिए: [a-z,A-Z,_][a-z,A-Z,0-9,_]*. ध्यान दें कि "<>" वर्ण सिंटैक्स से संबंधित हैं और इस प्रकार के लेबल के लिए अनिवार्य हैं।
• codelet_label: कोडलेट का नामकरण करने वाला एक विशिष्ट पहचानकर्ता है। कानूनी लेबल नाम को इस व्याकरण का पालन करना चाहिए: [a-z,A-Z,_][a-z,A-Z,0-9,_]*
• directive: निर्देश का नाम है;
• directive_parameters: निर्देश से जुड़े कुछ पैरामीटर निर्दिष्ट करता है। ये पैरामीटर विभिन्न प्रकार के हो सकते हैं और या तो निर्देश के लिए दिए गए कुछ तर्क निर्दिष्ट कर सकते हैं या निष्पादन का एक तरीका (उदाहरण के लिए एसिंक्रोनस बनाम सिंक्रोनस);
• [&]: एक वर्ण है जिसका उपयोग अगली पंक्ति पर निर्देश जारी रखने के लिए किया जाता है (सी और फोरट्रान के लिए समान)।

निर्देश पैरामीटर

किसी निर्देश से जुड़े पैरामीटर विभिन्न प्रकार के हो सकते हैं। नीचे OpenHMPP में परिभाषित निर्देश पैरामीटर दिए गए हैं:

• version = major.minor[.micro]: प्रीप्रोसेसर द्वारा विचार किए जाने वाले एचएमपीपी निर्देशों के संस्करण को निर्दिष्ट करता है।
• args[arg_items].size={dimsize[,dimsize]*}: एक गैर अदिश पैरामीटर (एक सरणी) का आकार निर्दिष्ट करता है।
• args[arg_items].io=[in|out|inout]: इंगित करता है कि निर्दिष्ट फ़ंक्शन तर्क या तो इनपुट, आउटपुट या दोनों हैं। डिफ़ॉल्ट रूप से, अयोग्य तर्क इनपुट होते हैं।
• cond = "expr": एक निष्पादन स्थिति को बूलियन सी या फोरट्रान अभिव्यक्ति के रूप में निर्दिष्ट करता है जिसे समूह या कोडलेट के निष्पादन को शुरू करने के लिए सत्य होना आवश्यक है।
• target=target_name[:target_name]*: निर्दिष्ट करता है कि दिए गए क्रम में किन लक्ष्यों का उपयोग करने का प्रयास करना है।
• asynchronous: निर्दिष्ट करता है कि कोडलेट निष्पादन अवरुद्ध नहीं हो रहा है (डिफ़ॉल्ट सिंक्रोनस है)।
• args[<arg_items>].advancedload=true: इंगित करता है कि निर्दिष्ट पैरामीटर पहले से लोड किए गए हैं। केवल इन या इनआउट पैरामीटर्स को प्रीलोड किया जा सकता है।
• args[arg_items].noupdate=true: यह संपत्ति निर्दिष्ट करती है कि डेटा पहले से ही HWA पर उपलब्ध है और इसलिए किसी स्थानांतरण की आवश्यकता नहीं है। जब यह संपत्ति सेट की जाती है, तो विचार किए गए तर्क पर कोई हस्तांतरण नहीं किया जाता है
• args[<arg_items>].addr="<expr>": <expr> एक अभिव्यक्ति है जो अपलोड किए जाने वाले डेटा का पता देती है।
• args[<arg_items>].const=true: इंगित करता है कि तर्क केवल एक बार अपलोड किया जाना है।

ओपनएचएमपीपी निर्देश

कोडलेट घोषित करने और निष्पादित करने के निर्देश

ए codelet निर्देश एक हार्डवेयर त्वरक पर दूरस्थ रूप से निष्पादित होने वाली गणना की घोषणा करता है। के लिए codelet निर्देश:

• कोडलेट लेबल अनिवार्य है और एप्लिकेशन में अद्वितीय होना चाहिए
• यदि कोई समूह परिभाषित नहीं है तो समूह लेबल की आवश्यकता नहीं है।
• कोडलेट निर्देश फ़ंक्शन घोषणा से ठीक पहले डाला जाता है।

निर्देश का सिंटैक्स है:

#pragma hmpp <grp_label> कोडलेट_लेबल कोडलेट
                            [, संस्करण = प्रमुख.मामूली[.माइक्रो]?]?
                            [, args[arg_items].io=में|बाहर|अंदर से*
                            [, args[arg_items].आकार={dimsize[,dimsize]*}]*
                            [, args[arg_items].const=true]*
                            [, cond=expr ]
                            [, लक्ष्य=target_name[:लक्ष्य_नाम]*]

विभिन्न उपयोगों या विभिन्न निष्पादन संदर्भों को निर्दिष्ट करने के लिए एक फ़ंक्शन में एक से अधिक कोडलेट निर्देश जोड़े जा सकते हैं। हालाँकि, किसी दिए गए कॉल साइट लेबल के लिए केवल एक कोडलेट निर्देश हो सकता है। callsite e> निर्देश निर्दिष्ट करता है कि प्रोग्राम में किसी दिए गए बिंदु पर कोडलेट का उपयोग कैसे किया जाए।

निर्देश का सिंटैक्स है:

#pragma hmpp <grp_label> कोडलेट_लेबल कॉलसाइट
                     [, अतुल्यकालिक]?
                     [, args[arg_items].आकार={dimsize[,dimsize]*}]*
                     [, args[arg_items].advancedload=सच|झूठा*
                     [, args[arg_items].addr= expr ]*
                     [, args[arg_items].noupdate=true]*

एक उदाहरण यहाँ दिखाया गया है:

 /* declaration of the codelet */
 #pragma hmpp simple1 codelet, args[outv].io=inout, target=CUDA
 static void matvec(int sn, int sm, float inv[sm], float inm[sn][sm], float *outv){
     int i, j;
     for (i = 0 ; i < sm ; i++) {
       float temp = outv[i];
       for (j = 0 ; j < sn ; j++) {
         temp += inv[j] * inm[i][ j];
     }
    outv[i] = temp;
  }
  
  int main(int argc, char **argv) {
    int n;
    ........
  
  /* codelet use */
  #pragma hmpp simple1 callsite, args[outv].size={n}
  matvec(n, m, myinc, inm, myoutv);
    ........
  }

कुछ मामलों में, पूरे एप्लिकेशन में डेटा के विशिष्ट प्रबंधन की आवश्यकता होती है (सीपीयू/जीपीयू डेटा मूवमेंट ऑप्टिमाइज़ेशन, साझा चर...)। group ई>निर्देश कोडलेट्स के समूह की घोषणा की अनुमति देता है। इस निर्देश में परिभाषित पैरामीटर समूह से संबंधित सभी कोडलेट्स पर लागू होते हैं। निर्देश का सिंटैक्स है:

#pragma hmpp <grp_label> समूह
                          [, संस्करण = <प्रमुख>.<छोटा>[.<माइक्रो>]?]?
                          [, लक्ष्य = target_name[:लक्ष्य_नाम]*?
                          [, cond = “expr”]?

संचार ओवरहेड को अनुकूलित करने के लिए डेटा स्थानांतरण निर्देश

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

• निर्देश आवंटित करें allocate e> निर्देश HWA को लॉक करता है और आवश्यक मात्रा में मेमोरी आवंटित करता है।

#pragma hmpp <grp_label> आवंटित [,args[arg_items].आकार={dimsize[,dimsize]*}]*

• निर्देश जारी करें release e> निर्देश निर्दिष्ट करता है कि किसी समूह या स्टैंड-अलोन कोडलेट के लिए HWA कब जारी करना है।

#pragma hmpp <grp_label>रिलीज़

• उन्नत लोड निर्देश advancedload ई> निर्देश कोडलेट के दूरस्थ निष्पादन से पहले डेटा प्रीफ़ेच करता है।
  

#pragma hmpp <grp_label> [कोडलेट_लेबल]? उन्नत लोड
                  ,args[arg_items]
                  [,args[arg_items].आकार={dimsize[,dimsize]*}]*
                  [,args[arg_items].addr= expr ]*
                  [,args[arg_items].सेक्शन={[subscript_triplet,]+}]*
                  [,अतुल्यकालिक]

• प्रत्यायोजितस्टोर निर्देश delegatedstore ई> निर्देश एक सिंक्रोनाइज़ेशन बाधा है जो एसिंक्रोनस कोडलेट निष्पादन के पूरा होने की प्रतीक्षा करता है और फिर परिणाम डाउनलोड करता है।
  

#pragma hmpp <grp_label> [कोडलेट_लेबल]? प्रतिनिधि स्टोर
                ,args[arg_items]
                [,args[arg_items].addr= expr ]*
                [,args[arg_items].सेक्शन={[subscript_triplet,]+}]*

• अतुल्यकालिक संगणनाएँ synchronize e> निर्देश एक एसिंक्रोनस कॉलसाइट निष्पादन के पूरा होने तक प्रतीक्षा करने को निर्दिष्ट करता है।

सिंक्रोनाइज़ निर्देश के लिए, कोडलेट लेबल हमेशा अनिवार्य होता है और यदि कोडलेट किसी समूह से संबंधित है तो समूह लेबल आवश्यक है।

#pragma hmpp <grp_label> कोडलेट_लेबल सिंक्रोनाइज़

• उदाहरण

निम्नलिखित उदाहरण में, डिवाइस आरंभीकरण, मेमोरी आवंटन और इनपुट डेटा का अपलोड केवल एक बार लूप के बाहर किया जाता है, लूप के प्रत्येक पुनरावृत्ति में नहीं। synchronize ई> निर्देश किसी अन्य पुनरावृत्ति को लॉन्च करने से पहले कोडलेट के अतुल्यकालिक निष्पादन के पूरा होने की प्रतीक्षा करने की अनुमति देता है। अंततः delegatedstore लूप के बाहर निर्देश sgemm परिणाम अपलोड करता है।

 int main(int argc, char **argv) {
 
 #pragma hmpp sgemm allocate, args[vin1;vin2;vout].size={size,size}
 #pragma hmpp sgemm advancedload, args[vin1;vin2;vout], args[m,n,k,alpha,beta]
   
 for ( j = 0 ; j < 2 ; j ++) {
    #pragma hmpp sgemm callsite, asynchronous, args[vin1;vin2;vout].advancedload=true, args[m,n,k,alpha,beta].advancedload=true
    sgemm (size, size, size, alpha, vin1, vin2, beta, vout);
    #pragma hmpp sgemm  synchronize
 }
 
 #pragma hmpp sgemm delegatedstore, args[vout]
 #pragma hmpp sgemm release

कोडलेट्स के बीच डेटा साझा करना

वे निर्देश सभी समूहों के लिए दिए गए नाम को साझा करते हुए सभी तर्कों को एक साथ जोड़ते हैं।

सभी मैप किए गए तर्कों के प्रकार और आयाम समान होने चाहिए। map e> निर्देश डिवाइस पर कई तर्कों को मैप करता है।

#pragma hmpp <grp_label> मानचित्र, तर्क[arg_items]

यह निर्देश काफी हद तक वैसा ही है map निर्देश सिवाय इसके कि मैप किए जाने वाले तर्क सीधे उनके नाम से निर्दिष्ट होते हैं। mapbyname ई> निर्देश एकाधिक के बराबर है map निर्देश

#pragma hmpp <grp_label>mapbyname [,variableName]+

=== वैश्विक चर === resident e> निर्देश एक समूह के भीतर कुछ चर को वैश्विक घोषित करता है। फिर उन वेरिएबल्स को समूह से संबंधित किसी भी कोडलेट से सीधे एक्सेस किया जा सकता है। यह निर्देश स्रोत कोड में इसके ठीक बाद घोषणा विवरण पर लागू होता है।

इस निर्देश का सिंटैक्स है:

#pragma hmpp <grp_label>निवासी
               [, args[::var_name].io=में|बाहर|अंदर से*
               [, args[::var_name].आकार={dimsize[,dimsize]*}]*
               [, args[::var_name].addr= expr ]*
               [, args[::var_name].const=true]*

संकेतन ::var_name उपसर्ग के साथ ::, निवासी के रूप में घोषित एप्लिकेशन के वेरिएबल को इंगित करता है।

क्षेत्रों का त्वरण

एक क्षेत्र कोडलेट/कॉलसाइट निर्देशों का एक विलय है। लक्ष्य कोडलेट बनाने के लिए कोड पुनर्गठन से बचना है। इसलिए, सभी विशेषताएँ उपलब्ध हैं codelet या callsite निर्देशों का उपयोग किया जा सकता है regions निर्देश

सी भाषा में:

#pragma hmpp [<MyGroup>] [लेबल] क्षेत्र
                           [, args[arg_items].io=में|बाहर|अंदर से*
                           [, cond = expr ]<
                           [, args[arg_items].const=true]*
                           [, लक्ष्य=target_name[:लक्ष्य_नाम]*]
                           [, args[arg_items].आकार={मंद आकार[,मंद आकार]*}]*
                           [, args[arg_items].advancedload=सच|झूठा*
                           [, args[arg_items].addr= expr ]*
                           [, args[arg_items].noupdate=true]*
                           [, अतुल्यकालिक]?
                           [, निजी=[arg_items]]*
   {
सी ब्लॉक स्टेटमेंट
   }

कार्यान्वयन

ओपनएचएमपीपी ओपन स्टैंडर्ड एचएमपीपी संस्करण 2.3 (मई 2009, सीएपीएस उद्यम) पर आधारित है।

OpenHMPP निर्देश-आधारित प्रोग्रामिंग मॉडल इसमें कार्यान्वित किया गया है:

• कैप्स कंपाइलर, हाइब्रिड कंप्यूटिंग के लिए कैप्स एंटरप्राइज कंपाइलर
• पाथस्केल ENZO कंपाइलर सूट (NVIDIA GPU का समर्थन)

OpenHMPP का उपयोग उच्च-प्रदर्शन कंप्यूटिंग अभिनेताओं द्वारा किया जाता हैतेल एवं गैस में, ऊर्जा, उत्पादन, वित्त, शिक्षा और अनुसंधान।

यह भी देखें

• जीपीजीपीयू
• समानांतर कंप्यूटिंग
• ओपनएसीसी
• ओपनसीएल