दिलचस्प पोस्ट
Google Finance API का उपयोग करके मैं स्टॉक उद्धरण कैसे प्राप्त कर सकता हूं? क्रोम कंसोल में जावास्क्रिप्ट फ़ाइल शामिल करें नया फ़ायरबेज क्लाउड मेसेजिंग सिस्टम के साथ अधिसूचना आइकन SQL सर्वर * ऑपरेटर? त्रुटि: समाप्त न किए गए उद्धृत स्ट्रिंग या उसके पास A2DP प्रोफ़ाइल के लिए एक रिसीवर के रूप में Android डिवाइस एंड्रॉइड 2.3 वाईफाई हॉटस्पॉट एपीआई एक अलग विधानसभा में कक्षा नाम से प्रकार का हल करें जावास्क्रिप्ट का उपयोग कर एक तत्व की XPath स्थिति की गणना कैसे करें? सूची तत्व से \ n कैसे निकालें? चेकबॉक्स की डिफ़ॉल्ट छवियों को कैसे बदला जाए ग्रहण में ब्रेकपॉइंट का उपयोग कैसे करें मैं एक बुनियादी UIButton प्रोग्राम कैसे बनाऊं? JSoup UserAgent, इसे सही कैसे सेट करें? मैं एक पृष्ठभूमि वाले / अलग एसएसएच सत्र को कैसे मारूं?

जीपीआरएफ के विकल्प

क्या अन्य प्रोग्राम gprof के रूप में एक ही काम करते हैं?

Solutions Collecting From Web of "जीपीआरएफ के विकल्प"

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

ऐतिहासिक कारणों से जीपीआरएफ (पेपर पढ़ें) मौजूद है अगर आपको लगता है कि यह आपको प्रदर्शन समस्याओं की खोज में मदद करेगा, तो इसे कभी भी विज्ञापन नहीं दिया गया था। यहां बताया गया है कि पेपर क्या कहता है:

विभिन्न कार्यान्वयन की लागतों की तुलना और मूल्यांकन करने के लिए प्रो-फाई का इस्तेमाल किया जा सकता है।

यह नहीं कहा जाता है कि यह मूल्यांकन करने के लिए विभिन्न कार्यान्वयनों की पहचान करने के लिए इस्तेमाल किया जा सकता है, हालांकि यह संकेत करता है कि यह विशेष परिस्थितियों में हो सकता है:

खासकर यदि प्रोग्राम के छोटे हिस्से को अपने निष्पादन समय पर हावी होने पर पाए जाते हैं।

ऐसी समस्याओं के बारे में क्या है जो स्थानीय नहीं हैं? क्या कोई बात नहीं है? जीपीआरएफ पर उम्मीदों को मत रखो जिसे इसके लिए कभी दावा नहीं किया गया था। यह केवल एक माप उपकरण है, और केवल CPU- बद्ध परिचालन

इसकी बजाय इसे आज़माएं
यहां एक 44x स्पीडअप का उदाहरण है
यहाँ एक 730x गति है
यहां एक 8-मिनट का वीडियो प्रदर्शन है।
यहां आंकड़ों का स्पष्टीकरण दिया गया है।
आलोचकों का जवाब यहां दिया गया है।

कार्यक्रमों के बारे में एक सरल अवलोकन है। किसी दिए गए निष्पादन में, प्रत्येक निर्देश पूरे समय (विशेषकर call निर्देशों) के कुछ अंशों के लिए जिम्मेदार है, अर्थात् यदि यह वहां नहीं था, तो समय खर्च नहीं किया जाएगा। उस समय के दौरान, निर्देश स्टैक ** पर है जब यह समझा जाता है, तो आप देख सकते हैं –

