Make your own free website on

;;;;;;; --- Profile Your Functions --- ;;;;;;;;;
;;   by (C.) Vladimir Nesterovsky, December 1998.
;;   Free for *non-commercial* personal use only
;;         with this notice unchanged.
;; Here's an AutoLISP profiler for measuring the execution
;; speed of your functions. Good for r12-r14; to use it under
;; r2000, change all your DEFUN's to DEFUN-Q's.
;; Unfortunately, we don't have access to a function's
;; lambda-list anymore in r2000's VisualLISP. :-(
;; Happy profiling!
;; usage: (profile-func 'your-function), then
;;        call it or a program that's calling it,
;;        then use (show-timers).
;;        When finished, call (profile-stop).
;; potential problems:
;;  slows down the execution while profiling many functions;
;;  time is measured by (getvar "date") that might not have
;;  fine enough resolution, depending on platform,
;;  so timings for fast routines might be not so reliable.
;;  but you can measure the execution of many repetitions of the
;;  same code with (defun test()(repeat 10000 (yourfunction)))
;;  and profiling it instead, with (profile-func 'test).

;; global variables
;;  vpn__profiled_funcs *symbol-names*
;;  various "vpn__*" vars during the execution
(DEFUN PROFILE-FUNC( FSYM / f fname arg-list formals )
 (if (not (atom fsym))
  (mapcar 'profile-func fsym)
    ((or (/= 'SYM (type FSYM))
          (not (ufuncp (SETQ F (EVAL FSYM))))
     (mapcar 'princ '(
       " must be quoted symbol of"
       " user-defined function to be profiled. "))
    ((member fsym vpn__profiled_funcs)
      (princ " ")
      (princ (sym2str fsym))
      (princ " is being profiled already. ")
      ;; profile this function
      (setq fname (sym2str fsym))

      (IF (= 'PAGETB (TYPE(CAR F))) ;; r12 stuff :-)))
        (SETQ F (CDR F))
      (SET (READ (STRCAT "vpn__orig_func_" FNAME)) F)

            FORMALS (if (MEMBER '/ ARG-LIST)
                      (REVERSE (CDR (MEMBER '/
                         (REVERSE ARG-LIST))))
      (EVAL (LIST 'DEFUN Fsym
                    (append formals
                      (list '/ 'result 'strtm 'endtm ))
        '(setq strtm (getvar "date"))
              (CONS (READ (STRCAT "vpn__orig_func_" FNAME))
        '(setq endtm (getvar "date"))
        (list '+= (list 'quote
               (READ (STRCAT "VPN__TIMER_FOR_" FNAME)))
            '(* 86400 (- endtm strtm))
        (list '+= (list 'quote
          (read (strcat "vpn__calls_for_" FNAME))) 1)
      (setq vpn__profiled_funcs
        (cons fsym vpn__profiled_funcs))
      (princ " ")

(defun profile-stop()
  (foreach x
    (atoms "vpn__timer_for_*,vpn__calls_for_*")
    (set (read x) nil)
  (setq vpn__profiled_funcs nil)

  (foreach x (atoms "vpn__timer_for_*,vpn__calls_for_*")
    (set (read x) 0)

(defun show-timers( / as nn tm )
  ((setq as (atoms "vpn__timer_for_*"))
   (foreach x (acad_strlsort as)
    (princ "\n")
    (princ (substr x 6))(princ ": n=")
    (princ (setq nn (eval (read
       (strcat "vpn__calls_for_" (substr x 16))))))
    (princ ", t=")
    (princ (setq tm (eval (read x))))
    (princ ", t/call=")(princ
       (if (zerop nn) "N/A" (/ (float tm) nn)))
    (princ ".")
  ((princ "\n No timers are being maintained."))
 (princ "\n")

(defun restore-funcs()
  (foreach x (atoms "vpn__orig_func_*")
    (set (read (substr x 16)) (eval (read x)))
    (set (read x) nil)

(defun restore-func(s / q2)
  (if (strp s)
    (if (eval (setq q2 (read
                (strcat "vpn__orig_func_" s))))
      (set (read s) (eval q2))
      (set q2 nil)
      (setq vpn__profiled_funcs
        (minuslist vpn__profiled_funcs (list (read s))))
      (foreach x
        (atoms (strcat "vpn__timer_for_" s
                       ",vpn__calls_for_" s))
        (set (read x) nil)
    (if s (restore-func (sym2str s)))

(defun show-funcs()
  (foreach x (atoms "vpn__orig_func_*")
   (print (list (setq x (substr x 16)) (eval(read x)))))

(defun sym2str (sym )
 (if (null *symbol-names*) ;; cache list empty
     (setq *symbol-names*  ;; build it
       (mapcar 'cons
         (atoms-family 0)
         (atoms-family 1))))
   ((cdr(assoc sym *symbol-names*)))
   ((cdar    ;; update cache list using SYMSTR
    (setq *symbol-names*
      (cons (cons sym (symstr sym))
            *symbol-names*)))) ))

;;convert symbol to string; found on Internet.
(defun symstr (sym)
    (if (= (type sym) 'SYM)
      ( (list
          (if (boundp sym)
            (cons '/ (atoms-family 0))
            (cons '/ (cons sym (atoms-family 0)))
          (list setq sym 1)
          (list car (list atoms-family 1))
        ) ) ) )

(defun ufuncp(f)   ;; User FUNCtion Predicate
    (listp f)
      (null (car f))              ;; no args
      (= (type (car f)) 'PAGETB)  ;; VMON
      (and                        ;; args list
        (listp (car f))
        (null (cdr (last* (car f))))   ;; not dotted list
        (apply '= (cons 'SYM
          (mapcar 'type (car f)))) ) ) ) )

;; last cons cell of a list
(defun last* (lst)
  (while (not (atom (cdr lst)))
    (setq lst (cdr lst)))

(defun += (symbolvariable incrementvalue)
 (if (numberp (eval symbolvariable))
   (set symbolvariable (+ incrementvalue
     (eval symbolvariable)))
   (set symbolvariable incrementvalue)

(defun atoms (pattern / lst)
 (setq pattern (strcase pattern))
 (foreach atomstring (atoms-family 1)
  (if (wcmatch atomstring pattern)
    (setq lst (cons atomstring lst))))
 (reverse lst))

(defun minuslist ( fromlist elementslist / tmplst )
 (foreach element fromlist
   (if (not (member element elementslist))
     (setq tmplst (cons element tmplst))))
 (reverse tmplst)

(defun profile-usage()
  (mapcar 'princ '(
    "\n       ---= Profile AutoLISP functions =---  "
    "\n by Vladimir Nesterovsky,"
    " 1998.\n\nUse (PROFILE-FUNC 'fsym), (RESTORE-FUNCS),"
    "and (PROFILE-STOP) to stop profiling."
;;;;;;;;;; PROFILE ends ;;;;;;;;;;;