|
| 1 | +""" |
| 2 | +A buffer that drops all elements put into it. Only to be used as the output |
| 3 | +buffer for a task - will throw if attached as an input. |
| 4 | +""" |
| 5 | +struct DropBuffer{T} end |
| 6 | +DropBuffer{T}(_) where T = DropBuffer{T}() |
| 7 | +Base.isempty(::DropBuffer) = true |
| 8 | +isfull(::DropBuffer) = false |
| 9 | +Base.put!(::DropBuffer, _) = nothing |
| 10 | +Base.take!(::DropBuffer) = error("Cannot `take!` from a DropBuffer") |
| 11 | + |
| 12 | +"A process-local buffer backed by a `Channel{T}`." |
| 13 | +struct ChannelBuffer{T} |
| 14 | + channel::Channel{T} |
| 15 | + len::Int |
| 16 | + count::Threads.Atomic{Int} |
| 17 | + ChannelBuffer{T}(len::Int=1024) where T = |
| 18 | + new{T}(Channel{T}(len), len, Threads.Atomic{Int}(0)) |
| 19 | +end |
| 20 | +Base.isempty(cb::ChannelBuffer) = isempty(cb.channel) |
| 21 | +isfull(cb::ChannelBuffer) = cb.count[] == cb.len |
| 22 | +function Base.put!(cb::ChannelBuffer{T}, x) where T |
| 23 | + put!(cb.channel, convert(T, x)) |
| 24 | + Threads.atomic_add!(cb.count, 1) |
| 25 | +end |
| 26 | +function Base.take!(cb::ChannelBuffer) |
| 27 | + take!(cb.channel) |
| 28 | + Threads.atomic_sub!(cb.count, 1) |
| 29 | +end |
| 30 | + |
| 31 | +"A cross-worker buffer backed by a `RemoteChannel{T}`." |
| 32 | +struct RemoteChannelBuffer{T} |
| 33 | + channel::RemoteChannel{Channel{T}} |
| 34 | + len::Int |
| 35 | + count::Threads.Atomic{Int} |
| 36 | + RemoteChannelBuffer{T}(len::Int=1024) where T = |
| 37 | + new{T}(RemoteChannel(()->Channel{T}(len)), len, Threads.Atomic{Int}(0)) |
| 38 | +end |
| 39 | +Base.isempty(cb::RemoteChannelBuffer) = isempty(cb.channel) |
| 40 | +isfull(cb::RemoteChannelBuffer) = cb.count[] == cb.len |
| 41 | +function Base.put!(cb::RemoteChannelBuffer{T}, x) where T |
| 42 | + put!(cb.channel, convert(T, x)) |
| 43 | + Threads.atomic_add!(cb.count, 1) |
| 44 | +end |
| 45 | +function Base.take!(cb::RemoteChannelBuffer) |
| 46 | + take!(cb.channel) |
| 47 | + Threads.atomic_sub!(cb.count, 1) |
| 48 | +end |
| 49 | + |
| 50 | +"A process-local ring buffer." |
| 51 | +mutable struct ProcessRingBuffer{T} |
| 52 | + read_idx::Int |
| 53 | + write_idx::Int |
| 54 | + @atomic count::Int |
| 55 | + buffer::Vector{T} |
| 56 | + function ProcessRingBuffer{T}(len::Int=1024) where T |
| 57 | + buffer = Vector{T}(undef, len) |
| 58 | + return new{T}(1, 1, 0, buffer) |
| 59 | + end |
| 60 | +end |
| 61 | +Base.isempty(rb::ProcessRingBuffer) = (@atomic rb.count) == 0 |
| 62 | +isfull(rb::ProcessRingBuffer) = (@atomic rb.count) == length(rb.buffer) |
| 63 | +function Base.put!(rb::ProcessRingBuffer{T}, x) where T |
| 64 | + len = length(rb.buffer) |
| 65 | + while (@atomic rb.count) == len |
| 66 | + yield() |
| 67 | + end |
| 68 | + to_write_idx = mod1(rb.write_idx, len) |
| 69 | + rb.buffer[to_write_idx] = convert(T, x) |
| 70 | + rb.write_idx += 1 |
| 71 | + @atomic rb.count += 1 |
| 72 | +end |
| 73 | +function Base.take!(rb::ProcessRingBuffer) |
| 74 | + while (@atomic rb.count) == 0 |
| 75 | + yield() |
| 76 | + end |
| 77 | + to_read_idx = rb.read_idx |
| 78 | + rb.read_idx += 1 |
| 79 | + @atomic rb.count -= 1 |
| 80 | + to_read_idx = mod1(to_read_idx, length(rb.buffer)) |
| 81 | + return rb.buffer[to_read_idx] |
| 82 | +end |
| 83 | + |
| 84 | +#= TODO |
| 85 | +"A server-local ring buffer backed by shared-memory." |
| 86 | +mutable struct ServerRingBuffer{T} |
| 87 | + read_idx::Int |
| 88 | + write_idx::Int |
| 89 | + @atomic count::Int |
| 90 | + buffer::Vector{T} |
| 91 | + function ServerRingBuffer{T}(len::Int=1024) where T |
| 92 | + buffer = Vector{T}(undef, len) |
| 93 | + return new{T}(1, 1, 0, buffer) |
| 94 | + end |
| 95 | +end |
| 96 | +Base.isempty(rb::ServerRingBuffer) = (@atomic rb.count) == 0 |
| 97 | +function Base.put!(rb::ServerRingBuffer{T}, x) where T |
| 98 | + len = length(rb.buffer) |
| 99 | + while (@atomic rb.count) == len |
| 100 | + yield() |
| 101 | + end |
| 102 | + to_write_idx = mod1(rb.write_idx, len) |
| 103 | + rb.buffer[to_write_idx] = convert(T, x) |
| 104 | + rb.write_idx += 1 |
| 105 | + @atomic rb.count += 1 |
| 106 | +end |
| 107 | +function Base.take!(rb::ServerRingBuffer) |
| 108 | + while (@atomic rb.count) == 0 |
| 109 | + yield() |
| 110 | + end |
| 111 | + to_read_idx = rb.read_idx |
| 112 | + rb.read_idx += 1 |
| 113 | + @atomic rb.count -= 1 |
| 114 | + to_read_idx = mod1(to_read_idx, length(rb.buffer)) |
| 115 | + return rb.buffer[to_read_idx] |
| 116 | +end |
| 117 | +=# |
| 118 | + |
| 119 | +#= |
| 120 | +"A TCP-based ring buffer." |
| 121 | +mutable struct TCPRingBuffer{T} |
| 122 | + read_idx::Int |
| 123 | + write_idx::Int |
| 124 | + @atomic count::Int |
| 125 | + buffer::Vector{T} |
| 126 | + function TCPRingBuffer{T}(len::Int=1024) where T |
| 127 | + buffer = Vector{T}(undef, len) |
| 128 | + return new{T}(1, 1, 0, buffer) |
| 129 | + end |
| 130 | +end |
| 131 | +Base.isempty(rb::TCPRingBuffer) = (@atomic rb.count) == 0 |
| 132 | +function Base.put!(rb::TCPRingBuffer{T}, x) where T |
| 133 | + len = length(rb.buffer) |
| 134 | + while (@atomic rb.count) == len |
| 135 | + yield() |
| 136 | + end |
| 137 | + to_write_idx = mod1(rb.write_idx, len) |
| 138 | + rb.buffer[to_write_idx] = convert(T, x) |
| 139 | + rb.write_idx += 1 |
| 140 | + @atomic rb.count += 1 |
| 141 | +end |
| 142 | +function Base.take!(rb::TCPRingBuffer) |
| 143 | + while (@atomic rb.count) == 0 |
| 144 | + yield() |
| 145 | + end |
| 146 | + to_read_idx = rb.read_idx |
| 147 | + rb.read_idx += 1 |
| 148 | + @atomic rb.count -= 1 |
| 149 | + to_read_idx = mod1(to_read_idx, length(rb.buffer)) |
| 150 | + return rb.buffer[to_read_idx] |
| 151 | +end |
| 152 | +=# |
| 153 | + |
| 154 | +#= |
| 155 | +""" |
| 156 | +A flexible puller which switches to the most efficient buffer type based |
| 157 | +on the sender and receiver locations. |
| 158 | +""" |
| 159 | +mutable struct UniBuffer{T} |
| 160 | + buffer::Union{ProcessRingBuffer{T}, Nothing} |
| 161 | +end |
| 162 | +function initialize_stream_buffer!(::Type{UniBuffer{T}}, T, send_proc, recv_proc, buffer_amount) where T |
| 163 | + if buffer_amount == 0 |
| 164 | + error("Return NullBuffer") |
| 165 | + end |
| 166 | + send_osproc = get_parent(send_proc) |
| 167 | + recv_osproc = get_parent(recv_proc) |
| 168 | + if send_osproc.pid == recv_osproc.pid |
| 169 | + inner = RingBuffer{T}(buffer_amount) |
| 170 | + elseif system_uuid(send_osproc.pid) == system_uuid(recv_osproc.pid) |
| 171 | + inner = ProcessBuffer{T}(buffer_amount) |
| 172 | + else |
| 173 | + inner = RemoteBuffer{T}(buffer_amount) |
| 174 | + end |
| 175 | + return UniBuffer{T}(buffer_amount) |
| 176 | +end |
| 177 | +
|
| 178 | +struct LocalPuller{T,B} |
| 179 | + buffer::B{T} |
| 180 | + id::UInt |
| 181 | + function LocalPuller{T,B}(id::UInt, buffer_amount::Integer) where {T,B} |
| 182 | + buffer = initialize_stream_buffer!(B, T, buffer_amount) |
| 183 | + return new{T,B}(buffer, id) |
| 184 | + end |
| 185 | +end |
| 186 | +function Base.take!(pull::LocalPuller{T,B}) where {T,B} |
| 187 | + if pull.buffer === nothing |
| 188 | + pull.buffer = |
| 189 | + error("Return NullBuffer") |
| 190 | + end |
| 191 | + value = take!(pull.buffer) |
| 192 | +end |
| 193 | +function initialize_input_stream!(stream::Stream{T,B}, id::UInt, send_proc::Processor, recv_proc::Processor, buffer_amount::Integer) where {T,B} |
| 194 | + local_buffer = remotecall_fetch(stream.ref.handle.owner, stream.ref.handle, id) do ref, id |
| 195 | + local_buffer, remote_buffer = initialize_stream_buffer!(B, T, send_proc, recv_proc, buffer_amount) |
| 196 | + ref.buffers[id] = remote_buffer |
| 197 | + return local_buffer |
| 198 | + end |
| 199 | + stream.buffer = local_buffer |
| 200 | + return stream |
| 201 | +end |
| 202 | +=# |
0 commit comments