🏓 🎅🏼 👩🏻‍⚕️ वित्तीय मॉडलिंग के लिए GPU का उपयोग करने का अनुभव 🖐️ 🖐🏾 ⛏️

इस लेख में, मैंने एक एकल गणना कार्य को अनुकूलित करने में अपने अनुभव का वर्णन किया है, एक यूनिप्रोसेसर एल्गोरिदम से लेकर एक मल्टीप्रोसेसर और एक ओपनसीएल संस्करण तक।

प्रस्तावना

परियोजनाओं में से एक (C #) मैं वित्तीय विश्लेषण और मॉडलिंग के लिए काम कर रहा हूं। यह उपयोगकर्ता को कुछ "पक्षी" भाषा में वित्तीय जानकारी (वित्तीय साधनों पर उद्धरण और अन्य डेटा) के प्रसंस्करण के लिए इनपुट मापदंडों और एल्गोरिदम के अनुक्रम का वर्णन करने की अनुमति देता है। एप्लिकेशन का उपयोग करके हल किए गए कार्यों में से एक ट्रेडिंग सिस्टम (टीएस) के मापदंडों का अनुकूलन है।

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

एल्गोरिथ्म

दुर्भाग्य से, इष्टतम को खोजने का एकमात्र तरीका पूर्ण बस्ट था।

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

पहला काम संस्करण

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

सीपीयू समानांतर प्रसंस्करण

टीएस मापदंडों के एक सेट पर Parallel.ForEach का उपयोग करके प्रवाह वितरण लागू किया गया था।

Parallel.ForEach(counters, counter => Process(points, counter));

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

 Parallel.For(0, processorCount, i => Process(points, block[i]));

इस कार्यान्वयन में, गुठली समान रूप से 99-100% तक लोड हुई और ऑपरेटिंग समय लगभग 4 गुना कम हो गया, क्योंकि यह समानांतर प्रसंस्करण के लिए लगभग एक आदर्श कार्य है।

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

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

GPU पोर्टिंग

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

मैंने iTunes से Stanford CUDA पाठ्यक्रम डाउनलोड किया और व्याख्यान देखना शुरू किया। व्याख्यान इस बात में अच्छे हैं कि वे वास्तुकला का एक सामान्य विचार देते हैं। सिद्धांत रूप में, पहले 5 व्याख्यानों का आधार मेरे लिए यह समझने के लिए पर्याप्त था कि मुझे क्या करने की आवश्यकता है। लेकिन मैंने इसे CUDA पर नहीं, बल्कि OpenCL पर लागू करने का निर्णय लिया। यह सिर्फ इतना हुआ कि मेरे पास घर पर एएमडी वीडियो कार्ड हैं, और काम पर एनवीआईडीआईए है।

व्याख्यान को देखने और OpenCL में CUDA शब्दों के अनुवाद के लिए एक शब्दकोश से लैस होने के बाद, चार घंटों में मैंने पहला कार्यान्वयन लिखा। OpenCL के साथ काम करने के लिए, मैंने OpenCL.Net का उपयोग किया।

वाहन मापदंडों के उद्धरण और सेट पर परिवर्तित डेटा वीडियो कार्ड पर फेंक दिया गया था। मापदंडों के प्रत्येक संयोजन को एक अलग स्ट्रीम में संसाधित किया गया था। यानी प्रारंभ में, प्रवाह ने अपने वाहन मापदंडों को पढ़ा और फिर उद्धरणों के पूरे इतिहास के माध्यम से हल किया। सभी संयोजनों को संसाधित करने के बाद, काम के परिणाम वीडियो कार्ड से लिए गए थे।

और फिर मैंने धक्कों की झड़ी लगा दी:

एल्गोरिथ्म ने कुछ गिना, लेकिन कुछ और गिना। परिणाम संदर्भों के साथ मेल नहीं खाते थे।
एक लंबी डिबगिंग के बाद, यह पता चला कि मैं गलत तरीके से सोच रहा था कि बूल 1 बाइट लेता है। स्पेसिफिकेशन के अनुसार , यह इंट में डिवाइस पर तैनात है और 4 बाइट्स लेता है। अस्पष्टता को खत्म करने के लिए, मैंने केवल ट्रांसमिट किए गए डेटा के प्रकार को इंट में बदल दिया।
एल्गोरिथ्म "लगभग एक ही" परिणाम का उत्पादन करना शुरू कर दिया। और परिणाम सीपीयू संस्करण की तुलना में लगातार थोड़ा बेहतर थे। एक बार फिर मैंने cl-code की समीक्षा की और त्रुटि नहीं पाई। मुझे सीपीयू संस्करण को दोबारा जांचना पड़ा, और हां, त्रुटि थी। यह पता चला कि अनुकूलन प्रक्रिया के दौरान, मैं अनावश्यक विकल्पों को त्यागने लगा था, जो कि वास्तव में कभी-कभी अतिश्योक्तिपूर्ण नहीं निकला। सीपीयू संस्करण से "अनुकूलन" को हटाने के बाद, परिणाम मेल खाने लगे।
इससे पहले, मैंने एक घरेलू कंप्यूटर पर सभी प्रयोग किए। काम पर जाँच करते समय, यह पता चला कि स्मृति के अभाव में कई के शुरू होने के बाद आवेदन मर जाता है। साथ ही घर में सब कुछ ठीक ठाक चला। यह पता चला कि मैंने वास्तव में मेमोरी को मुक्त नहीं किया था, लेकिन साथ ही, एएमडी के ओपनसीएल कार्यान्वयन ने इस प्रोग्रामर के कैंट को सामान्य रूप से संभाला। NVIDIA के ओपनसीएल कार्यान्वयन गलतियों को माफ नहीं करता है।

सिद्धांत रूप में, उसके बाद फाइन-ट्यूनिंग के लिए कुछ और पुनरावृत्तियां हुईं, जिनमें मैं कर्नेल एनालाइजर से मिला, लेकिन सामान्य तौर पर यह एक तैयार समाधान था।

परिणाम

नया संस्करण प्राप्त करने के बाद उपयोगकर्ता बहुत प्रसन्न था। यहां तक कि इसके कमजोर Radeon 5450 (80 सार्वभौमिक प्रोसेसर) पर, गणना दर्जनों बार तेज हुई।
उन्होंने तुरंत मुझे इस बारे में यातना देना शुरू कर दिया कि उनके कंप्यूटर में कितना शक्तिशाली कार्ड डाला जा सकता है (मैं उनके पीएसयू और एमपी के रिमोट डायग्नोस्टिक्स की कठिनाइयों के कारण पर्याप्त रूप से जवाब नहीं दे सका), कितने वीडियो कार्ड एक सिस्टम यूनिट में प्लग किए जा सकते हैं (उन्हें लिंक भेजने की इच्छा थी) बिटकॉइन खेतों की तस्वीरों के साथ गीक-पोर्न पर), और क्या एक बार में वीडियो कार्ड के साथ कई मशीनों को समानांतर करना संभव है।

पूरा होने से पहले, मैं उसी समस्या को हल करने के लिए समय देना चाहूंगा (2 दिनों के लिए स्टॉक डेटा का विश्लेषण):
1) AMD Phenom II X6 1090T (6 कोर, 100% लोड) - 4 घंटे 48 मिनट (288 मिनट)
2) Radeon 5850 (1440 सार्वभौमिक प्रोसेसर, लगभग 50% लोड) - 4 मिनट
यानी प्रसंस्करण समय 72 गुना कम हो गया था।

आपके ध्यान के लिए धन्यवाद, मुझे सवालों के जवाब देने में खुशी होगी। आरएफपी द्वारा टाइप किए गए टाइपोस के बारे में रिपोर्ट भेजने की सलाह दी जाती है, पीएम में डैश के साथ हाइफ़न को बदलने की आवश्यकताएं।