gprof प्रदर्शन के बारे में कुछ मिथकों का प्रतीक है, जैसे:

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

  2. उस समय का कार्य कोड के समय-उपभोक्ता लाइनों को कैप्चर करने के लिए अधिक महत्वपूर्ण है।
    उस मिथक का कारण यह है कि जीपीआरफ़ स्टैक नमूनों पर कब्जा करने में सक्षम नहीं था, इसलिए इसके बजाय कार्य के समय, उनके इनवोकेशन की गणना होती है, और कॉल ग्राफ़ को कैप्चर करने की कोशिश करता है। हालांकि, एक बार एक महँगा समारोह की पहचान की जाती है, आपको अब उस समय के लिए ज़िम्मेदार लाइनों के लिए अंदर देखने की ज़रूरत है। यदि स्टैक नमूने थे तो आपको देखने की आवश्यकता नहीं होगी, ये लाइनें नमूने पर होंगी। (एक सामान्य फ़ंक्शन में 100 – 1000 निर्देश हो सकते हैं। फ़ंक्शन कॉल 1 निर्देश है, इसलिए कुछ ऐसी चीज़ जो अनुमानित परिमाण के 2-3 ऑर्डर अधिक सटीक हैं।)

  3. कि कॉल ग्राफ़ महत्वपूर्ण है
    एक कार्यक्रम के बारे में आपको क्या जानने की ज़रूरत नहीं है, जहां यह अपना समय बिताता है, लेकिन क्यों जब यह किसी फ़ंक्शन में समय व्यतीत कर रहा है, तो स्टैक पर कोड की हर पंक्ति यह तर्क देती है कि यह क्यों है वहां की एक श्रृंखला है। यदि आप केवल स्टैक का हिस्सा देख सकते हैं, तो आप केवल उस कारण का एक हिस्सा देख सकते हैं, इसलिए आप यह सुनिश्चित करने के लिए नहीं बता सकते कि वह समय वास्तव में आवश्यक है। कॉल ग्राफ़ आपको क्या बताता है? प्रत्येक चाप आपको बताता है कि कुछ फंक्शन ए कुछ समय के कुछ फ़ंक्शन को कॉल करने की प्रक्रिया में था I यहां तक ​​कि अगर ए में केवल एक ऐसी कोड है जो बी को कॉल कर रही है, तो उस पंक्ति के कारण केवल एक छोटा सा हिस्सा देता है यदि आप बहुत भाग्यशाली हैं, तो हो सकता है कि उस पंक्ति का खराब कारण हो। आमतौर पर, आपको कई समानांतर लाइनों को देखने की जरूरत है, अगर यह खराब है, अगर एक कॉल बी एक से अधिक स्थान पर है, तो यह आपको कम बताता है

  4. कि पुनरावृत्ति एक मुश्किल भ्रामक मुद्दा है
    यह केवल इसलिए है क्योंकि जीपीआरएफ और अन्य प्रोफेयर एक कॉल-ग्राफ़ उत्पन्न करने की जरूरत महसूस करते हैं और फिर नोड्स के लिए विशेषता का समय देते हैं। यदि किसी के स्टैक के नमूने हैं, तो नमूनों पर दिखाई देने वाली प्रत्येक पंक्ति के कोड की समय-लागत एक बहुत ही सरल संख्या है – नमूनों का अंश जो उस पर है यदि रिकर्सन है, तो एक दी गई रेखा नमूने पर एक से अधिक बार दिखाई दे सकती है। कोई बात नहीं। मान लीजिए कि नमूनों को हर एन एमएस लिया जाता है, और रेखा उनमें से F% (अकेले या नहीं) पर दिखाई देती है। अगर उस पंक्ति को कोई समय नहीं लेने के लिए किया जा सकता है (जैसे इसे हटाने या उसके चारों ओर शाखाएं), तो उन नमूने गायब हो जाएंगे, और समय F% से कम हो जाएगा।

  5. कि समय माप की सटीकता (और इसलिए नमूने की एक बड़ी संख्या) महत्वपूर्ण है।
    इसके बारे में एक सेकंड सोचें। यदि कोड की एक पंक्ति पांच में से 3 नमूनों में है, तो अगर आप इसे एक लाइट बल्ब की तरह शूट कर सकते हैं, जो लगभग 60% कम समय का उपयोग किया जाता है। अब, आप जानते हैं कि यदि आपने 5 अलग-अलग नमूनों को लिया है, तो आप केवल 2 गुना या 4 जितने देख सकते हैं। इसलिए 60% माप 40% से 80% तक सामान्य सीमा की तरह अधिक है। यदि यह केवल 40% थी, तो क्या आप कहेंगे कि समस्या ठीक नहीं है? तो समय सटीकता का क्या मतलब है, जब आप वास्तव में क्या चाहते हैं तो समस्याओं को ढूंढना है ? 500 या 5000 नमूनों ने अधिक सटीकता के साथ समस्या को मापा होगा, लेकिन इसे और अधिक सही नहीं मिला होगा।

  6. कि बयान या समारोह invocations की गिनती उपयोगी है
    मान लीजिए कि आप जानते हैं कि फ़ंक्शन को 1000 बार बुलाया गया है क्या आप बता सकते हैं कि उस समय के किस अंश की कीमत है? आपको यह भी पता होना चाहिए कि चलाने के लिए कितना समय लगता है, औसतन, गिनती से गुणा करें, और कुल समय से विभाजित करें। औसत आवंटन का समय नैनोसेकंड से सेकंड तक भिन्न हो सकता है, इसलिए अकेले गिनती ज्यादा नहीं बताती यदि स्टैक नमूने हैं, तो नियमित या किसी भी कथन की लागत सिर्फ उन नमूनों का अंश है जो इसे चालू है। समय का वह अंश है जिसे सिद्धांत रूप से बचाया जा सकता है, यदि कोई भी समय लेने के लिए नियमित या वक्तव्य नहीं किया जा सकता है, तो प्रदर्शन का सबसे सीधा संबंध है।

  7. कि अवरुद्ध होने पर नमूने लेने की आवश्यकता नहीं है
    इस मिथक के कारण दो गुना हैं: 1) उस कार्यक्रम का इंतजार करते समय पीसी नमूना अर्थहीन है, और 2) समय की सटीकता के साथ व्यस्तता। हालांकि, (1) प्रोग्राम के लिए बहुत अच्छी तरह से कुछ के लिए इंतजार किया जा सकता है, जैसे कि फ़ाइल I / O, जिसे आपको जानने की आवश्यकता है , और कौन से नमूनों के नमूने प्रकट करते हैं (स्पष्ट रूप से आप उपयोगकर्ता इनपुट का इंतजार करते समय नमूने को बाहर करना चाहते हैं।) (2) यदि प्रोग्राम अन्य प्रक्रियाओं के साथ प्रतिस्पर्धा की वजह से बस प्रतीक्षा कर रहा है, तो यह संभवतः एक रैंडम तरीके से होता है जब यह चल रहा है। इसलिए जब कार्यक्रम में अधिक समय लग सकता है, उस आंकड़े पर कोई बड़ा असर नहीं होगा, जो मायने रखता है, उस वक्त का प्रतिशत जो उस वक्त स्टैक पर है।

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

  9. कि नमूने उच्च आवृत्ति पर लिया जाना चाहिए
    यह इस विचार से आया है कि प्रदर्शन की समस्या तेजी से अभिनय कर सकती है, और इसे हिट करने के लिए नमूने लगातार होने चाहिए। लेकिन, अगर समस्या 10 रुपये (या जो भी) के कुल चलने का समय है, तो 20% का कहना है, तो उस कुल समय में प्रत्येक नमूना को मारने का 20% मौका होगा, कोई समस्या नहीं अगर समस्या तब होती है इस तरह से एक टुकड़े में
    .....XXXXXXXX...........................
    .^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^ (20 नमूने, 4 हिट)
    या इस तरह के कई छोटे टुकड़ों में
    X...X...XX.X.........X.....X....X.....
    .^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^ (20 नमूने, 3 हिट)
    किसी भी तरह, हिट की संख्या 5 में 1 के बारे में औसत होगी, चाहे कितने नमूने न हों, या कितने कम (औसत = 20 * 0.2 = 4. मानक विचलन = +/- sqrt (20 * 0.2 * 0.8) = 1.8।)

  10. कि आप बाधाओं को खोजने की कोशिश कर रहे हैं
    जैसे कि वहाँ केवल एक ही थे निम्नलिखित निष्पादन समयरेखा पर विचार करें: vxvWvzvWvxvWvYvWvxvWv.vWvxvWvYvW
    इसमें वास्तविक उपयोगी कार्य होते हैं, जो कि प्रतिनिधित्व करते हैं . । समय के क्रम में क्रमशः 1/2, 1/4, 1/8, 1/16, 1/32 लेते हुए vWxYz कार्यक्षमता समस्याएं हैं। नमूनाकरण आसानी से पाता है इसे हटा दिया जाता है, छोड़कर
    xWzWxWYWxW.WxWYW
    अब कार्यक्रम चलाने के लिए आधे समय तक ले जाता है, और अब W आधा समय लेता है, और आसानी से पाया जाता है। इसे हटा दिया जाता है, छोड़कर
    xzxYx.xY
    यह प्रक्रिया जारी रहती है, हर बार सबसे बड़ी, प्रतिशत, कार्यक्षमता की समस्या को हटाने से, जब तक कि कुछ भी निकाला जा सकता है। अब केवल एक ही चीज़ मार डाला है . , जो मूल कार्यक्रम द्वारा इस्तेमाल किए गए समय के 1/32 में कार्यान्वित करता है। यह आवर्धन प्रभाव है , जिसके द्वारा किसी भी समस्या को दूर करने से शेष बड़ा बड़ा प्रतिशत बढ़ता है, क्योंकि प्रत्येक को कम किया जाता है।
    एक अन्य महत्वपूर्ण मुद्दा यह है कि हर एक समस्या पायी जानी चाहिए – 5 में से कोई भी गायब नहीं। कोई भी समस्या नहीं मिली है और तय की गई है कि अंतिम स्पीडअप अनुपात कम हो। बस कुछ खोजने, लेकिन सभी नहीं, "अच्छा पर्याप्त" नहीं है

जोड़ा गया: मैं एक कारण बताता हूं कि जीपीआरएफ लोकप्रिय क्यों है – यह सिखाया जा रहा है, संभवतः क्योंकि यह मुफ़्त है, सिखाने में आसान है, और यह एक लंबे समय के आसपास रहा है। एक त्वरित Google खोज कुछ शैक्षिक संस्थानों को यह सिखाती है जो इसे सिखाते हैं (या दिखाई देते हैं):

बर्कले बू क्लेमसन कोलोरैडो ड्यूक ईरलाहम फ्सू इंडियाना एमआईटी एमएसयू एनसीएसए.लिइन एनसीसीयूयूयूयूयूई प्रिंसटन एसएसयू स्टैनफोर्ड यूसीएसडी उमड उमिक यूटा यूटक्सास यूटीक वस्टल

** काम करने के लिए अनुरोध करने के अन्य तरीकों के अपवाद के साथ, यह बताए जाने का कोई कारण नहीं है कि , जैसे कि संदेश पोस्टिंग के द्वारा।

चूंकि मैंने यहां पेर्फ के बारे में कुछ नहीं देखा क्योंकि यह लिनक्स पर कर्नेल और यूजर एप्लिकेशंस के प्रोफाइलिंग के लिए एक नया उपकरण है और मैंने इस जानकारी को जोड़ने का फैसला किया है।

