Rearranging best fit thread-call into impl ns

Author: fogus

src/main/clojure/clojure/core/async.clj

@@ -30,12 +30,11 @@ to catch and handle."
             clojure.core.async.impl.go ;; TODO: make conditional
             [clojure.core.async.impl.mutex :as mutex]
             [clojure.core.async.impl.concurrent :as conc]
-            [clojure.core.async.impl.exec.threadpool :as threadp])
+            )
   (:import [java.util.concurrent.atomic AtomicLong]
            [java.util.concurrent.locks Lock]
            [java.util.concurrent Executors Executor ThreadLocalRandom ExecutorService]
-           [java.util Arrays ArrayList]
-           [clojure.lang Var]))
+           [java.util Arrays ArrayList]))
 
 (alias 'core 'clojure.core)
 
@@ -462,24 +461,7 @@ to catch and handle."
   [& body]
   (#'clojure.core.async.impl.go/go-impl &env body))
 
-(defn- best-fit-thread-call
-  [f exec]
-  (let [c (chan 1)
-        ^ExecutorService e (case exec
-                             :compute threadp/compute-executor
-                             :io threadp/io-executor
-                             threadp/mixed-executor)]
-    (let [binds (Var/getThreadBindingFrame)]
-      (.execute e
-                (fn []
-                  (Var/resetThreadBindingFrame binds)
-                  (try
-                    (let [ret (f)]
-                      (when-not (nil? ret)
-                        (>!! c ret)))
-                    (finally
-                      (close! c))))))
-    c))
+(require '[clojure.core.async.impl.exec.services :as exec-services])
 
 (defn thread-call
   "Executes f in another thread, returning immediately to the calling
@@ -488,15 +470,15 @@ to catch and handle."
   nature of f's workload, one of :mixed (default) :io or :compute
   whereby core.async may be able to choose a best fit thread type."
   [f]
-  (best-fit-thread-call f :mixed))
+  (exec-services/best-fit-thread-call f :mixed))
 
 (defmacro io-thread
   "Executes the body in a thread intended for blocking I/O workloads,
   returning immediately to the calling thread. The body must not do
   extended computation (if so, use 'thread' instead). Returns a channel
   which will receive the result of the body when completed, then close."
   [& body]
-  `(#'best-fit-thread-call (^:once fn* [] ~@body) :io))
+  `(exec-services/best-fit-thread-call (^:once fn* [] ~@body) :io))
 
 (defmacro thread
   "Executes the body in another thread, returning immediately to the

src/main/clojure/clojure/core/async/impl/exec/services.clj

@@ -0,0 +1,42 @@
+;;   Copyright (c) Rich Hickey and contributors. All rights reserved.
+;;   The use and distribution terms for this software are covered by the
+;;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;;   which can be found in the file epl-v10.html at the root of this distribution.
+;;   By using this software in any fashion, you are agreeing to be bound by
+;;   the terms of this license.
+;;   You must not remove this notice, or any other, from this software.
+
+(ns clojure.core.async.impl.exec.services
+  (:require [clojure.core.async.impl.concurrent :as conc])
+  (:import [java.util.concurrent Executors ExecutorService]
+           [clojure.lang Var]))
+
+(set! *warn-on-reflection* true)
+
+(defonce ^ExecutorService mixed-executor
+  (Executors/newCachedThreadPool (conc/counted-thread-factory "async-mixed-%d" true)))
+
+(defonce ^ExecutorService io-executor
+  (Executors/newCachedThreadPool (conc/counted-thread-factory "async-io-%d" true)))
+
+(defonce ^ExecutorService compute-executor
+  (Executors/newCachedThreadPool (conc/counted-thread-factory "async-compute-%d" true)))
+
+(defn best-fit-thread-call
+  [f exec]
+  (let [c (clojure.core.async/chan 1)
+        ^ExecutorService e (case exec
+                             :compute compute-executor
+                             :io io-executor
+                             mixed-executor)]
+    (let [binds (Var/getThreadBindingFrame)]
+      (.execute e
+                (fn []
+                  (Var/resetThreadBindingFrame binds)
+                  (try
+                    (let [ret (f)]
+                      (when-not (nil? ret)
+                        (clojure.core.async/>!! c ret)))
+                    (finally
+                      (clojure.core.async/close! c))))))
+    c))

src/main/clojure/clojure/core/async/impl/exec/threadpool.clj

@@ -30,12 +30,3 @@
      (reify impl/Executor
        (impl/exec [_ r]
          (.execute executor-svc ^Runnable r))))))
-
-(defonce ^ExecutorService mixed-executor
-  (Executors/newCachedThreadPool (conc/counted-thread-factory "async-mixed-%d" true)))
-
-(defonce ^ExecutorService io-executor
-  (Executors/newCachedThreadPool (conc/counted-thread-factory "async-io-%d" true)))
-
-(defonce ^ExecutorService compute-executor
-  (Executors/newCachedThreadPool (conc/counted-thread-factory "async-compute-%d" true)))