वास्तव में gcc का ffast-math क्या करता है?

Question

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

मैंने एसओ के माध्यम से इसी तरह के सवालों के लिए खुदाई करने की कोशिश की, लेकिन कुछ भी नहीं मिल सका।

Answer 1

जैसा कि आपने उल्लेख किया है, यह अनुकूलन की अनुमति देता है जो सख्त IEEE अनुपालन को संरक्षित नहीं करता है।

एक उदाहरण यह है:

x = x*x*x*x*x*x*x*x;

सेवा

x *= x;
x *= x;
x *= x;

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

मैंने वास्तव में यह देखने के लिए जाँच नहीं की है कि क्या जीसीसी वास्तव में इस विशेष अनुकूलन को करता है। लेकिन विचार एक ही है।

Comments

@Andrey: इस उदाहरण के लिए, आप 7 गुणक से नीचे 3. पर जाते हैं

— रहस्यमयी

@Andrey: गणितीय रूप से, यह सही होगा। लेकिन परिणाम अलग-अलग गोलाई के कारण पिछले कुछ बिट्स में थोड़ा भिन्न हो सकता है।

— रहस्यमयी

ज्यादातर मामलों में, यह मामूली अंतर कोई फर्क नहीं पड़ता (अपेक्षाकृत 10 ^ -16 के आदेश पर double, लेकिन आवेदन के आधार पर भिन्न होता है)। ध्यान देने वाली एक बात यह है कि फॉस्फेट-गणित अनुकूलन आवश्यक रूप से "अधिक" राउंड-ऑफ नहीं जोड़ते हैं। इसका एकमात्र कारण है कि यह IEEE अनुरूप नहीं है क्योंकि इसका उत्तर अलग है (यद्यपि थोड़ा सा) जो लिखा गया है, उससे अलग है।

— रहस्यमयी

@user: त्रुटि का परिमाण इनपुट डेटा पर निर्भर करता है। यह परिणाम के सापेक्ष छोटा होना चाहिए। उदाहरण के लिए, यदि x10 से छोटा है , तो मिस्टिकल के उदाहरण में त्रुटि 10 ^ -10 के आसपास होगी। लेकिन अगर x = 10e20, त्रुटि कई लाखों होने की संभावना है।

— बेन वोइगेट

@stefanct यह वास्तव में -fassociative-mathजिसके बारे में शामिल है -funsafe-math-optimizationsजिसमें बदले में सक्षम किया गया है -ffast-math क्यों GCC को अनुकूलित नहीं करता a*a*a*a*a*aहै (a*a*a)*(a*a*a)?

— phuclv

Answer 2

-ffast-math केवल IEEE अनुपालन को तोड़ने से बहुत अधिक है।

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

दूसरा, यह एकल-अनुदेश गणित कार्यों के बाद सेटिंग को अक्षम करता हैerrno , जिसका अर्थ है कि थ्रेड-लोकल वेरिएबल पर लिखने से बचें (यह कुछ आर्किटेक्चर पर उन कार्यों के लिए 100% अंतर कर सकता है)।

तीसरा, यह धारणा बनाता है कि सभी गणित परिमित हैं , जिसका अर्थ है कि NaN (या शून्य) के लिए कोई जांच उस स्थान पर नहीं की जाती है जहां उनके हानिकारक प्रभाव होंगे। यह माना जाता है कि ऐसा नहीं होने जा रहा है।

चौथा, यह विभाजन और पारस्परिक वर्गमूल के लिए पारस्परिक सन्निकटन को सक्षम बनाता है ।

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

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

Comments

डेमन, धन्यवाद! क्या आप कुछ संदर्भ जोड़ सकते हैं? जैसे gcc.gnu.org/oniltocs/gcc/Optimize-Options.html " -ffast-math सेट्स -fno-math-irno, -funsafe-math-optimizations, -ffinite-math-only, -fno-rounding-math, -fno-signaling -nans और -fcx- सीमित-सीमा। यह विकल्प प्रीप्रोसेसर मैक्रो FAST_MAT को परिभाषित करने का कारण बनता है। "और glibc से कुछ, जैसे ( math.hmath_errhandling के पास)" डिफ़ॉल्ट रूप से सभी फ़ंक्शन दोनों एक्सनो और अपवाद हैंडलिंग का समर्थन करते हैं। जीसीसी के तेज गणित मोड और अगर इनलाइन फंक्शंस परिभाषित किए जाते हैं तो यह सच नहीं हो सकता है। "

— ओस्गक्स

@javapowered: क्या यह "खतरनाक" है, इस बात पर निर्भर करता है कि आपको क्या गारंटी चाहिए। -ffast-mathसंकलक को कुछ कोनों को काटने और कुछ वादों (जैसा कि समझाया गया है) को तोड़ने की अनुमति देता है, जो सामान्य रूप से खतरनाक नहीं है और अधिकांश लोगों के लिए समस्या नहीं है। ज्यादातर लोगों के लिए, यह वही है, केवल तेज है। हालाँकि, यदि आपका कोड मानता है और इन वादों पर भरोसा करता है, तो आपका कोड आपकी अपेक्षा से अलग व्यवहार कर सकता है। आमतौर पर, यह मतलब है कि कार्यक्रम होगा लग रहे हैं काम ठीक है, ज्यादातर के लिए, लेकिन कुछ परिणामों "अप्रत्याशित" हो सकता है (जैसे कि, एक भौतिकी अनुकरण में, दो वस्तुओं टकराती ठीक से नहीं हो सकता है)।

— डेमोन

@ रोई: दोनों को एक दूसरे से स्वतंत्र होना चाहिए। -O2आम तौर पर "हर" कानूनी अनुकूलन को सक्षम करता है, जो कि गति के लिए व्यापार आकार को छोड़कर। -O3गति के लिए व्यापार आकार के अनुकूलन को भी सक्षम बनाता है। यह अभी भी 100% शुद्धता बनाए रखता है। -ffast-math"थोड़ा गलत" व्यवहार की अनुमति देकर गणितीय कार्यों को तेजी से करने का प्रयास जो आमतौर पर हानिकारक नहीं है, लेकिन मानक के शब्दों द्वारा गलत माना जाएगा। यदि आपका कोड दो संकलकों पर गति में वास्तव में बहुत भिन्न है (केवल 1-2% नहीं) तो जांचें कि आपका कोड कड़ाई से मानकों का अनुपालन कर रहा है और ...

— Damon

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

— डेमन

@ रोई: वह कोड मुझे वास्तव में छोटा और सरल नहीं लगता, न कि कुछ मिनटों (या घंटों) में गहराई से विश्लेषण। अन्य बातों के अलावा, इसमें एक प्रतीत होता है हानिरहित #pragma omp parallel for, और लूप बॉडी के भीतर आप फ़ंक्शन तर्कों द्वारा इंगित किए गए पते से पढ़ रहे हैं और लिख रहे हैं, और गैर-तुच्छ मात्रा में शाखाएं करते हैं। एक अशिक्षित अनुमान के रूप में, आप अपने कार्यान्वयन-परिभाषित इनवॉइस ऑफ थ्रेड्स के भीतर से कैश को जोर से मार सकते हैं, और MSVC गलत तरीके से इंटरमीडिएट स्टोर्स से बच सकते हैं जो नियमों का पालन करते हैं। बताना असंभव है।

— डेमॉन