https://github.com/juliaparallel/messageutils.jl
channels(), tspaces(), kvspaces() and more
https://github.com/juliaparallel/messageutils.jl
Last synced: 9 months ago
JSON representation
channels(), tspaces(), kvspaces() and more
- Host: GitHub
- URL: https://github.com/juliaparallel/messageutils.jl
- Owner: JuliaParallel
- License: other
- Created: 2014-02-14T09:30:06.000Z (over 12 years ago)
- Default Branch: master
- Last Pushed: 2023-03-14T12:48:16.000Z (about 3 years ago)
- Last Synced: 2025-05-06T18:50:19.007Z (about 1 year ago)
- Language: Julia
- Size: 16.6 KB
- Stars: 7
- Watchers: 7
- Forks: 5
- Open Issues: 4
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
README
MessageUtils
============
A collection of utilities for messaging
Channels
--------
Channels are like RemoteRefs, execpt that they are modelled as a queue and hence can hold
more than one message.
`channel(pid=myid(); T=Any, sz=1000)` constructs a channel on process `pid`, holds objects of
type `T` with a maximum number of entries `sz`.
The `channel` constructor returns an object reference of type `SyncObjRef{RemoteChannel}`
which can be passed around safely across processes.
`isready(c)`, `fetch(c)`, `take!(c)` and `put!(c, v)` have the same behaviour as the `RemoteRef`
equivalents.
`fetch` and `take!` block if there are no elements.
`put!` blocks if the channel already has `sz` elements present.
`fetch`, `take!` and `put!` all accept an optional `keyword` argument `timeout` which specifies
the maximum number of seconds to block. If the request cannot be fulfilled within the requested
time a `MUtilTimeOutEx` exception is thrown.
TSpaces
-------
TSpaces are tuple spaces. They store tuples, the first element of each tuple is a key
to the tuple.
The tuples are stored as a queue and duplicates are allowed.
`tspace(pid=myid(); sz=1000)` constructs a new tuple space and returns
a `SyncObjRef{RemoteTSpace}`
`put!(ts, v::Tuple)` adds a tuple `v` into the space `ts`.
`isready(ts,k)`, `fetch(ts, k)` and `take!(ts, k)` all require the key `k` to be specified when
used on a tuple space `ts`. It is matched against the first element of the tuples in the space.
If `k` is a `Regex` object, it is matched against all tuples where the firest element is a
`String`
`fetch`, `take!` and `put!` all accept an optional `keyword` argument `timeout` which specifies
the maximum number of seconds to block. If the request cannot be fulfilled within the requested
time a `MUtilTimeOutEx` exception is thrown.
KVSpaces
--------
This is a key-value store.
`kvspace(pid=myid(); sz=1000)` constructs a new key-value space and returns
a `SyncObjRef{RemoteKVSpace}`. Duplicates are not allowed. A `put!` with an existing key
overwrites the existing value
`put!(kvs, k, v)` adds key `k` and value `v` into the space `kvs`.
`isready(kvs,k)`, `fetch(kvs, k)` and `take!(kvs, k)` all require the key `k` to be specified when
used on a kv space `kvs`.
`fetch`, `take!` and `put!` all accept an optional `keyword` argument `timeout` which specifies
the maximum number of seconds to block. If the request cannot be fulfilled within the requested
time a `MUtilTimeOutEx` exception is thrown.
ctasks - Tasks with Channels
----------------------------
ctasks are named tasks with channels. The channels are used for messaging with the task.
`ctask(f::Function; pid=myid(), name="")` returns a `CTask` object that can be passed around
processors.
`f` is the function lanuched on processor `pid`. The ctask runs till function `f` terminates.
If `name` is specified, the task is addressable by name. The name-ctask mapping is stored in
a KV Space on pid 1.
Every ctask has two channels associated with it. One for incoming messages and one for outbound
messages.
The following functions can be used to send/recv messages from these channels.
`put!(msg::Tuple)` appends a message to a tasks outbound channel
`put!(ct::CTask, msg::Tuple)` appends a message to task `ct`'s inbound channel
`put!(ctname::String, msg::Tuple)` appends a message to task addressed by `ctname`'s inbound channel
`take!()` pops a message from the current tasks inbound channel
`take!(ct::CTask)` pops a message from task `ct`'s outbound channel
`take!(ctname::String)` pops a message from the task addressed by `ctname`'s outbound channel
The pipelining operator `|>` can be used to send a message to a task. For example:
`(:test_msg, "Hello") |> ct` will add the tuple `(:test_msg, "Hello")` to `ct`'s inbound channel
`put!`, `take!` both accept an optional `keyword` argument `timeout` which specifies
the maximum number of seconds to block. If the request cannot be fulfilled within the requested
time a `MUtilTimeOutEx` exception is thrown.
Note: The Julia 0.3 compatible version has `send`/`recv` in place of `put!`/`take`.
This has been renamed in 0.4 for consistency.