मैं क्विक कोड का प्रदर्शन कैसे माप सकता हूं?

Question

मैं अपने विशिष्ट कोड के प्रदर्शन को कैसे माप सकता हूं? मेरे द्वारा लिए गए समय को मापने के लिए कौन से उपकरण / बाहरी पैकेज उपलब्ध हैं?

कुल समय के अलावा, क्या मैं एक प्रोफ़ाइल देख सकता हूं, जो प्रति-कार्य किए गए समय को दर्शाता है? क्या मैं मेमोरी उपयोग को भी प्रोफाइल कर सकता हूं?

Comments

सवाल बहुत व्यापक है। किस तरह का प्रदर्शन? कहा पे? कब? " Emacs का प्रदर्शन " का मतलब कुछ भी और सब कुछ हो सकता है।

— ड्रू

@ ड्रू कई अन्य प्रोग्रामिंग भाषाओं में बेंचमार्क का एक सेट होता है (जैसे पायथन: speed.pypy.org , JS: Sunspider आदि), और मैं उम्मीद कर रहा था कि इसमें ऐलिस इंटरप्रेटर के लिए एक समान था।

— विल्फ्रेड ह्यूजेस

बेंचमार्किंग जैसे कि फ़ंक्शन द्वारा प्रदान की गई benchmarkऔर प्रोफाइलर Emacs के प्रदर्शन को मापता नहीं है । यह विशेष भावों के मूल्यांकन के प्रदर्शन को मापता है। यह Emacs के भीतर प्रदर्शन की तुलना करने में सहायक है। Emacs के प्रदर्शन को मापने के लिए आपको इसकी तुलना Emacs के अलावा किसी अन्य चीज़ के प्रदर्शन से करनी होगी। और यहीं से Emacs की चौड़ाई खेल में आती है। आप इस या उस के लिए Emacs बनाम XYZ को माप सकते हैं, लेकिन Emacs के प्रदर्शन को पूरी तरह से मापने के लिए आपको इस तरह की तुलना की आवश्यकता होगी।

— ड्रू

शायद आपका मतलब था " मैं Emacs में प्रदर्शन को कैसे माप सकता हूं "?

— ड्रू

ठीक है, मैंने Emacs.stackexchange.com/q/655/304 को बेंचमार्किंग Emacs के बारे में बताया है, और इस प्रश्न को बेंचमार्किंग / प्रोफाइलिंग के बारे में होना चाहिए।

— विल्फ्रेड ह्यूजेस

Answer 1

बेंचमार्क

सबसे सीधा विकल्प बिल्ट-इन benchmarkपैकेज है। इसका उपयोग उल्लेखनीय रूप से सरल है:

(benchmark 100 (form (to be evaluated)))

यह स्वतः पूर्ण है, इसलिए आपको इसकी आवश्यकता भी नहीं है।

रूपरेखा

बेंचमार्क समग्र परीक्षणों में अच्छा है, लेकिन अगर आपको प्रदर्शन समस्याएं हो रही हैं, तो यह आपको यह नहीं बताता है कि कौन से कार्य समस्या का कारण बन रहे हैं। उसके लिए, आपके पास (बिल्ट-इन) प्रोफाइलर भी है ।

1. इसके साथ शुरू करो M-x profiler-start।
2. कुछ समय लेने वाले ऑपरेशन करें।
3. के साथ रिपोर्ट प्राप्त करें M-x profiler-report।

आपको फ़ंक्शन कॉल के एक नेविगेट करने योग्य पेड़ के साथ एक बफर में ले जाना चाहिए।

Comments

benchmarkफ़ंक्शन काम नहीं करता है: जब मैं एक खुली हुई .cफ़ाइल के अंदर करता (benchmark 100 (c-font-lock-fontify-region 0 17355))हूं, तो मैं प्राप्त करता रहता हूं void-function jit-lock-bounds।

— हाय-एंजेल

FTR: एक विकल्प के रूप benchmarkमें कार्य benchmark-runऔर हैं benchmark-run-compiled। मेरे लिए मुख्य अंतर यह था कि दोनों कार्य वास्तव में काम करते हैं (मौजूदा टिप्पणी देखें) :

— Hi

Answer 2

@ मालाबार के उत्तर के अलावा, मैं with-timerअपने कोड के विभिन्न भागों (जैसे कि मेरी init.elफ़ाइल) को स्थायी रूप से लिखवाने के लिए कस्टम-निर्मित मैक्रो का उपयोग करता हूं ।

अंतर यह है कि जब आप benchmarkएक विशिष्ट बिट कोड के प्रदर्शन का अध्ययन करने की अनुमति देते हैं, तो आपको with-timerहमेशा कोड के प्रत्येक साधन वाले भाग में (बिना अधिक उपरिशायी बड़े हिस्सों के लिए खर्च किए गए) समय देता है, जो आपको जानने के लिए इनपुट देता है। आगे किस हिस्से की जांच होनी चाहिए।

