एक फ़्लोटिंग पॉइंट टूल चुनना - व्यावहारिक सुझाव

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

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

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

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

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

दूसरे दिन, मुझे एक सरल एल्गोरिथ्म के निष्पादन को अनुकूलित करने की आवश्यकता थी: 1 से दो सौ मिलियन तक सभी पूर्णांकों की साइन की राशि की गणना। वास्तव में, निश्चित रूप से, वास्तविक एल्गोरिथ्म कुछ अलग था, लेकिन मैं समस्याओं के समान वर्ग को हल करने के लिए एक इष्टतम उपकरण की तलाश कर रहा था, प्रारंभिक चरण में प्रत्येक प्रोटोटाइप में एक पूर्ण बुनियादी ढांचे का निर्माण करने का कोई मतलब नहीं था, इसलिए मैंने एल्गोरिथ्म को सीमा तक सरल किया। यदि आप सोच रहे हैं कि इस तरह के एल्गोरिदम की आवश्यकता क्यों हो सकती है, तो मुझे याद है कि त्रिकोणमितीय कार्यों का उपयोग किया जा सकता है, उदाहरण के लिए, कृत्रिम तंत्रिका नेटवर्क के लिए दहलीज सक्रियण फ़ंक्शन के रूप में। Spoiler: अध्ययन के परिणाम मेरे लिए पूरी तरह से अप्रत्याशित थे!

समस्या कथन:

कार्य बेंच: दोहरी एक्सोन E5 2670 @ 2.6 घिरे समय के दौरान सीपीयू आवृत्ति को कम करने वाली शामिल ऊर्जा-बचत प्रौद्योगिकी के साथ Ghz, हाइपरट्रेडिंग के साथ 2x8 भौतिक कोर, विंडोज सर्वर 2008-092 प्लेटफॉर्म पर 128 जीबी डीडीआर 3-1600 मेमोरी।



एक शुरुआत के लिए डबल सटीक (डबल, यानी, मानक x86 कोप्रोसेसर प्रारूपों में से एक) हमें पूरी तरह से संतुष्ट करेगा। आइए देखें कि विभिन्न संकलक, और फिर अलग-अलग कंप्यूटिंग आर्किटेक्चर, साइन की राशि की गणना के कार्य से कैसे निपटते हैं। दौड़ में भाग लेने वाले: मेपल 12, मेपल 17, मैटलैब R2013a, विजुअल बेसिक 6.0, विजुअल बेसिक.नेट और विजुअल C ++ 2012 (सामान्य तौर पर, जो हाथ में थे)। सभी समय मापन एक पुनरारंभ के बाद लिया गया था, और खर्च किए गए औसत समय के अनुरूप था।

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

आइए मेपल के साथ शुरू करते हैं:

st := time():evalhf(sum(sin(i),i=1..200000000));time() - st; 

मेपल 12 परिणाम:
1.25023042417602160 54.304 सेकंड में।

मेपल 17 परिणाम:
1.25023042417610020 19.656 सेकेंड में।

पहली नज़र में, मेपलसॉफ्ट इंजीनियरों का महान काम। उत्पाद के संस्करण से संस्करण में 75% सुधार हुआ। आइए देखें कि क्या 17 वां संस्करण भी इस प्रक्रिया को संकलित कर सकता है। भोले-भाले बुला रहे हैं

 cp:=Compiler:-Compile(proc(j::integer)::float;local i::integer: evalhf(sum(sin(i),i=1..j)) end proc:): 

हमें एक प्रक्रिया मिलती है जो किसी कारण से किसी भी स्थिति में शून्य पैदा करती है। हम एक वैकल्पिक - एक स्पष्ट चक्र का प्रयास करते हैं।

 p2 := proc(j::integer)::float;local i::integer,res::float;res:=0; for i from 1 to j do: res:=res+evalhf(sin(i)):end do; res end proc: 