सबसे पहले – यह लिनक्स के रूपरेखा के बारे में एक ट्यूटोरियल है

आप पेरफ का उपयोग कर सकते हैं यदि आपका लिनक्स कर्नेल 2.6.32 या ओपरोफ़ाइल से बड़ा है, यदि यह बड़ा हो। दोनों कार्यक्रमों से आपको आपके प्रोग्राम को gprof आवश्यकता नहीं है (जैसे gprof आवश्यकता है) हालांकि, -fno-omit-frame-pointer में सही ढंग से कॉल ग्राफ़ प्राप्त करने के लिए आपको -fno-omit-frame-pointer साथ प्रोग्राम बनाने की आवश्यकता है। उदाहरण के लिए: g++ -fno-omit-frame-pointer -O2 main.cpp

आप अपने आवेदन का "लाइव" विश्लेषण perf top साथ देख सकते हैं:

 sudo perf top -p `pidof a.out` -K 

या फिर आप चल रहे एप्लिकेशन के प्रदर्शन डेटा को रिकॉर्ड कर सकते हैं और उसके बाद उनका विश्लेषण कर सकते हैं:

1) प्रदर्शन डेटा रिकॉर्ड करने के लिए:

 perf record -p `pidof a.out` 

या 10 सेकंड के लिए रिकॉर्ड करने के लिए:

 perf record -p `pidof a.out` sleep 10 

