🤳🏽 🧟 🧚🏽 चौराहे पर डेवलपर: कैसे वेक्टर करना है? 🛫 ☘️ 🍀

वैश्वीकरण के विषय पर बहुत सी रोचक बातें लिखी गई हैं। आइए, एक उत्कृष्ट पोस्ट , जो ऑटो-वैश्वीकरण के काम के बारे में बहुत सारी उपयोगी बातें बताती है, इसे पढ़ने की अत्यधिक सलाह देते हैं। मुझे एक और सवाल में दिलचस्पी है। अब डेवलपर्स के पास "वेक्टर" कोड बनाने के लिए बड़ी संख्या में तरीके हैं - शुद्ध कोडांतरक से एक ही ऑटो-वेक्टराइज़र तक। किस तरह रोकें? आवश्यक और पर्याप्त के बीच संतुलन कैसे खोजें? हम इस बारे में बात करेंगे

तो, आप कई तरीकों से "पोषित" वेक्टर निर्देश प्राप्त कर सकते हैं। हम निम्न तालिका के रूप में योजनाबद्ध रूप से प्रतिनिधित्व करते हैं:

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

यह अब शुद्ध असेंबलर नहीं है, हालांकि, कोड को फिर से लिखने में अभी भी बहुत समय लगेगा। मान लीजिए कि एक साधारण लूप है जिसमें दो सरणियाँ जोड़ी जाती हैं, इस तरह दिखेगा:

#include <immintrin.h> double A[100], B[100], C[100]; for (int i = 0; i < 100; i += 4) { __m256d a = _mm256_load_pd(&A[i]); __m256d b = _mm256_load_pd(&B[i]); __m256d c = _mm256_add_pd(a, b); _mm256_store_pd(&C[i], c); }

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

एक ही उदाहरण के रूप में फिर से लिखा है:

 #include <dvec.h> // 4 elements per vector * 25 = 100 elements F64vec4 A[25], B[25], C[25]; for(int i = 0; i < 25; i++) C[i] = A[i] + B[i];

इस मामले में, हमें यह जानने की आवश्यकता नहीं है कि किन कार्यों का उपयोग करना है। कोड स्वयं काफी सुरुचिपूर्ण दिखता है, और डेवलपर के लिए वांछित वर्ग का डेटा बनाने के लिए यह पर्याप्त है। इस उदाहरण में, F64 का अर्थ है एक फ्लोट प्रकार का आकार 64 बिट्स, और vec4 इंटेल AVX (SSE के लिए vec2) का उपयोग करने के बारे में बात करता है।

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

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

 double A[1000], B[1000], C[1000], D[1000], E[1000]; for (int i = 0; i < 1000; i++) E[i] = (A[i] < B[i]) ? C[i] : D[i];

यदि हम आंतरिक कार्यों पर एक एनालॉग कोड बनाने की कोशिश करते हैं, तो वैश्वीकरण की गारंटी देते हुए, हमें कुछ इस तरह मिलेगा:

 double A[1000], B[1000], C[1000], D[1000], E[1000]; for (int i = 0; i < 1000; i += 2) { __m128d a = _mm_load_pd(&A[i]); __m128d b = _mm_load_pd(&B[i]); __m128d c = _mm_load_pd(&C[i]); __m128d d = _mm_load_pd(&D[i]); __m128d e; __m128d mask = _mm_cmplt_pd(a, b); e = _mm_or_pd( _mm_and_pd (mask, c), _mm_andnot_pd(mask, d)); _mm_store_pd(&E[i], e); }

यह अच्छा है जब कंपाइलर हमारे लिए ऐसा कर सकता है! यह अफ़सोस की बात है कि यह हमेशा नहीं होता है ... और ऐसे मामलों में जहां कंपाइलर सामना नहीं करता है, डेवलपर खुद उसकी मदद कर सकता है। ऐसा करने के लिए, आप निर्देशों के रूप में विशेष "ट्रिक्स" का उपयोग कर सकते हैं। उदाहरण के लिए, #pragma ivdep आपको बताएगा कि लूप में कोई निर्भरताएं नहीं हैं, और #pragma वेक्टर हमेशा आपको वैश्वीकरण की "दक्षता नीति" को अनदेखा करने की अनुमति देगा (अक्सर यदि कंपाइलर का मानना है कि चक्र को वेक्टर करना अक्षम है, कहते हैं, मेमोरी एक्सेस के कारण, यह है) ऐसा नहीं करता है)। लेकिन "शायद मदद" की श्रेणी से ये निर्देश। यदि कंपाइलर सुनिश्चित है कि निर्भरताएं हैं, तो यह लूप को वेक्टर नहीं करेगा, भले ही प्राग्म आइवीडीप हो।

इसलिए, मैंने दूसरे तरीके पर प्रकाश डाला, जो निर्देशों पर आधारित है, लेकिन काम के कई अन्य सिद्धांत हैं। ये क्रमशः नए मानक OpenMP 4.0 और Inte Cilk Plus #pragma omp simd और #pragma simd से निर्देश हैं। वे आपको अपने स्वयं के चेक के बारे में संकलक को पूरी तरह से "भूल" करने की अनुमति देते हैं, और डेवलपर द्वारा कहे गए पर पूरी तरह से भरोसा करते हैं। जिम्मेदारी, इस मामले में, स्वाभाविक रूप से उसके कंधों और सिर पर टिकी हुई है, इसलिए आपको सावधानी से कार्य करने की आवश्यकता है। इसलिए दूसरे तरीके की जरूरत है।

यह सुनिश्चित करने के लिए कि चेक अभी भी बने हुए हैं, लेकिन कोड को सदिश किए जाने की गारंटी है? दुर्भाग्य से, सी / सी ++ में मौजूद सिंटैक्स के साथ, कोई रास्ता नहीं है। लेकिन सरणियों (सरणी संकेतन) के साथ काम करने के लिए विशेष सिंटैक्स की क्षमताओं का उपयोग करना, जो कि Cilk Plus का हिस्सा है, ( पिछली पोस्ट को समझने के लिए कि वहां कितने हैं), यह संभव है। इसके अलावा, सिंटैक्स बहुत सरल है, कुछ हद तक फोरट्रान की याद दिलाता है, और इसका निम्न रूप है:

 base[first:length:stride]

नाम सेट करें, इंडेक्स शुरू करें, तत्वों की संख्या, चरण (वैकल्पिक) और आगे। पिछला उदाहरण इस तरह से इसके साथ फिर से लिखना होगा:

 double A[1000], B[1000], C[1000], D[1000], E[1000]; E[:] = (A[:] < B[:]) ? C[:] : D[:];

बृहदान्त्र का अर्थ है कि हम सभी तत्वों का उल्लेख कर रहे हैं। आप अधिक जटिल जोड़तोड़ भी कर सकते हैं। आइए बताते हैं यह कोड

 for (i = 0; i < 5; i++) A[(i*2) + 1] = B[(i*1) + 1];

अधिक कॉम्पैक्ट रूप से मेल खाएगा, और सबसे महत्वपूर्ण बात, यह वैश्वीकरण की गारंटी देता है:

 int A[10], *B; A[1:5:2] = B[1:5];

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

चौराहे पर डेवलपर: कैसे वेक्टर करना है?

More articles: