salsa/tests/gc/volatile_tests.rs
Niko Matsakis fad97eeb6a remove the DB parameter
This had two unexpected consequences, one unfortunate, one "medium":

* All `salsa::Database` must be `'static`. This falls out from
`Q::DynDb` not having access to any lifetimes, but also the defaulting
rules for `dyn QueryGroup` that make it `dyn QueryGroup + 'static`. We
don't really support generic databases anyway yet so this isn't a big
deal, and we can add workarounds later (ideally via GATs).

* It is now statically impossible to invoke `snapshot` from a query,
and so we don't need to test that it panics. This is because the
signature of `snapshot` returns a `Snapshot<Self>` and that is not
accessible to a `dyn QueryGroup` type. Similarly, invoking
`Runtime::snapshot` directly is not possible becaues it is
crate-private. So I removed the test. This seems ok, but eventually I
would like to expose ways for queries to do parallel
execution (matklad and I had talked about a "speculation" primitive
for enabling that).

* This commit is 99% boilerplate I did with search-and-replace. I also
rolled in a few other changes I might have preferred to factor out,
most notably removing the `GetQueryTable` plumbing trait in favor of
free-methods, but it was awkward to factor them out and get all the
generics right (so much simpler in this version).
2020-07-04 14:17:11 +00:00

72 lines
1.5 KiB
Rust

use crate::db;
use salsa::{Database, SweepStrategy};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
/// Query group for tests for how interned keys interact with GC.
#[salsa::query_group(Volatile)]
pub(crate) trait VolatileDatabase: Database {
#[salsa::input]
fn atomic_cell(&self) -> Arc<AtomicUsize>;
/// Underlying volatile query.
fn volatile(&self) -> usize;
/// This just executes the intern query and returns the result.
fn repeat1(&self) -> usize;
/// Same as `repeat_intern1`. =)
fn repeat2(&self) -> usize;
}
fn volatile(db: &dyn VolatileDatabase) -> usize {
db.salsa_runtime().report_untracked_read();
db.atomic_cell().load(Ordering::SeqCst)
}
fn repeat1(db: &dyn VolatileDatabase) -> usize {
db.volatile()
}
fn repeat2(db: &dyn VolatileDatabase) -> usize {
db.volatile()
}
#[test]
fn consistency_no_gc() {
let mut db = db::DatabaseImpl::default();
let cell = Arc::new(AtomicUsize::new(22));
db.set_atomic_cell(cell.clone());
let v1 = db.repeat1();
cell.store(23, Ordering::SeqCst);
let v2 = db.repeat2();
assert_eq!(v1, v2);
}
#[test]
fn consistency_with_gc() {
let mut db = db::DatabaseImpl::default();
let cell = Arc::new(AtomicUsize::new(22));
db.set_atomic_cell(cell.clone());
let v1 = db.repeat1();
cell.store(23, Ordering::SeqCst);
VolatileQuery.in_db(&db).sweep(
SweepStrategy::default()
.discard_everything()
.sweep_all_revisions(),
);
let v2 = db.repeat2();
assert_eq!(v1, v2);
}