(defmacro with-timer (title &rest forms)
  "Run the given FORMS, counting the elapsed time.
A message including the given TITLE and the corresponding elapsed
time is displayed."
  (declare (indent 1))
  (let ((nowvar (make-symbol "now"))
        (body   `(progn ,@forms)))
    `(let ((,nowvar (current-time)))
       (message "%s..." ,title)
       (prog1 ,body
         (let ((elapsed
                (float-time (time-subtract (current-time) ,nowvar))))
           (message "%s... done (%.3fs)" ,title elapsed))))))

उदाहरण का उपयोग करें:

(with-timer "Doing things"
  (form (to (be evaluated))))

*Messages*बफर में निम्नलिखित उत्पादन उपज :

Doing things... done (0.047s)

---

मुझे यह उल्लेख करना चाहिए कि यह use-package-with-elapsed-timerअपने उत्कृष्ट use-packageविस्तार में जॉन विएगले के मैक्रो से काफी प्रेरित है ।

Comments

यदि आप init.el को माप रहे हैं, तो आप संभवतः emacs स्टार्टअप प्रोफाइलर में रुचि लेंगे ।

— विल्फ्रेड ह्यूजेस

मैक्रों कमाल के हैं। यह अधिक वोटों का हकदार है।

— मालाबार

Emacs कुल इनिट समय रिकॉर्ड करता है। आप इसे कमांड से दिखा सकते हैं emacs-init-time।

— जो

@WilfredHughes हाँ, मैं उपयोग करता हूँ esupऔर मुझे यह पसंद है। लेकिन एक बार फिर से, इस तरह की चीज का हित with-timerइतना अधिक नहीं है कि किसी चीज को थोपी जाए। वास्तविक रुचि यह है कि आपके पास हमेशा प्रोफाइलिंग जानकारी होती है। जब भी मैं एमएसीएस शुरू करता हूं, मेरे *Messages*बफर में लाइनों की एक बंच होती है जो मुझे बताती है कि किस हिस्से में कितना समय लगा। अगर मुझे कुछ भी असामान्य लगता है, तो मैं चीजों को प्रोफाइल करने और अनुकूलित करने के लिए किसी भी अधिक पर्याप्त उपकरण का उपयोग कर सकता हूं।

— ffevotte

@ जोसे हाँ, emacs-init-timeदिलचस्प जानकारी का उत्पादन करता है। हालाँकि, यह केवल एक समावेशी बीता हुआ समय देता है, बिना इनिशियलाइज़ेशन के अलग-अलग हिस्सों को तोड़ने की संभावना के बिना।

— ffevotte

Answer 3

@ मालाबार के उत्तर के अलावा, ध्यान दें कि आप अपने कोड के संकलित निष्पादन समय को माप सकते हैं benchmark-run-compiled। यह मीट्रिक अक्सर व्याख्या किए गए निष्पादन समय की तुलना में बहुत अधिक प्रासंगिक है जो M-x benchmarkआपको देता है:

ELISP> (benchmark-run (cl-loop for i below (* 1000 1000) sum i))
(0.79330082 6 0.2081620540000002)

ELISP> (benchmark-run-compiled (cl-loop for i below (* 1000 1000) sum i))
(0.047896284 0 0.0)

तीन नंबर कुल बीता समय, जीसी रन की संख्या और जीसी में बिताए समय हैं।

Answer 4

बेंचमार्किंग न केवल संख्या प्राप्त करने के बारे में है, बल्कि परिणाम विश्लेषण के आधार पर निर्णय लेने के बारे में भी है।

नहीं है benchstat.el Melpa पर पैकेज है जो आपको लगता है कि सुविधाओं को पाने के लिए उपयोग कर सकते हैं benchstat कार्यक्रम प्रदान करता है।

यह तुलना-आधारित बेंचमार्किंग को लागू करता है जहां आप Xप्रदर्शन गुणों की जांच करते हैं Y।

बेंचस्टैट फ़ंक्शंस को एक benchmark-run-compiledरैपर के रूप में देखा जा सकता है जो न केवल जानकारी एकत्र करता है, बल्कि व्याख्या प्रारूप को पढ़ने के लिए आसान में वापस देता है। उसमे समाविष्ट हैं:

• बीता हुआ समय डेल्टा के बीच XऔरY
• औसत समय
• आवंटन राशि

बहुत सरल उपयोग उदाहरण:

(require 'benchstat)

;; Decide how much repetitions is needed.
;; This is the same as `benchmark-run-compiled` REPETITIONS argument.
(defconst repetitions 1000000)

;; Collect old code profile.
(benchstat-run :old repetitions (list 1 2))
;; Collect new code profile.
(benchstat-run :new repetitions (cons 1 2))

;; Display the results.
;; Can be run interactively by `M-x benchstat-compare'.
(benchstat-compare)

benchstat-compareएक अस्थायी बफर में परिणाम प्रस्तुत करना होगा:

name   old time/op    new time/op    delta
Emacs    44.2ms ± 6%    25.0ms ±15%  -43.38%  (p=0.000 n=10+10)

name   old allocs/op  new allocs/op  delta
Emacs      23.0 ± 0%      11.4 ± 5%  -50.43%  (p=0.000 n=10+10)

benchstatहालांकि आपको प्रोग्राम बाइनरी की आवश्यकता होगी । यदि आपने गो प्रोग्रामिंग भाषा का उपयोग किया है, तो सबसे अधिक संभावना है कि आपके सिस्टम में पहले से ही एक है। अन्यथा स्रोतों से इसे संकलित करने का एक विकल्प है।

लिनक्स / amd64 के लिए प्री-कनेक्टेड बाइनरी जीथब रिलीज पेज पर पाया जा सकता है ।