Clara durability should prefer ThreadLocal to dynamic vars

[kulkarnipushkar]

The use of the dyanamic vars in clara.rules.durability and clara.rules.durability.fressian namsespace are wasting unnecessary cpu cycles. A ThreadLocal does a subset of the work done by a Clojure dynamic var and we do not really need any of the more sophisticated properties of dynamic vars for our purposes here. The proposal is to change these to ThreadLocal.

With this change we could see the performance gain, please look at the below test result.

> (defrecord MyRecord1 [n]) 
> (defrecord MyRecord2 [n]) 
> (defrecord MyRecord3 [n]) 
> (defrecord MyRecord4 [n]) 
> (defrecord MyRecord5 [n]) 

> (def records (into [] 
cat 
(for [n (range 1e6)] 
[(MyRecord1. n) (MyRecord2. n) (MyRecord3. n) (MyRecord4. n) (MyRecord5. n)]))) 
> (time (do (serde records) nil)) 

BEFORE: "Elapsed time: 27723.323316 msecs"
AFTER: "Elapsed time: 24548.738085 msecs"

We could also see noticible performance gain in our production workflows.

[WilliamParker]

This is a cljc file, and this is not inside a reader conditional, so this will be compiled in the Clojure and ClojureScript code. ClojureScript is limited to using macros written in Clojure that take unevaluated ClojureScript code and return other ClojureScript code without any embedded JVM or JavaScript objects on either side. I'm surprised that this compiles and I'd like to understand how. In any event though it would make no sense for ClojureScript to use a JVM ThreadLocal so I think this should be inside a clj-only reader conditional.

[kulkarnipushkar]

moved thread-local-binding macro inside clj-only reader conditional

[WilliamParker]

@kulkarnipushkar please squash this PR into one commit.

[WilliamParker]

Elaborating a bit on the motivation for these changes, looking up a Clojure dynamic var involves more work than looking up a single JVM ThreadLocal. The implementation can be found at [1]. Among other things, there is a map of the bindings for the thread that the particular dynamic var involved has to be looked up in. This more dynamic approach allows Clojure to duplicate bindings between threads when a Clojure construct retrieves a new thread from Clojure's thread pool; the heart of this is [2] and its usages. In this case we don't need these properties since our durability implementation doesn't create new threads. Note that user code can be multithreaded; this doesn't impact that.

The performance difference between a dynamic var lookup and a ThreadLocal was noticeable in profiling of our production use cases.

1. https://github.com/clojure/clojure/blob/clojure-1.8.0/src/jvm/clojure/lang/Var.java#L194
2. https://github.com/clojure/clojure/blob/clojure-1.8.0/src/clj/clojure/core.clj#L1930