Does anyone know if it is possible to do lock-free programming in Haskell? I’m interested both in the question of whether the appropriate low-level primitives are available, and (if they are) on any information on what works in terms of using these to build working larger-scale systems in the pure functional context. (I’ve never done lock-free programming in a pure functional context before.) For instance, as I understand it the Control.Concurrent.Chan channels are built on top of MVars, which (as I understand things) use locks—could one in principle build versions of the Chan primitive which are lock free internally? How much performance gain might one hope to get?
I shoudl also say that I’m familiar with the existence of TVars, but don’t understand their internal implementation—I’ve been given to understand that they are mostly lock free, but I’m not sure if they’re entirely lock free. So any information on the internal implementation of TVars would also be helpful!
(This thread provides some discussion, but I wonder if there’s anything more up to date/more comprehensive.)
Not only does an MVar use locks, it is a lock abstraction. And, as I recall, individual STM primitives are optimistic, but there are locks used in various places in the STM implementation. Just remember the handy rhyme: “If it can block, then beware of locks”.
For real lock-free programming you want to use IORefs directly, along with
atomicModifyIORef.Edit: regarding black holes, as I recall the implementation is lock free, but I can’t vouch for the details. The mechanism is described in “Runtime Support for Multicore Haskell”: http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel/multicore-ghc.pdf
But that implementation underwent some tweaks, I think, as described in Simon Marlow’s 2010 Haskell Implementors Workshop talk “Scheduling Lazy Evaluation on Multicore”: http://haskell.org/haskellwiki/HaskellImplementorsWorkshop/2010. The slides are unfortunately offline, but the video should still work.