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)
32 -- An internal type that is thrown as a dynamic exception to
33 -- interrupt the running IO computation when the timeout has
36 data Timeout = Timeout Unique deriving Eq
37 INSTANCE_TYPEABLE0(Timeout,timeoutTc,"Timeout")
39 instance Show Timeout where
40 show _ = "<<timeout>>"
42 instance Exception Timeout
43 #endif /* !__GLASGOW_HASKELL__ */
45 -- |Wrap an 'IO' computation to time out and return @Nothing@ in case no result
46 -- is available within @n@ microseconds (@1\/10^6@ seconds). In case a result
47 -- is available before the timeout expires, @Just a@ is returned. A negative
48 -- timeout interval means \"wait indefinitely\". When specifying long timeouts,
49 -- be careful not to exceed @maxBound :: Int@.
51 -- The design of this combinator was guided by the objective that @timeout n f@
52 -- should behave exactly the same as @f@ as long as @f@ doesn't time out. This
53 -- means that @f@ has the same 'myThreadId' it would have without the timeout
54 -- wrapper. Any exceptions @f@ might throw cancel the timeout and propagate
55 -- further up. It also possible for @f@ to receive exceptions thrown to it by
58 -- A tricky implementation detail is the question of how to abort an @IO@
59 -- computation. This combinator relies on asynchronous exceptions internally.
60 -- The technique works very well for computations executing inside of the
61 -- Haskell runtime system, but it doesn't work at all for non-Haskell code.
62 -- Foreign function calls, for example, cannot be timed out with this
63 -- combinator simply because an arbitrary C function cannot receive
64 -- asynchronous exceptions. When @timeout@ is used to wrap an FFI call that
65 -- blocks, no timeout event can be delivered until the FFI call returns, which
66 -- pretty much negates the purpose of the combinator. In practice, however,
67 -- this limitation is less severe than it may sound. Standard I\/O functions
68 -- like 'System.IO.hGetBuf', 'System.IO.hPutBuf', Network.Socket.accept, or
69 -- 'System.IO.hWaitForInput' appear to be blocking, but they really don't
70 -- because the runtime system uses scheduling mechanisms like @select(2)@ to
71 -- perform asynchronous I\/O, so it is possible to interrupt standard socket
72 -- I\/O or file I\/O using this combinator.
74 timeout :: Int -> IO a -> IO (Maybe a)
75 #ifdef __GLASGOW_HASKELL__
78 | n == 0 = return Nothing
81 ex <- fmap Timeout newUnique
82 handleJust (\e -> if e == ex then Just () else Nothing)
83 (\_ -> return Nothing)
84 (bracket (forkIO (threadDelay n >> throwTo pid ex))
88 timeout n f = fmap Just f
89 #endif /* !__GLASGOW_HASKELL__ */