या कॉल ग्राफ़ के साथ रिकॉर्ड करने के लिए

 perf record -g -p `pidof a.out` 

2) दर्ज डेटा का विश्लेषण करने के लिए

 perf report --stdio perf report --stdio --sort=dso -g none perf report --stdio -g none perf report --stdio -g 

या फिर आप किसी एप्लिकेशन के प्रदर्शन डेटा को रिकॉर्ड कर सकते हैं और उसके बाद उसके द्वारा इस आवेदन को लॉन्च करने के बाद विश्लेषण कर सकते हैं और इसे बाहर निकलने का इंतजार कर सकते हैं:

 perf record ./a.out 

यह एक परीक्षण कार्यक्रम की रूपरेखा का एक उदाहरण है

परीक्षा कार्यक्रम फ़ाइल main.cpp में है (मैं संदेश के नीचे main.cpp रखूंगा):

मैं इसे इस तरह संकलित करता हूं:

 g++ -m64 -fno-omit-frame-pointer -g main.cpp -L. -ltcmalloc_minimal -o my_test 

मैं libmalloc_minimial.so उपयोग क्योंकि यह -fno-omit-frame-pointer साथ संकलित किया -fno-omit-frame-pointer जबकि libc malloc इस विकल्प के बिना संकलित किया जा रहा है। तब मैं अपना परीक्षण कार्यक्रम चलाता हूं

 ./my_test 100000000 

फिर मैं चल रहे प्रक्रिया का प्रदर्शन डेटा रिकॉर्ड करता हूं:

 perf record -g -p `pidof my_test` -o ./my_test.perf.data sleep 30 

फिर मैं लोड मॉड्यूल का विश्लेषण करता हूं:

perf रिपोर्ट –stdio -g none –sort comm, dso -i ./my_test.perf.data

 # Overhead Command Shared Object # ........ ....... ............................ # 70.06% my_test my_test 28.33% my_test libtcmalloc_minimal.so.0.1.0 1.61% my_test [kernel.kallsyms] 

फिर लोड प्रति फ़ंक्शन का विश्लेषण किया जाता है:

perf रिपोर्ट –stdio -g none -i ./my_test.perf.data | c ++ filt

 # Overhead Command Shared Object Symbol # ........ ....... ............................ ........................... # 29.30% my_test my_test [.] f2(long) 29.14% my_test my_test [.] f1(long) 15.17% my_test libtcmalloc_minimal.so.0.1.0 [.] operator new(unsigned long) 13.16% my_test libtcmalloc_minimal.so.0.1.0 [.] operator delete(void*) 9.44% my_test my_test [.] process_request(long) 1.01% my_test my_test [.] operator delete(void*)@plt 0.97% my_test my_test [.] operator new(unsigned long)@plt 0.20% my_test my_test [.] main 0.19% my_test [kernel.kallsyms] [k] apic_timer_interrupt 0.16% my_test [kernel.kallsyms] [k] _spin_lock 0.13% my_test [kernel.kallsyms] [k] native_write_msr_safe and so on ... 

फिर कॉल श्रृंखला का विश्लेषण किया जाता है:

perf रिपोर्ट –stdio -g ग्राफ -i ./my_test.perf.data | c ++ filt

 # Overhead Command Shared Object Symbol # ........ ....... ............................ ........................... # 29.30% my_test my_test [.] f2(long) | --- f2(long) | --29.01%-- process_request(long) main __libc_start_main 29.14% my_test my_test [.] f1(long) | --- f1(long) | |--15.05%-- process_request(long) | main | __libc_start_main | --13.79%-- f2(long) process_request(long) main __libc_start_main 15.17% my_test libtcmalloc_minimal.so.0.1.0 [.] operator new(unsigned long) | --- operator new(unsigned long) | |--11.44%-- f1(long) | | | |--5.75%-- process_request(long) | | main | | __libc_start_main | | | --5.69%-- f2(long) | process_request(long) | main | __libc_start_main | --3.01%-- process_request(long) main __libc_start_main 13.16% my_test libtcmalloc_minimal.so.0.1.0 [.] operator delete(void*) | --- operator delete(void*) | |--9.13%-- f1(long) | | | |--4.63%-- f2(long) | | process_request(long) | | main | | __libc_start_main | | | --4.51%-- process_request(long) | main | __libc_start_main | |--3.05%-- process_request(long) | main | __libc_start_main | --0.80%-- f2(long) process_request(long) main __libc_start_main 9.44% my_test my_test [.] process_request(long) | --- process_request(long) | --9.39%-- main __libc_start_main 1.01% my_test my_test [.] operator delete(void*)@plt | --- operator delete(void*)@plt 0.97% my_test my_test [.] operator new(unsigned long)@plt | --- operator new(unsigned long)@plt 0.20% my_test my_test [.] main 0.19% my_test [kernel.kallsyms] [k] apic_timer_interrupt 0.16% my_test [kernel.kallsyms] [k] _spin_lock and so on ... 

तो इस बिंदु पर आप जानते हैं कि आपका कार्यक्रम समय कहाँ बिताता है।

और यह परीक्षण के लिए मुख्य सीपीपी है:

 #include <stdio.h> #include <stdlib.h> #include <time.h> time_t f1(time_t time_value) { for (int j =0; j < 10; ++j) { ++time_value; if (j%5 == 0) { double *p = new double; delete p; } } return time_value; } time_t f2(time_t time_value) { for (int j =0; j < 40; ++j) { ++time_value; } time_value=f1(time_value); return time_value; } time_t process_request(time_t time_value) { for (int j =0; j < 10; ++j) { int *p = new int; delete p; for (int m =0; m < 10; ++m) { ++time_value; } } for (int i =0; i < 10; ++i) { time_value=f1(time_value); time_value=f2(time_value); } return time_value; } int main(int argc, char* argv2[]) { int number_loops = argc > 1 ? atoi(argv2[1]) : 1; time_t time_value = time(0); printf("number loops %d\n", number_loops); printf("time_value: %d\n", time_value ); for (int i =0; i < number_loops; ++i) { time_value = process_request(time_value); } printf("time_value: %ld\n", time_value ); return 0; } 

OProfile आज़माएं यह आपके कोड की रूपरेखा के लिए एक बेहतर उपकरण है मैं इंटेल VTune को भी सुझाव देगा

ऊपर दिए गए दो औजार कोड की एक विशेष पंक्ति में बिताए समय को कम कर सकते हैं, अपना कोड, विधानसभा दिखाने और कितना विशेष निर्देश लेता है। मैट्रिक के बगल में, आप विशिष्ट काउंटर, अर्थात कैश हिट आदि की भी पूछताछ कर सकते हैं।

Gprof के विपरीत, आप किसी भी प्रक्रिया / द्विआधारी अपने सिस्टम पर दो या तो दो का उपयोग कर प्रोफ़ाइल कर सकते हैं।

Google प्रदर्शन टूल में प्रोफ़फ़ेलर का उपयोग करने में सरलता शामिल है सीपीयू और हीप प्रोफाइलर उपलब्ध है।

Sysprof पर एक नज़र डालें

आपका वितरण पहले से ही हो सकता है

http://lttng.org/ यदि आप एक उच्च प्रदर्शन ट्रैसर चाहते हैं