यदि आप संकलन के बिना P2 चलाते हैं, तो परिणाम इंतजार नहीं कर सकता! कम से कम मैंने 10 मिनट इंतजार किया और हार मान ली। जाहिर है, मेपल रनटाइम के लिए, लूप की तुलना में योग फ़ंक्शन काफी अनुकूलित है। यद्यपि

 cp2:=Compiler:-Compile(p2): st := time():cp2(200000000);time() - st; 

मेपल 17 में एक उत्कृष्ट परिणाम देता है:
9.360 सेकेंड में 1.25023042417610020!

प्रणाली की "चाल" के बावजूद, दृढ़ता और सरलता दिखाते हुए, हम एक उत्कृष्ट प्रदर्शन को बढ़ावा देने में सक्षम थे :-)

Microsoft Visual Studio 2012 पर आगे बढ़ रहा है

मुझे अच्छी तरह से याद है कि कैसे एक समय पर मुझे अपने संकलित कोड की भयानक सुस्ती के साथ नेट प्लेटफॉर्म पर गहरी निराशा हुई थी। मेरा परीक्षण मामला (संकलित!) VB.Net 2003 में VB6 कोड की तुलना में लगभग 8 गुना धीमा था, इसलिए मुझे VB.Net 2012 के लिए एक परियोजना बनाते समय कोई भ्रम नहीं था।

 Public Class Form1 Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load Dim i As Long, res As Double, tm As DateTime tm = Now For i = 1 To 200000000 res = res + Math.Sin(i) Next TextBox1.Text = res & vbNewLine & Now.Subtract(tm).TotalSeconds.ToString("0.000") End Sub End Class 

जैसा कि यह निकला, व्यर्थ में!

VB.Net 2012 का परिणाम:
11.980 सेकंड में 1.25023042417527। बुरा नहीं है!

बेशक, मैंने विज़ुअल C ++ कंपाइलर को अनुकूलित करने के लिए मुख्य आशाएँ सौंपी हैं, जो किसी नेट स्लैग के बिना, अपने मूल निष्पादन योग्य कोड में निम्नलिखित प्रक्रिया को संकलित करने का इरादा रखता है:

 #include <iostream> #include <windows.h> using namespace std; int main() { double res=0.0; int dw = GetTickCount(); for (int i = 1; i <= 200000000; i++) res+=sin(i); cout.precision(20); cout << "Result: " << res << " after " << (GetTickCount()-dw); } 

उपयोग की जाने वाली चाबियां / O2 और / Ot हैं:


VC ++ का परिणाम। नेट 2012:
बिल्कुल प्रभावित नहीं: 11.404 सेकंड में 1.2502304241761002।

पुराने स्कूल VB6 की बारी

कोड बहुत सरल लगता है:

  res = 0: for i = 1 To 200000000: res = res + Sin(i) : Next i 

हम अधिकतम अनुकूलन के साथ संकलित करते हैं:



और हमें VB6 के मुकाबले में चैंपियन मिला:
परिणाम: 1.25023042417543, समय बिताया: 0:00:09 (9.092153)

अब मुझे समझाएं कि 12 साल पहले का उत्पाद किस तरह से नए कंपाइलरों को सभी प्रकार से समर्पित करता है! ऐसा लगता है कि एमएस अपमानजनक है, लेकिन यह एक और बातचीत का विषय है। यदि आप डिस्सेम्बलर लिस्टिंग को देखते हैं, तो आप देख सकते हैं कि वीसी ++ कंपाइलर ने ईमानदारी से कोड को सदिश कर दिया है:



यह सच है, मैं SSE2 पर इस साइन कार्यान्वयन के विवरण को नहीं जानता, लेकिन विजुअल बेसिक 6 द्वारा उपयोग किए गए FPU स्टैक सिंगल-ऑपरेंड कमांड को खो देता है तो क्या अच्छा है? मैं आपको एक रहस्य बताता हूं, इस तरह की अप्रिय खोज के बाद, मैंने इंटेल समानांतर स्टूडियो XE 2013 का एक परीक्षण संस्करण डाउनलोड किया और QxSSE4.2 कुंजी के साथ Intel C ++ 13 कंपाइलर में प्रोजेक्ट को फिर से बनाया, और फिर QxAVX - परिणाम 13-15 सेकंड के क्षेत्र में और भी बदतर हो गए। इस तरह के परिणामों के बाद, एक जंगली विचार उत्पन्न हुआ - शायद मेरे सर्वर के प्रोसेसर के साथ सब कुछ नहीं है? मैंने एक और मशीन पर VB6 और VC ++ 2012 की तुलना शुरू की, दो कोर के साथ एक पुराना कोर डुओ 6600। SSE संस्करण का अंतराल और भी बड़ा है। केवल तार्किक व्याख्या यह है कि कोर वास्तुकला के साथ शुरू, इंटेल इंजीनियरों ने एसएसई की तुलना में एफपीयू संचालन के प्रदर्शन में काफी सुधार किया, और माइक्रोसॉफ्ट और इंटेल कंपाइलर्स के डेवलपर्स ने इस तथ्य को खो दिया।

ऊपर की तस्वीर में, आप, वैसे, देख सकते हैं कि हॉट स्पॉट मोड में Vtune एम्पलीफायर प्रोफाइलर SSE निर्देशों के लिए समय गणना के साथ सामना नहीं कर सकता है। यदि आप उसे मानते हैं, तो मेरे कोड में सबसे अधिक समय लेने वाला ऑपरेशन लूप काउंटर को बढ़ाना है! शैक्षणिक रुचि से बाहर, चूंकि इंटेल पैकेज स्थापित किया गया था, मैंने एडवाइजर XE 2013 उत्पाद के माध्यम से मॉड्यूल चलाया, जिसे कोड में स्थानों को दिखाने के लिए डिज़ाइन किया गया था जिसे समानांतर किया जा सकता है। डेटा निर्भरता के बिना एक छोटे चक्र में, साझा निष्पादन के बिना साझा संसाधनों के बिना, इस उत्पाद को ऐसे स्थान नहीं मिल सकते हैं। खैर, और अधिक जटिल मामलों में इस कार्यक्रम पर भरोसा कैसे करें? तेजी से, एक भावना है कि इंटेल प्रोग्रामर उत्पादों को जारी कर रहे हैं, हालांकि अच्छी तरह से प्रचारित हैं, लेकिन अभ्यास के लिए बहुत कम उपयोग (और न केवल प्रोग्रामर, यदि आप कॉर्न घोषणाओं और लारबी और नाइट्स कॉर्नर की पुन: घोषणाओं को याद करते हैं)। खैर, हमारे पास अभी भी मतलूब है।

मतलाब के साथ प्रयोग सुखद आश्चर्यचकित करता है

टाइपिंग

 tic;sum(sin(1:200000000));toc; 

लगभग तुरंत हम परिणाम देखते हैं:

1.250230424175050, बीता हुआ समय 3.621641 सेकंड है।

अच्छा, अच्छा! यह पता चला कि चतुर माटलब ने तुरंत इस अभिव्यक्ति को मेरी स्थानीय मशीन पर भौतिक कोर की संख्या से समानांतर कर दिया, जिससे उनका पूरा भार सुनिश्चित हो गया। अच्छा लगा, है न? आखिरकार, मैंने शक्तिशाली हार्डवेयर के लिए भुगतान किया और इसे 100% उपयोग करने के लिए सॉफ़्टवेयर (वैसे, बिल्कुल भी सस्ता नहीं) पसंद करेंगे। MathWorks इंजीनियर्स का सम्मान!

