दिलचस्प पोस्ट
कैसे चुनें कि तत्व को विशिष्ट वर्ग नहीं है ऑडियो IOS उद्देश्य-सी चलाएं सेलेनियम वेबड्राइवर सी # का उपयोग करके ड्रॉप डाउन में कोई विकल्प कैसे चुन सकता है? v ++ के लिए अपरिभाषित संदर्भ c ++ क्या हर बार जब आप डर्बी डाटाबेस को कनेक्ट करते हैं तो तालिकाओं को बनाना आवश्यक है? एचटीएमएल सामग्री को वीबीए में पार्स करें क्रोम में "एक्सेस-कंट्रोल-अनुमति-उत्पत्ति द्वारा मूल की नल की अनुमति नहीं है" क्यूं कर? क्या फ़ाइल के पुराने संस्करण को देखने के लिए एक त्वरित git कमांड है? इंटरफेस या अमूर्त वर्ग का उपयोग कब करना है? दोनों का उपयोग कब किया जाए? कैसे एक नियमित अभिव्यक्ति MySQL में जगह करने के लिए? NumPy में MATLAB के repmat के बराबर क्या है आईसीएस एंड्रॉइड जीपीएस प्रोग्राम को सक्षम करते हैं? संसाधन फ़ोल्डर में javafx fxml फ़ाइलों को कैसे संदर्भित करें? नियमित अभिव्यक्ति बनाम। स्ट्रिंग पार्सिंग अल्फ़ान्यूमेरिक और अंडरस्कोर के लिए नियमित अभिव्यक्ति

मैं लिनक्स में C ++ कोड को कैसे चल सकता हूं?

मेरे पास एक सी + + एप्लीकेशन है, जो कि लिनक्स पर चल रहा है, जो मैं अनुकूलन की प्रक्रिया में हूं। मैं कैसे तय कर सकता हूं कि मेरे कोड के किन क्षेत्रों में धीरे धीरे चल रहा है?

Solutions Collecting From Web of "मैं लिनक्स में C ++ कोड को कैसे चल सकता हूं?"

यदि आपका लक्ष्य एक प्रोफ़फ़ेलर का उपयोग करना है, तो सुझाए गए किसी एक का उपयोग करें

हालांकि, यदि आप जल्दी में हैं और आप अपने प्रोग्राम को डिबगर के अंतर्गत मैन्युअल रूप से बाधित कर सकते हैं, जबकि यह अधीनस्थ धीमा है, प्रदर्शन की समस्याओं को खोजने का एक आसान तरीका है

बस इसे कई बार रोकें, और हर बार कॉल स्टैक को देखें। यदि कुछ कोड है जो कुछ प्रतिशत समय, 20% या 50% या जो कुछ भी बर्बाद कर रहा है, तो यह संभावना है कि आप प्रत्येक नमूने पर कार्य में इसे पकड़ लेंगे। तो ऐसा लगभग नमूनों का प्रतिशत है, जिस पर आप इसे देखेंगे। कोई शिक्षित अनुमान की आवश्यकता नहीं है अगर आपको लगता है कि समस्या क्या है, तो इससे यह साबित होगा या इसका खंडन करेगा।

आपके पास अलग-अलग आकार की कई प्रदर्शन समस्याएं हो सकती हैं यदि आप उनमें से किसी एक को साफ करते हैं, तो शेष उत्तीर्ण होने पर, एक बड़ा प्रतिशत लेते हैं, और आसानी से स्थान प्राप्त करेंगे। यह बढ़ाई हुई प्रभाव , जब कई समस्याओं से ग्रस्त हो, तो वास्तव में बड़े पैमाने पर गतिरोध कारक पैदा कर सकता है।

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

  1. वे निर्देश स्तर पर संक्षेप नहीं करते हैं, और
  2. वे पुनरावर्ती की उपस्थिति में भ्रामक सारांश देते हैं

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

पीएस यह बहु-धागा कार्यक्रमों पर भी किया जा सकता है यदि समय पर किसी बिंदु पर धागा पूल के कॉल-स्टैक नमूने एकत्र करने का कोई तरीका है, क्योंकि जावा में है

पी पी एस किसी न किसी सामान्यता के रूप में, आपके सॉफ्टवेयर में आपके पास अमूर्त की अधिक परतें, अधिक संभावना है कि आप यह पाते हैं कि यह प्रदर्शन की समस्याओं का कारण है (और गति प्राप्त करने का अवसर)।

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

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

जोड़ा: मैं इसे कैसे काम करता है की एक Bayesian स्पष्टीकरण बनाने के लिए। मान लीजिए कि कुछ अनुदेश I (कॉल या अन्यथा) है, जो कॉल स्टैक पर है, उस समय के कुछ अंश f (और इस तरह अधिक लागत)। सादगी के लिए, मान लीजिए कि हमें नहीं पता है कि f क्या है, लेकिन मान लीजिए कि यह 0.1, 0.2, 0.3, … 0.9, 1.0 है, और इनमें से प्रत्येक संभावनाओं की पूर्व संभावना 0.1 है, इसलिए इन सभी लागत समान रूप से हैं संभावना एक प्राथमिकता

तो मान लीजिए कि हम सिर्फ 2 स्टैक नमूनों को लेते हैं, और हम दोनों नमूनों में, निर्देशित अवलोकन o=2/2 2/2 पर, निर्देश देखें I यह I के आवृत्ति f के नए अनुमान बताता है, इस के अनुसार:

 Prior P(f=x) x P(o=2/2|f=x) P(o=2/2&&f=x) P(o=2/2&&f >= x) P(f >= x) 0.1 1 1 0.1 0.1 0.25974026 0.1 0.9 0.81 0.081 0.181 0.47012987 0.1 0.8 0.64 0.064 0.245 0.636363636 0.1 0.7 0.49 0.049 0.294 0.763636364 0.1 0.6 0.36 0.036 0.33 0.857142857 0.1 0.5 0.25 0.025 0.355 0.922077922 0.1 0.4 0.16 0.016 0.371 0.963636364 0.1 0.3 0.09 0.009 0.38 0.987012987 0.1 0.2 0.04 0.004 0.384 0.997402597 0.1 0.1 0.01 0.001 0.385 1 P(o=2/2) 0.385 

अंतिम कॉलम कहता है कि, उदाहरण के लिए, 60% की पूर्व धारणा से, f => 0.5% 92% है।

मान लीजिए कि पूर्व धारणाएं अलग हैं मान लीजिए कि हम पी (एफ = 0.1) है .991 (लगभग निश्चित), और अन्य सभी संभावनाएं लगभग असंभव (0.001) हैं। दूसरे शब्दों में, हमारी पूर्व निश्चितता यह है कि I सस्ता I । तब हम प्राप्त करते हैं:

 Prior P(f=x) x P(o=2/2|f=x) P(o=2/2&& f=x) P(o=2/2&&f >= x) P(f >= x) 0.001 1 1 0.001 0.001 0.072727273 0.001 0.9 0.81 0.00081 0.00181 0.131636364 0.001 0.8 0.64 0.00064 0.00245 0.178181818 0.001 0.7 0.49 0.00049 0.00294 0.213818182 0.001 0.6 0.36 0.00036 0.0033 0.24 0.001 0.5 0.25 0.00025 0.00355 0.258181818 0.001 0.4 0.16 0.00016 0.00371 0.269818182 0.001 0.3 0.09 0.00009 0.0038 0.276363636 0.001 0.2 0.04 0.00004 0.00384 0.279272727 0.991 0.1 0.01 0.00991 0.01375 1 P(o=2/2) 0.01375 

अब यह कहते हैं कि पी (एफ> = 0.5) 26% है, जो कि 0.6% की पूर्व धारणा से ऊपर है। तो Bayes हमें की संभावित लागत के हमारे अनुमान को अपडेट करने की अनुमति देता है I अगर डेटा की मात्रा बहुत कम है, तो यह हमें सही नहीं बताती कि लागत क्या है, केवल यह कि मूल्य निर्धारण के लिए पर्याप्त बड़ा है।

