Line data Source code
1 : use std::panic::AssertUnwindSafe;
2 : use std::sync::atomic::{AtomicBool, AtomicU8, AtomicU32, Ordering};
3 : use std::sync::{Arc, OnceLock, mpsc};
4 : use std::thread::JoinHandle;
5 :
6 : use tracing::{debug, error, trace};
7 :
8 : use crate::time::Timing;
9 :
10 : /// Stores status of the running threads. Threads are registered in the runtime upon creation
11 : /// and deregistered upon termination.
12 : pub struct Runtime {
13 : // stores handles to all threads that are currently running
14 : threads: Vec<ThreadHandle>,
15 : // stores current time and pending wakeups
16 : clock: Arc<Timing>,
17 : // thread counter
18 : thread_counter: AtomicU32,
19 : // Thread step counter -- how many times all threads has been actually
20 : // stepped (note that all world/time/executor/thread have slightly different
21 : // meaning of steps). For observability.
22 : pub step_counter: u64,
23 : }
24 :
25 : impl Runtime {
26 : /// Init new runtime, no running threads.
27 528 : pub fn new(clock: Arc<Timing>) -> Self {
28 528 : Self {
29 528 : threads: Vec::new(),
30 528 : clock,
31 528 : thread_counter: AtomicU32::new(0),
32 528 : step_counter: 0,
33 528 : }
34 528 : }
35 :
36 : /// Spawn a new thread and register it in the runtime.
37 19662 : pub fn spawn<F>(&mut self, f: F) -> ExternalHandle
38 19662 : where
39 19662 : F: FnOnce() + Send + 'static,
40 19662 : {
41 19662 : let (tx, rx) = mpsc::channel();
42 19662 :
43 19662 : let clock = self.clock.clone();
44 19662 : let tid = self.thread_counter.fetch_add(1, Ordering::SeqCst);
45 19662 : debug!("spawning thread-{}", tid);
46 :
47 19662 : let join = std::thread::spawn(move || {
48 19662 : let _guard = tracing::info_span!("", tid).entered();
49 19662 :
50 19662 : let res = std::panic::catch_unwind(AssertUnwindSafe(|| {
51 19662 : with_thread_context(|ctx| {
52 19662 : assert!(ctx.clock.set(clock).is_ok());
53 19662 : ctx.id.store(tid, Ordering::SeqCst);
54 19662 : tx.send(ctx.clone()).expect("failed to send thread context");
55 19662 : // suspend thread to put it to `threads` in sleeping state
56 19662 : ctx.yield_me(0);
57 19662 : });
58 19662 :
59 19662 : // start user-provided function
60 19662 : f();
61 19662 : }));
62 19662 : debug!("thread finished");
63 :
64 19604 : if let Err(e) = res {
65 19584 : with_thread_context(|ctx| {
66 19584 : if !ctx.allow_panic.load(std::sync::atomic::Ordering::SeqCst) {
67 0 : error!("thread panicked, terminating the process: {:?}", e);
68 0 : std::process::exit(1);
69 19584 : }
70 19584 :
71 19584 : debug!("thread panicked: {:?}", e);
72 19584 : let mut result = ctx.result.lock();
73 19584 : if result.0 == -1 {
74 19089 : *result = (256, format!("thread panicked: {:?}", e));
75 19089 : }
76 19584 : });
77 19584 : }
78 :
79 19604 : with_thread_context(|ctx| {
80 19604 : ctx.finish_me();
81 19604 : });
82 19662 : });
83 19662 :
84 19662 : let ctx = rx.recv().expect("failed to receive thread context");
85 19662 : let handle = ThreadHandle::new(ctx.clone(), join);
86 19662 :
87 19662 : self.threads.push(handle);
88 19662 :
89 19662 : ExternalHandle { ctx }
90 19662 : }
91 :
92 : /// Returns true if there are any unfinished activity, such as running thread or pending events.
93 : /// Otherwise returns false, which means all threads are blocked forever.
94 414882 : pub fn step(&mut self) -> bool {
95 414882 : trace!("runtime step");
96 :
97 : // have we run any thread?
98 414882 : let mut ran = false;
99 414882 :
100 2070291 : self.threads.retain(|thread: &ThreadHandle| {
101 2070291 : let res = thread.ctx.wakeup.compare_exchange(
102 2070291 : PENDING_WAKEUP,
103 2070291 : NO_WAKEUP,
104 2070291 : Ordering::SeqCst,
105 2070291 : Ordering::SeqCst,
106 2070291 : );
107 2070291 : if res.is_err() {
108 : // thread has no pending wakeups, leaving as is
109 1783859 : return true;
110 286432 : }
111 286432 : ran = true;
112 286432 :
113 286432 : trace!("entering thread-{}", thread.ctx.tid());
114 286432 : let status = thread.step();
115 286432 : self.step_counter += 1;
116 286432 : trace!(
117 0 : "out of thread-{} with status {:?}",
118 0 : thread.ctx.tid(),
119 : status
120 : );
121 :
122 286432 : if status == Status::Sleep {
123 266828 : true
124 : } else {
125 19604 : trace!("thread has finished");
126 : // removing the thread from the list
127 19604 : false
128 : }
129 2070291 : });
130 414882 :
131 414882 : if !ran {
132 219407 : trace!("no threads were run, stepping clock");
133 219407 : if let Some(ctx_to_wake) = self.clock.step() {
134 218859 : trace!("waking up thread-{}", ctx_to_wake.tid());
135 218859 : ctx_to_wake.inc_wake();
136 : } else {
137 548 : return false;
138 : }
139 195475 : }
140 :
141 414334 : true
142 414882 : }
143 :
144 : /// Kill all threads. This is done by setting a flag in each thread context and waking it up.
145 1008 : pub fn crash_all_threads(&mut self) {
146 2853 : for thread in self.threads.iter() {
147 2853 : thread.ctx.crash_stop();
148 2853 : }
149 :
150 : // all threads should be finished after a few steps
151 1512 : while !self.threads.is_empty() {
152 504 : self.step();
153 504 : }
154 1008 : }
155 : }
156 :
157 : impl Drop for Runtime {
158 503 : fn drop(&mut self) {
159 503 : debug!("dropping the runtime");
160 503 : self.crash_all_threads();
161 503 : }
162 : }
163 :
164 : #[derive(Clone)]
165 : pub struct ExternalHandle {
166 : ctx: Arc<ThreadContext>,
167 : }
168 :
169 : impl ExternalHandle {
170 : /// Returns true if thread has finished execution.
171 429011 : pub fn is_finished(&self) -> bool {
172 429011 : let status = self.ctx.mutex.lock();
173 429011 : *status == Status::Finished
174 429011 : }
175 :
176 : /// Returns exitcode and message, which is available after thread has finished execution.
177 482 : pub fn result(&self) -> (i32, String) {
178 482 : let result = self.ctx.result.lock();
179 482 : result.clone()
180 482 : }
181 :
182 : /// Returns thread id.
183 16 : pub fn id(&self) -> u32 {
184 16 : self.ctx.id.load(Ordering::SeqCst)
185 16 : }
186 :
187 : /// Sets a flag to crash thread on the next wakeup.
188 16582 : pub fn crash_stop(&self) {
189 16582 : self.ctx.crash_stop();
190 16582 : }
191 : }
192 :
193 : struct ThreadHandle {
194 : ctx: Arc<ThreadContext>,
195 : _join: JoinHandle<()>,
196 : }
197 :
198 : impl ThreadHandle {
199 : /// Create a new [`ThreadHandle`] and wait until thread will enter [`Status::Sleep`] state.
200 19662 : fn new(ctx: Arc<ThreadContext>, join: JoinHandle<()>) -> Self {
201 19662 : let mut status = ctx.mutex.lock();
202 : // wait until thread will go into the first yield
203 19697 : while *status != Status::Sleep {
204 35 : ctx.condvar.wait(&mut status);
205 35 : }
206 19662 : drop(status);
207 19662 :
208 19662 : Self { ctx, _join: join }
209 19662 : }
210 :
211 : /// Allows thread to execute one step of its execution.
212 : /// Returns [`Status`] of the thread after the step.
213 286432 : fn step(&self) -> Status {
214 286432 : let mut status = self.ctx.mutex.lock();
215 286432 : assert!(matches!(*status, Status::Sleep));
216 :
217 286432 : *status = Status::Running;
218 286432 : self.ctx.condvar.notify_all();
219 :
220 572864 : while *status == Status::Running {
221 286432 : self.ctx.condvar.wait(&mut status);
222 286432 : }
223 :
224 286432 : *status
225 286432 : }
226 : }
227 :
228 : #[derive(Clone, Copy, Debug, PartialEq, Eq)]
229 : enum Status {
230 : /// Thread is running.
231 : Running,
232 : /// Waiting for event to complete, will be resumed by the executor step, once wakeup flag is set.
233 : Sleep,
234 : /// Thread finished execution.
235 : Finished,
236 : }
237 :
238 : const NO_WAKEUP: u8 = 0;
239 : const PENDING_WAKEUP: u8 = 1;
240 :
241 : pub struct ThreadContext {
242 : id: AtomicU32,
243 : // used to block thread until it is woken up
244 : mutex: parking_lot::Mutex<Status>,
245 : condvar: parking_lot::Condvar,
246 : // used as a flag to indicate runtime that thread is ready to be woken up
247 : wakeup: AtomicU8,
248 : clock: OnceLock<Arc<Timing>>,
249 : // execution result, set by exit() call
250 : result: parking_lot::Mutex<(i32, String)>,
251 : // determines if process should be killed on receiving panic
252 : allow_panic: AtomicBool,
253 : // acts as a signal that thread should crash itself on the next wakeup
254 : crash_request: AtomicBool,
255 : }
256 :
257 : impl ThreadContext {
258 20190 : pub(crate) fn new() -> Self {
259 20190 : Self {
260 20190 : id: AtomicU32::new(0),
261 20190 : mutex: parking_lot::Mutex::new(Status::Running),
262 20190 : condvar: parking_lot::Condvar::new(),
263 20190 : wakeup: AtomicU8::new(NO_WAKEUP),
264 20190 : clock: OnceLock::new(),
265 20190 : result: parking_lot::Mutex::new((-1, String::new())),
266 20190 : allow_panic: AtomicBool::new(false),
267 20190 : crash_request: AtomicBool::new(false),
268 20190 : }
269 20190 : }
270 : }
271 :
272 : // Functions for executor to control thread execution.
273 : impl ThreadContext {
274 : /// Set atomic flag to indicate that thread is ready to be woken up.
275 681602 : fn inc_wake(&self) {
276 681602 : self.wakeup.store(PENDING_WAKEUP, Ordering::SeqCst);
277 681602 : }
278 :
279 : /// Internal function used for event queues.
280 180115 : pub(crate) fn schedule_wakeup(self: &Arc<Self>, after_ms: u64) {
281 180115 : self.clock
282 180115 : .get()
283 180115 : .unwrap()
284 180115 : .schedule_wakeup(after_ms, self.clone());
285 180115 : }
286 :
287 1 : fn tid(&self) -> u32 {
288 1 : self.id.load(Ordering::SeqCst)
289 1 : }
290 :
291 19435 : fn crash_stop(&self) {
292 19435 : let status = self.mutex.lock();
293 19435 : if *status == Status::Finished {
294 13 : debug!(
295 0 : "trying to crash thread-{}, which is already finished",
296 0 : self.tid()
297 : );
298 13 : return;
299 19422 : }
300 19422 : assert!(matches!(*status, Status::Sleep));
301 19422 : drop(status);
302 19422 :
303 19422 : self.allow_panic.store(true, Ordering::SeqCst);
304 19422 : self.crash_request.store(true, Ordering::SeqCst);
305 19422 : // set a wakeup
306 19422 : self.inc_wake();
307 : // it will panic on the next wakeup
308 19435 : }
309 : }
310 :
311 : // Internal functions.
312 : impl ThreadContext {
313 : /// Blocks thread until it's woken up by the executor. If `after_ms` is 0, is will be
314 : /// woken on the next step. If `after_ms` > 0, wakeup is scheduled after that time.
315 : /// Otherwise wakeup is not scheduled inside `yield_me`, and should be arranged before
316 : /// calling this function.
317 286490 : fn yield_me(self: &Arc<Self>, after_ms: i64) {
318 286490 : let mut status = self.mutex.lock();
319 286490 : assert!(matches!(*status, Status::Running));
320 :
321 286490 : match after_ms.cmp(&0) {
322 236779 : std::cmp::Ordering::Less => {
323 236779 : // block until something wakes us up
324 236779 : }
325 21159 : std::cmp::Ordering::Equal => {
326 21159 : // tell executor that we are ready to be woken up
327 21159 : self.inc_wake();
328 21159 : }
329 28552 : std::cmp::Ordering::Greater => {
330 28552 : // schedule wakeup
331 28552 : self.clock
332 28552 : .get()
333 28552 : .unwrap()
334 28552 : .schedule_wakeup(after_ms as u64, self.clone());
335 28552 : }
336 : }
337 :
338 286490 : *status = Status::Sleep;
339 286490 : self.condvar.notify_all();
340 :
341 : // wait until executor wakes us up
342 572980 : while *status != Status::Running {
343 286490 : self.condvar.wait(&mut status);
344 286490 : }
345 :
346 286490 : if self.crash_request.load(Ordering::SeqCst) {
347 19089 : panic!("crashed by request");
348 267401 : }
349 267401 : }
350 :
351 : /// Called only once, exactly before thread finishes execution.
352 19604 : fn finish_me(&self) {
353 19604 : let mut status = self.mutex.lock();
354 19604 : assert!(matches!(*status, Status::Running));
355 :
356 19604 : *status = Status::Finished;
357 19604 : {
358 19604 : let mut result = self.result.lock();
359 19604 : if result.0 == -1 {
360 20 : *result = (0, "finished normally".to_owned());
361 19584 : }
362 : }
363 19604 : self.condvar.notify_all();
364 19604 : }
365 : }
366 :
367 : /// Invokes the given closure with a reference to the current thread [`ThreadContext`].
368 : #[inline(always)]
369 1886369 : fn with_thread_context<T>(f: impl FnOnce(&Arc<ThreadContext>) -> T) -> T {
370 1886369 : thread_local!(static THREAD_DATA: Arc<ThreadContext> = Arc::new(ThreadContext::new()));
371 1886369 : THREAD_DATA.with(f)
372 1886369 : }
373 :
374 : /// Waker is used to wake up threads that are blocked on condition.
375 : /// It keeps track of contexts [`Arc<ThreadContext>`] and can increment the counter
376 : /// of several contexts to send a notification.
377 : pub struct Waker {
378 : // contexts that are waiting for a notification
379 : contexts: parking_lot::Mutex<smallvec::SmallVec<[Arc<ThreadContext>; 8]>>,
380 : }
381 :
382 : impl Default for Waker {
383 0 : fn default() -> Self {
384 0 : Self::new()
385 0 : }
386 : }
387 :
388 : impl Waker {
389 80611 : pub fn new() -> Self {
390 80611 : Self {
391 80611 : contexts: parking_lot::Mutex::new(smallvec::SmallVec::new()),
392 80611 : }
393 80611 : }
394 :
395 : /// Subscribe current thread to receive a wake notification later.
396 845477 : pub fn wake_me_later(&self) {
397 845477 : with_thread_context(|ctx| {
398 845477 : self.contexts.lock().push(ctx.clone());
399 845477 : });
400 845477 : }
401 :
402 : /// Wake up all threads that are waiting for a notification and clear the list.
403 124595 : pub fn wake_all(&self) {
404 124595 : let mut v = self.contexts.lock();
405 422162 : for ctx in v.iter() {
406 422162 : ctx.inc_wake();
407 422162 : }
408 124595 : v.clear();
409 124595 : }
410 : }
411 :
412 : /// See [`ThreadContext::yield_me`].
413 266828 : pub fn yield_me(after_ms: i64) {
414 266828 : with_thread_context(|ctx| ctx.yield_me(after_ms))
415 266828 : }
416 :
417 : /// Get current time.
418 714191 : pub fn now() -> u64 {
419 714191 : with_thread_context(|ctx| ctx.clock.get().unwrap().now())
420 714191 : }
421 :
422 495 : pub fn exit(code: i32, msg: String) {
423 495 : with_thread_context(|ctx| {
424 495 : ctx.allow_panic.store(true, Ordering::SeqCst);
425 495 : let mut result = ctx.result.lock();
426 495 : *result = (code, msg);
427 495 : panic!("exit");
428 495 : });
429 : }
430 :
431 528 : pub(crate) fn get_thread_ctx() -> Arc<ThreadContext> {
432 528 : with_thread_context(|ctx| ctx.clone())
433 528 : }
434 :
435 : /// Trait for polling channels until they have something.
436 : pub trait PollSome {
437 : /// Schedule wakeup for message arrival.
438 : fn wake_me(&self);
439 :
440 : /// Check if channel has a ready message.
441 : fn has_some(&self) -> bool;
442 : }
443 :
444 : /// Blocks current thread until one of the channels has a ready message. Returns
445 : /// index of the channel that has a message. If timeout is reached, returns None.
446 : ///
447 : /// Negative timeout means block forever. Zero timeout means check channels and return
448 : /// immediately. Positive timeout means block until timeout is reached.
449 106388 : pub fn epoll_chans(chans: &[Box<dyn PollSome>], timeout: i64) -> Option<usize> {
450 106388 : let deadline = if timeout < 0 {
451 77404 : 0
452 : } else {
453 28984 : now() + timeout as u64
454 : };
455 :
456 : loop {
457 1044403 : for chan in chans {
458 842715 : chan.wake_me()
459 : }
460 :
461 679222 : for (i, chan) in chans.iter().enumerate() {
462 679222 : if chan.has_some() {
463 85451 : return Some(i);
464 593771 : }
465 : }
466 :
467 98019 : if timeout < 0 {
468 66748 : // block until wakeup
469 66748 : yield_me(-1);
470 66748 : } else {
471 31271 : let current_time = now();
472 31271 : if current_time >= deadline {
473 2719 : return None;
474 28552 : }
475 28552 :
476 28552 : yield_me((deadline - current_time) as i64);
477 : }
478 : }
479 88170 : }
|
