(chapter-start 'core-benchmarking "utils for benchmarking / measuring performance improvements")

;; (def bm-cond ()
;;   (if (< 3 5) "less" "more"))

;; (def bm-cond-lex (var)
;;   (if var "present" "absent"))

;; (def bm-cond-sym ()
;;   (if bm-cond-sym-value "present" "absent"))

;; (def bm-cond-3 ()
;;   (bm-cond-lex 1)
;;   (bm-cond-lex nil))

;; (def bm-cond-4 ()
;;   (assign bm-cond-sym-value 1)
;;   (bm-cond-sym)
;;   (assign bm-cond-sym-value nil)
;;   (bm-cond-sym))

;; (def bm-cond-LEX-LEX-LIT (a b)
;;   (if a b nil))

;; (def bm-cond-LEX-CND-LIT (a)
;;   (if a (if (< a 3) "yes" "no") "other"))

;; (def bm-cond-6 ()
;;   (if (< 3 5) (+ 3 5) (- 3 5)))

;; (def bm-cond-7 ()
;;   (bm-cond-LEX-CND-LIT nil)
;;   (bm-cond-LEX-CND-LIT 1)
;;   (bm-cond-LEX-CND-LIT 5))

;; (def bm-cond-5 ()
;;   (bm-cond-LEX-LEX-LIT 1 2)
;;   (bm-cond-LEX-LEX-LIT nil 3))

;; (def bm-cond-OR (x)
;;   (if x x "no"))

;; (def bm-cond-OR2 (x y z)
;;   (if x x (if y y z)))

;; (def bm-cond-8 ()
;;   (bm-cond-OR 1)
;;   (bm-cond-OR nil))

;; (def bm-cond-OR-LEX-LEX (x y)
;;   (if x x y))

;; (def bm-cond-9 ()
;;   (bm-cond-OR-LEX-LEX 1)
;;   (bm-cond-OR-LEX-LEX nil))

;; (def bm-cond-10 ()
;;   (bm-cond-OR2 1 2 3)
;;   (bm-cond-OR2 nil 2 3)
;;   (bm-cond-OR2 nil nil 3)
;;   (bm-cond-OR2 nil nil nil))

;; (def bm-cond-lex-lit-lit ()
;;   (no nil)
;;   (no 1))

;; (def bm-faster-do ()
;;   (each x '(0 1 2 3 4 5 6 7 8 9) ;; each uses 'do internally
;;     x))

;; (def bm-pythag ()
;;   (for i 1 50
;;     (for j 1 50
;;       (sqrt (+ (* i i) (* j j))))))

;; (def bm-len-str ()
;;   (len "abcd"))

;; (def bm-len-pair ()
;;   (len '(a b c d)))

;; (def bm-len-hash ()
;;   (len {a 1}))

;; (def bm-len-fn ()
;;   (len list))

;; (assign a 1)
;; (assign b 1)

;; (def bm-add-globals () (+ a b))

;; (def bm-lc-0 () 0)
;; (def bm-lc-1 (a) a)
;; (def bm-lc-2 (a b) (a b))
;; (def bm-lc-3 (a b c) (a b c))
;; (def bm-lc-4 (a b c d) (a b c d))

;; (def bm-lc-0R a a)
;; (def bm-lc-1R (a . b) (apply a b))
;; (def bm-lc-2R (a b . c) (apply a b c))
;; (def bm-lc-3R (a b c . d) (apply a b c d))
;; (def bm-lc-4R (a b c d . e) (apply a b c d e))

;; (def bm-plus-0 () (+))
;; (def bm-plus-1 (a) (+ a))
;; (def bm-plus-2 (a b) (+ a b))
;; (def bm-plus-3 (a b c) (+ a b c))
;; (def bm-f-1 (a) (a))
;; (def bm-f-2 (a b) (a b))
;; (def bm-f-3 (a b c) (a b c))

;; (def bm-0-arg-times-call () (*))
;; (def bm-1-arg-times-call () (* 23))
;; (def bm-2-arg-times-call () (* 23 24))
;; (def bm-3-arg-times-call () (* 23 24 25))
;; (def bm-4-arg-times-call () (* 23 24 25 26))

;; (def bm-plus-0-call () (bm-plus-0))
;; (def bm-plus-1-call () (bm-plus-1 1))
;; (def bm-plus-2-call () (bm-plus-2 1 2))
;; (def bm-plus-3-call () (bm-plus-3 1 2 3))
;; (def bm-f-1-call () (for i 0 10 (bm-f-1 +)))
;; (def bm-f-2-call () (for i 0 10 (bm-f-2 + 2)))
;; (def bm-f-3-call () (for i 0 10 (bm-f-3 + 2 3)))

;; (def bm-0-lc-call () (bm-lc-0))
;; (def bm-1-lc-call () (bm-lc-1 +))
;; (def bm-2-lc-call () (bm-lc-2 + 1))
;; (def bm-3-lc-call () (bm-lc-3 + 1 2))
;; (def bm-4-lc-call () (bm-lc-4 + 1 2 3))

;; (def bm-0R-lc-call () (bm-lc-0R +))
;; (def bm-1R-lc-call () (bm-lc-1R + 1))
;; (def bm-2R-lc-call () (bm-lc-2R + 1 2))
;; (def bm-3R-lc-call () (bm-lc-3R + 1 2 3))
;; (def bm-4R-lc-call () (bm-lc-4R + 1 2 3 4))

;; (def bm-complicated-0 (a b c) (a (+ 1 b) (+ 1 c)))

;; (def bm-complicated ()
;;   (bm-complicated-0 +
;;                     (bm-complicated-0 * 3 (bm-complicated-0 + 3 6))
;;                     (bm-complicated-0 - 10 (bm-complicated-0 - 13 8))))

;; (def bm-pre-compile-test ()
;;   (for i 1 10
;;        (pre-compile (dox-src rbs))))

;; (def bm-sym-lex-lex-lex () (with (a 1 b 2 c 3) (+ a b c)))
;; (def bm-sym-lex-lit-lex () (with (a 1 c 3) (+ a 2 c)))

;; (def bm-hash-fill ()
;;   (with (h {} v1 1 v2 2 v3 3 v4 4 v5 5 v6 6)
;;     (= h.aa v1) (= h.ab v2) (= h.ac v3) (= h.ba v4) (= h.bb v5) (= h.bc v6)
;;     (= h.ca v1) (= h.cb v2) (= h.cc v3) (= h.ca v4) (= h.cb v5) (= h.cc v6)
;;     (= h.da v1) (= h.db v2) (= h.dc v3) (= h.da v4) (= h.db v5) (= h.dc v6)
;;     (= h.aa v1) (= h.ab v2) (= h.ac v3) (= h.ba v4) (= h.bb v5) (= h.bc v6)
;;     (= h.ca v1) (= h.cb v2) (= h.cc v3) (= h.ca v4) (= h.cb v5) (= h.cc v6)
;;     (= h.da v1) (= h.db v2) (= h.dc v3) (= h.da v4) (= h.db v5) (= h.dc v6)))

  ;; (def bm-acc ()
  ;;   (accum z
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)))

  ;; (def bm-facc ()
  ;;   (faccum z
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)
  ;;     (z 0) (z 1) (z 2) (z 3) (z 4) (z 5) (z 6) (z 7) (z 8) (z 9)))

(in-private
  (def bm-j ()
    (j "abc" '(d e f (g h i)) (list "jk" "lm")))

  (def bm-or-lex-lex-lex (a b c) (or a b c))
  (def bm-faster-or ()
    (bm-or-lex-lex-lex 1 2 3)
    (bm-or-lex-lex-lex nil 2 3))

  (def build-mapsum-data (count data)
    (if (> count 0)
        (build-mapsum-data (- count 1)
                           (cons { mappit (rand 10) }
                                 data))
        data))

  (let mapsum-data (build-mapsum-data 1000)
    (def bm-mapsum    () (mapsum &mappit mapsum-data))
    (def bm-mapreduce () (mapreduce &mappit + mapsum-data 0))))



(def bm-repeat (f n)
  ; used in benchmarking
  (for b 1 n (f)))

(def bm (desc f repeats iterations)
     (p "\n================================================")
     (p "Benchmark: ~desc - ~repeats runs of ~iterations iterations each")
     (let times 0
          (for reps 1 repeats
               (let started (time)
                    (bm-repeat f iterations)
                    (let elapsed (- (time) started)
                         (assign times (+ elapsed times))
                         (p "  took: ~elapsed ms, ~(/ elapsed iterations) ms per iteration"))))
          (p "total ~(just times), average ~(/ times repeats) per run")
          (p "================================================\n")
          "~desc : total ~(just times), average ~(/ times repeats) per run"))

(def rbs (name)
  (let summary nil
    ;; (push (bm "accum    "   bm-acc             10  500) summary)
    ;; (push (bm "accum    "   bm-facc            10  500) summary)
    ;; (push (bm "mapsum    "   bm-mapsum             10  100) summary)
    ;; (push (bm "mapreduce "   bm-mapreduce          10  100) summary)
    ;; (push (bm "cond with OR       "   bm-faster-or             10  40000) summary)
    ;; (push (bm "cond with OR       "   bm-cond-9             10  40000) summary)
    ;; (push (bm "cond with OR       "   bm-cond-9             10  100000) summary)
    ;; (push (bm "cond with OR       "   bm-cond-lex-lit-lit             10  100000) summary)
    ;; (push (bm "optimise DO forms "   bm-faster-do             10  10000) summary)
    ;; (push (bm "length of string "   bm-len-str              10  40000) summary)
    ;; (push (bm "length of pair "     bm-len-pair                10  10000) summary)
    ;; (push (bm "sig opt 1"           bm-sym-lex-lex-lex         10 100000) summary)
    ;; (push (bm "sig opt 2"           bm-sym-lex-lit-lex         10 100000) summary)
    ;; (push (bm "hashing"             bm-hash-fill               10 5000) summary)
    ;; (push (bm "length of hash "     bm-len-hash             10  15000) summary)
    ;; (push (bm "length of uncountable "     bm-len-fn        10  50000) summary)
    ;; (push (bm "cond               "   bm-cond-3             10   50000) summary)
    ;; (push (bm "cond               "   bm-cond-4             10   50000) summary)
    ;; (push (bm "cond               "   bm-cond-5             10   50000) summary)
    ;; (push (bm "cond               "   bm-cond-6             10   50000) summary)
    ;; (push (bm "cond               "   bm-cond-7             10   50000) summary)
    (each s summary (p name " " s))))