Skip to content
Fetching contributors…
Cannot retrieve contributors at this time
907 lines (788 sloc) 31.7 KB
;;; profiler.el --- UI and helper functions for Emacs's native profiler -*- lexical-binding: t -*-
;; Copyright (C) 2012-2015 Free Software Foundation, Inc.
;; Author: Tomohiro Matsuyama <>
;; Keywords: lisp
;; This file is part of GNU Emacs.
;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <>.
;;; Commentary:
;; See Info node `(elisp)Profiling'.
;;; Code:
(require 'cl-lib)
(require 'pcase)
(defgroup profiler nil
"Emacs profiler."
:group 'lisp
:version "24.3"
:prefix "profiler-")
(defconst profiler-version "24.3")
(defcustom profiler-sampling-interval 1000000
"Default sampling interval in nanoseconds."
:type 'integer
:group 'profiler)
;;; Utilities
(defun profiler-ensure-string (object)
(cond ((stringp object)
((symbolp object)
(symbol-name object))
((numberp object)
(number-to-string object))
(format "%s" object))))
(defun profiler-format-percent (number divisor)
(concat (number-to-string (/ (* number 100) divisor)) "%"))
(defun profiler-format-number (number)
"Format NUMBER in human readable string."
(if (and (integerp number) (> number 0))
(cl-loop with i = (% (1+ (floor (log number 10))) 3)
for c in (append (number-to-string number) nil)
if (= i 0)
collect ?, into s
and do (setq i 3)
collect c into s
do (cl-decf i)
finally return
(apply 'string (if (eq (car s) ?,) (cdr s) s)))
(profiler-ensure-string number)))
(defun profiler-format (fmt &rest args)
(cl-loop for (width align subfmt) in fmt
for arg in args
for str = (cond
((consp subfmt)
(apply 'profiler-format subfmt arg))
((stringp subfmt)
(format subfmt arg))
((and (symbolp subfmt)
(fboundp subfmt))
(funcall subfmt arg))
(profiler-ensure-string arg)))
for len = (length str)
if (< width len)
collect (progn (put-text-property (max 0 (- width 2)) len
'invisible 'profiler str)
str) into frags
(let ((padding (make-string (max 0 (- width len)) ?\s)))
(cl-ecase align
(left (concat str padding))
(right (concat padding str))))
into frags
finally return (apply #'concat frags)))
;;; Entries
(defun profiler-format-entry (entry)
"Format ENTRY in human readable string. ENTRY would be a
function name of a function itself."
(cond ((memq (car-safe entry) '(closure lambda))
(format "#<lambda 0x%x>" (sxhash entry)))
((byte-code-function-p entry)
(format "#<compiled 0x%x>" (sxhash entry)))
((or (subrp entry) (symbolp entry) (stringp entry))
(format "%s" entry))
(format "#<unknown 0x%x>" (sxhash entry)))))
(defun profiler-fixup-entry (entry)
(if (symbolp entry)
(profiler-format-entry entry)))
;;; Backtraces
(defun profiler-fixup-backtrace (backtrace)
(apply 'vector (mapcar 'profiler-fixup-entry backtrace)))
;;; Logs
;; The C code returns the log in the form of a hash-table where the keys are
;; vectors (of size profiler-max-stack-depth, holding truncated
;; backtraces, where the first element is the top of the stack) and
;; the values are integers (which count how many times this backtrace
;; has been seen, multiplied by a "weight factor" which is either the
;; sampling-interval or the memory being allocated).
(defun profiler-compare-logs (log1 log2)
"Compare LOG1 with LOG2 and return diff."
(let ((newlog (make-hash-table :test 'equal)))
;; Make a copy of `log1' into `newlog'.
(maphash (lambda (backtrace count) (puthash backtrace count newlog))
(maphash (lambda (backtrace count)
(puthash backtrace (- (gethash backtrace log1 0) count)
(defun profiler-fixup-log (log)
(let ((newlog (make-hash-table :test 'equal)))
(maphash (lambda (backtrace count)
(puthash (profiler-fixup-backtrace backtrace)
count newlog))
;;; Profiles
(cl-defstruct (profiler-profile (:type vector)
(:constructor profiler-make-profile))
(tag 'profiler-profile)
(version profiler-version)
;; - `type' has a value indicating the kind of profile (`memory' or `cpu').
;; - `log' indicates the profile log.
;; - `timestamp' has a value giving the time when the profile was obtained.
;; - `diff-p' indicates if this profile represents a diff between two profiles.
type log timestamp diff-p)
(defun profiler-compare-profiles (profile1 profile2)
"Compare PROFILE1 with PROFILE2 and return diff."
(unless (eq (profiler-profile-type profile1)
(profiler-profile-type profile2))
(error "Can't compare different type of profiles"))
:type (profiler-profile-type profile1)
:timestamp (current-time)
:diff-p t
:log (profiler-compare-logs
(profiler-profile-log profile1)
(profiler-profile-log profile2))))
(defun profiler-fixup-profile (profile)
"Fixup PROFILE so that the profile could be serialized into file."
:type (profiler-profile-type profile)
:timestamp (profiler-profile-timestamp profile)
:diff-p (profiler-profile-diff-p profile)
:log (profiler-fixup-log (profiler-profile-log profile))))
(defun profiler-write-profile (profile filename &optional confirm)
"Write PROFILE into file FILENAME."
(let (print-level print-length)
(print (profiler-fixup-profile profile)
(write-file filename confirm)))
(defun profiler-read-profile (filename)
"Read profile from file FILENAME."
;; FIXME: tag and version check
(insert-file-contents filename)
(goto-char (point-min))
(read (current-buffer))))
(defun profiler-running-p (&optional mode)
"Return non-nil if the profiler is running.
Optional argument MODE means only check for the specified mode (cpu or mem)."
(cond ((eq mode 'cpu) (and (fboundp 'profiler-cpu-running-p)
((eq mode 'mem) (profiler-memory-running-p))
(t (or (profiler-running-p 'cpu)
(profiler-running-p 'mem)))))
(defun profiler-cpu-profile ()
"Return CPU profile."
(when (profiler-running-p 'cpu)
:type 'cpu
:timestamp (current-time)
:log (profiler-cpu-log))))
(defun profiler-memory-profile ()
"Return memory profile."
(when (profiler-memory-running-p)
:type 'memory
:timestamp (current-time)
:log (profiler-memory-log))))
;;; Calltrees
(cl-defstruct (profiler-calltree (:constructor profiler-make-calltree))
(count 0) (count-percent "")
parent children)
(defun profiler-calltree-leaf-p (tree)
(null (profiler-calltree-children tree)))
(defun profiler-calltree-count< (a b)
(cond ((eq (profiler-calltree-entry a) t) t)
((eq (profiler-calltree-entry b) t) nil)
(t (< (profiler-calltree-count a)
(profiler-calltree-count b)))))
(defun profiler-calltree-count> (a b)
(not (profiler-calltree-count< a b)))
(defun profiler-calltree-depth (tree)
(let ((d 0))
(while (setq tree (profiler-calltree-parent tree))
(cl-incf d))
(defun profiler-calltree-find (tree entry)
"Return a child tree of ENTRY under TREE."
(let (result (children (profiler-calltree-children tree)))
(while (and children (null result))
(let ((child (car children)))
(when (function-equal (profiler-calltree-entry child) entry)
(setq result child))
(setq children (cdr children))))
(defun profiler-calltree-walk (calltree function)
(funcall function calltree)
(dolist (child (profiler-calltree-children calltree))
(profiler-calltree-walk child function)))
(defun profiler-calltree-build-1 (tree log &optional reverse)
;; This doesn't try to stitch up partial backtraces together.
;; We still use it for reverse calltrees, but for forward calltrees, we use
;; profiler-calltree-build-unified instead now.
(lambda (backtrace count)
(let ((node tree)
(max (length backtrace)))
(dotimes (i max)
(let ((entry (aref backtrace (if reverse i (- max i 1)))))
(when entry
(let ((child (profiler-calltree-find node entry)))
(unless child
(setq child (profiler-make-calltree
:entry entry :parent node))
(push child (profiler-calltree-children node)))
(cl-incf (profiler-calltree-count child) count)
(setq node child)))))))
(define-hash-table-test 'profiler-function-equal #'function-equal
(lambda (f) (cond
((byte-code-function-p f) (aref f 1))
((eq (car-safe f) 'closure) (cddr f))
(t f))))
(defun profiler-calltree-build-unified (tree log)
;; Let's try to unify all those partial backtraces into a single
;; call tree. First, we record in fun-map all the functions that appear
;; in `log' and where they appear.
(let ((fun-map (make-hash-table :test 'profiler-function-equal))
(parent-map (make-hash-table :test 'eq))
(leftover-tree (profiler-make-calltree
:entry (intern "...") :parent tree)))
(push leftover-tree (profiler-calltree-children tree))
(lambda (backtrace _count)
(let ((max (length backtrace)))
;; Don't record the head elements in there, since we want to use this
;; fun-map to find parents of partial backtraces, but parents only
;; make sense if they have something "above".
(dotimes (i (1- max))
(let ((f (aref backtrace i)))
(when f
(push (cons i backtrace) (gethash f fun-map)))))))
;; Then, for each partial backtrace, try to find a parent backtrace
;; (i.e. a backtrace that describes (part of) the truncated part of
;; the partial backtrace). For a partial backtrace like "[f3 f2 f1]" (f3
;; is deeper), any backtrace that includes f1 could be a parent; and indeed
;; the counts of this partial backtrace could each come from a different
;; parent backtrace (some of which may not even be in `log'). So we should
;; consider each backtrace that includes f1 and give it some percentage of
;; `count'. But we can't know for sure what percentage to give to each
;; possible parent.
;; The "right" way might be to give a percentage proportional to the counts
;; already registered for that parent, or some such statistical principle.
;; But instead, we will give all our counts to a single "best
;; matching" parent. So let's look for the best matching parent, and store
;; the result in parent-map.
;; Using the "best matching parent" is important also to try and avoid
;; stitching together backtraces that can't possibly go together.
;; For example, when the head is `apply' (or `mapcar', ...), we want to
;; make sure we don't just use any parent that calls `apply', since most of
;; them would never, in turn, cause apply to call the subsequent function.
(lambda (backtrace _count)
(let* ((max (1- (length backtrace)))
(head (aref backtrace max))
(best-parent nil)
(best-match (1+ max))
(parents (gethash head fun-map)))
(pcase-dolist (`(,i . ,parent) parents)
(when t ;; (<= (- max i) best-match) ;Else, it can't be better.
(let ((match max)
(imatch i))
(cl-assert (>= match imatch))
(cl-assert (function-equal (aref backtrace max)
(aref parent i)))
(while (progn
(cl-decf imatch) (cl-decf match)
(when (> imatch 0)
(function-equal (aref backtrace match)
(aref parent imatch)))))
(when (< match best-match)
(cl-assert (<= (- max i) best-match))
;; Let's make sure this parent is not already our child: we
;; don't want cycles here!
(let ((valid t)
(tmp-parent parent))
(while (setq tmp-parent
(if (eq tmp-parent backtrace)
(setq valid nil)
(cdr (gethash tmp-parent parent-map)))))
(when valid
(setq best-match match)
(setq best-parent (cons i parent))))))))
(puthash backtrace best-parent parent-map)))
;; Now we have a single parent per backtrace, so we have a unified tree.
;; Let's build the actual call-tree from it.
(lambda (backtrace count)
(let ((node tree)
(parents (list (cons -1 backtrace)))
(tmp backtrace)
(max (length backtrace)))
(while (setq tmp (gethash tmp parent-map))
(push tmp parents)
(setq tmp (cdr tmp)))
(when (aref (cdar parents) (1- max))
(cl-incf (profiler-calltree-count leftover-tree) count)
(setq node leftover-tree))
(pcase-dolist (`(,i . ,parent) parents)
(let ((j (1- max)))
(while (> j i)
(let ((f (aref parent j)))
(cl-decf j)
(when f
(let ((child (profiler-calltree-find node f)))
(unless child
(setq child (profiler-make-calltree
:entry f :parent node))
(push child (profiler-calltree-children node)))
(cl-incf (profiler-calltree-count child) count)
(setq node child)))))))))
(defun profiler-calltree-compute-percentages (tree)
(let ((total-count 0))
;; FIXME: the memory profiler's total wraps around all too easily!
(dolist (child (profiler-calltree-children tree))
(cl-incf total-count (profiler-calltree-count child)))
(unless (zerop total-count)
tree (lambda (node)
(setf (profiler-calltree-count-percent node)
(profiler-format-percent (profiler-calltree-count node)
(cl-defun profiler-calltree-build (log &key reverse)
(let ((tree (profiler-make-calltree)))
(if reverse
(profiler-calltree-build-1 tree log reverse)
(profiler-calltree-build-unified tree log))
(profiler-calltree-compute-percentages tree)
(defun profiler-calltree-sort (tree predicate)
(let ((children (profiler-calltree-children tree)))
(setf (profiler-calltree-children tree) (sort children predicate))
(dolist (child (profiler-calltree-children tree))
(profiler-calltree-sort child predicate))))
;;; Report rendering
(defcustom profiler-report-closed-mark "+"
"An indicator of closed calltrees."
:type 'string
:group 'profiler)
(defcustom profiler-report-open-mark "-"
"An indicator of open calltrees."
:type 'string
:group 'profiler)
(defcustom profiler-report-leaf-mark " "
"An indicator of calltree leaves."
:type 'string
:group 'profiler)
(defvar profiler-report-cpu-line-format
'((50 left)
(24 right ((19 right)
(5 right)))))
(defvar profiler-report-memory-line-format
'((55 left)
(19 right ((14 right profiler-format-number)
(5 right)))))
(defvar-local profiler-report-profile nil
"The current profile.")
(defvar-local profiler-report-reversed nil
"True if calltree is rendered in bottom-up. Do not touch this
variable directly.")
(defvar-local profiler-report-order nil
"The value can be `ascending' or `descending'. Do not touch
this variable directly.")
(defun profiler-report-make-entry-part (entry)
(let ((string (cond
((eq entry t)
((and (symbolp entry)
(fboundp entry))
(propertize (symbol-name entry)
'face 'link
'mouse-face 'highlight
'help-echo "\
mouse-2: jump to definition\n\
RET: expand or collapse"))
(profiler-format-entry entry)))))
(propertize string 'profiler-entry entry)))
(defun profiler-report-make-name-part (tree)
(let* ((entry (profiler-calltree-entry tree))
(depth (profiler-calltree-depth tree))
(indent (make-string (* (1- depth) 1) ?\s))
(mark (if (profiler-calltree-leaf-p tree)
(entry (profiler-report-make-entry-part entry)))
(format "%s%s %s" indent mark entry)))
(defun profiler-report-header-line-format (fmt &rest args)
(let* ((header (apply #'profiler-format fmt args))
(escaped (replace-regexp-in-string "%" "%%" header)))
(concat " " escaped)))
(defun profiler-report-line-format (tree)
(let ((diff-p (profiler-profile-diff-p profiler-report-profile))
(name-part (profiler-report-make-name-part tree))
(count (profiler-calltree-count tree))
(count-percent (profiler-calltree-count-percent tree)))
(profiler-format (cl-ecase (profiler-profile-type profiler-report-profile)
(cpu profiler-report-cpu-line-format)
(memory profiler-report-memory-line-format))
(if diff-p
(list (if (> count 0)
(format "+%s" count)
(list count count-percent)))))
(defun profiler-report-insert-calltree (tree)
(let ((line (profiler-report-line-format tree)))
(insert (propertize (concat line "\n") 'calltree tree))))
(defun profiler-report-insert-calltree-children (tree)
(mapc #'profiler-report-insert-calltree
(profiler-calltree-children tree)))
;;; Report mode
(defvar profiler-report-mode-map
(let ((map (make-sparse-keymap)))
(define-key map "n" 'profiler-report-next-entry)
(define-key map "p" 'profiler-report-previous-entry)
;; I find it annoying more than helpful to not be able to navigate
;; normally with the cursor keys. --Stef
;; (define-key map [down] 'profiler-report-next-entry)
;; (define-key map [up] 'profiler-report-previous-entry)
(define-key map "\r" 'profiler-report-toggle-entry)
(define-key map "\t" 'profiler-report-toggle-entry)
(define-key map "i" 'profiler-report-toggle-entry)
(define-key map "f" 'profiler-report-find-entry)
(define-key map "j" 'profiler-report-find-entry)
(define-key map [mouse-2] 'profiler-report-find-entry)
(define-key map "d" 'profiler-report-describe-entry)
(define-key map "C" 'profiler-report-render-calltree)
(define-key map "B" 'profiler-report-render-reversed-calltree)
(define-key map "A" 'profiler-report-ascending-sort)
(define-key map "D" 'profiler-report-descending-sort)
(define-key map "=" 'profiler-report-compare-profile)
(define-key map (kbd "C-x C-w") 'profiler-report-write-profile)
(easy-menu-define profiler-report-menu map "Menu for Profiler Report mode."
["Next Entry" profiler-report-next-entry :active t
:help "Move to next entry"]
["Previous Entry" profiler-report-previous-entry :active t
:help "Move to previous entry"]
["Toggle Entry" profiler-report-toggle-entry
:active (profiler-report-calltree-at-point)
:help "Expand or collapse the current entry"]
["Find Entry" profiler-report-find-entry
;; FIXME should deactivate if not on a known function.
:active (profiler-report-calltree-at-point)
:help "Find the definition of the current entry"]
["Describe Entry" profiler-report-describe-entry
:active (profiler-report-calltree-at-point)
:help "Show the documentation of the current entry"]
["Show Calltree" profiler-report-render-calltree
:active profiler-report-reversed
:help "Show calltree view"]
["Show Reversed Calltree" profiler-report-render-reversed-calltree
:active (not profiler-report-reversed)
:help "Show reversed calltree view"]
["Sort Ascending" profiler-report-ascending-sort
:active (not (eq profiler-report-order 'ascending))
:help "Sort calltree view in ascending order"]
["Sort Descending" profiler-report-descending-sort
:active (not (eq profiler-report-order 'descending))
:help "Sort calltree view in descending order"]
["Compare Profile..." profiler-report-compare-profile :active t
:help "Compare current profile with another"]
["Write Profile..." profiler-report-write-profile :active t
:help "Write current profile to a file"]
["Start Profiler" profiler-start :active (not (profiler-running-p))
:help "Start profiling"]
["Stop Profiler" profiler-stop :active (profiler-running-p)
:help "Stop profiling"]
["New Report" profiler-report :active (profiler-running-p)
:help "Make a new report"]))
"Keymap for `profiler-report-mode'.")
(defun profiler-report-make-buffer-name (profile)
(format "*%s-Profiler-Report %s*"
(cl-ecase (profiler-profile-type profile) (cpu 'CPU) (memory 'Memory))
(format-time-string "%Y-%m-%d %T" (profiler-profile-timestamp profile))))
(defun profiler-report-setup-buffer-1 (profile)
"Make a buffer for PROFILE and return it."
(let* ((buf-name (profiler-report-make-buffer-name profile))
(buffer (get-buffer-create buf-name)))
(with-current-buffer buffer
(setq profiler-report-profile profile
profiler-report-reversed nil
profiler-report-order 'descending))
(defun profiler-report-setup-buffer (profile)
"Make a buffer for PROFILE with rendering the profile and
return it."
(let ((buffer (profiler-report-setup-buffer-1 profile)))
(with-current-buffer buffer
(define-derived-mode profiler-report-mode special-mode "Profiler-Report"
"Profiler Report Mode."
(add-to-invisibility-spec '(profiler . t))
(setq buffer-read-only t
buffer-undo-list t
truncate-lines t))
;;; Report commands
(defun profiler-report-calltree-at-point (&optional point)
(get-text-property (or point (point)) 'calltree))
(defun profiler-report-move-to-entry ()
(let ((point (next-single-property-change
(line-beginning-position) 'profiler-entry)))
(if point
(goto-char point)
(defun profiler-report-next-entry ()
"Move cursor to next entry."
(defun profiler-report-previous-entry ()
"Move cursor to previous entry."
(forward-line -1)
(defun profiler-report-expand-entry (&optional full)
"Expand entry at point.
With a prefix argument, expand the whole subtree."
(interactive "P")
(when (search-forward (concat profiler-report-closed-mark " ")
(line-end-position) t)
(let ((tree (profiler-report-calltree-at-point)))
(when tree
(let ((inhibit-read-only t))
(replace-match (concat profiler-report-open-mark " "))
(let ((first (point))
(last (copy-marker (point) t)))
(profiler-report-insert-calltree-children tree)
(when full
(goto-char first)
(while (< (point) last)
(forward-line 1))))
(defun profiler-report-collapse-entry ()
"Collapse entry at point."
(when (search-forward (concat profiler-report-open-mark " ")
(line-end-position) t)
(let* ((tree (profiler-report-calltree-at-point))
(depth (profiler-calltree-depth tree))
(start (line-beginning-position 2))
(when tree
(let ((inhibit-read-only t))
(replace-match (concat profiler-report-closed-mark " "))
(while (and (eq (forward-line) 0)
(let ((child (get-text-property (point) 'calltree)))
(and child
(numberp (setq d (profiler-calltree-depth child)))))
(> d depth)))
(delete-region start (line-beginning-position)))))
(defun profiler-report-toggle-entry (&optional arg)
"Expand entry at point if the tree is collapsed,
otherwise collapse."
(interactive "P")
(or (profiler-report-expand-entry arg)
(defun profiler-report-find-entry (&optional event)
"Find entry at point."
(interactive (list last-nonmenu-event))
(if event (window-buffer (posn-window (event-start event)))
(and event (setq event (event-end event))
(posn-set-point event))
(let ((tree (profiler-report-calltree-at-point)))
(when tree
(let ((entry (profiler-calltree-entry tree)))
(find-function entry))))))
(defun profiler-report-describe-entry ()
"Describe entry at point."
(let ((tree (profiler-report-calltree-at-point)))
(when tree
(let ((entry (profiler-calltree-entry tree)))
(require 'help-fns)
(describe-function entry)))))
(cl-defun profiler-report-render-calltree-1
(profile &key reverse (order 'descending))
(let ((calltree (profiler-calltree-build
(profiler-profile-log profile)
:reverse reverse)))
(setq header-line-format
(cl-ecase (profiler-profile-type profile)
"Function" (list "CPU samples" "%")))
"Function" (list "Bytes" "%")))))
(let ((predicate (cl-ecase order
(ascending #'profiler-calltree-count<)
(descending #'profiler-calltree-count>))))
(profiler-calltree-sort calltree predicate))
(let ((inhibit-read-only t))
(profiler-report-insert-calltree-children calltree)
(goto-char (point-min))
(defun profiler-report-rerender-calltree ()
(profiler-report-render-calltree-1 profiler-report-profile
:reverse profiler-report-reversed
:order profiler-report-order))
(defun profiler-report-render-calltree ()
"Render calltree view."
(setq profiler-report-reversed nil)
(defun profiler-report-render-reversed-calltree ()
"Render reversed calltree view."
(setq profiler-report-reversed t)
(defun profiler-report-ascending-sort ()
"Sort calltree view in ascending order."
(setq profiler-report-order 'ascending)
(defun profiler-report-descending-sort ()
"Sort calltree view in descending order."
(setq profiler-report-order 'descending)
(defun profiler-report-profile (profile)
(switch-to-buffer (profiler-report-setup-buffer profile)))
(defun profiler-report-profile-other-window (profile)
(switch-to-buffer-other-window (profiler-report-setup-buffer profile)))
(defun profiler-report-profile-other-frame (profile)
(switch-to-buffer-other-frame (profiler-report-setup-buffer profile)))
(defun profiler-report-compare-profile (buffer)
"Compare the current profile with another."
(interactive (list (read-buffer "Compare to: ")))
(let* ((profile1 (with-current-buffer buffer profiler-report-profile))
(profile2 profiler-report-profile)
(diff-profile (profiler-compare-profiles profile1 profile2)))
(profiler-report-profile diff-profile)))
(defun profiler-report-write-profile (filename &optional confirm)
"Write the current profile into file FILENAME."
(list (read-file-name "Write profile: " default-directory)
(not current-prefix-arg)))
(profiler-write-profile profiler-report-profile
;;; Profiler commands
(defun profiler-start (mode)
"Start/restart profilers.
MODE can be one of `cpu', `mem', or `cpu+mem'.
If MODE is `cpu' or `cpu+mem', time-based profiler will be started.
Also, if MODE is `mem' or `cpu+mem', then memory profiler will be started."
(list (if (not (fboundp 'profiler-cpu-start)) 'mem
(intern (completing-read "Mode (default cpu): "
'("cpu" "mem" "cpu+mem")
nil t nil nil "cpu")))))
(cl-ecase mode
(profiler-cpu-start profiler-sampling-interval)
(message "CPU profiler started"))
(message "Memory profiler started"))
(profiler-cpu-start profiler-sampling-interval)
(message "CPU and memory profiler started"))))
(defun profiler-stop ()
"Stop started profilers. Profiler logs will be kept."
(let ((cpu (if (fboundp 'profiler-cpu-stop) (profiler-cpu-stop)))
(mem (profiler-memory-stop)))
(message "%s profiler stopped"
(cond ((and mem cpu) "CPU and memory")
(mem "Memory")
(cpu "CPU")
(t "No")))))
(defun profiler-reset ()
"Reset profiler logs."
(when (fboundp 'profiler-cpu-log)
(ignore (profiler-cpu-log)))
(ignore (profiler-memory-log))
(defun profiler-report-cpu ()
(let ((profile (profiler-cpu-profile)))
(when profile
(profiler-report-profile-other-window profile))))
(defun profiler-report-memory ()
(let ((profile (profiler-memory-profile)))
(when profile
(profiler-report-profile-other-window profile))))
(defun profiler-report ()
"Report profiling results."
(defun profiler-find-profile (filename)
"Open profile FILENAME."
(list (read-file-name "Find profile: " default-directory)))
(profiler-report-profile (profiler-read-profile filename)))
(defun profiler-find-profile-other-window (filename)
"Open profile FILENAME."
(list (read-file-name "Find profile: " default-directory)))
(profiler-report-profile-other-window (profiler-read-profile filename)))
(defun profiler-find-profile-other-frame (filename)
"Open profile FILENAME."
(list (read-file-name "Find profile: " default-directory)))
(profiler-report-profile-other-frame(profiler-read-profile filename)))
;;; Profiling helpers
;; (cl-defmacro with-cpu-profiling ((&key sampling-interval) &rest body)
;; `(unwind-protect
;; (progn
;; (ignore (profiler-cpu-log))
;; (profiler-cpu-start ,sampling-interval)
;; ,@body)
;; (profiler-cpu-stop)
;; (profiler--report-cpu)))
;; (defmacro with-memory-profiling (&rest body)
;; `(unwind-protect
;; (progn
;; (ignore (profiler-memory-log))
;; (profiler-memory-start)
;; ,@body)
;; (profiler-memory-stop)
;; (profiler--report-memory)))
(provide 'profiler)
;;; profiler.el ends here
Something went wrong with that request. Please try again.