Busses
A Bus
is actually is a bunch of links. Reading from and writing into data is performed as in the case of Links.
Construction of Bus
A Bus
is constructed by specifying its element type T
, the number of links nlinks
and the buffer length of its links.
Jusdl.Connections.Bus
— TypeBus(links::AbstractVector{L}) where L<:Link
Constructs a Bus
consisting of links
links.
Bus(dtype::Type{T}, nlinks::Int, ln::Int=64) where T
Constructs a Bus
consisting of links of length nlinks
. T
is element type of links. ln
is the buffer length of links.
Bus(nlinks::Int=1, ln::Int=64)
Constructs a Bus
consisting of links of length nlinks
. Float64
is element type of links. ln
is the buffer length of links.
Example
julia> Bus([Link() for i = 1 : 3])
Bus(nlinks:3, eltype:Link{Float64}, isreadable:false, iswritable:false)
julia> Bus(Int, 5, 10)
Bus(nlinks:5, eltype:Link{Int64}, isreadable:false, iswritable:false)
julia> Bus()
Bus(nlinks:1, eltype:Link{Float64}, isreadable:false, iswritable:false)
Connection and Disconnection of Busses
The Bus
ses can be connected to and disconnected from each other. When connected any data written to the master bus is also written all slave busses. See the following example.
Let us connect two busses and connect them together.
julia> b1 = Bus(2, 5) # Bus with `2` links with buffer length of `5`.
2-element Bus{Link{Float64}}:
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> b2 = Bus(2, 5) # Bus with `2` links with buffer length of `5`.
2-element Bus{Link{Float64}}:
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> connect(b1, b2)
Here, b1
is the master bus and b2
is the slave bus. That is, data written to b1
is also written into b2
.
julia> t1 = @async while true
val = take!(b1)
all(val .=== NaN) && break
println("Took " * string(val))
end
Task (runnable) @0x00007f70295b7340
julia> t2 = @async while true
val = take!(b2)
all(val .=== NaN) && break
println("Took " * string(val))
end
Task (runnable) @0x00007f70295b7820
julia> put!(b1, [5., 10.]);
Took [5.0, 10.0]
Took [5.0, 10.0]
julia> [b1[i].buffer.data for i = 1 : 2]
2-element Array{Array{Float64,1},1}:
[5.0, 0.0, 0.0, 0.0, 0.0]
[10.0, 0.0, 0.0, 0.0, 0.0]
julia> [b2[i].buffer.data for i = 1 : 2]
2-element Array{Array{Float64,1},1}:
[5.0, 0.0, 0.0, 0.0, 0.0]
[10.0, 0.0, 0.0, 0.0, 0.0]
Note that the data [5, 10]
written to b1
is also written b2
since they are connected.
The Bus
ses connected to each other can be disconnected. When disconnected, the data written to master is not written to slaves
julia> disconnect(b1, b2)
julia> isconnected(b1, b2)
false
Data Flow through Busses
Data flow through the Bus
ses is very similar to the case in Link
s. See Data Flow through Links for information about data flow through Link
s. Runnable tasks must be bound to the links of the busses for data flow through the Bus
. Again, put!
and take!
functions are used to write data from a Bus
and read from data from a Bus
.
Base.put!
— Methodput!(bus::Bus, vals)
Puts vals
to bus
. Each item in vals
is putted to the links
of the bus
.
The bus
must be writable to be read. That is, there must be a runnable tasks bound to links of the bus
that reads data from bus
.
Example
julia> bus = Bus();
julia> t = @async while true
val = take!(bus)
all(val .=== NaN) && break
println("Took " * string(val))
end;
julia> put!(bus, [1.])
Took [1.0]
1-element Array{Float64,1}:
1.0
julia> put!(bus, [NaN])
1-element Array{Float64,1}:
NaN
Base.take!
— Methodtake!(bus::Bus)
Takes an element from bus
. Each link of the bus
is a read and a vector containing the results is returned.
The bus
must be readable to be read. That is, there must be a runnable tasks bound to links of the bus
that writes data to bus
.
Example
julia> b = Bus()
Bus(nlinks:1, eltype:Link{Float64}, isreadable:false, iswritable:false)
julia> t = @async for val in 1 : 5
put!(b, [val])
end;
julia> take!(b)
1-element Array{Float64,1}:
1.0
julia> take!(b)
1-element Array{Float64,1}:
2.0
Any data written to a Bus
is recorded into the buffers of its links.
@repl writing_to_busses
using Jusdl # hide
b = Bus(2, 5);
t = @async while true
val = take!(b)
all(val .=== NaN) && break
println("Took " * string(val))
end
put!(b, 1.);
b[1].buffer.data
Indexing and Iteration of Busses
Busses can be indexed similarly to the arrays in Julia. When indexed, the corresponding link of the bus is returned.
julia> using Jusdl # hide
julia> b = Bus(3)
3-element Bus{Link{Float64}}:
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> b[1]
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> b[end]
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> b[:]
3-element Array{Link{Float64},1}:
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> b[1] = Link()
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> b[1:2] = [Link(), Link()]
2-element Array{Link{Float64},1}:
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
The iteration of Bus
ses in a loop is also possible. When iterated, the links of the Bus
is returned.
julia> using Jusdl # hide
julia> bus = Bus(3)
3-element Bus{Link{Float64}}:
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> for link in bus
@show link
end
link = Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
link = Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
link = Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Full API
Jusdl.Connections.hasslaves
— Methodhasslaves(bus:Bus)
Returns true
is all the links of bus
has slaves. See also hasslaves(link::Link)
Jusdl.Connections.hasmaster
— Methodhasmaster(bus::Bus)
Returns true
is all the links of bus
has master. See alsos hasmaster(link::Link)
Base.close
— Methodclose(bus::Bus)
Closes bus
. When closed, no more data flow is possible for bus
.
Jusdl.Connections.isfull
— Methodisfull(bus::Bus)
Returns true
when the links of bus
are full.
Base.isreadable
— Methodisreadable(bus::Bus)
Returns true
if all the links of bus
is readable.
Base.iswritable
— Methodiswritable(bus::Bus)
Returns true
if all the links of bus
is writable.
Jusdl.Connections.snapshot
— Methodsnapshot(bus::Bus)
Returns all the data in links of bus
.
Jusdl.Connections.launch
— Methodlaunch(bus::Bus)
Launches every link of bus
. See launch(link::Link)
Jusdl.Connections.launch
— Methodlaunch(bus::Bus, valrange::AbstractVector)
Launches every links of bus
with every item of valrange
. See [launch(link:Link, valrange)
(@ref)]
Base.size
— Methodsize(bus::Bus)
Retruns size of bus
.
Base.getindex
— Methodgetindex(bus::Bus, idx::Vararg{Int, N}) where N
Returns elements from bus
at index idx
. Same as bus[idx]
.
Example
julia> bus = Bus(3);
julia> bus[1]
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> bus[end]
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> bus[:]
3-element Array{Link{Float64},1}:
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Base.setindex!
— Methodsetindex!(bus::Bus, item, idx::Vararg{Int, N}) where N
Sets item
to bus
at index idx
. Same as bus[idx] = item
.
Example
julia> bus = Bus(3);
julia> bus[1] = Link()
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> bus[end] = Link(5)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
julia> bus[1:2] = [Link(), Link()]
2-element Array{Link{Float64},1}:
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)