लूप की तुलना में वेक्टरेशन, सामान्य रूप से तेज़ क्यों है?

Question

क्यों, हार्डवेयर प्रदर्शन संचालन के निम्नतम स्तर पर और सामान्य अंतर्निहित संचालन शामिल हैं (यानी, कोडिंग करते समय सभी प्रोग्रामिंग भाषाओं के वास्तविक कार्यान्वयन के लिए चीजें सामान्य), क्या वेक्टरेशन आमतौर पर लूपिंग से नाटकीय रूप से तेज़ है?

लूपिंग करते समय कंप्यूटर क्या करता है जब यह वेक्टरेशन का उपयोग करते समय नहीं करता है (मैं कंप्यूटर की वास्तविक गणनाओं के बारे में बात कर रहा हूं, प्रोग्रामर क्या नहीं लिखता), या यह अलग-अलग क्या करता है?

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

Answer 1

वेक्टरेशन (जैसे शब्द सामान्य रूप से उपयोग किया जाता है) सिमड (एकल निर्देश, एकाधिक डेटा) ऑपरेशन को संदर्भित करता है।

इसका मतलब है, संक्षेप में, एक निर्देश समानांतर में कई ऑपरेटरों पर एक ही ऑपरेशन करता है। उदाहरण के लिए, एक स्केलर द्वारा आकार एन के एक वेक्टर के लिए, चलो ऑपरेटर की संख्या को उस आकार पर कॉल करें जिसे वह एक साथ चालू कर सकता है। यदि ऐसा है, तो इसे निष्पादित करने के लिए आवश्यक निर्देशों की संख्या लगभग एन/एम है, जहां (पूरी तरह से स्केलर ऑपरेशंस के साथ) इसे एन ऑपरेशंस करना होगा।

उदाहरण के लिए, इंटेल का वर्तमान AVX 2 निर्देश सेट 256-बिट रजिस्टरों का उपयोग करता है। इन्हें 64-बिट्स के 4 ऑपरेटरों के सेट, या 32 बिट्स के 8 ऑपरेटरों को एक सेट (और चालू) करने के लिए उपयोग किया जा सकता है।

तो, मान लीजिए कि आप 32-बिट, सिंगल-प्रेसिजन वास्तविक संख्याओं से निपट रहे हैं, इसका मतलब है कि एक ही निर्देश 8 ऑपरेशन (गुणा, आपके मामले में) एक बार में कर सकता है, इसलिए (कम से कम सिद्धांत में) आप कर सकते हैं केवल एन/8 गुणा निर्देशों का उपयोग करके एन गुणों को खत्म करें। कम से कम सिद्धांत में, यह ऑपरेशन को एक समय में एक निर्देश निष्पादित करने की अनुमति देने के लिए लगभग 8 गुना तेजी से पूरा करने की अनुमति देनी चाहिए।

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

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

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

फिर, बहु-थ्रेडिंग - अलग-अलग प्रोसेसर/कोर पर (कम से कम तार्किक रूप से) निर्देशों की एकाधिक धाराएं चल रही हैं।

तो, एक आधुनिक सीपीयू कह सकता है, 4 कोर, जिनमें से प्रत्येक प्रति घड़ी 2 वेक्टर गुणा निष्पादित कर सकता है, और उनमें से प्रत्येक निर्देश 8 ऑपरेटरों पर काम कर सकता है। तो, कम से कम सिद्धांत में, यह प्रति घड़ी 4 * 2 * 8 = 64 संचालन कर सकता है।

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

Answer 2

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

कई संख्यात्मक समस्याएं, विशेष रूप से आंशिक अंतर समीकरणों का समाधान, बड़ी संख्या में कोशिकाओं, तत्वों या नोड्स के लिए समान गणना की आवश्यकता होती है। वेक्टरिज़ेशन समानांतर में कई कोशिकाओं/तत्वों/नोड्स के लिए गणना करता है।

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

Answer 3

वेक्टरेशन के दो मुख्य लाभ हैं।

1. प्राथमिक लाभ यह है कि हार्डवेयर वेक्टर निर्देश समर्थन करने के लिए तैयार किया गया है आम तौर पर हार्डवेयर कि सामान्य रूप में कई ALU ऑपरेशनों को जब वेक्टर निर्देश उपयोग किया जाता है में सक्षम है है। उदाहरण के लिए, यदि आप इसे 16-तत्व वेक्टर निर्देश के साथ 16 परिवर्धन करने के लिए कहते हैं, तो इसमें 16 समानांतर योजक हो सकते हैं जो सभी परिवर्धन एक साथ कर सकते हैं। उन सभी योजकों तक पहुंचने के लिए केवल तरीका वेक्टरेशन के माध्यम से है। स्केलर निर्देशों के साथ आपको केवल 1 अकेला योजक मिलता है।

2. आमतौर पर वेक्टर निर्देशों का उपयोग करके कुछ ओवरहेड बचाया जाता है। आप बड़े हिस्से में डेटा लोड करते हैं और स्टोर करते हैं (कुछ हालिया इंटेल सीपीयू पर एक समय में 512 बिट्स तक) और प्रत्येक लूप पुनरावृत्ति अधिक काम करता है ताकि लूप ओवरहेड आम तौर पर सापेक्ष अर्थ में कम हो, और आपको कम निर्देशों की आवश्यकता है आदि, तो सीपीयू सामने के अंत भूमि के ऊपर कम है एक ही काम करते हैं

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

---

या 16 वर्ष की कम से कम 15, शायद एक अदिश संचालन करने के लिए भी किया जाता है।

आप लूप अनलोलिंग की लागत पर स्केलर मामले में शायद समान लूप-ओवरहेड लाभ प्राप्त कर सकते हैं।