Roughly measure function performance

[Lambeaux]

Having an easy way to measure the speed at which an arbitrary function executes would be handy for measuring the impact of pmap and similar multithreaded optimizations. This can be either a function or a macro. One crude attempt at the function approach is below.

(defn with-time-log
  ;; Unable to resolve var: f in this context
  "Wraps execution of function f in order to measure f's execution time."
  [f & args]
  (let [#_f-meta #_(meta (var f))
        #_f-name #_(if f-meta (:name f-meta) "-inaccessible-name-")
        start (System/currentTimeMillis)
        result (apply f args)
        end (System/currentTimeMillis)]
    (do start
        result
        end
        (println (str "Time elapsed for fn"
                      #_f-name
                      ": "
                      (float (/ (- end start) 1000))
                      " ms"))
        result)))

Note several problems:

• Arbitrary Clojure Vars cannot be passed around or accessed by just anyone so obtaining the function name demands a macro so access is conducted through the same ns all the time; this is the issue with f-meta and f-name and would make reporting easier with the function name.
• Clojure is lazy by default and after some fiddling, even with forcing side effects, the time is logging way too quickly and is not correct; probably a simple fix but need to revisit later.