संकलन करने की कोशिश करते हैं? ऐसा करने के लिए, अभिव्यक्ति को एम-फ़ाइल में स्थानांतरित करें। और फिर एक और आश्चर्य हमें इंतजार कर रहा है। असम्बद्ध टिक; फास्टसम (200000000); टो; पहले से ही 5.607512 सेकंड के लिए बीता समय देता है। किसने पहले ही इसका सामना किया है, क्या बात है? मेरे लिए, यह एक रहस्य है। हम तैनाती कमांड की मदद का उपयोग करते हैं, कुछ मिनटों की प्रतीक्षा करते हैं, और माटलैब आधे मेगाबाइट में हमारे लिए एक विषम निष्पादन योग्य बनाता है। हां, कंपाइलर की विकास टीम के पास काम करने के लिए कुछ और है - तुलना के लिए, वीसी ++ का आकार 46Kb है, VB.Net 30Kb है, Vb6 36Kb है। लेकिन मतलूब संकलित निष्पादन योग्य हमें क्या देगा?

1.2502, बीता हुआ समय 10.716620 सेकंड है।
संकलित संस्करण में, जैसा कि आप देख सकते हैं, किसी कारण के लिए लूप का स्वचालित समानांतर गायब हो जाता है। मेरा दिल मुझसे कहता है कि कंपनी समानांतर कम्प्यूटिंग टूलबॉक्स के लिए अतिरिक्त पैसा चाहती है :-)

किसी भी स्थिति में, हमारे पास एक एकल थ्रेडेड द्वारा VB6 लीडर है, इसलिए मैंने इस वातावरण में एक सरल एक्टिव Exe सर्वर लिखा है, जो हमें दिए गए थ्रेड्स की संख्या पर हमारी गणना को समानांतर बनाने की अनुमति देता है:



आइए देखें कि वर्कफ़्लो की संख्या 1 से 32 तक बढ़ने पर हमारा समाधान कितना अच्छा हो जाता है। सच कहूँ तो, मुझे यकीन था कि जब तक यह भौतिक प्रोसेसर कोर की संख्या में छत से नहीं टकराएगा, प्रदर्शन बढ़ेगा, क्योंकि HT वर्चुअल कोर के लिए संसाधन कहाँ से प्राप्त होते हैं अस्थायी बिंदु अगर FPU पाइपलाइन पहले से ही पूरी तरह से कब्जा कर लिया है?




फिर भी, 14 तार्किक कोर शामिल हैं, निष्पादन समय को 20% तक कम करना संभव था: टी (16) = 0.803 सेकंड से। to t (30) = 0.645 शायद परिणाम अधिक प्रभावशाली होगा यदि प्रोसेसर शुरू में पावर सेविंग मोड में नहीं थे, क्योंकि 0.6 सेकंड में, ऐसा लगता है कि उनके पास घड़ी की आवृत्ति को अधिकतम तक बढ़ाने का समय नहीं है।

GPGPU

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

सामान्य तौर पर, मुझे कहना होगा कि मैं एनवीडिया का बहुत सम्मान करता हूं। सबसे पहले, क्योंकि यह शायद एकमात्र कंपनी है जो वास्तव में आम जनता के लिए उच्च-समानांतर कंप्यूटिंग (सम्मेलनों, सेमिनारों, घटनाओं, सक्रिय विकास और सॉफ्टवेयर और वास्तुकला के सुधार) को बढ़ावा देती है, और दूसरी बात, क्योंकि यह विशेष की बिक्री स्थापित करने में कामयाब रही " हार्डवेयर ”और नए उच्च प्रदर्शन कंप्यूटिंग क्षेत्र में नेतृत्व ले। हां, एएमडी (एटीआई) समाधान अधिक शक्तिशाली हैं, एएमडी कार्ड में अधिक गीगाफ्लॉप हो सकते हैं, लेकिन फायरस्ट्रीम के लिए विकसित करना शुरू करने की कोशिश करें - आपको एएमडी वेबसाइट पर किसी भी व्याख्यात्मक दस्तावेज या प्रौद्योगिकी का एक बुद्धिमान विवरण नहीं मिलेगा। ऐसा लगता है जैसे एएमडी प्रोग्रामर / मार्केटर्स / एग्जिक्यूटिव्स ने प्रतिभाशाली एटीआई इंजीनियरों के काम को दफन कर दिया। तो अब तक हमारी पसंद CUDA है! वैसे, अगर आपको CUDA 5 और विजुअल स्टूडियो 2012 को एकीकृत करने में कोई समस्या है, तो आप इस लेख की सिफारिशों का उपयोग कर सकते हैं।

