सटीकता और प्रदर्शन के बीच संतुलन

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

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

ये सभी कुंजियाँ अंततः आपको निम्नलिखित संकलक नियमों को नियंत्रित करने और संबंधित सवालों के जवाब देने की अनुमति देती हैं:

मूल्य सुरक्षा
क्या कोई कंपाइलर रूपांतरण कर सकता है जो परिणाम को बदल सकता है?
उदाहरण के लिए, सुरक्षित मोड में, कंपाइलर x / x एक्सप्रेशन को 1.0 में ऑप्टिमाइज़ नहीं करेगा, क्योंकि रन टाइम पर वैल्यू 0 या NaN हो सकती है। इसके अलावा, गणना के अनुक्रम को बदलना (विशेष रूप से, सहक्रियाशीलता या वितरण का नियम) निषिद्ध हो सकता है।

अभिव्यक्ति की गणना में सटीकता (फ्लोटिंग-पॉइंट एक्सप्रेशन मूल्यांकन)
संकलक को इंटरमीडिएट परिणामों से कैसे राउंड करना चाहिए (मुझे क्या सटीकता चुननी चाहिए)?

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

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

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

इसलिए, इन 5 मुख्य प्रश्नों को कंपाइलर विकल्पों द्वारा नियंत्रित किया जा सकता है:

विकल्प	सुरक्षा	शुद्धता	FMA	पर्यावरण	अपवाद
ठीक स्रोत	भिन्न	कोड कोड	हां	नहीं	नहीं
कठोर	भिन्न	कोड	नहीं	हां	हां
तेज = १ (डिफ़ॉल्ट)	असुरक्षित	अज्ञात है	हां	नहीं	नहीं
तेज = २	असुरक्षित	अज्ञात है	हां	नहीं	नहीं
सिवाय except-	बदलता नहीं है	कोड कोड	नहीं बदलता है	नहीं बदलता है	हां नहीं

मान लें कि हमने पता लगाया कि इन विकल्पों को क्या नियंत्रित करता है। आइए उदाहरणों के साथ समझने की कोशिश करें कि उनका उपयोग कैसे और किस लिए किया जाए।

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

float KahanSum(const float A[], int n ) { float sum=0, Y, T; float C=0; //A running compensation for lost low-order bits. for (int i=0; i<n; i++) { Y = A[i] - C; //So far, so good: C is zero. T = sum + Y; //Alas, sum is big, Y small, so low-order digits of Y are lost. C = T - sum - Y; //(T - sum) recovers the high-order part of Y; //subtracting y recovers -(low part of y) sum = T; //Next time around, the lost low part will be added to y in a fresh attempt. } return sum; } 

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

इस तथ्य के मद्देनजर कि सी चक्र के बाहर है और 0 के बराबर स्थिर है, फिर

 Y = A[i] - C ==> Y = A[i] T = sum + Y ==> T = sum + A[i] sum = T ==> sum = sum + A[i] 

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

वैसे, इन विकल्पों के विभिन्न संयोजन दिलचस्प हैं, क्योंकि एक भावना है कि सटीक और स्रोत एक ही काम कर रहे हैं। सभी मॉडल 3 समूहों में विभाजित हैं:

• ए: सटीक, तेज, सख्त
• बी: स्रोत
• सी: को छोड़कर

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

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

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

 float a, b, c, d; double x; ... x = a*b + c*d; 

इस तरह संकलक द्वारा व्याख्या की जाएगी:

 float a, b, c, d; double x; ... register tmp1 = a*b; register tmp2 = c*d; register tmp3 = tmp1+tmp2; x = (double) tmp3; 

बारीकियों, ज़ाहिर है, महत्वपूर्ण हैं, लेकिन अगर आप समझते हैं कि क्या नियंत्रित करना है और कैसे, आप आसानी से किसी अन्य संकलक पर स्विच कर सकते हैं, मुख्य बात यह है कि यह डेवलपर को यह नियंत्रण क्षमता प्रदान करता है।

वैसे, इस विषय पर MSDN पर एक उत्कृष्ट लेख है , जिसमें Microsoft कंपाइलर के व्यवहार के बारे में विस्तार से वर्णन किया गया है, और कई उदाहरणों पर विचार किया गया है।

हम एक और उदाहरण पर लौटेंगे, इस बार फोरट्रान पर (मैंने शुरुआत में वैज्ञानिक विषय का उल्लेख किया है):

 REAL T0, T1, T2; ... T0 = 4.0E + 0.1E + T1 + T2 

सवाल यह है कि, इस अभिव्यक्ति को –fp- मॉडल फास्ट स्विच के साथ कैसे माना जाएगा? उपरोक्त तालिका के आधार पर, यह माना जा सकता है कि जोड़ किसी भी क्रम में किया जा सकता है, सटीकता का उपयोग एकल (एकल), डबल (डबल), या विस्तारित परिणामों की गणना में डबल (विस्तारित) किया जाएगा, जबकि निरंतर मूल्य की गणना की जा सकती है अग्रिम में।

उदाहरण के लिए, कंपाइलर हमारे कोड की व्याख्या इस प्रकार कर सकता है:

 REAL T0, T1, T2; ... T0 = (T1 + T2) + 4.1E; 

या

 REAL T0, T1, T2; ... T0 = (T1 + 4.1E) + T2; 

-Fp- मॉडल स्रोत विकल्प सेट करते समय (या -fp- मॉडल सटीक, यदि अलग-अलग उपयोग किया जाता है, तो वे समतुल्य हैं), इसके अलावा कोड में निर्दिष्ट क्रम में कड़ाई से प्रदर्शन किया जाएगा, एकल परिशुद्धता का उपयोग किया जाएगा (कोड के रूप में), निरंतर अग्रिम में गणना की जा सकती है। डिफ़ॉल्ट गोलाई का उपयोग करना:

 REAL T0, T1, T2; ... T0 = ((4.1E + T1) + T2); 

ठीक है, सटीकता पर नियंत्रण का सबसे "कठिन" स्तर -fp- मॉडल सख्त है।
इस मामले में, हमें ऐसा कुछ मिलता है:

 REAL T0, T1, T2; ... T0 = REAL ((((REAL)4.0E + (REAL)0.1E) + (REAL)T1) + (REAL)T2); 

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

दरअसल, यह सब मैं इस पोस्ट के ढांचे के बारे में बताना चाहता था। फ़्लोटिंग-पॉइंट नंबरों के साथ काम करने का विषय बहुत व्यापक है, और इसके बारे में बताने के लिए अभी भी कुछ है ... कहते हैं, जिन विकल्पों पर विचार किया जाता है, इसके अलावा झंडे भी हैं प्री-डिवा, प्री-स्क्वैर, -ftz, -assume: protect_parens, IE7 754-2008 मानक, जो यह कई संकलकों में समर्थित है और जिसमें बहुत कुछ दिलचस्प है ... इसलिए उचित रुचि के साथ, हम इस बातचीत को जारी रखेंगे।