Feldspar.Run.Concurrent

Documentation

data ThreadId :: *

Instances

Show ThreadId

Methods

showsPrec :: Int -> ThreadId -> ShowS

show :: ThreadId -> String

showList :: [ThreadId] -> ShowS

data Chan k k1 t a :: forall k k1. k1 -> k -> *

A bounded channel.

data Closeable :: *

data Uncloseable :: *

class Transferable a where

Minimal complete definition

calcChanSize, untypedReadChan, untypedWriteChan

Associated Types

type SizeSpec a :: *

Size specification of a channel. In most of the cases, it is a natural number representing how many elements could be stored at the same time in the channel.

Methods

calcChanSize :: proxy a -> SizeSpec a -> ChanSize Data PrimType' Length

Maps a size specification to an internal channel size representation, that is a map from primitive types to quantities. The byte size of the channel will be calculated as the sum of multiplying the byte size of each type with its quantity.

newChan :: SizeSpec a -> Run (Chan Uncloseable a)

Create a new channel. Writing a reference type to a channel will copy contents into the channel, so modifying it post-write is completely safe.

newCloseableChan :: SizeSpec a -> Run (Chan Closeable a)

readChan :: Chan t a -> Run a

Read an element from a channel. If channel is empty, blocks until there is an item available. If closeChan has been called on the channel *and* if the channel is empty, readChan returns an undefined value immediately.

untypedReadChan :: Chan t c -> Run a

Reads a value from any kind of channel. Instances should define this, but the user should never call it.

writeChan :: Chan t a -> a -> Run (Data Bool)

Write a data element to a channel. If closeChan has been called on the channel, all calls to writeChan become non-blocking no-ops and return False, otherwise returns True. If the channel is full, this function blocks until there's space in the queue.

untypedWriteChan :: Chan t c -> a -> Run (Data Bool)

Writes a value to any kind of channel. Instances should define this, but the user should never call it.

Instances

PrimType' a => Transferable (Data a)

Associated Types

type SizeSpec (Data a) :: *

Methods

calcChanSize :: proxy (Data a) -> SizeSpec (Data a) -> ChanSize * Data PrimType' Length

newChan :: SizeSpec (Data a) -> Run (Chan * * Uncloseable (Data a))

newCloseableChan :: SizeSpec (Data a) -> Run (Chan * * Closeable (Data a))

readChan :: Chan * * t (Data a) -> Run (Data a)

untypedReadChan :: Chan * * t c -> Run (Data a)

writeChan :: Chan * * t (Data a) -> Data a -> Run (Data Bool)

untypedWriteChan :: Chan * * t c -> Data a -> Run (Data Bool)

(Syntax a, BulkTransferable a, (~) * (ContainerType a) (Arr a)) => Transferable (Pull a)

Associated Types

type SizeSpec (Pull a) :: *

Methods

calcChanSize :: proxy (Pull a) -> SizeSpec (Pull a) -> ChanSize * Data PrimType' Length

newChan :: SizeSpec (Pull a) -> Run (Chan * * Uncloseable (Pull a))

newCloseableChan :: SizeSpec (Pull a) -> Run (Chan * * Closeable (Pull a))

readChan :: Chan * * t (Pull a) -> Run (Pull a)

untypedReadChan :: Chan * * t c -> Run (Pull a)

writeChan :: Chan * * t (Pull a) -> Pull a -> Run (Data Bool)

untypedWriteChan :: Chan * * t c -> Pull a -> Run (Data Bool)

(Transferable a, Transferable b, (~) * (SizeSpec a) (SizeSpec b)) => Transferable (a, b)

Associated Types

type SizeSpec (a, b) :: *

Methods

calcChanSize :: proxy (a, b) -> SizeSpec (a, b) -> ChanSize * Data PrimType' Length

newChan :: SizeSpec (a, b) -> Run (Chan * * Uncloseable (a, b))

newCloseableChan :: SizeSpec (a, b) -> Run (Chan * * Closeable (a, b))

readChan :: Chan * * t (a, b) -> Run (a, b)

untypedReadChan :: Chan * * t c -> Run (a, b)

writeChan :: Chan * * t (a, b) -> (a, b) -> Run (Data Bool)

untypedWriteChan :: Chan * * t c -> (a, b) -> Run (Data Bool)

(Transferable a, Transferable b, Transferable c, (~) * (SizeSpec a) (SizeSpec b), (~) * (SizeSpec b) (SizeSpec c)) => Transferable (a, b, c)

Associated Types

type SizeSpec (a, b, c) :: *

Methods