तो, हमारे चमत्कार उपकरण के पास क्या संसाधन हैं?



जैसा कि आप देख सकते हैं, सैद्धांतिक रूप से हम दो जीपीयू उपकरणों पर 16 * 1536 * 2 = 49152 थ्रेड में गणना चला सकते हैं। वास्तव में, सब कुछ इतना रसीला नहीं है - फर्मी में साइन को विशेष कार्यों की इकाइयों में गिना जाता है, जिनमें से 4 मल्टीप्रोसेसर (एसएम) पर हैं। कुल हम एक ही समय में 16 * 4 * 2 = 128 मान (फिर से सैद्धांतिक रूप से) की गणना कर सकते हैं।

मैं तुरंत CUDA वास्तुकला के विवरण में नहीं जाना चाहूंगा, विशेष रूप से CUDA के लिए अनुकूलन की सूक्ष्मताओं में - यह विज्ञान और कला दोनों में और स्वयं के लिए है। इसलिए, आइए थ्रस्ट लाइब्रेरी में एक त्वरित प्रोटोटाइप के साथ शुरू करते हैं, जो कि क्यूएडीए मॉडल के उच्च स्तर के कारण प्रोग्रामर्स की उत्पादकता बढ़ाने के लिए डिज़ाइन किया गया है, निचले स्तर के सीयूडीए सी के अलावा।

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

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

हम शक्तिशाली ट्रांसफॉर्म_्रेड्यूस फ़ंक्शन का उपयोग करेंगे, जो आपको एक तार्किक चरण में सरणी के तत्वों को परिवर्तित करने और योग करने की अनुमति देता है। चलिए इसके लिए एक विशेष फ़नकार sin_op बनाते हैं। कोड काफी सरल है:

 #include <thrust/transform_reduce.h> #include <thrust/device_vector.h> #include <thrust/host_vector.h> #include <thrust/functional.h> #include <thrust/sequence.h> #include <windows.h> using namespace std; template <typename T> struct sin_op { __host__ __device__ T operator()(const T& x) const { return sin(x); } }; int main(void) { int dw = GetTickCount(); int n=10; double res=0.0; sin_op<double> tr_op; thrust::plus<double> red_op; thrust::device_vector<int> i(200000000/n); for (int j=1;j<=n;j++) { thrust::sequence(i.begin(), i.end(),200000000/n*(j-1)+1); res = thrust::transform_reduce(i.begin(), i.end(), tr_op, res, red_op); } cout.precision(20); cout << res << endl<< "Total Time: " << (GetTickCount()-dw) << endl; } 

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

1.704 सेकंड में 1.2502304241755013।

निराशा की कोई सीमा नहीं है। काकबे परिणाम संकेत देता है कि पुस्तकालय त्वरक को हमारी कल्पना में आकर्षित करने के लिए मजबूर नहीं करता है। वास्तव में, यदि आप विस्तृत समय को देखते हैं, तो यह पता चलता है कि पुस्तकालय पहले डिवाइस की अपेक्षाकृत धीमी मुख्य मेमोरी में शून्य का एक विशाल सरणी रखने की कोशिश करता है (जो समय का 35% खर्च करता है), फिर प्राकृतिक संख्या 1,2,3 ... (40%) के साथ इन शून्य को ओवरराइट करता है समय), ठीक है, शेष 25% समय साइन को जोड़ने और सीधे जोड़ने (प्लस ऑपरेटर द्वारा कमी, और धीमी गति से मुख्य मेमोरी में) में शामिल है।

दुखी होकर, हम याद करते हैं कि इस पुस्तकालय में आभासी पुनरावृत्तियों (फैंसी पुनरावृत्तियों) हैं। हम प्रलेखन में देखते हैं - ठीक है, निश्चित रूप से,

