| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Data.TLS.PThread.Internal
Description
Like Data.TLS.PThread, but this also exports internal functionality not exposed in the public interface.
There are no API guaranteees whatsoever for this module, so use it with with caution.
Synopsis
- mkTLS :: IO a -> IO (TLS a)
- getTLS :: TLS a -> IO a
- allTLS :: TLS a -> IO [a]
- forEachTLS_ :: TLS a -> (a -> IO ()) -> IO ()
- freeTLS :: TLS a -> IO ()
- freeAllTLS :: TLS a -> IO ()
- type Key = Word
- get_pthread_key_size :: Int
- pthread_key_create :: Ptr Key -> Ptr () -> IO Int
- easy_make_pthread_key :: IO Key
- pthread_getspecific :: Key -> IO (StablePtr a)
- pthread_setspecific :: Key -> StablePtr a -> IO Int
- pthread_key_delete :: Key -> IO Int
- check_error :: ()
- setspecific :: Key -> StablePtr a -> IO ()
- delete :: Key -> IO ()
- data TLS a = TLS {}
Documentation
Make a new per-thread variable. This guarantees that no two
threads that execute getTLS simultaneosly will receive the same
copy of the value. Generally, to meet this guarantee there must be
AT LEAST one copy of the TLS variable for each distinct OS thread
that calls getAll. But this is a lower bound, and there may be
*more*. In particular, there could be one per Haskell IO thread
rather than per OS thread.
Thread safe.
getTLS :: TLS a -> IO a Source #
Fetches the copy of the TLS variable of the running OS thread.
The returned value is reliable only if the current thread is bound.
For this reason, this function calls error if the current thread is
unbound.
Fetch this thread's copy of the TLS variable. Note that all
values returned by this function may be immune to garbage collected
until freeTLS is called.
Thread safe.
allTLS :: TLS a -> IO [a] Source #
After a TLS-based computation is complete, iterate through all the copies of the TLS variable which were used by all threads.
NOT thread safe.
forEachTLS_ :: TLS a -> (a -> IO ()) -> IO () Source #
Like allTLS, but apply a computation directly rather than
building a list.
freeAllTLS :: TLS a -> IO () Source #
Release all copies of the TLS variable, across all threads. This does not guarantee the storage will be freed immediately, but it guarantees that the storage can be reclaimed in the future.
The TLS value is still usable after this call, but any future calls
to getTLS must initialize new state.
Not thread safe.
check_error :: () Source #