calcChanSize :: proxy (a, b, c) -> SizeSpec (a, b, c) -> ChanSize * Data PrimType' Length

newChan :: SizeSpec (a, b, c) -> Run (Chan * * Uncloseable (a, b, c))

newCloseableChan :: SizeSpec (a, b, c) -> Run (Chan * * Closeable (a, b, c))

readChan :: Chan * * t (a, b, c) -> Run (a, b, c)

untypedReadChan :: Chan * * t c -> Run (a, b, c)

writeChan :: Chan * * t (a, b, c) -> (a, b, c) -> Run (Data Bool)

untypedWriteChan :: Chan * * t c -> (a, b, c) -> Run (Data Bool)

(Transferable a, Transferable b, Transferable c, Transferable d, (~) * (SizeSpec a) (SizeSpec b), (~) * (SizeSpec b) (SizeSpec c), (~) * (SizeSpec c) (SizeSpec d)) => Transferable (a, b, c, d)

Associated Types

type SizeSpec (a, b, c, d) :: *

Methods

calcChanSize :: proxy (a, b, c, d) -> SizeSpec (a, b, c, d) -> ChanSize * Data PrimType' Length

newChan :: SizeSpec (a, b, c, d) -> Run (Chan * * Uncloseable (a, b, c, d))

newCloseableChan :: SizeSpec (a, b, c, d) -> Run (Chan * * Closeable (a, b, c, d))

readChan :: Chan * * t (a, b, c, d) -> Run (a, b, c, d)

untypedReadChan :: Chan * * t c -> Run (a, b, c, d)

writeChan :: Chan * * t (a, b, c, d) -> (a, b, c, d) -> Run (Data Bool)

untypedWriteChan :: Chan * * t c -> (a, b, c, d) -> Run (Data Bool)

class Transferable a => BulkTransferable a where

Minimal complete definition

untypedReadChanBuf, untypedWriteChanBuf

Associated Types

type ContainerType a :: *

Methods

readChanBuf :: Chan t a -> Data Index -> Data Index -> ContainerType a -> Run (Data Bool)

Read an arbitrary number of elements from a channel into an array. The semantics are the same as for readChan, where "channel is empty" is defined as "channel contains less data than requested". Returns False without reading any data if the channel is closed.

untypedReadChanBuf :: proxy a -> Chan t c -> Data Index -> Data Index -> ContainerType a -> Run (Data Bool)

Read an arbitrary number of elements from any channel into an array. Instances should define this, but the user should never call it.

writeChanBuf :: Chan t a -> Data Index -> Data Index -> ContainerType a -> Run (Data Bool)

Write an arbitrary number of elements from an array into an channel. The semantics are the same as for writeChan, where "channel is full" is defined as "channel has insufficient free space to store all written data".

untypedWriteChanBuf :: proxy a -> Chan t c -> Data Index -> Data Index -> ContainerType a -> Run (Data Bool)

Write an arbitrary number of elements from an array into any channel. Instances should define this, but the user should never call it.

Instances

PrimType' a => BulkTransferable (Data a)

Associated Types

type ContainerType (Data a) :: *

Methods

readChanBuf :: Chan * * t (Data a) -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

untypedReadChanBuf :: proxy (Data a) -> Chan * * t c -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

writeChanBuf :: Chan * * t (Data a) -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

untypedWriteChanBuf :: proxy (Data a) -> Chan * * t c -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

fork :: Run () -> Run ThreadId

Fork off a computation as a new thread.

forkWithId :: (ThreadId -> Run ()) -> Run ThreadId

Fork off a computation as a new thread, with access to its own thread ID.

asyncKillThread :: ThreadId -> Run ()

Forcibly terminate a thread, then continue execution immediately.

killThread :: ThreadId -> Run ()

Forcibly terminate a thread. Blocks until the thread is actually dead.

waitThread :: ThreadId -> Run ()

Wait for a thread to terminate.

delayThread :: Integral i => Data i -> Run ()

Sleep for a given amount of microseconds. Implemented with usleep. A C compiler might require a feature test macro to be defined, otherwise it emits a warning about an implicitly declared function. For more details, see: http://man7.org/linux/man-pages/man3/usleep.3.html

closeChan :: Chan Closeable a -> Run ()

Close a channel. All subsequent write operations will be no-ops. After the channel is drained, all subsequent read operations will be no-ops as well.

lastChanReadOK :: Chan Closeable a -> Run (Data Bool)

When readChan was last called on the given channel, did the read succeed? Always returns True unless closeChan has been called on the channel. Always returns True if the channel has never been read.