1 -------------------------------------------------------------------------------
3 -- Module : System.Timeout
4 -- Copyright : (c) The University of Glasgow 2007
5 -- License : BSD-style (see the file libraries/base/LICENSE)
7 -- Maintainer : libraries@haskell.org
8 -- Stability : experimental
9 -- Portability : non-portable
11 -- Attach a timeout event to arbitrary 'IO' computations.
13 -------------------------------------------------------------------------------
15 #ifdef __GLASGOW_HASKELL__
19 module System.Timeout ( timeout ) where
21 #ifdef __GLASGOW_HASKELL__
22 import Prelude (Show(show), IO, Ord((<)), Eq((==)), Int,
24 import Data.Maybe (Maybe(..))
25 import Control.Monad (Monad(..))
26 import Control.Concurrent (forkIO, threadDelay, myThreadId, killThread)
27 import Control.Exception (Exception, handleJust, throwTo, bracket)
29 import Data.Unique (Unique, newUnique)
31 -- An internal type that is thrown as a dynamic exception to
32 -- interrupt the running IO computation when the timeout has
35 data Timeout = Timeout Unique deriving Eq
36 INSTANCE_TYPEABLE0(Timeout,timeoutTc,"Timeout")
38 instance Show Timeout where
39 show _ = "<<timeout>>"
41 instance Exception Timeout
42 #endif /* !__GLASGOW_HASKELL__ */
44 -- |Wrap an 'IO' computation to time out and return @Nothing@ in case no result
45 -- is available within @n@ microseconds (@1\/10^6@ seconds). In case a result
46 -- is available before the timeout expires, @Just a@ is returned. A negative
47 -- timeout interval means \"wait indefinitely\". When specifying long timeouts,
48 -- be careful not to exceed @maxBound :: Int@.
50 -- The design of this combinator was guided by the objective that @timeout n f@
51 -- should behave exactly the same as @f@ as long as @f@ doesn't time out. This
52 -- means that @f@ has the same 'myThreadId' it would have without the timeout
53 -- wrapper. Any exceptions @f@ might throw cancel the timeout and propagate
54 -- further up. It also possible for @f@ to receive exceptions thrown to it by
57 -- A tricky implementation detail is the question of how to abort an @IO@
58 -- computation. This combinator relies on asynchronous exceptions internally.
59 -- The technique works very well for computations executing inside of the
60 -- Haskell runtime system, but it doesn't work at all for non-Haskell code.
61 -- Foreign function calls, for example, cannot be timed out with this
62 -- combinator simply because an arbitrary C function cannot receive
63 -- asynchronous exceptions. When @timeout@ is used to wrap an FFI call that
64 -- blocks, no timeout event can be delivered until the FFI call returns, which
65 -- pretty much negates the purpose of the combinator. In practice, however,
66 -- this limitation is less severe than it may sound. Standard I\/O functions
67 -- like 'System.IO.hGetBuf', 'System.IO.hPutBuf', Network.Socket.accept, or
68 -- 'System.IO.hWaitForInput' appear to be blocking, but they really don't
69 -- because the runtime system uses scheduling mechanisms like @select(2)@ to
70 -- perform asynchronous I\/O, so it is possible to interrupt standard socket
71 -- I\/O or file I\/O using this combinator.
73 timeout :: Int -> IO a -> IO (Maybe a)
74 #ifdef __GLASGOW_HASKELL__
77 | n == 0 = return Nothing
80 ex <- fmap Timeout newUnique
81 handleJust (\e -> if e == ex then Just () else Nothing)
82 (\_ -> return Nothing)
83 (bracket (forkIO (threadDelay n >> throwTo pid ex))
87 timeout n f = fmap Just f
88 #endif /* !__GLASGOW_HASKELL__ */