"कार्य जवाब से सहमत है!"

मैं अक्सर काम पर एक सवाल सुनता हूं, जिसमें अधिकांश भाग के लिए, शैक्षणिक वातावरण से, वहां की गई गणना की विशाल मात्रा को देखते हुए: “हमारे परिणाम एक ही एप्लिकेशन को लॉन्च करने से अलग क्यों हैं? हम इसमें कुछ भी नहीं बदलते हैं। '' यह ध्यान देने योग्य है कि इस बारे में पहले से ही एक बातचीत थी, लेकिन केवल आंशिक रूप से सवाल का जवाब दे रही थी। मैं इस समस्या के बारे में कुछ और बात करने की कोशिश करूंगा।

हम एक ही सिस्टम पर निम्न चित्र क्यों देख सकते हैं:


या, दो अलग मशीनों पर, निम्नलिखित, कहें:


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


सब कुछ अपेक्षित लगता है, अगर हम गणितज्ञों के रूप में मानते हैं। अब मान लें कि हम एक ही सटीक संख्या के साथ काम करते हैं, और एक बड़ी संख्या के साथ एक छोटी संख्या जोड़ते हैं:


मशीन अंकगणित के दृष्टिकोण से, हमें IEEE 754 मानक के अनुसार सही परिणाम मिला है। और निम्नलिखित परिणाम भी सत्य है:


यहीं से सारी समस्याएं सामने आने लगती हैं। आखिरकार, संकलक हमारे कोड को बहुत अच्छी तरह से अनुकूलित कर सकता है ताकि अभिव्यक्तियों में परिवर्धन का क्रम बदल जाए, और बहुत कुछ। और -fp-model विकल्प यहां मदद करेंगे, जिसके बारे में मैंने पहले ही विस्तार से बात की थी।

लेकिन सब कुछ संकलक पर निर्भर नहीं करता है। याद रखें, मूल प्रश्न इस तरह लग रहा था कि कोड में कुछ भी नहीं बदल रहा था, जिसका अर्थ है कि यह "आश्वस्त" नहीं था, लेकिन परिणाम अभी भी अलग हैं।

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

1) ऑप्टिमाइज़ेशन सहेजें, लेकिन एक ही समय में डेटा को स्पष्ट रूप से संरेखित करें, उदाहरण के लिए, _mm_malloc () और _mm_free () का उपयोग करके। फोरट्रान का एक निर्देश है ! DIR $ ATTRIBUTES ALIGN: 64 :: arrayname , साथ ही कम्पाइलर ऑप्शन -ignign array64byte
2) -दो-मॉडल सटीक विकल्प का उपयोग करते हुए कटौती और कई अन्य अनुकूलन का परित्याग करना, जो प्रदर्शन में नुकसान की पूर्ति करेगा।

बहुत बढ़िया! माना कि हमने अपने कोड को सटीक मॉडल के साथ संकलित किया है, लेकिन परिणाम अभी भी सुसंगत नहीं हैं। अब गलत क्या है? वास्तव में, कई कारण हैं।

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

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

सब ठीक है। हमने इसे जोड़ा, लेकिन फिर से यह मदद नहीं करता है।
फिर एक संदेह है कि पुस्तकालयों का उपयोग किया जाता है कि आप "कब्ज" के लिए अपनी इच्छा के बारे में नहीं जानते हैं। मैं पहले गणितीय कार्यों की कॉल पर ध्यान देना चाहता हूं। –Fp- मॉडल विकल्प आपको फ़ंक्शन कॉल की निरंतरता प्राप्त करने की अनुमति देता है, लेकिन विभिन्न आर्किटेक्चर (गैर-इंटेल वाले सहित) पर समान परिणाम प्राप्त करने के लिए -fimf-arch-संगति स्विच का उपयोग करने की सिफारिश की जाती है।

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

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

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

वैसे, ऐसा सवाल। क्यों, अलग-अलग Xeons के साथ सिस्टम पर उदाहरण में, (ऊपर चित्र), क्या हमें अलग-अलग परिणाम मिले? मैंने स्पष्ट रूप से इसके बारे में नहीं लिखा था, आपके विचारों को सुनना दिलचस्प होगा।