111 lines
2.7 KiB
Rust
111 lines
2.7 KiB
Rust
//! Test for cycle recover spread across two threads.
|
|
//! See `../cycles.rs` for a complete listing of cycle tests,
|
|
//! both intra and cross thread.
|
|
|
|
use crate::setup::{Knobs, ParDatabaseImpl};
|
|
use salsa::ParallelDatabase;
|
|
use test_log::test;
|
|
|
|
// Recover cycle test:
|
|
//
|
|
// The pattern is as follows.
|
|
//
|
|
// Thread A Thread B
|
|
// -------- --------
|
|
// a1 b1
|
|
// | wait for stage 1 (blocks)
|
|
// signal stage 1 |
|
|
// wait for stage 2 (blocks) (unblocked)
|
|
// | |
|
|
// | b2
|
|
// | b3
|
|
// | a1 (blocks -> stage 2)
|
|
// (unblocked) |
|
|
// a2 (cycle detected) |
|
|
// b3 recovers
|
|
// b2 resumes
|
|
// b1 panics because bug
|
|
|
|
#[test]
|
|
fn parallel_cycle_mid_recovers() {
|
|
let db = ParDatabaseImpl::default();
|
|
db.knobs().signal_on_will_block.set(2);
|
|
|
|
let thread_a = std::thread::spawn({
|
|
let db = db.snapshot();
|
|
move || db.a1(1)
|
|
});
|
|
|
|
let thread_b = std::thread::spawn({
|
|
let db = db.snapshot();
|
|
move || db.b1(1)
|
|
});
|
|
|
|
// We expect that the recovery function yields
|
|
// `1 * 20 + 2`, which is returned (and forwarded)
|
|
// to b1, and from there to a2 and a1.
|
|
assert_eq!(thread_a.join().unwrap(), 22);
|
|
assert_eq!(thread_b.join().unwrap(), 22);
|
|
}
|
|
|
|
#[salsa::query_group(ParallelCycleMidRecovers)]
|
|
pub(crate) trait TestDatabase: Knobs {
|
|
fn a1(&self, key: i32) -> i32;
|
|
|
|
fn a2(&self, key: i32) -> i32;
|
|
|
|
#[salsa::cycle(recover_b1)]
|
|
fn b1(&self, key: i32) -> i32;
|
|
|
|
fn b2(&self, key: i32) -> i32;
|
|
|
|
#[salsa::cycle(recover_b3)]
|
|
fn b3(&self, key: i32) -> i32;
|
|
}
|
|
|
|
fn recover_b1(_db: &dyn TestDatabase, _cycle: &salsa::Cycle, key: &i32) -> i32 {
|
|
tracing::debug!("recover_b1");
|
|
key * 20 + 2
|
|
}
|
|
|
|
fn recover_b3(_db: &dyn TestDatabase, _cycle: &salsa::Cycle, key: &i32) -> i32 {
|
|
tracing::debug!("recover_b1");
|
|
key * 200 + 2
|
|
}
|
|
|
|
fn a1(db: &dyn TestDatabase, key: i32) -> i32 {
|
|
// tell thread b we have started
|
|
db.signal(1);
|
|
|
|
// wait for thread b to block on a1
|
|
db.wait_for(2);
|
|
|
|
db.a2(key)
|
|
}
|
|
|
|
fn a2(db: &dyn TestDatabase, key: i32) -> i32 {
|
|
// create the cycle
|
|
db.b1(key)
|
|
}
|
|
|
|
fn b1(db: &dyn TestDatabase, key: i32) -> i32 {
|
|
// wait for thread a to have started
|
|
db.wait_for(1);
|
|
|
|
db.b2(key);
|
|
|
|
0
|
|
}
|
|
|
|
fn b2(db: &dyn TestDatabase, key: i32) -> i32 {
|
|
// will encounter a cycle but recover
|
|
db.b3(key);
|
|
db.b1(key); // hasn't recovered yet
|
|
0
|
|
}
|
|
|
|
fn b3(db: &dyn TestDatabase, key: i32) -> i32 {
|
|
// will block on thread a, signaling stage 2
|
|
db.a1(key)
|
|
}
|