ClojureScript Map Search Slow

Question

I have a simple map:

(def my-map {[1 2 3] 1 [1 2 4] 5 [3 4 2] 3 [4 5 3] 3 [5 2 5] 6 [9 2 1] 5 [8 3 1] 6}) 

which I use to perform a search. However, this does pretty poorly:

 (time (doseq [x (range 500)] (my-map [1 2 8]))) "Elapsed time: 170 msecs" 

On the same machine, Clojure can do 500,000 in about 236 ms, or about 700 times faster. Although it is not unexpected for Clojure to be faster than ClojureScript, I am confused why ClojureScript will be much slower.

Any ideas on how I could make a simple multi-valued search map, as shown above, efficiently and readable in ClojureScript? I know that making a bunch of if instead of using a solution with a vector key will certainly work faster, but I'm looking at something more readable / supported.

Just update the additional information. The foregoing was done in Firefox, so it’s slower than V8. Following:

 (def my-map2 (into cljs.core.PersistentHashMap/EMPTY {[1 2 3] 1 [1 2 4] 5 [3 4 2] 3 [4 5 3] 3 [5 2 5] 6 [9 2 1] 5 [8 3 1] 6})) (defn p1 [] (let [v [1 2 8]] (dotimes [_ 5] (time (dotimes [_ 500000] (get my-map2 v)))))) 

gives:

 "Elapsed time: 3295 msecs" "Elapsed time: 3246 msecs" "Elapsed time: 3113 msecs" "Elapsed time: 3107 msecs" "Elapsed time: 3121 msecs" 

in Chromium Version 25.0.1364.160 Ubuntu 13.04 (25.0.1364.160-0ubuntu3). So it's about 13 times slower in ClojureScript than Clojure, but much better than before. Also note that I run this directly in the replica of the browser.

Answer 1

On my machine, which runs your specific example with advanced compilation, it takes ~ 14 ms on my Macbook Air 1.7ghz, which runs a relatively recent v8 built from source.

To make sure that we are comparing what we are comparing, it is best to write something like this:

 (let [v [1 2 8]] (dotimes [_ 5] (time (dotimes [_ 500000] (get my-map v))))) 

On my machine, it takes ~ 70 ms on the machine for the Clojure JVM. ClojureScript runs for approximately ~ 3600 ms, approximately 50 times slower. What for? This is because by default we save PersistentArrayMap, where Clojure does not define small hash maps with complex keys.

What happens if you instead define my map as follows:

 (def my-map (into cljs.core.PersistentHashMap/Empty [[1 2 3] 1 [1 2 4] 5 [3 4 2] 3 [4 5 3] 3 [5 2 5] 6 [9 2 1] 5 [8 3 1] 6])) 

Then the control point takes ~ 170 ms, which is not so far from the Clojure JVM.

Thus, there are many optimizations that Clojure implements that we have not yet received. However, I would say that for Clojure's idiomatic code, I believe that best of all we can hope for highly tuned JavaScript engines like V8 are 2-10X from the Clojure JVM ..