BB Benchmarks

bb-optimized.clj

(ns binarytrees)

(defn bottom-up-tree [item depth]
  (if (> depth 0)
    [(bottom-up-tree (dec (* 2 item)) (dec depth))
     (bottom-up-tree (* 2 item) (dec depth))
     item]
    [nil nil item]))

(defn item-check [i]
  (if (nth i 0)
    (+ (nth i 2) (item-check (nth i 0)) (- (item-check (nth i 1))))
    (nth i 2)))

(defn iterate-trees [mx mn d]
  (println (* 2 (bit-shift-left 1 (int (+ mx mn (- d))))) "\t trees of depth " d "\t check: "
           (reduce + (map (fn [i]
                            (+ (item-check (bottom-up-tree i d))
                               (item-check (bottom-up-tree (- i) d))))
                          (range 1 (inc (bit-shift-left 1 (int (+ mx mn (- d))))))))))

(def min-depth 4)

(defn main [max-depth]
  (let [stretch-depth (inc max-depth)
        tree (bottom-up-tree 0 stretch-depth)
        check (item-check tree)]
    (println "stretch tree of depth " stretch-depth "\t check:" check)
    (let [long-lived-tree (bottom-up-tree 0 max-depth)]
      (doseq [d (range min-depth stretch-depth 2)]
        (iterate-trees max-depth min-depth d))
      (println "long lived tree of depth " max-depth "\t check: %d" (item-check long-lived-tree)))))

(let [n 15
      max-depth (if (> (+ min-depth 2) n) (+ min-depth 2) n)]
 (main max-depth))

results.md

Run the same code 3 times, get the best result

Code	bb v0.10.163	bb v0.10.164	nbb	Lumo	Cherry	Squint	Shadow-CLJS Compiled
with-record	11380 ms	10480 ms	26700 ms	2410 ms	---	---	438 ms
with-vectors	8960 ms	6800 ms	23150 ms	3800 ms	1680 ms	---	1320 ms
with-js-vectors	---	---	25910 ms	3300 ms	1070 ms	---	378 ms
bb-optimized	3670 ms	3580 ms	7200 ms	3720 ms	1760 ms	---	1390 ms

For squint, it does compile but displays the wrong result; for Chery, it does not yet support defrecord

To have some comparisson, I changed the squint code in the last (bb-optimized) example to replace bit_shit_left with << and remove int$ so the code at least can run. I also compiled replacing doseq's range with (vec (range...)) - this gives me 352 ms

with-js-vectors.cljs

(ns binarytrees)

(defn bottom-up-tree [item depth]
  (if (> depth 0)
    #js [(bottom-up-tree (dec (* 2 item)) (dec depth))
         (bottom-up-tree (* 2 item) (dec depth))
         item]
    #js [nil nil item]))

(defn item-check [[left right item]]
  (if (nil? left)
    item
    (+ item (item-check left) (- (item-check right)))))


(defn iterate-trees [mx mn d]
  (let [iterations (bit-shift-left 1 (int (+ mx mn (- d))))]
    (println (* 2 iterations) "\t trees of depth " d "\t check: "
             (reduce + (map (fn [i]
                              (+ (item-check (bottom-up-tree i d))
                                 (item-check (bottom-up-tree (- i) d))))
                            (range 1 (inc iterations)))))))

(def min-depth 4)

(defn main [max-depth]
  (let [stretch-depth (inc max-depth)]
    (let [tree (bottom-up-tree 0 stretch-depth)
          check (item-check tree)]
      (println "stretch tree of depth " stretch-depth "\t check:" check))
    (let [long-lived-tree (bottom-up-tree 0 max-depth)]
      (doseq [d (range min-depth stretch-depth 2)]
        (iterate-trees max-depth min-depth d))
      (println "long lived tree of depth " max-depth "\t check: %d" (item-check long-lived-tree)))))

(let [n 15
      max-depth (if (> (+ min-depth 2) n) (+ min-depth 2) n)]
 (main max-depth))

with-record.clj

(ns binarytrees)

(defrecord TreeNode [left right ^int item])

(defn bottom-up-tree [item depth]
  (if (> depth 0)
    (TreeNode.
     (bottom-up-tree (dec (* 2 item)) (dec depth))
     (bottom-up-tree (* 2 item) (dec depth))
     item)
    (TreeNode. nil nil item)))

(defn item-check [node]
  (if (nil? (:left node))
    (:item node)
    (+ (:item node) (item-check (:left node)) (- (item-check (:right node))))))


(defn iterate-trees [mx mn d]
  (let [iterations (bit-shift-left 1 (int (+ mx mn (- d))))]
    (println (* 2 iterations) "\t trees of depth " d "\t check: "
             (reduce + (map (fn [i]
                              (+ (item-check (bottom-up-tree i d))
                                 (item-check (bottom-up-tree (- i) d))))
                            (range 1 (inc iterations)))))))

(def min-depth 4)

(defn main [max-depth]
  (let [stretch-depth (inc max-depth)]
    (let [tree (bottom-up-tree 0 stretch-depth)
          check (item-check tree)]
      (println "stretch tree of depth " stretch-depth "\t check:" check))
    (let [long-lived-tree (bottom-up-tree 0 max-depth)]
      (doseq [d (range min-depth stretch-depth 2)]
        (iterate-trees max-depth min-depth d))
      (println "long lived tree of depth " max-depth "\t check: %d" (item-check long-lived-tree)))))

(let [n 15
      max-depth (if (> (+ min-depth 2) n) (+ min-depth 2) n)]
 (main max-depth))

with-vectors.clj

(ns binarytrees)

(defn bottom-up-tree [item depth]
  (if (> depth 0)
    [(bottom-up-tree (dec (* 2 item)) (dec depth))
     (bottom-up-tree (* 2 item) (dec depth))
     item]
    [nil nil item]))

(defn item-check [[left right item]]
  (if (nil? left)
    item
    (+ item (item-check left) (- (item-check right)))))


(defn iterate-trees [mx mn d]
  (let [iterations (bit-shift-left 1 (int (+ mx mn (- d))))]
    (println (* 2 iterations) "\t trees of depth " d "\t check: "
             (reduce + (map (fn [i]
                              (+ (item-check (bottom-up-tree i d))
                                 (item-check (bottom-up-tree (- i) d))))
                            (range 1 (inc iterations)))))))

(def min-depth 4)

(defn main [max-depth]
  (let [stretch-depth (inc max-depth)]
    (let [tree (bottom-up-tree 0 stretch-depth)
          check (item-check tree)]
      (println "stretch tree of depth " stretch-depth "\t check:" check))
    (let [long-lived-tree (bottom-up-tree 0 max-depth)]
      (doseq [d (range min-depth stretch-depth 2)]
        (iterate-trees max-depth min-depth d))
      (println "long lived tree of depth " max-depth "\t check: %d" (item-check long-lived-tree)))))

(let [n 15
      max-depth (if (> (+ min-depth 2) n) (+ min-depth 2) n)]
 (main max-depth))