Buffer

A Buffer is a used to buffer the data flowing the connections of a model. Data can be read from and written into a buffer. The mode of the buffer determines the way to read from and write into the buffers.

Buffer Modes

BufferMode determines the way the data is read from and written into a Buffer. Basically, there are four buffer modes: Normal, Cyclic, Fifo and Lifo. Normal, Fifo and Lifo are subtypes of LinearMode and Cyclic is a subtype of CyclicMode.

Buffer Constructors

The Buffer construction is very similar to the construction of arrays in Julia. Just specify the mode, element type and length of the buffer. Here are some examples:

julia> using Causal # hide

julia> Buffer{Fifo}(2, 5)
2×5 Buffer{Fifo,Float64,2}

julia> Buffer{Cyclic}(2, 10)
2×10 Buffer{Cyclic,Float64,2}

julia> Buffer{Lifo}(Bool, 2, 5)
2×5 Buffer{Lifo,Bool,2}

julia> Buffer(5)
5-element Buffer{Cyclic,Float64,1}

Writing Data into Buffers

Writing data into a Buffer is done with write! function. Recall that when the buffer is full, no more data can be written into the buffer if the buffer mode is of type LinearMode.


julia> normalbuf = Buffer{Normal}(3)
3-element Buffer{Normal,Float64,1}

julia> foreach(item -> write!(normalbuf, item), 1:3)

julia> normalbuf
3-element Buffer{Normal,Float64,1}:
 3.0
 2.0
 1.0

julia> write!(normalbuf, 4.)
ERROR: Buffer is full

This situation is the same for Lifo and Fifo buffers, but not the case for Cyclic buffer.


julia> cyclicbuf = Buffer{Cyclic}(3)
3-element Buffer{Cyclic,Float64,1}

julia> foreach(item -> write!(cyclicbuf, item), 1:3)

julia> cyclicbuf
3-element Buffer{Cyclic,Float64,1}:
 3.0
 2.0
 1.0

julia> write!(cyclicbuf, 3.)
3.0

julia> write!(cyclicbuf, 4.)
4.0

Reading Data from Buffers

Reading data from a Buffer is done with read function.

julia> using Causal # hide

julia> nbuf, cbuf, fbuf, lbuf = Buffer{Normal}(5), Buffer{Cyclic}(5), Buffer{Lifo}(5), Buffer{Fifo}(5)
(Buffer(mode:Normal, eltype:Float64, size:(5,), index:1, state:empty), Buffer(mode:Cyclic, eltype:Float64, size:(5,), index:1, state:empty), Buffer(mode:Lifo, eltype:Float64, size:(5,), index:1, state:empty), Buffer(mode:Fifo, eltype:Float64, size:(5,), index:1, state:empty))

julia> foreach(buf -> foreach(item -> write!(buf, item), 1 : 5), [nbuf, cbuf, fbuf, lbuf])

julia> for buf in [nbuf, cbuf, fbuf, lbuf]
           @show buf
           for i in 1 : 5
               @show read(buf)
           end
       end
buf = Buffer(mode:Normal, eltype:Float64, size:(5,), index:6, state:full)
read(buf) = 5.0
read(buf) = 5.0
read(buf) = 5.0
read(buf) = 5.0
read(buf) = 5.0
buf = Buffer(mode:Cyclic, eltype:Float64, size:(5,), index:1, state:full)
read(buf) = 5.0
read(buf) = 5.0
read(buf) = 5.0
read(buf) = 5.0
read(buf) = 5.0
buf = Buffer(mode:Lifo, eltype:Float64, size:(5,), index:6, state:full)
read(buf) = 5.0
read(buf) = 4.0
read(buf) = 3.0
read(buf) = 2.0
read(buf) = 1.0
buf = Buffer(mode:Fifo, eltype:Float64, size:(5,), index:6, state:full)
read(buf) = 1.0
read(buf) = 2.0
read(buf) = 3.0
read(buf) = 4.0
read(buf) = 5.0

AbstractArray Interface of Buffers

A Buffer can be indexed using the similar syntax of arrays in Julia. That is, getindex and setindex! methods can be used with known Julia syntax. i.e. getindex(buf, idx) is equal to buf[idx] and setindex(buf, val, idx) is equal to buf[idx] = val.


julia> buf = Buffer(5)
5-element Buffer{Cyclic,Float64,1}

julia> size(buf)
(5,)

julia> length(buf)
5

julia> for val in 1 : 5
           write!(buf, 2val)
       end

julia> buf[1]
10.0

julia> buf[3:4]
2-element Array{Float64,1}:
 6.0
 4.0

julia> buf[[3, 5]]
2-element Array{Float64,1}:
 6.0
 2.0

julia> buf[end]
2.0

julia> buf[1] = 5
5

julia> buf[3:5] = [7, 8, 9]
3-element Array{Int64,1}:
 7
 8
 9

Full API

Causal.Buffer — Type

mutable struct Buffer{M<:BufferMode, T, N} <: AbstractArray{T,N}

Constructs a Buffer of size sz with element type of T. M is the mode of the Buffer that determines how data is to read from and written into the Buffer. There exists for different buffer modes:

Normal: See Normal
Cyclic: See Cyclic
Lifo: See Lifo
Fifo: See Fifo

The default mode for Buffer is Cyclic and default element type is Float64.

Buffer{M}(sz::Int...) where {M, T}

Constructs a Buffer of size sz and with element type of T and mode M.

Buffer(dtype::Type{T}, sz::Int...) where T

Constructs a Buffer of size sz and element type T. The mode of buffer is Cyclic.

Buffer(sz::Int...)

Constructs a Buffer of size sz with mode Cyclic and element type of Float64.

Buffer{M}(data::AbstractVecOrMat{T}) where {M, T<:Real}

Constructs a Buffer with data.

Fields

internals::Array{Array{T,N},1} where N where T
Internal data containers
src::Int64
Input containter
dst::Int64
Output container
index::Int64
Buffer index
state::Symbol
Current state of buffer. May be :full, :empty, :nonempty
id::Base.UUID
Unique identifier

Example

julia> buf = Buffer(5)
5-element Buffer{Cyclic,Float64,1}

julia> buf = Buffer{Fifo}(2, 5)
2×5 Buffer{Fifo,Float64,2}

julia> buf = Buffer{Lifo}(collect(reshape(1:8, 2, 4)))
2×4 Buffer{Lifo,Int64,2}