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 | } | ||