जबकि निरंतर_केटर और काउंटिंग_इटरेटर सरणियों के रूप में कार्य करते हैं, उन्हें वास्तव में किसी मेमोरी मेमोरी की आवश्यकता नहीं होती है। जब भी हम इन पुनरावृत्तियों में से किसी एक का संदर्भ लेते हैं, तो यह ऑन-द-फ्लाई का उचित मूल्य उत्पन्न करता है और इसे कॉलिंग फ़ंक्शन पर लौटाता है।

एक गिनती के पुनरावृत्ति चिकित्सक ने आदेश दिया है:

 #include <thrust/iterator/counting_iterator.h> #include <thrust/transform_reduce.h> #include <thrust/device_vector.h> #include <thrust/host_vector.h> #include <thrust/functional.h> #include <thrust/sequence.h> #include <windows.h> using namespace std; template <typename T> struct sin_op { __host__ __device__ T operator()(const T& x) const { return sin(x); } }; int main(void) { int dw = GetTickCount(); double res=0.0; sin_op<double> tr_op; thrust::plus<double> red_op; thrust::counting_iterator<int> first(1); thrust::counting_iterator<int> last = first + 200000000; res = thrust::transform_reduce(first, last, tr_op, res, red_op); cout.precision(20); cout << res << endl<< "Total Time: " << (GetTickCount()-dw)<< endl; } 

नेतृत्व समय क्या है? उन्होंने मुख्य स्मृति के साथ अक्षम संचालन से छुटकारा पाकर इसे लगभग आधा कर दिया:

0.780 सेकंड में 1.2502304241761253।

