Showing the changes to src/vm/channel.cpp (1 of 40 files). Show all
Unified · Split
| @@ -0,0 +1,292 @@ | ||
| 1 | +// | |
| 2 | +// Dis VM | |
| 3 | +// File: channel.cpp | |
| 4 | +// Author: arr | |
| 5 | +// | |
| 6 | + | |
| 7 | +#include <runtime.h> | |
| 8 | +#include <vm_memory.h> | |
| 9 | +#include <debug.h> | |
| 10 | +#include <exceptions.h> | |
| 11 | + | |
| 12 | +using namespace disvm; | |
| 13 | +using namespace disvm::runtime; | |
| 14 | + | |
| 15 | +vm_request_mutex_t::vm_request_mutex_t() | |
| 16 | + : pending_request{ false } | |
| 17 | +{ } | |
| 18 | + | |
| 19 | +vm_channel_request_t::vm_channel_request_t(uint32_t thread_id, vm_request_mutex_t &request_mutex) | |
| 20 | + : data{ nullptr } | |
| 21 | + , request_mutex{ request_mutex } | |
| 22 | + , thread_id{ thread_id } | |
| 23 | +{ } | |
| 24 | + | |
| 25 | +std::shared_ptr<const type_descriptor_t> vm_channel_t::type_desc() | |
| 26 | +{ | |
| 27 | + return intrinsic_type_desc::type<vm_channel_t>(); | |
| 28 | +} | |
| 29 | + | |
| 30 | +vm_channel_t::vm_channel_t( | |
| 31 | + std::shared_ptr<const type_descriptor_t> td, | |
| 32 | + std::function<void(pointer_t, pointer_t, const type_descriptor_t *)> transfer, | |
| 33 | + word_t buffer_len) | |
| 34 | + : vm_alloc_t(vm_channel_t::type_desc()) | |
| 35 | + , _data_buffer{ nullptr } | |
| 36 | + , _data_buffer_head{ 0 } | |
| 37 | + , _data_buffer_count{ 0 } | |
| 38 | + , _data_transfer{ transfer } | |
| 39 | + , _data_type{ td } | |
| 40 | +{ | |
| 41 | + if (buffer_len < 0) | |
| 42 | + throw out_of_range_memory{}; | |
| 43 | + | |
| 44 | + if (buffer_len > 0) | |
| 45 | + _data_buffer = new vm_array_t{ td, buffer_len }; | |
| 46 | + | |
| 47 | + debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm channel\n"); | |
| 48 | +} | |
| 49 | + | |
| 50 | +vm_channel_t::~vm_channel_t() | |
| 51 | +{ | |
| 52 | + dec_ref_count_and_free(_data_buffer); | |
| 53 | + debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: vm channel\n"); | |
| 54 | +} | |
| 55 | + | |
| 56 | +std::shared_ptr<const type_descriptor_t> vm_channel_t::get_data_type() const | |
| 57 | +{ | |
| 58 | + return _data_type; | |
| 59 | +} | |
| 60 | + | |
| 61 | +bool vm_channel_t::send_data(vm_channel_request_t &send_request) | |
| 62 | +{ | |
| 63 | + assert(send_request.request_handled_callback != nullptr && send_request.data != nullptr); | |
| 64 | + | |
| 65 | + std::lock(_data_lock, send_request.request_mutex.get().pending_request_lock); | |
| 66 | + std::unique_lock<std::mutex> data_lock{ _data_lock, std::adopt_lock }; | |
| 67 | + std::lock_guard<std::mutex> curr_req_lock{ send_request.request_mutex.get().pending_request_lock, std::adopt_lock }; | |
| 68 | + | |
| 69 | + if (!send_request.request_mutex.get().pending_request) | |
| 70 | + return false; | |
| 71 | + | |
| 72 | + // Assert the sender cannot also be a receiver in the channel | |
| 73 | + assert(std::end(_data_receivers) == std::find_if( | |
| 74 | + std::begin(_data_receivers), | |
| 75 | + std::end(_data_receivers), | |
| 76 | + [&send_request](const vm_channel_request_t &req) { return req.thread_id == send_request.thread_id; })); | |
| 77 | + | |
| 78 | + auto pending_req_lock = std::unique_lock<std::mutex>{}; | |
| 79 | + for (;;) | |
| 80 | + { | |
| 81 | + if (_data_receivers.empty()) | |
| 82 | + { | |
| 83 | + // Check if there is room in the channel buffer | |
| 84 | + if (_data_buffer != nullptr) | |
| 85 | + { | |
| 86 | + if (try_send_to_buffer(send_request)) | |
| 87 | + return true; | |
| 88 | + } | |
| 89 | + | |
| 90 | + if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>()) | |
| 91 | + debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: send: queue: %d\n", send_request.thread_id); | |
| 92 | + | |
| 93 | + _data_senders.emplace_back(std::move(send_request)); | |
| 94 | + return false; | |
| 95 | + } | |
| 96 | + | |
| 97 | + auto &receiver_maybe = _data_receivers.front(); | |
| 98 | + | |
| 99 | + // Take lock and check the pending request status | |
| 100 | + pending_req_lock = std::unique_lock<std::mutex>{ receiver_maybe.request_mutex.get().pending_request_lock }; | |
| 101 | + if (receiver_maybe.request_mutex.get().pending_request) | |
| 102 | + { | |
| 103 | + // Indicate both request mutexes as non-pending | |
| 104 | + send_request.request_mutex.get().pending_request = false; | |
| 105 | + receiver_maybe.request_mutex.get().pending_request = false; | |
| 106 | + break; | |
| 107 | + } | |
| 108 | + | |
| 109 | + pending_req_lock.unlock(); | |
| 110 | + _data_receivers.pop_front(); | |
| 111 | + } | |
| 112 | + | |
| 113 | + // Remove the receiver from the list | |
| 114 | + auto receiver = std::move(_data_receivers.front()); | |
| 115 | + _data_receivers.pop_front(); | |
| 116 | + | |
| 117 | + // Transfer data | |
| 118 | + _data_transfer(receiver.data, send_request.data, _data_type.get()); | |
| 119 | + | |
| 120 | + // Release channel and pending request lock after data transfer | |
| 121 | + pending_req_lock.unlock(); | |
| 122 | + data_lock.unlock(); | |
| 123 | + | |
| 124 | + if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>()) | |
| 125 | + debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: send: %d %d\n", send_request.thread_id, receiver.thread_id); | |
| 126 | + | |
| 127 | + receiver.request_handled_callback(*this); | |
| 128 | + | |
| 129 | + return true; | |
| 130 | +} | |
| 131 | + | |
| 132 | +bool vm_channel_t::receive_data(vm_channel_request_t &receive_request) | |
| 133 | +{ | |
| 134 | + assert(receive_request.request_handled_callback != nullptr && receive_request.data != nullptr); | |
| 135 | + | |
| 136 | + std::lock(_data_lock, receive_request.request_mutex.get().pending_request_lock); | |
| 137 | + std::unique_lock<std::mutex> data_lock{ _data_lock, std::adopt_lock }; | |
| 138 | + std::lock_guard<std::mutex> curr_req_lock{ receive_request.request_mutex.get().pending_request_lock, std::adopt_lock }; | |
| 139 | + | |
| 140 | + if (!receive_request.request_mutex.get().pending_request) | |
| 141 | + return false; | |
| 142 | + | |
| 143 | + // Assert the receiver cannot also be a sender in the channel | |
| 144 | + assert(std::end(_data_senders) == std::find_if( | |
| 145 | + std::begin(_data_senders), | |
| 146 | + std::end(_data_senders), | |
| 147 | + [&receive_request](const vm_channel_request_t &req) { return req.thread_id == receive_request.thread_id; })); | |
| 148 | + | |
| 149 | + auto pending_req_lock = std::unique_lock<std::mutex>{}; | |
| 150 | + for (;;) | |
| 151 | + { | |
| 152 | + if (_data_senders.empty()) | |
| 153 | + { | |
| 154 | + // Check if there is data in the channel buffer | |
| 155 | + if (_data_buffer != nullptr) | |
| 156 | + { | |
| 157 | + if (try_receive_from_buffer(receive_request)) | |
| 158 | + return true; | |
| 159 | + } | |
| 160 | + | |
| 161 | + if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>()) | |
| 162 | + debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: receive: queue: %d\n", receive_request.thread_id); | |
| 163 | + | |
| 164 | + _data_receivers.emplace_back(std::move(receive_request)); | |
| 165 | + return false; | |
| 166 | + } | |
| 167 | + | |
| 168 | + auto &sender_maybe = _data_senders.front(); | |
| 169 | + | |
| 170 | + // Take lock and check the pending request status | |
| 171 | + pending_req_lock = std::unique_lock<std::mutex>{ sender_maybe.request_mutex.get().pending_request_lock }; | |
| 172 | + if (sender_maybe.request_mutex.get().pending_request) | |
| 173 | + { | |
| 174 | + // Indicate both request mutexes as non-pending | |
| 175 | + receive_request.request_mutex.get().pending_request = false; | |
| 176 | + sender_maybe.request_mutex.get().pending_request = false; | |
| 177 | + break; | |
| 178 | + } | |
| 179 | + | |
| 180 | + pending_req_lock.unlock(); | |
| 181 | + _data_senders.pop_front(); | |
| 182 | + } | |
| 183 | + | |
| 184 | + // Remove the sender from the list | |
| 185 | + auto sender = std::move(_data_senders.front()); | |
| 186 | + _data_senders.pop_front(); | |
| 187 | + | |
| 188 | + // Check if there is data in the channel buffer. This is being | |
| 189 | + // done to avoid starving threads that found a full buffer when | |
| 190 | + // attempting to satisfy a request. | |
| 191 | + if (_data_buffer != nullptr && try_receive_from_buffer(receive_request)) | |
| 192 | + { | |
| 193 | + // Data was taken from the buffer, so the current pending sender | |
| 194 | + // can now use the empty slot. | |
| 195 | + auto did_send = try_send_to_buffer(sender); | |
| 196 | + assert(did_send && "Should be room in buffer"); | |
| 197 | + } | |
| 198 | + else | |
| 199 | + { | |
| 200 | + // Transfer data since there wasn't anything in the buffer | |
| 201 | + _data_transfer(receive_request.data, sender.data, _data_type.get()); | |
| 202 | + | |
| 203 | + if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>()) | |
| 204 | + debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: receive: %d %d\n", receive_request.thread_id, sender.thread_id); | |
| 205 | + } | |
| 206 | + | |
| 207 | + // Release channel and pending request lock after data transfer | |
| 208 | + pending_req_lock.unlock(); | |
| 209 | + data_lock.unlock(); | |
| 210 | + | |
| 211 | + sender.request_handled_callback(*this); | |
| 212 | + | |
| 213 | + return true; | |
| 214 | +} | |
| 215 | + | |
| 216 | +void vm_channel_t::cancel_request(uint32_t thread_id) | |
| 217 | +{ | |
| 218 | + std::lock_guard<std::mutex> lock{ _data_lock }; | |
| 219 | + | |
| 220 | + // Create a predicate function based on the input | |
| 221 | + auto request_predicate = [thread_id](const vm_channel_request_t &req) { return req.thread_id == thread_id; }; | |
| 222 | + | |
| 223 | + auto receiver_iter = std::find_if(std::begin(_data_receivers), std::end(_data_receivers), request_predicate); | |
| 224 | + if (receiver_iter != std::end(_data_receivers)) | |
| 225 | + { | |
| 226 | + _data_receivers.erase(receiver_iter); | |
| 227 | + } | |
| 228 | + else | |
| 229 | + { | |
| 230 | + auto sender_iter = std::find_if(std::begin(_data_senders), std::end(_data_senders), request_predicate); | |
| 231 | + if (sender_iter == std::end(_data_senders)) | |
| 232 | + return; | |
| 233 | + | |
| 234 | + _data_senders.erase(sender_iter); | |
| 235 | + } | |
| 236 | + | |
| 237 | + if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>()) | |
| 238 | + debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: cancel: request: %d\n", thread_id); | |
| 239 | +} | |
| 240 | + | |
| 241 | +bool vm_channel_t::try_send_to_buffer(vm_channel_request_t &send_request) | |
| 242 | +{ | |
| 243 | + assert(_data_buffer != nullptr); | |
| 244 | + | |
| 245 | + const auto buffer_length = static_cast<uint32_t>(_data_buffer->get_length()); | |
| 246 | + if (_data_buffer_count == buffer_length) | |
| 247 | + return false; | |
| 248 | + | |
| 249 | + auto next_buffer_index = _data_buffer_head + _data_buffer_count; | |
| 250 | + if (next_buffer_index >= buffer_length) | |
| 251 | + next_buffer_index -= buffer_length; | |
| 252 | + | |
| 253 | + _data_buffer_count++; | |
| 254 | + | |
| 255 | + auto dest = _data_buffer->at(next_buffer_index); | |
| 256 | + | |
| 257 | + // Transfer data to buffer | |
| 258 | + _data_transfer(dest, send_request.data, _data_type.get()); | |
| 259 | + send_request.request_mutex.get().pending_request = false; | |
| 260 | + | |
| 261 | + if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>()) | |
| 262 | + debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: send: buffer: %d\n", send_request.thread_id); | |
| 263 | + | |
| 264 | + return true; | |
| 265 | +} | |
| 266 | + | |
| 267 | +bool vm_channel_t::try_receive_from_buffer(vm_channel_request_t &receive_request) | |
| 268 | +{ | |
| 269 | + assert(_data_buffer != nullptr); | |
| 270 | + | |
| 271 | + if (_data_buffer_count == 0) | |
| 272 | + return false; | |
| 273 | + | |
| 274 | + auto src = _data_buffer->at(_data_buffer_head); | |
| 275 | + _data_buffer_head++; | |
| 276 | + | |
| 277 | + const auto buffer_length = _data_buffer->get_length(); | |
| 278 | + if (_data_buffer_head == buffer_length) | |
| 279 | + _data_buffer_head = 0; | |
| 280 | + | |
| 281 | + _data_buffer_count--; | |
| 282 | + | |
| 283 | + // Transfer data from buffer | |
| 284 | + _data_transfer(receive_request.data, src, _data_type.get()); | |
| 285 | + | |
| 286 | + receive_request.request_mutex.get().pending_request = false; | |
| 287 | + | |
| 288 | + if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>()) | |
| 289 | + debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: receive: buffer: %d\n", receive_request.thread_id); | |
| 290 | + | |
| 291 | + return true; | |
| 292 | +} | |