transducer-vs-unrolled

transducer-vs-unrolled.clj

; I was curious as to whether unrolling
; this use of transducers would be faster
; 
; in fact it's slower

; we're given an array which we
; process using fns f, g and h

(defn test1-xf [^bytes data]
  (comp
    (map (fn [i] (f data i (+ 1 i))))
    (partition-all 3)
    (map (fn [p] (apply g p)))
    (partition-all 2)
    (map (fn [p] (apply h p)))))

; using transducers
; Execution time mean : 5.355734 µs
(defn test1 [^bytes data]
  (sequence (test1-xf data)
    (range 12 (* 12 4) 2)))

; unrolled
; Execution time mean : 8.817436 µs
(defmacro make-test2 []
  `(defn ~'test2 [~'data]
    ~(vec
      (sequence
        (comp
          (map (fn [i] `(f ~'data ~i ~(+ 1 i))))
          (partition-all 3)
          (map (fn [p] `(g ~@p)))
          (partition-all 2)
          (map (fn [[a g]] `(h ~a ~g))))
        (range 12 (* 12 4) 2)))))

(macroexpand '(make-test2))
=>
(def test2
 (clojure.core/fn
  ([data]
   [(h
     (g
      (f data 12 13)
      (f data 14 15)
      (f data 16 17))
     (g
      (f data 18 19)
      (f data 20 21)
      (f data 22 23)))
    (h
     (g
      (f data 24 25)
      (f data 26 27)
      (f data 28 29))
     (g
      (f data 30 31)
      (f data 32 33)
      (f data 34 35)))
    (h
     (g
      (f data 36 37)
      (f data 38 39)
      (f data 40 41))
     (g
      (f data 42 43)
      (f data 44 45)
      (f data 46 47)))])))

full benchmarks:

(bench (test2 tb1))
Evaluation count : 5622060 in 60 samples of 93701 calls.
             Execution time mean : 10.728191 µs
    Execution time std-deviation : 68.035173 ns
   Execution time lower quantile : 10.620603 µs ( 2.5%)
   Execution time upper quantile : 10.874791 µs (97.5%)
                   Overhead used : 9.090463 ns

Found 1 outliers in 60 samples (1.6667 %)
	low-severe	 1 (1.6667 %)
 Variance from outliers : 1.6389 % Variance is slightly inflated by outliers
=> nil
(bench (test1 tb1))
Evaluation count : 10959660 in 60 samples of 182661 calls.
             Execution time mean : 5.583302 µs
    Execution time std-deviation : 51.027292 ns
   Execution time lower quantile : 5.499769 µs ( 2.5%)
   Execution time upper quantile : 5.699451 µs (97.5%)
                   Overhead used : 9.090463 ns

Found 5 outliers in 60 samples (8.3333 %)
	low-severe	 4 (6.6667 %)
	low-mild	 1 (1.6667 %)
 Variance from outliers : 1.6389 % Variance is slightly inflated by outliers

Tufte profling gives the times for partition-all and map:

  pId     nCalls        Min      50% ≤      90% ≤      95% ≤      99% ≤        Max       Mean   MAD       Total   Clock

  :map    360,000   363.00ns     2.24μs     6.16μs     6.95μs    11.76μs     4.71ms     2.99μs  ±80%      1.07s     129%
   :pa    320,000   116.00ns   153.00ns     5.85μs     6.27μs    10.94μs     4.71ms     1.99μs ±115%    638.06ms     76%

Accounted 1.71s 205%
Clock 834.28ms 100%