यह ध्यान में रखा जाना चाहिए कि प्रतीक्षा के साथ डिवाइस के संदर्भ में एक खाली कॉल भी कुछ लेता है, मेरे पास कम से कम इस समय औसतन 26 सेकंड है। जैसा कि यह हो सकता है, यहां तक ​​कि 0.52 सेकंड भी वह परिणाम नहीं है जो आप कई समानांतर रेखाओं के चरम प्रदर्शन के साथ बड़े पैमाने पर समानांतर वास्तुकला डिवाइस से उम्मीद करेंगे। आइए हम CUDA C में खुद को लिखने का प्रयास करें, जो प्रारंभिक योग करेगा। यह इतना मुश्किल नहीं है ... इसके लिए हम अपनी गणना को समान लंबाई के ब्लॉक में विभाजित करते हैं। प्रत्येक ब्लॉक तेजी से साझा की गई मेमोरी में अपने तत्वों की एक समानांतर कमी को पूरा करेगा, और ब्लॉक इंडेक्स के बराबर ऑफसेट पर त्वरक की वैश्विक मेमोरी में परिणाम को बचाएगा:

 __global__ void SumOfSinuses(double *partial_res, int n) { // extern-     extern __shared__ double sdata[]; //    int i =blockIdx.x*blockDim.x+threadIdx.x; sdata[threadIdx.x] = (i <= n) ? sin((double)i) : 0; __syncthreads(); //      for (int s=blockDim.x/2; s>0; s>>=1) { if (threadIdx.x < s) { sdata[threadIdx.x] += sdata[threadIdx.x + s]; } __syncthreads(); } //       ,    if (threadIdx.x == 0) partial_res[blockIdx.x] = sdata[0]; } 

सैद्धांतिक रूप से, हमारे डिवाइस पर एक ब्लॉक अधिकतम 1024 शब्द तक का हो सकता है। SumOfSinuses कर्नेल के लिए पहली कॉल के बाद, हमारे पास डिवाइस की मेमोरी में लगभग 200 हजार मध्यवर्ती शब्द होंगे, जिसे आसानी से जोर देने के लिए एकल कॉल के साथ जोड़ा जा सकता है :: कम करना:

 int main(void) { int dw = GetTickCount(); int N=200000000+1; cudaDeviceProp deviceProp; cudaGetDeviceProperties(&deviceProp, 0); double *partial_res; int rest=N;int i=0;double res=0; int threads_per_block=1024;//deviceProp.maxThreadsPerBlock; int max_ind=deviceProp.maxGridSize[0] * threads_per_block; checkCudaErrors(cudaMalloc(&partial_res, max_ind/threads_per_block*sizeof(double))); thrust::device_ptr<double> arr_ptr(partial_res); do { int num_blocks=min((min(rest,max_ind) % threads_per_block==0) ? min(rest,max_ind)/threads_per_block : min(rest,max_ind)/threads_per_block+1,deviceProp.maxGridSize[0]); SumOfSinuses<<<num_blocks,threads_per_block,threads_per_block*sizeof(double)>>>(partial_res,i*max_ind,N); checkCudaErrors(cudaDeviceSynchronize()); //  thrust-         ,        res = thrust::reduce(arr_ptr, arr_ptr+num_blocks,res); rest -=num_blocks*threads_per_block; i++; } while (rest>0); cudaFree(partial_res); cout.precision(20); cout << res << endl<< "Total Time: " << (GetTickCount()-dw)<< endl; } 

0.749 सेकेंड में 1.2502304241758133।

मुझे डू लूप का उपयोग करना होगा क्योंकि क्यूडा ब्लॉक का जाल आकार सीमित है। इसलिए, हमारे मामले में, कोर को लूप से तीन बार कहा जाता है, जो हर बार लगभग 70 मिलियन शब्दों को संसाधित करता है। यह पता चलता है कि प्रदर्शन फिर भी दोहरे परिशुद्धता के साथ पारलौकिक कार्यों की गणना में टिकी हुई है, इसलिए थ्रस्ट अपेक्षाकृत कम प्रदर्शन के लिए दोषी नहीं है, और मैं पहले विकल्प का उपयोग करने की सलाह दूंगा, जिसमें अधिक समझ और सुरुचिपूर्ण कोड होगा। वैसे, हमारे दृष्टिकोण को अभी तक CUDA- संगत उपकरणों (जिनमें एक स्थानीय क्लस्टर आयोजित किया जा सकता है) की संख्या से कम नहीं किया गया है। क्या इसे ठीक किया जा सकता है? यह पता चलता है कि दो उपकरणों और संपूर्ण सहायक बाइंडिंग (cudaSetDevice, cudaStreamCreate / cudaStreamDestroy) को किसी कारण से सरल स्विच करने में लगभग 0.5 सेकंड का समय लग गया है। यही है, यह पता चला है कि अगर कर्नेल लंबे समय तक चलते हैं तो कई CUDA उपकरणों को स्केल करना फायदेमंद होता है ताकि स्विचिंग संदर्भों का ओवरहेड अदृश्य हो। हमारे मामले में, ऐसा नहीं है, इसलिए हम लेख के दायरे के बाहर कई उपकरणों में स्केलिंग छोड़ देते हैं (शायद मुझे मेजबान पक्ष पर कई धाराओं का उपयोग करना चाहिए था, मुझे यकीन नहीं है)।

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

 tic; res=0.0;n=10;stride=200000000/n; for j=1:n X=stride*(j-1)+1:stride*j; A=gpuArray(X); res=res+sum(sin(A)); end toc; gather(res) 

1.250230424175708, बीता हुआ समय 2.872859 सेकंड है।

मुझे तुरंत अपने दोहरे चिप त्वरक के दोनों प्रोसेसर पर काम करने के लिए कोड नहीं मिल सकता है, मैनुअल में इस विषय का पूरी तरह से उल्लेख नहीं किया गया है। Spmd काम करता है, एक मिश्रित सरणी, जिसे 2 भागों में विभाजित किया जाता है, बनाया जाता है। हालांकि, कुछ बिंदु पर, प्रोग्राम यह कहते हुए विफल हो जाता है कि डेटा अब उपलब्ध नहीं है। पहले से ही matlab में कई GPU के साथ काम किया ;-) वैसे भी, Matlab संस्करण थ्रस्ट में हमारे कार्यान्वयन से तेज नहीं होगा।

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