com.github.jlangch.venice.timing.venice Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of venice Show documentation
Venice, a sandboxed Lisp implemented in Java.
The newest version!
;;;;   __    __         _
;;;;   \ \  / /__ _ __ (_) ___ ___
;;;;    \ \/ / _ \ '_ \| |/ __/ _ \
;;;;     \  /  __/ | | | | (_|  __/
;;;;      \/ \___|_| |_|_|\___\___|
;;;;
;;;;
;;;; Copyright 2017-2024 Venice
;;;;
;;;; Licensed under the Apache License, Version 2.0 (the "License");
;;;; you may not use this file except in compliance with the License.
;;;; You may obtain a copy of the License at
;;;;
;;;;     http://www.apache.org/licenses/LICENSE-2.0
;;;;
;;;; Unless required by applicable law or agreed to in writing, software
;;;; distributed under the License is distributed on an "AS IS" BASIS,
;;;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
;;;; See the License for the specific language governing permissions and
;;;; limitations under the License.

;;;; Venice timing functions


(ns timing)


(defn
  ^{ :arglists '(
        "(timing/run f)", 
        "(timing/run f start-msg)")
     :doc
        """
        Runs a function f with printing the elapsed time.
        Returns the value that f has produced.
        """
     :examples '(
        "(timing/run #(sleep 500))"
        """(timing/run #(sleep 500) "Sleeping...")""" ) 
     :see-also '(
        "timing/elapsed" ) }

  run

  ([f]
    (timing/run f nil nil))

  ([f start-msg]
    (timing/run f start-msg nil))

  ([f start-msg end-msg]
    { :pre [(fn? f) 
            (or (nil? start-msg) (string? start-msg))
            (or (nil? end-msg) (fn? end-msg) (string? end-msg))] }
    (when start-msg 
      (println start-msg))
    (let [start   (current-time-millis)
          retval  (f)
          elapsed (- (current-time-millis) start)]
      (when end-msg 
        (if (fn? end-msg) (end-msg retval) (println end-msg)))
      (println "Elapsed:" (format-milli-time elapsed :precision 2))
      retval)))


(defn
  ^{ :arglists '(
        "(timing/elapsed f)" )
     :doc
        """
        Runs a function f and returns the elapsed time in milliseconds.
        """
     :examples '(
        "(timing/elapsed #(sleep 500))" ) 
     :see-also '(
        "timing/run" ) }

  elapsed [f]
    { :pre [(fn? f)] }
    (let [start   (current-time-millis)
          retval  (f)
          elapsed (- (current-time-millis) start)]
      elapsed))