System.Posix.Pthreads

Reexports

Definitions

pthreadSelf : HasIO io => io PthreadT

  Returns the thread ID of the current thread.

Totality: total
Visibility: export

pthreadJoin : Has Errno es => EIO1 f => PthreadT -> f es ()

  Blocks the current thread and waits for the given thread to terminate.

Totality: total
Visibility: export

mkmutex : Has Errno es => EIO1 f => MutexType -> f es MutexT

  Allocates and initializes a new mutex of the given type.
  
  This must be freed with `destroyMutex`.

Totality: total
Visibility: export

destroyMutex : HasIO io => MutexT -> io ()

  Destroys a mutex and frees the memory allocated for it.

Totality: total
Visibility: export

lockMutex : Has Errno es => EIO1 f => MutexT -> f es ()

  Tries to lock the given mutex, blocking the calling thread
  in case it is already locked.

Totality: total
Visibility: export

timedlockMutex : Has Errno es => EIO1 f => MutexT -> Clock Duration -> f es Bool

  Like `lockMutex` but returns a boolean with `False` indicating
  that the lock timed out

Totality: total
Visibility: export

trylockMutex : Has Errno es => EIO1 f => MutexT -> f es Bool

  Like `lockMutex` but returns `False` in case the mutex is
  already locked.

Totality: total
Visibility: export

unlockMutex : Has Errno es => EIO1 f => MutexT -> f es ()

  Unlocks the given mutex.
  
  This is an error if the calling thread is not the one holding
  the mutex's lock.

Totality: total
Visibility: export

mkcond : Has Errno es => EIO1 f => f es CondT

  Allocates and initializes a new condition variable.
  
  This must be freed with `destroyCond`.

Totality: total
Visibility: export

destroyCond : HasIO io => CondT -> io ()

  Destroys a condition variable and frees the memory allocated for it.

Totality: total
Visibility: export

condSignal : Has Errno es => EIO1 f => CondT -> f es ()

  Signals the given `pthread_cond_t`.
  
  If several threads are waiting on the condition, it is unspecified
  which of them will be signalled. We are only guaranteed that at least
  of them will be woken up.

Totality: total
Visibility: export

condBroadcast : Has Errno es => EIO1 f => CondT -> f es ()

  Broadcasts the given `pthread_cond_t`.
  
  This will wake up all threads waiting on the given condition.

Totality: total
Visibility: export

condWait : Has Errno es => EIO1 f => CondT -> MutexT -> f es ()

  Blocks the given thread and waits for the given condition to
  be signalled.
  
  Note: The mutex must have been locked by the calling thread. The
  lock is automatically released upon calling `condWait`, and when
  the thread is woken up, the mutex will automatically be locked again.

Totality: total
Visibility: export

condTimedwait : Has Errno es => EIO1 f => CondT -> MutexT -> Clock UTC -> f es Bool

  Like `condWait` but will return `False` in case the operation timed out.

Totality: total
Visibility: export

pthreadCancel : Has Errno es => EIO1 f => PthreadT -> f es ()

  Sends a cancelation request to the given thread.

Totality: total
Visibility: export

pthreadTestCancel : HasIO io => io ()

  Tests for thread cancelation in the absence of other cancelation
  points.

Totality: total
Visibility: export

setCancelType : HasIO io => CancelType -> io CancelType

  Sets the current thread's cancel type returning the previous cancel type.

Totality: total
Visibility: export

setCancelState : HasIO io => CancelState -> io CancelState

  Sets the current thread's cancel state returning the previous cancel state.

Totality: total
Visibility: export

pthreadSigmask : Has Errno es => EIO1 f => How -> List Signal -> f es ()

  Adjust the thread's signal mask according to the given `How`
  and signal set.

Totality: total
Visibility: export

pthreadSiggetmask : HasIO io => io SigsetT

  Returns the current signal mask of the thread.
  
  Note: This allocates a new `sigset_t` pointer and returns the
        previously set signal mask. Client code is responsible to
        free the memory for this once it is no longer used.

Totality: total
Visibility: export

pthreadKill : Has Errno es => EIO1 f => PthreadT -> Signal -> f es ()

  Sends the given signal to the given thread.

Totality: total
Visibility: export