, yield -- :: IO ()
, labelThread -- :: ThreadId -> String -> IO ()
, forkProcessPrim -- :: IO Int
- , forkProcess -- :: IO (Maybe Int)
-- Waiting
, threadDelay -- :: Int -> IO ()
import GHC.Base
import GHC.IOBase ( IO(..), MVar(..), ioException, IOException(..), IOErrorType(..) )
import GHC.Num ( fromInteger, negate )
+import GHC.Real ( fromIntegral )
import GHC.Base ( Int(..) )
import GHC.Exception ( Exception(..), AsyncException(..) )
import GHC.Pack ( packCString# )
useful when debugging or diagnosing the behaviour of a concurrent
program.
-NOTE: in GHC, if you have a 'ThreadId', you essentially have
+/Note/: in GHC, if you have a 'ThreadId', you essentially have
a pointer to the thread itself. This means the thread itself can\'t be
garbage collected until you drop the 'ThreadId'.
This misfeature will hopefully be corrected at a later date.
+
+/Note/: Hugs does not provide any operations on other threads;
+it defines 'ThreadId' as a synonym for ().
-}
--forkIO has now been hoisted out into the Concurrent library.
-{- | 'killThread' terminates the given thread (Note: 'killThread' is
-not implemented in Hugs). Any work already done by the thread isn\'t
+{- | 'killThread' terminates the given thread (GHC only).
+Any work already done by the thread isn\'t
lost: the computation is suspended until required by another thread.
The memory used by the thread will be garbage collected if it isn\'t
referenced from anywhere. The 'killThread' function is defined in
killThread :: ThreadId -> IO ()
killThread tid = throwTo tid (AsyncException ThreadKilled)
-{- | 'throwTo' raises an arbitrary exception in the target thread.
+{- | 'throwTo' raises an arbitrary exception in the target thread (GHC only).
'throwTo' does not return until the exception has been raised in the
target thread. The calling thread can thus be certain that the target
throwTo (ThreadId id) ex = IO $ \ s ->
case (killThread# id ex s) of s1 -> (# s1, () #)
--- | Returns the 'ThreadId' of the calling thread.
+-- | Returns the 'ThreadId' of the calling thread (GHC only).
myThreadId :: IO ThreadId
myThreadId = IO $ \s ->
case (myThreadId# s) of (# s1, id #) -> (# s1, ThreadId id #)
adr = byteArrayContents# ps in
case (labelThread# t adr s) of s1 -> (# s1, () #)
-{- | This function is a replacement for "Posix.forkProcess": This implementation
-/will stop all other Concurrent Haskell threads/ in the (heavyweight) forked copy.
-'forkProcessPrim' returns the pid of the child process to the parent, 0 to the child,
-and a value less than 0 in case of errors. See also: 'forkProcess'.
+{- | This function is a replacement for 'System.Posix.Process.forkProcessAll':
+This implementation /will stop all other Concurrent Haskell threads/ in the
+(heavyweight) forked copy.
+'forkProcessPrim' returns the pid of the child process to the parent, 0 to the
+child, and a value less than 0 in case of errors. See also:
+'System.Posix.Process.forkProcess' in package @unix@.
Without this function, you need excessive and often impractical
explicit synchronization using the regular Concurrent Haskell constructs to assure
To work around this problem, call 'forkProcessPrim' from the main thread.
-}
+-- XXX RTS should know about 'pid_t'.
+
forkProcessPrim :: IO Int
forkProcessPrim = IO $ \s -> case (forkProcess# s) of (# s1, id #) -> (# s1, (I# id) #)
-{- | 'forkProcess' is a wrapper around 'forkProcessPrim' similar to the one found in
-"Posix.forkProcess" which returns a Maybe-type. The child receives @Nothing@, the
-parent @Just (pid::Int)@. In case of an error, an exception is thrown.
-
-NOTE: currently, main threads are not stopped in the child process.
-To work around this problem, call 'forkProcess' from the main thread.
--}
-
-forkProcess :: IO (Maybe Int)
-forkProcess = do
- pid <- forkProcessPrim
- case pid of
- -1 -> ioException (IOError Nothing -- stolen from hslibs/posix/PosixUtil
- SystemError
- "forkProcess"
- ""
- Nothing)
- 0 -> return Nothing
- _ -> return (Just pid)
-
-- Nota Bene: 'pseq' used to be 'seq'
-- but 'seq' is now defined in PrelGHC
--
case isEmptyMVar# mv# s# of
(# s2#, flg #) -> (# s2#, not (flg ==# 0#) #)
--- |Add a finalizer to an 'MVar'. See "Foreign.ForeignPtr" and
+-- |Add a finalizer to an 'MVar' (GHC only). See "Foreign.ForeignPtr" and
-- "System.Mem.Weak" for more about finalizers.
addMVarFinalizer :: MVar a -> IO () -> IO ()
addMVarFinalizer (MVar m) finalizer =
\begin{code}
-- |The 'threadDelay' operation will cause the current thread to
--- suspend for a given number of microseconds. Note that the resolution
+-- suspend for a given number of microseconds (GHC only).
+--
+-- Note that the resolution
-- used by the Haskell runtime system\'s internal timer together with the
-- fact that the thread may take some time to be rescheduled after the
-- time has expired, means that the accuracy is more like 1\/50 second.
threadDelay :: Int -> IO ()
-- | Block the current thread until data is available to read on the
--- given file descriptor.
+-- given file descriptor (GHC only).
threadWaitRead :: Int -> IO ()
-- | Block the current thread until data can be written to the
--- given file descriptor.
+-- given file descriptor (GHC only).
threadWaitWrite :: Int -> IO ()
threadDelay (I# ms) = IO $ \s -> case delay# ms s of s -> (# s, () #)
projects / ghc-base.git / blobdiff