History

Initial public commit for Dis VM

arr committed 10 years ago

Commit f95902eNo parent (first commit)40 files · +9358 −0Browse files

Showing the changes to src/vm/channel.cpp (1 of 40 files). Show all

Unified · Split

src/vm/channel.cpp+292−0
@@ -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
12using namespace disvm;
13using namespace disvm::runtime;
14
15vm_request_mutex_t::vm_request_mutex_t()
16 : pending_request{ false }
17{ }
18
19vm_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
25std::shared_ptr<const type_descriptor_t> vm_channel_t::type_desc()
26{
27 return intrinsic_type_desc::type<vm_channel_t>();
28}
29
30vm_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
50vm_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
56std::shared_ptr<const type_descriptor_t> vm_channel_t::get_data_type() const
57{
58 return _data_type;
59}
60
61bool 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
132bool 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
216void 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
241bool 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
267bool 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}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t