Question

Sometimes I want to run a maximum amount of IO actions in parallel at once for network-activity, etc. I whipped up a small concurrent thread function which works well with https://gist.github.com/810920, but this isn’t really a pool as all IO actions must finish before others can start.

The type of what I’m looking for would be something like:

runPool :: Int -> [IO a] -> IO [a]

and should be able to operate on finite and infinite lists.

The pipes package looks like it would be able to achieve this quite well, but I feel there is probably a similar solution to the gist I have provided just using mvars, etc, from the haskell-platform.

Has anyone encountered an idiomatic solution without any heavy dependencies?

Answer 1

You need a thread pool, if you want something short, you could get inspiration from Control.ThreadPool (from the control-engine package which also provide more general functions), for instance threadPoolIO is just :

threadPoolIO :: Int -> (a -> IO b) -> IO (Chan a, Chan b)
threadPoolIO nr mutator = do
    input <- newChan
    output <- newChan
    forM_ [1..nr] $
        \_ -> forkIO (forever $ do
            i <- readChan input
            o <- mutator i
            writeChan output o)
    return (input, output)

It use two Chan for communication with the outside but that’s usually what you want, it really help writing code that don’t mess up.

If you absolutely want to wrap it up in a function of your type you can encapsulate the communication too :

runPool :: Int -> [IO a] -> IO [a]
runPool n as = do
  (input, output) <- threadPoolIO n (id)
  forM_ as $ writeChan input
  sequence (repeat (length as) $ readChan output)

This won’t keep the order of your actions, is that a problem (it’s easy to correct by transmitting the index of the action or just using an array instead to store the responses) ?

Note : the n threads will stay alive forever with this simplistic version, adding a “killAll” returned action to threadPoolIO would resolve this problem handily if you intend to create and trash several of those pool in a long running application (if not, given the weight of threads in Haskell, it’s probably not worth the bother).
Note that this function works on finite lists only, that’s because IO is normally strict so you can’t start to process elements of IO [a] before the whole list is produced, if you really want that you’ll have either to use lazy IO with unsafeInterleaveIO (maybe not the best idea) or completely change your model and use something like conduits to stream your results.