module SDL.Raw.Thread (
createThread,
detachThread,
getThreadID,
getThreadName,
setThreadPriority,
tlsCreate,
tlsGet,
tlsSet,
threadID,
waitThread,
condBroadcast,
condSignal,
condWait,
condWaitTimeout,
createCond,
createMutex,
createSemaphore,
destroyCond,
destroyMutex,
destroySemaphore,
lockMutex,
semPost,
semTryWait,
semValue,
semWait,
semWaitTimeout,
tryLockMutex,
unlockMutex,
atomicAdd,
atomicCAS,
atomicCASPtr,
atomicDecRef,
atomicGet,
atomicGetPtr,
atomicIncRef,
atomicLock,
atomicSet,
atomicSetPtr,
atomicTryLock,
atomicUnlock
) where
import Control.Monad.IO.Class
import Data.Word
import Foreign.C.String
import Foreign.C.Types
import Foreign.Ptr
import SDL.Raw.Enum
import SDL.Raw.Types
foreign import ccall "SDL.h SDL_CreateThread" createThreadFFI :: ThreadFunction -> CString -> IO (Ptr ())
foreign import ccall "SDL.h SDL_DetachThread" detachThreadFFI :: Ptr Thread -> IO ()
foreign import ccall "SDL.h SDL_GetThreadID" getThreadIDFFI :: Ptr Thread -> IO ThreadID
foreign import ccall "SDL.h SDL_GetThreadName" getThreadNameFFI :: Ptr Thread -> IO CString
foreign import ccall "SDL.h SDL_SetThreadPriority" setThreadPriorityFFI :: ThreadPriority -> IO CInt
foreign import ccall "SDL.h SDL_TLSCreate" tlsCreateFFI :: IO TLSID
foreign import ccall "SDL.h SDL_TLSGet" tlsGetFFI :: TLSID -> IO (Ptr ())
foreign import ccall "SDL.h SDL_TLSSet" tlsSetFFI :: TLSID -> Ptr () -> FunPtr (Ptr () -> IO ()) -> IO CInt
foreign import ccall "SDL.h SDL_ThreadID" threadIDFFI :: IO ThreadID
foreign import ccall "SDL.h SDL_WaitThread" waitThreadFFI :: Ptr Thread -> Ptr CInt -> IO ()
foreign import ccall "SDL.h SDL_CondBroadcast" condBroadcastFFI :: Ptr Cond -> IO CInt
foreign import ccall "SDL.h SDL_CondSignal" condSignalFFI :: Ptr Cond -> IO CInt
foreign import ccall "SDL.h SDL_CondWait" condWaitFFI :: Ptr Cond -> Ptr Mutex -> IO CInt
foreign import ccall "SDL.h SDL_CondWaitTimeout" condWaitTimeoutFFI :: Ptr Cond -> Ptr Mutex -> Word32 -> IO CInt
foreign import ccall "SDL.h SDL_CreateCond" createCondFFI :: IO (Ptr Cond)
foreign import ccall "SDL.h SDL_CreateMutex" createMutexFFI :: IO (Ptr Mutex)
foreign import ccall "SDL.h SDL_CreateSemaphore" createSemaphoreFFI :: Word32 -> IO (Ptr Sem)
foreign import ccall "SDL.h SDL_DestroyCond" destroyCondFFI :: Ptr Cond -> IO ()
foreign import ccall "SDL.h SDL_DestroyMutex" destroyMutexFFI :: Ptr Mutex -> IO ()
foreign import ccall "SDL.h SDL_DestroySemaphore" destroySemaphoreFFI :: Ptr Sem -> IO ()
foreign import ccall "SDL.h SDL_LockMutex" lockMutexFFI :: Ptr Mutex -> IO CInt
foreign import ccall "SDL.h SDL_SemPost" semPostFFI :: Ptr Sem -> IO CInt
foreign import ccall "SDL.h SDL_SemTryWait" semTryWaitFFI :: Ptr Sem -> IO CInt
foreign import ccall "SDL.h SDL_SemValue" semValueFFI :: Ptr Sem -> IO Word32
foreign import ccall "SDL.h SDL_SemWait" semWaitFFI :: Ptr Sem -> IO CInt
foreign import ccall "SDL.h SDL_SemWaitTimeout" semWaitTimeoutFFI :: Ptr Sem -> Word32 -> IO CInt
foreign import ccall "SDL.h SDL_TryLockMutex" tryLockMutexFFI :: Ptr Mutex -> IO CInt
foreign import ccall "SDL.h SDL_UnlockMutex" unlockMutexFFI :: Ptr Mutex -> IO CInt
foreign import ccall "SDL.h SDL_AtomicAdd" atomicAddFFI :: Ptr Atomic -> CInt -> IO CInt
foreign import ccall "SDL.h SDL_AtomicCAS" atomicCASFFI :: Ptr Atomic -> CInt -> CInt -> IO Bool
foreign import ccall "SDL.h SDL_AtomicCASPtr" atomicCASPtrFFI :: Ptr (Ptr ()) -> Ptr () -> Ptr () -> IO Bool
foreign import ccall "SDL.h SDL_AtomicGet" atomicGetFFI :: Ptr Atomic -> IO CInt
foreign import ccall "SDL.h SDL_AtomicGetPtr" atomicGetPtrFFI :: Ptr (Ptr ()) -> IO (Ptr ())
foreign import ccall "SDL.h SDL_AtomicLock" atomicLockFFI :: Ptr SpinLock -> IO ()
foreign import ccall "SDL.h SDL_AtomicSet" atomicSetFFI :: Ptr Atomic -> CInt -> IO CInt
foreign import ccall "SDL.h SDL_AtomicSetPtr" atomicSetPtrFFI :: Ptr (Ptr ()) -> Ptr () -> IO (Ptr ())
foreign import ccall "SDL.h SDL_AtomicTryLock" atomicTryLockFFI :: Ptr SpinLock -> IO Bool
foreign import ccall "SDL.h SDL_AtomicUnlock" atomicUnlockFFI :: Ptr SpinLock -> IO ()
createThread :: MonadIO m => ThreadFunction -> CString -> m (Ptr ())
createThread :: ThreadFunction -> CString -> m (Ptr ())
createThread ThreadFunction
v1 CString
v2 = IO (Ptr ()) -> m (Ptr ())
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ ThreadFunction -> CString -> IO (Ptr ())
createThreadFFI ThreadFunction
v1 CString
v2
{-# INLINE createThread #-}
detachThread :: MonadIO m => Ptr Thread -> m ()
detachThread :: Ptr (Ptr ()) -> m ()
detachThread Ptr (Ptr ())
v1 = IO () -> m ()
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO ()
detachThreadFFI Ptr (Ptr ())
v1
{-# INLINE detachThread #-}
getThreadID :: MonadIO m => Ptr Thread -> m ThreadID
getThreadID :: Ptr (Ptr ()) -> m ThreadID
getThreadID Ptr (Ptr ())
v1 = IO ThreadID -> m ThreadID
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO ThreadID -> m ThreadID) -> IO ThreadID -> m ThreadID
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO ThreadID
getThreadIDFFI Ptr (Ptr ())
v1
{-# INLINE getThreadID #-}
getThreadName :: MonadIO m => Ptr Thread -> m CString
getThreadName :: Ptr (Ptr ()) -> m CString
getThreadName Ptr (Ptr ())
v1 = IO CString -> m CString
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CString -> m CString) -> IO CString -> m CString
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO CString
getThreadNameFFI Ptr (Ptr ())
v1
{-# INLINE getThreadName #-}
setThreadPriority :: MonadIO m => ThreadPriority -> m CInt
setThreadPriority :: ThreadPriority -> m CInt
setThreadPriority ThreadPriority
v1 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ ThreadPriority -> IO CInt
setThreadPriorityFFI ThreadPriority
v1
{-# INLINE setThreadPriority #-}
tlsCreate :: MonadIO m => m TLSID
tlsCreate :: m TLSID
tlsCreate = IO TLSID -> m TLSID
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO IO TLSID
tlsCreateFFI
{-# INLINE tlsCreate #-}
tlsGet :: MonadIO m => TLSID -> m (Ptr ())
tlsGet :: TLSID -> m (Ptr ())
tlsGet TLSID
v1 = IO (Ptr ()) -> m (Ptr ())
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ TLSID -> IO (Ptr ())
tlsGetFFI TLSID
v1
{-# INLINE tlsGet #-}
tlsSet :: MonadIO m => TLSID -> Ptr () -> FunPtr (Ptr () -> IO ()) -> m CInt
tlsSet :: TLSID -> Ptr () -> FunPtr (Ptr () -> IO ()) -> m CInt
tlsSet TLSID
v1 Ptr ()
v2 FunPtr (Ptr () -> IO ())
v3 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ TLSID -> Ptr () -> FunPtr (Ptr () -> IO ()) -> IO CInt
tlsSetFFI TLSID
v1 Ptr ()
v2 FunPtr (Ptr () -> IO ())
v3
{-# INLINE tlsSet #-}
threadID :: MonadIO m => m ThreadID
threadID :: m ThreadID
threadID = IO ThreadID -> m ThreadID
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO IO ThreadID
threadIDFFI
{-# INLINE threadID #-}
waitThread :: MonadIO m => Ptr Thread -> Ptr CInt -> m ()
waitThread :: Ptr (Ptr ()) -> Ptr CInt -> m ()
waitThread Ptr (Ptr ())
v1 Ptr CInt
v2 = IO () -> m ()
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> Ptr CInt -> IO ()
waitThreadFFI Ptr (Ptr ())
v1 Ptr CInt
v2
{-# INLINE waitThread #-}
condBroadcast :: MonadIO m => Ptr Cond -> m CInt
condBroadcast :: Ptr (Ptr ()) -> m CInt
condBroadcast Ptr (Ptr ())
v1 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO CInt
condBroadcastFFI Ptr (Ptr ())
v1
{-# INLINE condBroadcast #-}
condSignal :: MonadIO m => Ptr Cond -> m CInt
condSignal :: Ptr (Ptr ()) -> m CInt
condSignal Ptr (Ptr ())
v1 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO CInt
condSignalFFI Ptr (Ptr ())
v1
{-# INLINE condSignal #-}
condWait :: MonadIO m => Ptr Cond -> Ptr Mutex -> m CInt
condWait :: Ptr (Ptr ()) -> Ptr (Ptr ()) -> m CInt
condWait Ptr (Ptr ())
v1 Ptr (Ptr ())
v2 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> Ptr (Ptr ()) -> IO CInt
condWaitFFI Ptr (Ptr ())
v1 Ptr (Ptr ())
v2
{-# INLINE condWait #-}
condWaitTimeout :: MonadIO m => Ptr Cond -> Ptr Mutex -> Word32 -> m CInt
condWaitTimeout :: Ptr (Ptr ()) -> Ptr (Ptr ()) -> ThreadPriority -> m CInt
condWaitTimeout Ptr (Ptr ())
v1 Ptr (Ptr ())
v2 ThreadPriority
v3 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> Ptr (Ptr ()) -> ThreadPriority -> IO CInt
condWaitTimeoutFFI Ptr (Ptr ())
v1 Ptr (Ptr ())
v2 ThreadPriority
v3
{-# INLINE condWaitTimeout #-}
createCond :: MonadIO m => m (Ptr Cond)
createCond :: m (Ptr (Ptr ()))
createCond = IO (Ptr (Ptr ())) -> m (Ptr (Ptr ()))
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO IO (Ptr (Ptr ()))
createCondFFI
{-# INLINE createCond #-}
createMutex :: MonadIO m => m (Ptr Mutex)
createMutex :: m (Ptr (Ptr ()))
createMutex = IO (Ptr (Ptr ())) -> m (Ptr (Ptr ()))
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO IO (Ptr (Ptr ()))
createMutexFFI
{-# INLINE createMutex #-}
createSemaphore :: MonadIO m => Word32 -> m (Ptr Sem)
createSemaphore :: ThreadPriority -> m (Ptr (Ptr ()))
createSemaphore ThreadPriority
v1 = IO (Ptr (Ptr ())) -> m (Ptr (Ptr ()))
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr (Ptr ())) -> m (Ptr (Ptr ())))
-> IO (Ptr (Ptr ())) -> m (Ptr (Ptr ()))
forall a b. (a -> b) -> a -> b
$ ThreadPriority -> IO (Ptr (Ptr ()))
createSemaphoreFFI ThreadPriority
v1
{-# INLINE createSemaphore #-}
destroyCond :: MonadIO m => Ptr Cond -> m ()
destroyCond :: Ptr (Ptr ()) -> m ()
destroyCond Ptr (Ptr ())
v1 = IO () -> m ()
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO ()
destroyCondFFI Ptr (Ptr ())
v1
{-# INLINE destroyCond #-}
destroyMutex :: MonadIO m => Ptr Mutex -> m ()
destroyMutex :: Ptr (Ptr ()) -> m ()
destroyMutex Ptr (Ptr ())
v1 = IO () -> m ()
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO ()
destroyMutexFFI Ptr (Ptr ())
v1
{-# INLINE destroyMutex #-}
destroySemaphore :: MonadIO m => Ptr Sem -> m ()
destroySemaphore :: Ptr (Ptr ()) -> m ()
destroySemaphore Ptr (Ptr ())
v1 = IO () -> m ()
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO ()
destroySemaphoreFFI Ptr (Ptr ())
v1
{-# INLINE destroySemaphore #-}
lockMutex :: MonadIO m => Ptr Mutex -> m CInt
lockMutex :: Ptr (Ptr ()) -> m CInt
lockMutex Ptr (Ptr ())
v1 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO CInt
lockMutexFFI Ptr (Ptr ())
v1
{-# INLINE lockMutex #-}
semPost :: MonadIO m => Ptr Sem -> m CInt
semPost :: Ptr (Ptr ()) -> m CInt
semPost Ptr (Ptr ())
v1 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO CInt
semPostFFI Ptr (Ptr ())
v1
{-# INLINE semPost #-}
semTryWait :: MonadIO m => Ptr Sem -> m CInt
semTryWait :: Ptr (Ptr ()) -> m CInt
semTryWait Ptr (Ptr ())
v1 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO CInt
semTryWaitFFI Ptr (Ptr ())
v1
{-# INLINE semTryWait #-}
semValue :: MonadIO m => Ptr Sem -> m Word32
semValue :: Ptr (Ptr ()) -> m ThreadPriority
semValue Ptr (Ptr ())
v1 = IO ThreadPriority -> m ThreadPriority
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO ThreadPriority -> m ThreadPriority)
-> IO ThreadPriority -> m ThreadPriority
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO ThreadPriority
semValueFFI Ptr (Ptr ())
v1
{-# INLINE semValue #-}
semWait :: MonadIO m => Ptr Sem -> m CInt
semWait :: Ptr (Ptr ()) -> m CInt
semWait Ptr (Ptr ())
v1 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO CInt
semWaitFFI Ptr (Ptr ())
v1
{-# INLINE semWait #-}
semWaitTimeout :: MonadIO m => Ptr Sem -> Word32 -> m CInt
semWaitTimeout :: Ptr (Ptr ()) -> ThreadPriority -> m CInt
semWaitTimeout Ptr (Ptr ())
v1 ThreadPriority
v2 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> ThreadPriority -> IO CInt
semWaitTimeoutFFI Ptr (Ptr ())
v1 ThreadPriority
v2
{-# INLINE semWaitTimeout #-}
tryLockMutex :: MonadIO m => Ptr Mutex -> m CInt
tryLockMutex :: Ptr (Ptr ()) -> m CInt
tryLockMutex Ptr (Ptr ())
v1 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO CInt
tryLockMutexFFI Ptr (Ptr ())
v1
{-# INLINE tryLockMutex #-}
unlockMutex :: MonadIO m => Ptr Mutex -> m CInt
unlockMutex :: Ptr (Ptr ()) -> m CInt
unlockMutex Ptr (Ptr ())
v1 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO CInt
unlockMutexFFI Ptr (Ptr ())
v1
{-# INLINE unlockMutex #-}
atomicAdd :: MonadIO m => Ptr Atomic -> CInt -> m CInt
atomicAdd :: Ptr Atomic -> CInt -> m CInt
atomicAdd Ptr Atomic
v1 CInt
v2 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr Atomic -> CInt -> IO CInt
atomicAddFFI Ptr Atomic
v1 CInt
v2
{-# INLINE atomicAdd #-}
atomicCAS :: MonadIO m => Ptr Atomic -> CInt -> CInt -> m Bool
atomicCAS :: Ptr Atomic -> CInt -> CInt -> m Bool
atomicCAS Ptr Atomic
v1 CInt
v2 CInt
v3 = IO Bool -> m Bool
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ Ptr Atomic -> CInt -> CInt -> IO Bool
atomicCASFFI Ptr Atomic
v1 CInt
v2 CInt
v3
{-# INLINE atomicCAS #-}
atomicCASPtr :: MonadIO m => Ptr (Ptr ()) -> Ptr () -> Ptr () -> m Bool
atomicCASPtr :: Ptr (Ptr ()) -> Ptr () -> Ptr () -> m Bool
atomicCASPtr Ptr (Ptr ())
v1 Ptr ()
v2 Ptr ()
v3 = IO Bool -> m Bool
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> Ptr () -> Ptr () -> IO Bool
atomicCASPtrFFI Ptr (Ptr ())
v1 Ptr ()
v2 Ptr ()
v3
{-# INLINE atomicCASPtr #-}
atomicDecRef :: Ptr Atomic -> IO Bool
atomicDecRef :: Ptr Atomic -> IO Bool
atomicDecRef Ptr Atomic
a = do
CInt
old <- Ptr Atomic -> CInt -> IO CInt
forall (m :: Type -> Type).
MonadIO m =>
Ptr Atomic -> CInt -> m CInt
atomicAdd Ptr Atomic
a (-CInt
1)
Bool -> IO Bool
forall (m :: Type -> Type) a. Monad m => a -> m a
return (Bool -> IO Bool) -> Bool -> IO Bool
forall a b. (a -> b) -> a -> b
$ CInt
old CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
== CInt
1
{-# INLINE atomicDecRef #-}
atomicGet :: MonadIO m => Ptr Atomic -> m CInt
atomicGet :: Ptr Atomic -> m CInt
atomicGet Ptr Atomic
v1 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr Atomic -> IO CInt
atomicGetFFI Ptr Atomic
v1
{-# INLINE atomicGet #-}
atomicGetPtr :: MonadIO m => Ptr (Ptr ()) -> m (Ptr ())
atomicGetPtr :: Ptr (Ptr ()) -> m (Ptr ())
atomicGetPtr Ptr (Ptr ())
v1 = IO (Ptr ()) -> m (Ptr ())
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> IO (Ptr ())
atomicGetPtrFFI Ptr (Ptr ())
v1
{-# INLINE atomicGetPtr #-}
atomicIncRef :: Ptr Atomic -> IO CInt
atomicIncRef :: Ptr Atomic -> IO CInt
atomicIncRef Ptr Atomic
a = Ptr Atomic -> CInt -> IO CInt
forall (m :: Type -> Type).
MonadIO m =>
Ptr Atomic -> CInt -> m CInt
atomicAdd Ptr Atomic
a CInt
1
{-# INLINE atomicIncRef #-}
atomicLock :: MonadIO m => Ptr SpinLock -> m ()
atomicLock :: Ptr CInt -> m ()
atomicLock Ptr CInt
v1 = IO () -> m ()
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> IO ()
atomicLockFFI Ptr CInt
v1
{-# INLINE atomicLock #-}
atomicSet :: MonadIO m => Ptr Atomic -> CInt -> m CInt
atomicSet :: Ptr Atomic -> CInt -> m CInt
atomicSet Ptr Atomic
v1 CInt
v2 = IO CInt -> m CInt
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Ptr Atomic -> CInt -> IO CInt
atomicSetFFI Ptr Atomic
v1 CInt
v2
{-# INLINE atomicSet #-}
atomicSetPtr :: MonadIO m => Ptr (Ptr ()) -> Ptr () -> m (Ptr ())
atomicSetPtr :: Ptr (Ptr ()) -> Ptr () -> m (Ptr ())
atomicSetPtr Ptr (Ptr ())
v1 Ptr ()
v2 = IO (Ptr ()) -> m (Ptr ())
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> Ptr () -> IO (Ptr ())
atomicSetPtrFFI Ptr (Ptr ())
v1 Ptr ()
v2
{-# INLINE atomicSetPtr #-}
atomicTryLock :: MonadIO m => Ptr SpinLock -> m Bool
atomicTryLock :: Ptr CInt -> m Bool
atomicTryLock Ptr CInt
v1 = IO Bool -> m Bool
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> IO Bool
atomicTryLockFFI Ptr CInt
v1
{-# INLINE atomicTryLock #-}
atomicUnlock :: MonadIO m => Ptr SpinLock -> m ()
atomicUnlock :: Ptr CInt -> m ()
atomicUnlock Ptr CInt
v1 = IO () -> m ()
forall (m :: Type -> Type) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> IO ()
atomicUnlockFFI Ptr CInt
v1
{-# INLINE atomicUnlock #-}