10

How could I watch several files/sockets from Haskell and wait for these to become readable/writable?

Is there anything like the select/epoll/... in Haskell? Or I am forced to spawn one thread per file/socket and always use the blocking resource from within that thread?

Chris Stryczynski
  • 30,145
  • 48
  • 175
  • 286
Ricardo
  • 1,778
  • 1
  • 19
  • 32

2 Answers2

16

The question is wrong: you aren't forced to spawn one thread per file/socket and use blocking calls, you get to spawn one thread per file/socket and use blocking calls. This is the cleanest solution (in any language); the only reason to avoid it in other languages is that it's a bit inefficient there. GHC's threads are cheap enough, however, that it is not inefficient in Haskell. (Additionally, behind the scenes, GHC's IO manager uses an epoll-alike to wake up threads as appropriate.)

Daniel Wagner
  • 145,880
  • 9
  • 220
  • 380
  • Thanks for the clarification :-) I was also thinking from languages like Erlang, where you spawn a light process and it is quite common to receive data from several sockets in the same process. – Ricardo Jul 31 '12 at 16:45
  • 1
    Then how do you block on a file descriptor until something happens? Just saying "threads" isn't really answering the question. – pdxleif May 17 '18 at 04:29
  • 1
    @pdxleif With e.g. `hGetChar` or `hPutChar`. – Daniel Wagner May 17 '18 at 04:31
  • That sort of works, but I just want to be notified of an action on the descriptor, not actually read data from it. If I use hGetChar to retrieve data from it, I get an exception "resource exhausted (Resource temporarily unavailable)" when I subsequently run the function that's actually supposed to read the data from it. – pdxleif May 17 '18 at 04:52
  • 1
    Turns out there's `threadWaitRead` and `threadWaitWrite` in `Control.Concurrent` to block the current thread until a file descriptor is ready for reading / writing, without actually doing reading or writing. – pdxleif May 17 '18 at 06:02
4

There's a wrapper for select(2): https://hackage.haskell.org/package/select
Example usage here: https://github.com/pxqr/udev/blob/master/examples/monitor.hs#L36

There's a wrapper for poll(2): https://hackage.haskell.org/package/poll

GHC base comes with functionality that wraps epoll on Linux (and equivalent on other platforms) in the GHC.Event module.
Example usage: 

import GHC.Event
import Data.Maybe (fromMaybe)
import Control.Concurrent (threadDelay)

main = do
  fd <- getSomeFileDescriptorOfInterest
  mgr <- fromMaybe (error "Must be compiled with -threaded") <$> getSystemEventManager
  registerFd mgr (\fdkey event -> print event) fd evtRead OneShot
  threadDelay 100000000

More documentation at http://hackage.haskell.org/package/base-4.11.1.0/docs/GHC-Event.html

Example use of an older version of the lib at https://wiki.haskell.org/Simple_Servers#Epoll-based_event_callbacks Though, the loop in that example has since been moved to the hidden module GHC.Event.Manager, and is not exported publicly as far as I can tell. GHC.Event itself says "This module should be considered GHC internal."

In Control.Concurrent there's threadWaitRead and threadWaitWrite. So, to translate the above epoll example:

import Control.Concurrent (threadWaitRead)

main = do
  fd <- getSomeFileDescriptorOfInterest
  threadWaitRead fd
  putStrLn "Got a read ready event"

You can wrap the threadWaitRead and subsequent IO action in Control.Monad.forever to run them repeatedly. You can also wrap the thing in forkIO to run it in the background while your program does something else.

pdxleif
  • 1,750
  • 16
  • 15
  • Turns out there's `threadWaitRead` and `threadWaitWrite` in `Control.Concurrent` to block the current thread until a file descriptor is ready for reading / writing, without actually doing reading or writing. – pdxleif May 17 '18 at 06:02
  • `select` is POSIX function, is it possible to use this package `select` in Windows? Haskell is MinGW based, so I hope it could work, but I am not sure... – RandomB Feb 26 '22 at 06:07
  • I would just use `Control.Concurrent.threadWaitRead` - which is already part of GHC, and should be cross-platform. I would not recommend use of that `select` library. – pdxleif Mar 03 '22 at 20:55