aboutsummaryrefslogtreecommitdiff
path: root/vendor/rayon-core/src/thread_pool/test.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/rayon-core/src/thread_pool/test.rs')
-rw-r--r--vendor/rayon-core/src/thread_pool/test.rs418
1 files changed, 0 insertions, 418 deletions
diff --git a/vendor/rayon-core/src/thread_pool/test.rs b/vendor/rayon-core/src/thread_pool/test.rs
deleted file mode 100644
index 88b3628..0000000
--- a/vendor/rayon-core/src/thread_pool/test.rs
+++ /dev/null
@@ -1,418 +0,0 @@
-#![cfg(test)]
-
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::mpsc::channel;
-use std::sync::{Arc, Mutex};
-
-use crate::{join, Scope, ScopeFifo, ThreadPool, ThreadPoolBuilder};
-
-#[test]
-#[should_panic(expected = "Hello, world!")]
-fn panic_propagate() {
- let thread_pool = ThreadPoolBuilder::new().build().unwrap();
- thread_pool.install(|| {
- panic!("Hello, world!");
- });
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn workers_stop() {
- let registry;
-
- {
- // once we exit this block, thread-pool will be dropped
- let thread_pool = ThreadPoolBuilder::new().num_threads(22).build().unwrap();
- registry = thread_pool.install(|| {
- // do some work on these threads
- join_a_lot(22);
-
- Arc::clone(&thread_pool.registry)
- });
- assert_eq!(registry.num_threads(), 22);
- }
-
- // once thread-pool is dropped, registry should terminate, which
- // should lead to worker threads stopping
- registry.wait_until_stopped();
-}
-
-fn join_a_lot(n: usize) {
- if n > 0 {
- join(|| join_a_lot(n - 1), || join_a_lot(n - 1));
- }
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn sleeper_stop() {
- use std::{thread, time};
-
- let registry;
-
- {
- // once we exit this block, thread-pool will be dropped
- let thread_pool = ThreadPoolBuilder::new().num_threads(22).build().unwrap();
- registry = Arc::clone(&thread_pool.registry);
-
- // Give time for at least some of the thread pool to fall asleep.
- thread::sleep(time::Duration::from_secs(1));
- }
-
- // once thread-pool is dropped, registry should terminate, which
- // should lead to worker threads stopping
- registry.wait_until_stopped();
-}
-
-/// Creates a start/exit handler that increments an atomic counter.
-fn count_handler() -> (Arc<AtomicUsize>, impl Fn(usize)) {
- let count = Arc::new(AtomicUsize::new(0));
- (Arc::clone(&count), move |_| {
- count.fetch_add(1, Ordering::SeqCst);
- })
-}
-
-/// Wait until a counter is no longer shared, then return its value.
-fn wait_for_counter(mut counter: Arc<AtomicUsize>) -> usize {
- use std::{thread, time};
-
- for _ in 0..60 {
- counter = match Arc::try_unwrap(counter) {
- Ok(counter) => return counter.into_inner(),
- Err(counter) => {
- thread::sleep(time::Duration::from_secs(1));
- counter
- }
- };
- }
-
- // That's too long!
- panic!("Counter is still shared!");
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn failed_thread_stack() {
- // Note: we first tried to force failure with a `usize::MAX` stack, but
- // macOS and Windows weren't fazed, or at least didn't fail the way we want.
- // They work with `isize::MAX`, but 32-bit platforms may feasibly allocate a
- // 2GB stack, so it might not fail until the second thread.
- let stack_size = ::std::isize::MAX as usize;
-
- let (start_count, start_handler) = count_handler();
- let (exit_count, exit_handler) = count_handler();
- let builder = ThreadPoolBuilder::new()
- .num_threads(10)
- .stack_size(stack_size)
- .start_handler(start_handler)
- .exit_handler(exit_handler);
-
- let pool = builder.build();
- assert!(pool.is_err(), "thread stack should have failed!");
-
- // With such a huge stack, 64-bit will probably fail on the first thread;
- // 32-bit might manage the first 2GB, but certainly fail the second.
- let start_count = wait_for_counter(start_count);
- assert!(start_count <= 1);
- assert_eq!(start_count, wait_for_counter(exit_count));
-}
-
-#[test]
-#[cfg_attr(not(panic = "unwind"), ignore)]
-fn panic_thread_name() {
- let (start_count, start_handler) = count_handler();
- let (exit_count, exit_handler) = count_handler();
- let builder = ThreadPoolBuilder::new()
- .num_threads(10)
- .start_handler(start_handler)
- .exit_handler(exit_handler)
- .thread_name(|i| {
- if i >= 5 {
- panic!();
- }
- format!("panic_thread_name#{}", i)
- });
-
- let pool = crate::unwind::halt_unwinding(|| builder.build());
- assert!(pool.is_err(), "thread-name panic should propagate!");
-
- // Assuming they're created in order, threads 0 through 4 should have
- // been started already, and then terminated by the panic.
- assert_eq!(5, wait_for_counter(start_count));
- assert_eq!(5, wait_for_counter(exit_count));
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn self_install() {
- let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
-
- // If the inner `install` blocks, then nothing will actually run it!
- assert!(pool.install(|| pool.install(|| true)));
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn mutual_install() {
- let pool1 = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
- let pool2 = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
-
- let ok = pool1.install(|| {
- // This creates a dependency from `pool1` -> `pool2`
- pool2.install(|| {
- // This creates a dependency from `pool2` -> `pool1`
- pool1.install(|| {
- // If they blocked on inter-pool installs, there would be no
- // threads left to run this!
- true
- })
- })
- });
- assert!(ok);
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn mutual_install_sleepy() {
- use std::{thread, time};
-
- let pool1 = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
- let pool2 = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
-
- let ok = pool1.install(|| {
- // This creates a dependency from `pool1` -> `pool2`
- pool2.install(|| {
- // Give `pool1` time to fall asleep.
- thread::sleep(time::Duration::from_secs(1));
-
- // This creates a dependency from `pool2` -> `pool1`
- pool1.install(|| {
- // Give `pool2` time to fall asleep.
- thread::sleep(time::Duration::from_secs(1));
-
- // If they blocked on inter-pool installs, there would be no
- // threads left to run this!
- true
- })
- })
- });
- assert!(ok);
-}
-
-#[test]
-#[allow(deprecated)]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn check_thread_pool_new() {
- let pool = ThreadPool::new(crate::Configuration::new().num_threads(22)).unwrap();
- assert_eq!(pool.current_num_threads(), 22);
-}
-
-macro_rules! test_scope_order {
- ($scope:ident => $spawn:ident) => {{
- let builder = ThreadPoolBuilder::new().num_threads(1);
- let pool = builder.build().unwrap();
- pool.install(|| {
- let vec = Mutex::new(vec![]);
- pool.$scope(|scope| {
- let vec = &vec;
- for i in 0..10 {
- scope.$spawn(move |_| {
- vec.lock().unwrap().push(i);
- });
- }
- });
- vec.into_inner().unwrap()
- })
- }};
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn scope_lifo_order() {
- let vec = test_scope_order!(scope => spawn);
- let expected: Vec<i32> = (0..10).rev().collect(); // LIFO -> reversed
- assert_eq!(vec, expected);
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn scope_fifo_order() {
- let vec = test_scope_order!(scope_fifo => spawn_fifo);
- let expected: Vec<i32> = (0..10).collect(); // FIFO -> natural order
- assert_eq!(vec, expected);
-}
-
-macro_rules! test_spawn_order {
- ($spawn:ident) => {{
- let builder = ThreadPoolBuilder::new().num_threads(1);
- let pool = &builder.build().unwrap();
- let (tx, rx) = channel();
- pool.install(move || {
- for i in 0..10 {
- let tx = tx.clone();
- pool.$spawn(move || {
- tx.send(i).unwrap();
- });
- }
- });
- rx.iter().collect::<Vec<i32>>()
- }};
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn spawn_lifo_order() {
- let vec = test_spawn_order!(spawn);
- let expected: Vec<i32> = (0..10).rev().collect(); // LIFO -> reversed
- assert_eq!(vec, expected);
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn spawn_fifo_order() {
- let vec = test_spawn_order!(spawn_fifo);
- let expected: Vec<i32> = (0..10).collect(); // FIFO -> natural order
- assert_eq!(vec, expected);
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn nested_scopes() {
- // Create matching scopes for every thread pool.
- fn nest<'scope, OP>(pools: &[ThreadPool], scopes: Vec<&Scope<'scope>>, op: OP)
- where
- OP: FnOnce(&[&Scope<'scope>]) + Send,
- {
- if let Some((pool, tail)) = pools.split_first() {
- pool.scope(move |s| {
- // This move reduces the reference lifetimes by variance to match s,
- // but the actual scopes are still tied to the invariant 'scope.
- let mut scopes = scopes;
- scopes.push(s);
- nest(tail, scopes, op)
- })
- } else {
- (op)(&scopes)
- }
- }
-
- let pools: Vec<_> = (0..10)
- .map(|_| ThreadPoolBuilder::new().num_threads(1).build().unwrap())
- .collect();
-
- let counter = AtomicUsize::new(0);
- nest(&pools, vec![], |scopes| {
- for &s in scopes {
- s.spawn(|_| {
- // Our 'scope lets us borrow the counter in every pool.
- counter.fetch_add(1, Ordering::Relaxed);
- });
- }
- });
- assert_eq!(counter.into_inner(), pools.len());
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn nested_fifo_scopes() {
- // Create matching fifo scopes for every thread pool.
- fn nest<'scope, OP>(pools: &[ThreadPool], scopes: Vec<&ScopeFifo<'scope>>, op: OP)
- where
- OP: FnOnce(&[&ScopeFifo<'scope>]) + Send,
- {
- if let Some((pool, tail)) = pools.split_first() {
- pool.scope_fifo(move |s| {
- // This move reduces the reference lifetimes by variance to match s,
- // but the actual scopes are still tied to the invariant 'scope.
- let mut scopes = scopes;
- scopes.push(s);
- nest(tail, scopes, op)
- })
- } else {
- (op)(&scopes)
- }
- }
-
- let pools: Vec<_> = (0..10)
- .map(|_| ThreadPoolBuilder::new().num_threads(1).build().unwrap())
- .collect();
-
- let counter = AtomicUsize::new(0);
- nest(&pools, vec![], |scopes| {
- for &s in scopes {
- s.spawn_fifo(|_| {
- // Our 'scope lets us borrow the counter in every pool.
- counter.fetch_add(1, Ordering::Relaxed);
- });
- }
- });
- assert_eq!(counter.into_inner(), pools.len());
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn in_place_scope_no_deadlock() {
- let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
- let (tx, rx) = channel();
- let rx_ref = &rx;
- pool.in_place_scope(move |s| {
- // With regular scopes this closure would never run because this scope op
- // itself would block the only worker thread.
- s.spawn(move |_| {
- tx.send(()).unwrap();
- });
- rx_ref.recv().unwrap();
- });
-}
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn in_place_scope_fifo_no_deadlock() {
- let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
- let (tx, rx) = channel();
- let rx_ref = &rx;
- pool.in_place_scope_fifo(move |s| {
- // With regular scopes this closure would never run because this scope op
- // itself would block the only worker thread.
- s.spawn_fifo(move |_| {
- tx.send(()).unwrap();
- });
- rx_ref.recv().unwrap();
- });
-}
-
-#[test]
-fn yield_now_to_spawn() {
- let (tx, rx) = channel();
-
- // Queue a regular spawn.
- crate::spawn(move || tx.send(22).unwrap());
-
- // The single-threaded fallback mode (for wasm etc.) won't
- // get a chance to run the spawn if we never yield to it.
- crate::registry::in_worker(move |_, _| {
- crate::yield_now();
- });
-
- // The spawn **must** have started by now, but we still might have to wait
- // for it to finish if a different thread stole it first.
- assert_eq!(22, rx.recv().unwrap());
-}
-
-#[test]
-fn yield_local_to_spawn() {
- let (tx, rx) = channel();
-
- // Queue a regular spawn.
- crate::spawn(move || tx.send(22).unwrap());
-
- // The single-threaded fallback mode (for wasm etc.) won't
- // get a chance to run the spawn if we never yield to it.
- crate::registry::in_worker(move |_, _| {
- crate::yield_local();
- });
-
- // The spawn **must** have started by now, but we still might have to wait
- // for it to finish if a different thread stole it first.
- assert_eq!(22, rx.recv().unwrap());
-}
Copyright © 2024 Valentin A. Popov. All Rights Reverse Engineered.