Line data Source code
1 : use std::{collections::VecDeque, sync::Arc};
2 :
3 : use parking_lot::{Mutex, MutexGuard};
4 :
5 : use crate::executor::{self, PollSome, Waker};
6 :
7 : /// FIFO channel with blocking send and receive. Can be cloned and shared between threads.
8 : /// Blocking functions should be used only from threads that are managed by the executor.
9 : pub struct Chan<T> {
10 : shared: Arc<State<T>>,
11 : }
12 :
13 : impl<T> Clone for Chan<T> {
14 2426930 : fn clone(&self) -> Self {
15 2426930 : Chan {
16 2426930 : shared: self.shared.clone(),
17 2426930 : }
18 2426930 : }
19 : }
20 :
21 : impl<T> Default for Chan<T> {
22 0 : fn default() -> Self {
23 0 : Self::new()
24 0 : }
25 : }
26 :
27 : impl<T> Chan<T> {
28 314153 : pub fn new() -> Chan<T> {
29 314153 : Chan {
30 314153 : shared: Arc::new(State {
31 314153 : queue: Mutex::new(VecDeque::new()),
32 314153 : waker: Waker::new(),
33 314153 : }),
34 314153 : }
35 314153 : }
36 :
37 : /// Get a message from the front of the queue, block if the queue is empty.
38 : /// If not called from the executor thread, it can block forever.
39 2112 : pub fn recv(&self) -> T {
40 2112 : self.shared.recv()
41 2112 : }
42 :
43 : /// Panic if the queue is empty.
44 259013 : pub fn must_recv(&self) -> T {
45 259013 : self.shared
46 259013 : .try_recv()
47 259013 : .expect("message should've been ready")
48 259013 : }
49 :
50 : /// Get a message from the front of the queue, return None if the queue is empty.
51 : /// Never blocks.
52 227891 : pub fn try_recv(&self) -> Option<T> {
53 227891 : self.shared.try_recv()
54 227891 : }
55 :
56 : /// Send a message to the back of the queue.
57 472504 : pub fn send(&self, t: T) {
58 472504 : self.shared.send(t);
59 472504 : }
60 : }
61 :
62 : struct State<T> {
63 : queue: Mutex<VecDeque<T>>,
64 : waker: Waker,
65 : }
66 :
67 : impl<T> State<T> {
68 472504 : fn send(&self, t: T) {
69 472504 : self.queue.lock().push_back(t);
70 472504 : self.waker.wake_all();
71 472504 : }
72 :
73 486904 : fn try_recv(&self) -> Option<T> {
74 486904 : let mut q = self.queue.lock();
75 486904 : q.pop_front()
76 486904 : }
77 :
78 2112 : fn recv(&self) -> T {
79 2112 : // interrupt the receiver to prevent consuming everything at once
80 2112 : executor::yield_me(0);
81 2112 :
82 2112 : let mut queue = self.queue.lock();
83 2112 : if let Some(t) = queue.pop_front() {
84 0 : return t;
85 2112 : }
86 : loop {
87 5084 : self.waker.wake_me_later();
88 5084 : if let Some(t) = queue.pop_front() {
89 1863 : return t;
90 2972 : }
91 2972 : MutexGuard::unlocked(&mut queue, || {
92 2972 : executor::yield_me(-1);
93 2972 : });
94 : }
95 1863 : }
96 : }
97 :
98 : impl<T> PollSome for Chan<T> {
99 : /// Schedules a wakeup for the current thread.
100 3043021 : fn wake_me(&self) {
101 3043021 : self.shared.waker.wake_me_later();
102 3043021 : }
103 :
104 : /// Checks if chan has any pending messages.
105 2451104 : fn has_some(&self) -> bool {
106 2451104 : !self.shared.queue.lock().is_empty()
107 2451104 : }
108 : }
|