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

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