mirror of
https://github.com/salsa-rs/salsa.git
synced 2024-11-24 20:20:26 +00:00
fad97eeb6a
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).
102 lines
2.8 KiB
Rust
102 lines
2.8 KiB
Rust
//! Test setting LRU actually limits the number of things in the database;
|
|
use std::sync::{
|
|
atomic::{AtomicUsize, Ordering},
|
|
Arc,
|
|
};
|
|
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
struct HotPotato(u32);
|
|
|
|
static N_POTATOES: AtomicUsize = AtomicUsize::new(0);
|
|
|
|
impl HotPotato {
|
|
fn new(id: u32) -> HotPotato {
|
|
N_POTATOES.fetch_add(1, Ordering::SeqCst);
|
|
HotPotato(id)
|
|
}
|
|
}
|
|
|
|
impl Drop for HotPotato {
|
|
fn drop(&mut self) {
|
|
N_POTATOES.fetch_sub(1, Ordering::SeqCst);
|
|
}
|
|
}
|
|
|
|
#[salsa::query_group(QueryGroupStorage)]
|
|
trait QueryGroup: salsa::Database {
|
|
fn get(&self, x: u32) -> Arc<HotPotato>;
|
|
fn get_volatile(&self, x: u32) -> usize;
|
|
}
|
|
|
|
fn get(_db: &dyn QueryGroup, x: u32) -> Arc<HotPotato> {
|
|
Arc::new(HotPotato::new(x))
|
|
}
|
|
|
|
fn get_volatile(db: &dyn QueryGroup, _x: u32) -> usize {
|
|
static COUNTER: AtomicUsize = AtomicUsize::new(0);
|
|
db.salsa_runtime().report_untracked_read();
|
|
COUNTER.fetch_add(1, Ordering::SeqCst)
|
|
}
|
|
|
|
#[salsa::database(QueryGroupStorage)]
|
|
#[derive(Default)]
|
|
struct Database {
|
|
storage: salsa::Storage<Self>,
|
|
}
|
|
|
|
impl salsa::Database for Database {}
|
|
|
|
#[test]
|
|
fn lru_works() {
|
|
let mut db = Database::default();
|
|
GetQuery.in_db_mut(&mut db).set_lru_capacity(32);
|
|
assert_eq!(N_POTATOES.load(Ordering::SeqCst), 0);
|
|
|
|
for i in 0..128u32 {
|
|
let p = db.get(i);
|
|
assert_eq!(p.0, i)
|
|
}
|
|
assert_eq!(N_POTATOES.load(Ordering::SeqCst), 32);
|
|
|
|
for i in 0..128u32 {
|
|
let p = db.get(i);
|
|
assert_eq!(p.0, i)
|
|
}
|
|
assert_eq!(N_POTATOES.load(Ordering::SeqCst), 32);
|
|
|
|
GetQuery.in_db_mut(&mut db).set_lru_capacity(32);
|
|
assert_eq!(N_POTATOES.load(Ordering::SeqCst), 32);
|
|
|
|
GetQuery.in_db_mut(&mut db).set_lru_capacity(64);
|
|
assert_eq!(N_POTATOES.load(Ordering::SeqCst), 32);
|
|
for i in 0..128u32 {
|
|
let p = db.get(i);
|
|
assert_eq!(p.0, i)
|
|
}
|
|
assert_eq!(N_POTATOES.load(Ordering::SeqCst), 64);
|
|
|
|
// Special case: setting capacity to zero disables LRU
|
|
GetQuery.in_db_mut(&mut db).set_lru_capacity(0);
|
|
assert_eq!(N_POTATOES.load(Ordering::SeqCst), 64);
|
|
for i in 0..128u32 {
|
|
let p = db.get(i);
|
|
assert_eq!(p.0, i)
|
|
}
|
|
assert_eq!(N_POTATOES.load(Ordering::SeqCst), 128);
|
|
|
|
drop(db);
|
|
assert_eq!(N_POTATOES.load(Ordering::SeqCst), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn lru_doesnt_break_volatile_queries() {
|
|
let mut db = Database::default();
|
|
GetVolatileQuery.in_db_mut(&mut db).set_lru_capacity(32);
|
|
// Here, we check that we execute each volatile query at most once, despite
|
|
// LRU. That does mean that we have more values in DB than the LRU capacity,
|
|
// but it's much better than inconsistent results from volatile queries!
|
|
for i in (0..3).flat_map(|_| 0..128usize) {
|
|
let x = db.get_volatile(i as u32);
|
|
assert_eq!(x, i)
|
|
}
|
|
}
|