प्रोफाइलिंग रूबी कोड

Question

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

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

शायद मैं इसे गलत कर रहा हूं? क्या विकल्प हैं? Google खोज मेरे लिए कुछ भी नहीं लाती है।

Answer 1

बहुत से प्रोफाइलर इस तरह हैं। आपको जो जानने की आवश्यकता है वह नहीं है जहां प्रोग्राम अपना समय बिताता है, लेकिन क्यों। Any references on Dynamic Code Analysis?

जोड़ा गया: Here's how मुझे अपने कोड में "बाधाएं" मिलती हैं। (मुझे उस शब्द से नफरत है।) Here's a list कारणों से क्यों।

यह मानना ​​पूरी तरह से स्वाभाविक है कि "बाधाओं" को खोजने के लिए आपको किसी भी तरह से मापने की ज़रूरत है। यह इतना स्वाभाविक है कि लगभग सभी प्रोफाइलर इस पर आधारित हैं।

असल में, ढूंढना और मापना एक ही समस्या नहीं है। यह देखने के लिए मापने की आवश्यकता है कि आपको क्या मिला (और निश्चित) ने एक अंतर बनाया है। मुझे ठीक करने के लिए क्या ढूँढना है, मापने से डीबगिंग की तरह है।

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

मान लीजिए कि कोड केवल आवश्यकतानुसार दो गुना लेता है। इसका मतलब है कि जब आप इसे रोकते हैं, तो 50% मौका होता है कि आप इसे अनावश्यक चीज़ कर देखेंगे। यदि आप इसे रोकते हैं और इसे 10 बार देखते हैं, तो आप इसे लगभग 5 बार इस अधिनियम में पकड़ लेंगे। वास्तव में, जैसे ही आप इसे कुछ कर देखते हैं, आप 2 नमूने के रूप में अनुकूलित कर सकते हैं, आपको "बाधा" मिल गई है। इसे ठीक करें, गति को मापें, इसे दिखाएं, और दोहराएं।

भले ही आपकी सबसे बड़ी समस्या बहुत बड़ी न हो, फिर भी यह विधि अंततः इसे पाई जाएगी। इसके अलावा, एक आवर्धन घटना है, जहां बड़े लोगों को हटाने के बाद छोटी समस्याएं ढूंढना आसान हो जाती है। यह आपको तब तक जारी रखने की अनुमति देता है जब तक कोड लगभग इष्टतम न हो।

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

Answer 2

यह मेरा ही सवाल है, लेकिन मैं मैं इसे यहाँ जोड़ने के लिए है कि एक उपकरण है जो रूपरेखा के लिए इतना अद्भुत है पाया:

http://samsaffron.com/archive/2013/03/19/flame-graphs-in-ruby-miniprofiler

Flamegraphs आश्चर्यजनक प्रदर्शन की समस्याओं का स्रोत बनाने स्पष्ट, रिश्तेदार बैकट्रैस को देखने के लिए।

Answer 3

वास्तव में अपने कोड में ड्रिल करने के लिए stackprof देखें।

यहां इसका उपयोग करने के तरीके पर एक त्वरित समाधान है: मणि इंस्टॉल करें: gem install stackprof। अपने कोड में जोड़ें: require 'stackprof' और बात यह है कि आप इस के साथ जाँच करना चाहते हैं चारों ओर:

Mode: cpu(1000) 
Samples: 9145 (1.25% miss rate) 
GC: 448 (4.90%) 

TOTAL (pct)  SAMPLES (pct)  FRAME 
    236 (2.6%)   231 (2.5%)  String#blank? 
    546 (6.0%)   216 (2.4%)  ActiveRecord::ConnectionAdapters::Mysql2Adapter#select 
    212 (2.3%)   199 (2.2%)  Mysql2::Client#query_with_timing 
    190 (2.1%)   155 (1.7%)  ERB::Util#html_escape`` 

यहाँ:

StackProf.run(mode: :cpu, out: 'stackprof-output.dump') do {YOUR_CODE} end

अपने गहरे लाल रंग का स्क्रिप्ट जाना stackprof stackprof.dump साथ टर्मिनल में उत्पादन की जांच चलाने के बाद आप अपने सभी तरीकों को देख सकते हैं जिनके लिए बहुत समय की आवश्यकता होती है। अब भयानक हिस्सा: में ड्रिल करने के लिए सिर्फ stackprof stackprof.dump --method String#blank? करते हैं और आप विशेष विधि के लिए उत्पादन प्राप्त करें:

String#blank? (lib/active_support/core_ext/object/blank.rb:80) 
    samples: 231 self (2.5%)/ 236 total (2.6%) 
    callers: 
    112 ( 47.5%) Object#present? 
    code: 
            | 80 | def blank? 
    187 (2.0%)/ 187 (2.0%) | 81 |  self !~ /[^[:space:]]/ 
            | 82 | end 

और आप काफी आसानी से अपने कोड का कौन सा हिस्सा बार चलाने के लिए का एक बहुत लेता है यह पता लगाने कर सकते हैं।

आप एक दृश्य उत्पादन प्राप्त करना चाहते हैं stackprof stackprof.dump --graphviz >> stackprof.dot और Graphviz (brew install graphviz) dot- T pdf -o stackprof.pdf stackprof.dot का उपयोग कर एक सुंदर पीडीएफ उत्पादन है, जो तरीकों कि एक लंबे समय से चलाने के लिए ले पर प्रकाश डाला गया मिलता है।

Answer 4

वहाँ भी, ruby -rprofile या समतुल्य रूप रूबी स्रोत के भीतर से है require 'profile'

प्रलेखन:

https://ruby-doc.org/stdlib-2.1.0/libdoc/profiler/rdoc/Profiler__.html