फिर भी इसे देखने के लिए एक अन्य तरीका को उत्तराधिकार का नियम कहा जाता है। यदि आप एक सिक्का 2 बार फ्लिप करते हैं, और यह दोनों बार सिर आता है, तो क्या यह आपको सिक्का के संभावित भार के बारे में बताता है? जवाब देने का सम्मानित तरीका यह कहना है कि यह औसत मूल्य (हिट + 1 की संख्या) / (प्रयासों की संख्या + 2) = (2 + 1) / (2 + 2) = 75% के साथ एक बीटा वितरण है।

(चाबी यह है कि हम एक बार से ज्यादा देखते हैं। अगर हम इसे केवल एक बार देखते हैं, तो वह उस f > 0 के अलावा बहुत कुछ नहीं बताता है।

इसलिए, यहां तक ​​कि बहुत कम नमूनों से हमें निर्देशों की लागत के बारे में बहुत कुछ बता सकता है जो इसे देखता है। (और यह उन्हें एक आवृत्ति के साथ देखेंगे, औसतन, उनकी लागत के लिए आनुपातिक। यदि नमूनों को लिया जाता है, और f लागत है, तो I nf+/-sqrt(nf(1-f)) नमूनों पर दिखाई देगा। उदाहरण , n=10 , f=0.3 , यह 3+/-1.4 नमूनों है।)


जोड़ा, मापने और यादृच्छिक स्टैक नमूने के बीच अंतर के लिए एक सहज महसूस करने के लिए:
अब प्रोफेयर हैं जो नमूना स्टैक, यहां तक ​​कि दीवार-घड़ी के समय पर, लेकिन जो बाहर निकलता है वह मापन (या गर्म पथ या गर्म स्थान है, जिसमें से एक "बाधा" आसानी से छिपाया जा सकता है)। वे आपको नहीं दिखाते हैं (और वे आसानी से) वास्तविक नमूने स्वयं कर सकते हैं और यदि आपका लक्ष्य बड़बड़ाहट खोजना है, तो आप की संख्या को देखने की ज़रूरत है, औसतन , 2 उस समय के अंश से विभाजित है तो अगर इसमें 30% समय लगता है, औसतन 2 / .3 = 6.7 नमूने, यह दिखाएगा, और मौका यह है कि 20 नमूने दिखाएंगे कि यह 99.2% है।

यहां मापन की जांच करने और स्टैक नमूनों की जांच करने में अंतर के एक ऑफ-कफ का चित्रण है। टोंटी इस तरह एक बड़ा ब्लॉब हो सकता है, या बहुत से छोटे, यह कोई फर्क नहीं पड़ता।

यहां छवि विवरण दर्ज करें

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

आप निम्न विकल्पों के साथ वालग्रिंड का उपयोग कर सकते हैं

 valgrind --tool=callgrind ./(Your binary) 

यह callgrind.out.x नामक फ़ाइल उत्पन्न करेगा। आप इस फ़ाइल को पढ़ने के लिए फिर kcachegrind उपकरण का उपयोग कर सकते हैं। यह आपको परिणामों के साथ चीजों का एक ग्राफिकल विश्लेषण देगा जैसे लाइनों की लागत कितनी है

मुझे लगता है कि आप जीसीसी का प्रयोग कर रहे हैं मानक समाधान जीपीआरएफ के साथ प्रोफ़ाइल के लिए होगा।

प्रोफाइलिंग से पहले संकलन को जोड़ना सुनिश्चित करें:

 cc -o myprog myprog.c utils.c -g -pg 

मैंने अभी तक इसकी कोशिश नहीं की है लेकिन मैंने सुना है कि Google-perftools के बारे में अच्छी चीजें यह निश्चित रूप से एक कोशिश के लायक है

संबंधित प्रश्न यहां ।

कुछ अन्य buzzwords यदि gprof आपके लिए नौकरी नहीं करता है: वालग्रिंड , इंटेल वीट्यून , सन डीटी्रेस

नए कर्नेल (जैसे नवीनतम उबंटु कर्नेल) नए 'पेर्फ' औजार ( apt-get install linux-tools ) उर्फ फाउंडेशन के साथ आते हैं ।

ये क्लासिक सैंपलिंग प्रोफेबलर्स ( मैन पेज ) के साथ-साथ भयानक टाइमचैर्ट भी आते हैं !

महत्वपूर्ण बात यह है कि ये उपकरण सिस्टम प्रोफाइलिंग हो सकते हैं और न केवल प्रोफ़लिंग को प्रोसेसिंग कर सकते हैं – वे थ्रेड्स, प्रोसेस और कर्नेल के बीच बातचीत दिखा सकते हैं और आपको प्रक्रियाओं के बीच शेड्यूलिंग और आई / ओ निर्भरता को समझने में मदद करता है।

वैकल्पिक शब्द

मैं Valgrind और Callgrind का उपयोग मेरे प्रोफाइलिंग उपकरण सूट के लिए आधार के रूप में करूँगा। क्या जानना महत्वपूर्ण है कि वालग्रिंड मूल रूप से एक आभासी मशीन है:

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

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

Valgrind पर एक और उपकरण का निर्माण मासफ़ है मैं इसे हेफ़ मेमरी उपयोग प्रोफ़ाइल के लिए उपयोग करता हूं। यह महान काम करता है यह क्या करता है कि यह आपको स्मृति उपयोग के स्नैपशॉट देता है – विस्तृत जानकारी स्मृति का WHAT प्रतिशत कैसा है और WHO ने इसे वहां रखा था इस तरह की जानकारी आवेदन चलाने के समय के विभिन्न बिंदुओं पर उपलब्ध है।

यह नाजोगोब के जीपीआरएफ के उत्तर की प्रतिक्रिया है

मैं पिछले दो दिनों में जीपीआरएफ का उपयोग कर रहा हूं और पहले से ही तीन महत्वपूर्ण सीमाएं पाई हैं, जिनमें से एक ने मुझे कहीं और दस्तावेज नहीं देखा है (अभी तक):

  1. यह बहु-थ्रेडेड कोड पर ठीक से काम नहीं करता है, जब तक कि आप एक वैकल्पिक हल का उपयोग नहीं करते

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

  3. यह कहता है कि "… संख्या-के-कॉल के आंकड़े गिनती से प्राप्त होते हैं, नमूना नहीं। वे पूरी तरह से सही हैं …"। फिर भी मुझे अपना कॉल ग्राफ़ मुझे 5345859132 + 784984078 कॉल आँकड़ों के रूप में कॉल सबसे ज्यादा बुलाए जाने वाले कार्यों के रूप में मिल रहा है, जहां पहले नंबर को प्रत्यक्ष कॉल माना जाता है, और दूसरा पुनरावर्ती कॉल (जो स्वयं से हैं)। चूंकि यह निहित है मैं एक बग था, मैं कोड में लंबे (64-बिट) काउंटरों में डाल दिया और फिर से वही रन किया। मेरी गिनती: 534585 9 32 प्रत्यक्ष और 780 9 4, 9 5,406 आत्म-पुनरावर्ती कॉल वहां बहुत सारे अंक हैं, इसलिए मैं पुनरावर्ती कॉलों को इंगित करूँगा जो मैं माप 78bn कर रहा हूँ, जीपीआरएफ से 784 मीटर बनाम: 100 अलग-अलग कारक दोनों रन एकल थ्रेडेड और अप्रयुक्त कोड थे, एक संकलित-जी और अन्य -पीपी।

यह जीएनयू ग्रोप्रफ (डेबियन के लिए जीएनयू बिन्तुल्टी ) 2.18.0.20080103 64-बिट डेबियन लेनी के तहत चल रहा था, अगर यह किसी को मदद करता है

valgrind --tool=callgrind चलाने का valgrind --tool=callgrind कुछ विकल्पों के बिना काफी पूरा नहीं है। हम आमतौर पर Valgrind के तहत धीमे स्टार्टअप समय के 10 मिनट प्रोफाइल नहीं करना चाहते हैं और हमारे प्रोग्राम को प्रोफ़ाइल करना चाहते हैं जब यह कुछ काम कर रहा हो

तो मैं यही सलाह देता हूं। पहला प्रोग्राम चलाएं:

 valgrind --tool=callgrind --dump-instr=yes -v --instr-atstart=no ./binary > tmp 

अब जब यह काम करता है और हम प्रोफाइलिंग शुरू करना चाहते हैं तो हमें किसी अन्य विंडो में चलाना चाहिए:

 callgrind_control -i on 

यह प्रोफाइलिंग चालू करता है इसे बंद करने और पूरे कार्य को रोकने के लिए हम इसका प्रयोग कर सकते हैं:

 callgrind_control -k 

अब हमारे पास कुछ फाइलें हैं- callgrind.out. * वर्तमान निर्देशिका में। प्रोफाइलिंग परिणामों का उपयोग देखने के लिए:

 kcachegrind callgrind.out.* 

मैं "स्व" कॉलम हैडर पर क्लिक करने के लिए अगले विंडो में सुझाव देता हूं, अन्यथा यह दिखाता है कि "मुख्य ()" सबसे अधिक समय लेने वाला कार्य है "स्व" से पता चलता है कि प्रत्येक समारोह में स्वयं कितने समय लगे, न कि आश्रितों के साथ।

Valgrind, callgrind और kcachegrind का उपयोग करें:

 valgrind --tool=callgrind ./(Your binary) 

callgrind.out.x उत्पन्न करता है इसे पढ़ें।

Gprof (ऐड-पीजी) का उपयोग करें:

 cc -o myprog myprog.c utils.c -g -pg 

(बहु-थ्रेड्स, फ़ंक्शन पॉइंटर्स के लिए अच्छा नहीं)

Google-perftools का उपयोग करें:

टाइम सैंपलिंग का उपयोग करता है, I / O और CPU बाधाओं का खुलासा किया गया है।

इंटेल VTune सर्वश्रेष्ठ है (शैक्षिक उद्देश्यों के लिए निशुल्क)

दूसरों: एएमडी कोडॅनैलिस्ट, ओपरफाइल, 'पेर्फ' टूल्स (एपटी-मिल इंस्टाल लिनक्स-टूल्स)

ये दो तरीके हैं जो मैं अपने कोड को गति देने के लिए उपयोग करता हूं:

सीपीयू बाध्य अनुप्रयोगों के लिए:

  1. अपने कोड के संदिग्ध भागों की पहचान करने के लिए DEBUG मोड में एक प्रोफ़फ़ेलर का उपयोग करें
  2. फिर रीलीज़ मोड पर स्विच करें और अपने कोड के संदिग्ध वर्गों पर टिप्पणी करें (इसे कुछ भी न छूएं) जब तक आप प्रदर्शन में परिवर्तन नहीं देखते हैं

I / O बाध्य अनुप्रयोगों के लिए:

  1. अपने कोड के संदिग्ध भागों की पहचान करने के लिए रिलीज़ मोड में एक प्रोफाइल का उपयोग करें।

एनबी

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

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

आई / ओ-बाउंड के लिए, प्रोफाइलर अभी भी रिले मोड में I / O परिचालन की पहचान कर सकता है क्योंकि आई / ओ ऑपरेशन या तो बाह्य रूप से एक साझा लाइब्रेरी से जुड़े होते हैं (ज्यादातर समय) या खराब स्थिति में, कॉल वेक्टर को अवरुद्ध करें (जो कि प्रोफ़ाइलर द्वारा आसानी से पहचाना जा सकता है)।