Comparing usage of Clojure's go-blocks vs. Go's goroutines

I'm trying to understand the implementation characteristics and the resulting performance of Clojure's go-blocks vs. Go's goroutines.

In Clojure >!! and <!! block the current thread, meaning that they can only be used when threads are created explicitly (otherwise the "only" main thread is blocked). >! and <! are parking because the go macro manages an implicit state machine that juggles multiple "processes".

However, in Go this is all hidden in the runtime, where goroutines play both roles.

So is this correct to say that Clojure code would be equivalent to Go when only using the parking versions? Since there's a thread-pool in the go macro, this is kind-of like Go's thread pool underlying goroutines. Except that performance will be worse, because Go does this in the runtime while Clojure manages it explicitly in Clojure code?

Broadly speaking, yes, the behavior of Clojure's go macro is similar to "goroutines" when using the "parking" <! and >!.

However, any performance effects are likely to be highly-specific to both the workload and the environment: operating system, number of cores, heap size, etc.

Clojure's go macro compiles its contents into a state machine composed of lots of little functions, which are dispatched through a standard Java thread pool. There isn't any other scheduling implemented in the Clojure implementation right now.

The Go language has its own internal scheduler for "goroutines," which may be able to do more sophisticated scheduling based on internal runtime knowledge. It also provides runtime inspection of "goroutines" which is not possible with Clojure's go macro.