diff --git a/Cargo.toml b/Cargo.toml index 6883d72d..cb72420c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,8 +6,8 @@ repository = "https://github.com/cberner/redb" readme = "README.md" license = "MIT OR Apache-2.0" version = "2.4.0" -edition = "2021" -rust-version = "1.81" +edition = "2024" +rust-version = "1.85" authors = ["Christopher Berner "] exclude = ["fuzz/"] @@ -26,7 +26,7 @@ libc = "0.2.104" # Common test/bench dependencies [dev-dependencies] -rand = "0.8" +rand = "0.9" tempfile = "3.5.0" # for backwards compatibility testing - pin at 1.0.0 redb1 = { version = "=1.0.0", package = "redb" } diff --git a/benches/common.rs b/benches/common.rs index 7c6c37e7..0ccab252 100644 --- a/benches/common.rs +++ b/benches/common.rs @@ -95,9 +95,15 @@ impl<'a> RedbBenchDatabase<'a> { } } -impl<'a> BenchDatabase for RedbBenchDatabase<'a> { - type W<'db> = RedbBenchWriteTransaction where Self: 'db; - type R<'db> = RedbBenchReadTransaction where Self: 'db; +impl BenchDatabase for RedbBenchDatabase<'_> { + type W<'db> + = RedbBenchWriteTransaction + where + Self: 'db; + type R<'db> + = RedbBenchReadTransaction + where + Self: 'db; fn db_type_name() -> &'static str { "redb" @@ -124,7 +130,10 @@ pub struct RedbBenchReadTransaction { } impl BenchReadTransaction for RedbBenchReadTransaction { - type T<'txn> = RedbBenchReader where Self: 'txn; + type T<'txn> + = RedbBenchReader + where + Self: 'txn; fn get_reader(&self) -> Self::T<'_> { let table = self.txn.open_table(X).unwrap(); @@ -137,8 +146,14 @@ pub struct RedbBenchReader { } impl BenchReader for RedbBenchReader { - type Output<'out> = RedbAccessGuard<'out> where Self: 'out; - type Iterator<'out> = RedbBenchIterator<'out> where Self: 'out; + type Output<'out> + = RedbAccessGuard<'out> + where + Self: 'out; + type Iterator<'out> + = RedbBenchIterator<'out> + where + Self: 'out; fn get<'a>(&'a self, key: &[u8]) -> Option> { self.table.get(key).unwrap().map(RedbAccessGuard::new) @@ -159,7 +174,10 @@ pub struct RedbBenchIterator<'a> { } impl BenchIterator for RedbBenchIterator<'_> { - type Output<'a> = RedbAccessGuard<'a> where Self: 'a; + type Output<'a> + = RedbAccessGuard<'a> + where + Self: 'a; fn next(&mut self) -> Option<(Self::Output<'_>, Self::Output<'_>)> { self.iter.next().map(|item| { @@ -179,7 +197,7 @@ impl<'a> RedbAccessGuard<'a> { } } -impl<'a> AsRef<[u8]> for RedbAccessGuard<'a> { +impl AsRef<[u8]> for RedbAccessGuard<'_> { fn as_ref(&self) -> &[u8] { self.inner.value() } @@ -190,7 +208,10 @@ pub struct RedbBenchWriteTransaction { } impl BenchWriteTransaction for RedbBenchWriteTransaction { - type W<'txn> = RedbBenchInserter<'txn> where Self: 'txn; + type W<'txn> + = RedbBenchInserter<'txn> + where + Self: 'txn; fn get_inserter(&mut self) -> Self::W<'_> { let table = self.txn.open_table(X).unwrap(); @@ -227,9 +248,15 @@ impl<'a> SledBenchDatabase<'a> { } } -impl<'a> BenchDatabase for SledBenchDatabase<'a> { - type W<'db> = SledBenchWriteTransaction<'db> where Self: 'db; - type R<'db> = SledBenchReadTransaction<'db> where Self: 'db; +impl BenchDatabase for SledBenchDatabase<'_> { + type W<'db> + = SledBenchWriteTransaction<'db> + where + Self: 'db; + type R<'db> + = SledBenchReadTransaction<'db> + where + Self: 'db; fn db_type_name() -> &'static str { "sled" @@ -252,7 +279,10 @@ pub struct SledBenchReadTransaction<'db> { } impl<'db> BenchReadTransaction for SledBenchReadTransaction<'db> { - type T<'txn> = SledBenchReader<'db> where Self: 'txn; + type T<'txn> + = SledBenchReader<'db> + where + Self: 'txn; fn get_reader(&self) -> Self::T<'_> { SledBenchReader { db: self.db } @@ -263,9 +293,15 @@ pub struct SledBenchReader<'db> { db: &'db sled::Db, } -impl<'db> BenchReader for SledBenchReader<'db> { - type Output<'out> = sled::IVec where Self: 'out; - type Iterator<'out> = SledBenchIterator where Self: 'out; +impl BenchReader for SledBenchReader<'_> { + type Output<'out> + = sled::IVec + where + Self: 'out; + type Iterator<'out> + = SledBenchIterator + where + Self: 'out; fn get(&self, key: &[u8]) -> Option { self.db.get(key).unwrap() @@ -286,7 +322,10 @@ pub struct SledBenchIterator { } impl BenchIterator for SledBenchIterator { - type Output<'out> = sled::IVec where Self: 'out; + type Output<'out> + = sled::IVec + where + Self: 'out; fn next(&mut self) -> Option<(Self::Output<'_>, Self::Output<'_>)> { self.iter.next().map(|x| x.unwrap()) @@ -298,8 +337,11 @@ pub struct SledBenchWriteTransaction<'a> { db_dir: &'a Path, } -impl<'a> BenchWriteTransaction for SledBenchWriteTransaction<'a> { - type W<'txn> = SledBenchInserter<'txn> where Self: 'txn; +impl BenchWriteTransaction for SledBenchWriteTransaction<'_> { + type W<'txn> + = SledBenchInserter<'txn> + where + Self: 'txn; fn get_inserter(&mut self) -> Self::W<'_> { SledBenchInserter { db: self.db } @@ -325,7 +367,7 @@ pub struct SledBenchInserter<'a> { db: &'a sled::Db, } -impl<'a> BenchInserter for SledBenchInserter<'a> { +impl BenchInserter for SledBenchInserter<'_> { fn insert(&mut self, key: &[u8], value: &[u8]) -> Result<(), ()> { self.db.insert(key, value).map(|_| ()).map_err(|_| ()) } @@ -350,8 +392,14 @@ impl HeedBenchDatabase { } impl BenchDatabase for HeedBenchDatabase { - type W<'db> = HeedBenchWriteTransaction<'db> where Self: 'db; - type R<'db> = HeedBenchReadTransaction<'db> where Self: 'db; + type W<'db> + = HeedBenchWriteTransaction<'db> + where + Self: 'db; + type R<'db> + = HeedBenchReadTransaction<'db> + where + Self: 'db; fn db_type_name() -> &'static str { "lmdb" @@ -415,7 +463,10 @@ pub struct HeedBenchWriteTransaction<'db> { } impl<'db> BenchWriteTransaction for HeedBenchWriteTransaction<'db> { - type W<'txn> = HeedBenchInserter<'txn, 'db> where Self: 'txn; + type W<'txn> + = HeedBenchInserter<'txn, 'db> + where + Self: 'txn; fn get_inserter(&mut self) -> Self::W<'_> { Self::W { @@ -464,7 +515,10 @@ pub struct HeedBenchReadTransaction<'db> { } impl<'db> BenchReadTransaction for HeedBenchReadTransaction<'db> { - type T<'txn> = HeedBenchReader<'txn, 'db> where Self: 'txn; + type T<'txn> + = HeedBenchReader<'txn, 'db> + where + Self: 'txn; fn get_reader(&self) -> Self::T<'_> { Self::T { @@ -479,9 +533,15 @@ pub struct HeedBenchReader<'txn, 'db> { txn: &'txn heed::RoTxn<'db>, } -impl<'txn, 'db> BenchReader for HeedBenchReader<'txn, 'db> { - type Output<'out> = &'out [u8] where Self: 'out; - type Iterator<'out> = HeedBenchIterator<'out> where Self: 'out; +impl BenchReader for HeedBenchReader<'_, '_> { + type Output<'out> + = &'out [u8] + where + Self: 'out; + type Iterator<'out> + = HeedBenchIterator<'out> + where + Self: 'out; fn get(&self, key: &[u8]) -> Option<&[u8]> { self.db.get(self.txn, key).unwrap() @@ -504,7 +564,10 @@ pub struct HeedBenchIterator<'a> { } impl BenchIterator for HeedBenchIterator<'_> { - type Output<'out> = &'out [u8] where Self: 'out; + type Output<'out> + = &'out [u8] + where + Self: 'out; fn next(&mut self) -> Option<(Self::Output<'_>, Self::Output<'_>)> { self.iter.next().map(|x| x.unwrap()) @@ -521,9 +584,15 @@ impl<'a> RocksdbBenchDatabase<'a> { } } -impl<'a> BenchDatabase for RocksdbBenchDatabase<'a> { - type W<'db> = RocksdbBenchWriteTransaction<'db> where Self: 'db; - type R<'db> = RocksdbBenchReadTransaction<'db> where Self: 'db; +impl BenchDatabase for RocksdbBenchDatabase<'_> { + type W<'db> + = RocksdbBenchWriteTransaction<'db> + where + Self: 'db; + type R<'db> + = RocksdbBenchReadTransaction<'db> + where + Self: 'db; fn db_type_name() -> &'static str { "rocksdb" @@ -558,8 +627,11 @@ pub struct RocksdbBenchWriteTransaction<'a> { db_dir: PathBuf, } -impl<'a> BenchWriteTransaction for RocksdbBenchWriteTransaction<'a> { - type W<'txn> = RocksdbBenchInserter<'txn> where Self: 'txn; +impl BenchWriteTransaction for RocksdbBenchWriteTransaction<'_> { + type W<'txn> + = RocksdbBenchInserter<'txn> + where + Self: 'txn; fn get_inserter(&mut self) -> Self::W<'_> { RocksdbBenchInserter { txn: &self.txn } @@ -603,7 +675,10 @@ pub struct RocksdbBenchReadTransaction<'db> { } impl<'db> BenchReadTransaction for RocksdbBenchReadTransaction<'db> { - type T<'txn> = RocksdbBenchReader<'db, 'txn> where Self: 'txn; + type T<'txn> + = RocksdbBenchReader<'db, 'txn> + where + Self: 'txn; fn get_reader(&self) -> Self::T<'_> { RocksdbBenchReader { @@ -616,9 +691,15 @@ pub struct RocksdbBenchReader<'db, 'txn> { snapshot: &'txn rocksdb::SnapshotWithThreadMode<'db, OptimisticTransactionDB>, } -impl<'db, 'txn> BenchReader for RocksdbBenchReader<'db, 'txn> { - type Output<'out> = Vec where Self: 'out; - type Iterator<'out> = RocksdbBenchIterator<'out> where Self: 'out; +impl BenchReader for RocksdbBenchReader<'_, '_> { + type Output<'out> + = Vec + where + Self: 'out; + type Iterator<'out> + = RocksdbBenchIterator<'out> + where + Self: 'out; fn get(&self, key: &[u8]) -> Option> { self.snapshot.get(key).unwrap() @@ -642,7 +723,10 @@ pub struct RocksdbBenchIterator<'a> { } impl BenchIterator for RocksdbBenchIterator<'_> { - type Output<'out> = Box<[u8]> where Self: 'out; + type Output<'out> + = Box<[u8]> + where + Self: 'out; fn next(&mut self) -> Option<(Self::Output<'_>, Self::Output<'_>)> { self.iter.next().map(|x| { @@ -675,9 +759,15 @@ impl<'a> SanakirjaBenchDatabase<'a> { } } -impl<'a> BenchDatabase for SanakirjaBenchDatabase<'a> { - type W<'db> = SanakirjaBenchWriteTransaction<'db> where Self: 'db; - type R<'db> = SanakirjaBenchReadTransaction<'db> where Self: 'db; +impl BenchDatabase for SanakirjaBenchDatabase<'_> { + type W<'db> + = SanakirjaBenchWriteTransaction<'db> + where + Self: 'db; + type R<'db> + = SanakirjaBenchReadTransaction<'db> + where + Self: 'db; fn db_type_name() -> &'static str { "sanakirja" @@ -704,7 +794,10 @@ pub struct SanakirjaBenchWriteTransaction<'db> { } impl<'db> BenchWriteTransaction for SanakirjaBenchWriteTransaction<'db> { - type W<'txn> = SanakirjaBenchInserter<'db, 'txn> where Self: 'txn; + type W<'txn> + = SanakirjaBenchInserter<'db, 'txn> + where + Self: 'txn; fn get_inserter(&mut self) -> Self::W<'_> { let table = self.txn.root_db(0).unwrap(); @@ -762,7 +855,10 @@ pub struct SanakirjaBenchReadTransaction<'db> { } impl<'db> BenchReadTransaction for SanakirjaBenchReadTransaction<'db> { - type T<'txn> = SanakirjaBenchReader<'db, 'txn> where Self: 'txn; + type T<'txn> + = SanakirjaBenchReader<'db, 'txn> + where + Self: 'txn; fn get_reader(&self) -> Self::T<'_> { let table = self.txn.root_db(0).unwrap(); @@ -780,8 +876,14 @@ pub struct SanakirjaBenchReader<'db, 'txn> { } impl<'db, 'txn> BenchReader for SanakirjaBenchReader<'db, 'txn> { - type Output<'out> = &'out [u8] where Self: 'out; - type Iterator<'out> = SanakirjaBenchIterator<'db, 'txn> where Self: 'out; + type Output<'out> + = &'out [u8] + where + Self: 'out; + type Iterator<'out> + = SanakirjaBenchIterator<'db, 'txn> + where + Self: 'out; fn get(&self, key: &[u8]) -> Option<&[u8]> { sanakirja::btree::get(self.txn, &self.table, key, None) @@ -813,8 +915,11 @@ pub struct SanakirjaBenchIterator<'db, 'txn> { >, } -impl<'db, 'txn> BenchIterator for SanakirjaBenchIterator<'db, 'txn> { - type Output<'out> = &'txn [u8] where Self: 'out; +impl<'txn> BenchIterator for SanakirjaBenchIterator<'_, 'txn> { + type Output<'out> + = &'txn [u8] + where + Self: 'out; fn next(&mut self) -> Option<(Self::Output<'_>, Self::Output<'_>)> { self.iter.next().map(|x| { @@ -835,7 +940,7 @@ impl<'a> FjallBenchDatabase<'a> { } } -impl<'a> BenchDatabase for FjallBenchDatabase<'a> { +impl BenchDatabase for FjallBenchDatabase<'_> { type W<'db> = FjallBenchWriteTransaction<'db> where @@ -892,7 +997,7 @@ pub struct FjallBenchReader<'a> { txn: &'a fjall::ReadTransaction, } -impl<'db> BenchReader for FjallBenchReader<'db> { +impl BenchReader for FjallBenchReader<'_> { type Output<'out> = fjall::Slice where diff --git a/benches/int_benchmark.rs b/benches/int_benchmark.rs index 4f0a9a2a..63ef746f 100644 --- a/benches/int_benchmark.rs +++ b/benches/int_benchmark.rs @@ -14,18 +14,18 @@ use std::time::{Duration, Instant}; const ELEMENTS: usize = 1_000_000; /// Returns pairs of key, value -fn gen_data(count: usize) -> Vec<(u32, u64)> { +fn random_data(count: usize) -> Vec<(u32, u64)> { let mut rng = StdRng::seed_from_u64(0); let mut pairs = vec![]; for _ in 0..count { - pairs.push(rng.gen()); + pairs.push(rng.random()); } pairs } fn benchmark(db: T) -> Vec<(&'static str, Duration)> { let mut results = Vec::new(); - let pairs = gen_data(1_000_000); + let pairs = random_data(1_000_000); let mut written = 0; let start = Instant::now(); diff --git a/benches/large_values_benchmark.rs b/benches/large_values_benchmark.rs index e697dbe1..6fc6ba98 100644 --- a/benches/large_values_benchmark.rs +++ b/benches/large_values_benchmark.rs @@ -12,12 +12,12 @@ use std::time::{Duration, Instant}; const ELEMENTS: usize = 1_000_000; /// Returns pairs of key, value -fn gen_data(count: usize, key_size: usize, value_size: usize) -> Vec<(Vec, Vec)> { +fn random_data(count: usize, key_size: usize, value_size: usize) -> Vec<(Vec, Vec)> { let mut pairs = vec![]; for _ in 0..count { - let key: Vec = (0..key_size).map(|_| rand::thread_rng().gen()).collect(); - let value: Vec = (0..value_size).map(|_| rand::thread_rng().gen()).collect(); + let key: Vec = (0..key_size).map(|_| rand::rng().random()).collect(); + let value: Vec = (0..value_size).map(|_| rand::rng().random()).collect(); pairs.push((key, value)); } @@ -26,10 +26,10 @@ fn gen_data(count: usize, key_size: usize, value_size: usize) -> Vec<(Vec, V fn benchmark(db: T) -> Vec<(&'static str, Duration)> { let mut results = Vec::new(); - let mut pairs = gen_data(1_000_000, 24, 150); + let mut pairs = random_data(1_000_000, 24, 150); let mut written = 0; - let mut bigpairs = gen_data(100, 24, 2_000_000); + let mut bigpairs = random_data(100, 24, 2_000_000); let bigelements = 4000; let start = Instant::now(); diff --git a/benches/lmdb_benchmark.rs b/benches/lmdb_benchmark.rs index 39753e54..dd114aeb 100644 --- a/benches/lmdb_benchmark.rs +++ b/benches/lmdb_benchmark.rs @@ -46,7 +46,7 @@ fn fill_slice(slice: &mut [u8], rng: &mut fastrand::Rng) { } /// Returns pairs of key, value -fn gen_pair(rng: &mut fastrand::Rng) -> ([u8; KEY_SIZE], Vec) { +fn random_pair(rng: &mut fastrand::Rng) -> ([u8; KEY_SIZE], Vec) { let mut key = [0u8; KEY_SIZE]; fill_slice(&mut key, rng); let mut value = vec![0u8; VALUE_SIZE]; @@ -65,7 +65,7 @@ fn make_rng_shards(shards: usize, elements: usize) -> Vec { for i in 0..shards { let mut rng = make_rng(); for _ in 0..(i * elements_per_shard) { - gen_pair(&mut rng); + random_pair(&mut rng); } rngs.push(rng); } @@ -83,7 +83,7 @@ fn benchmark(db: T, path: &Path) -> Vec<(String, let mut inserter = txn.get_inserter(); { for _ in 0..ELEMENTS { - let (key, value) = gen_pair(&mut rng); + let (key, value) = random_pair(&mut rng); inserter.insert(&key, &value).unwrap(); } } @@ -106,7 +106,7 @@ fn benchmark(db: T, path: &Path) -> Vec<(String, for _ in 0..writes { let mut txn = db.write_transaction(); let mut inserter = txn.get_inserter(); - let (key, value) = gen_pair(&mut rng); + let (key, value) = random_pair(&mut rng); inserter.insert(&key, &value).unwrap(); drop(inserter); txn.commit().unwrap(); @@ -133,7 +133,7 @@ fn benchmark(db: T, path: &Path) -> Vec<(String, let mut txn = db.write_transaction(); let mut inserter = txn.get_inserter(); for _ in 0..batch_size { - let (key, value) = gen_pair(&mut rng); + let (key, value) = random_pair(&mut rng); inserter.insert(&key, &value).unwrap(); } drop(inserter); @@ -171,7 +171,7 @@ fn benchmark(db: T, path: &Path) -> Vec<(String, let mut expected_checksum = 0u64; let reader = txn.get_reader(); for _ in 0..ELEMENTS { - let (key, value) = gen_pair(&mut rng); + let (key, value) = random_pair(&mut rng); let result = reader.get(&key).unwrap(); checksum += result.as_ref()[0] as u64; expected_checksum += value[0] as u64; @@ -195,7 +195,7 @@ fn benchmark(db: T, path: &Path) -> Vec<(String, let mut value_sum = 0; let num_scan = 10; for _ in 0..ELEMENTS { - let (key, _value) = gen_pair(&mut rng); + let (key, _value) = random_pair(&mut rng); let mut iter = reader.range_from(&key); for _ in 0..num_scan { if let Some((_, value)) = iter.next() { @@ -236,7 +236,7 @@ fn benchmark(db: T, path: &Path) -> Vec<(String, let mut expected_checksum = 0u64; let reader = txn.get_reader(); for _ in 0..(ELEMENTS / num_threads) { - let (key, value) = gen_pair(&mut rng); + let (key, value) = random_pair(&mut rng); let result = reader.get(&key).unwrap(); checksum += result.as_ref()[0] as u64; expected_checksum += value[0] as u64; @@ -268,7 +268,7 @@ fn benchmark(db: T, path: &Path) -> Vec<(String, let mut txn = db.write_transaction(); let mut inserter = txn.get_inserter(); for _ in 0..deletes { - let (key, _value) = gen_pair(&mut rng); + let (key, _value) = random_pair(&mut rng); inserter.remove(&key).unwrap(); } drop(inserter); @@ -302,7 +302,7 @@ fn benchmark(db: T, path: &Path) -> Vec<(String, { let mut txn = db.write_transaction(); let mut inserter = txn.get_inserter(); - let (key, value) = gen_pair(&mut rng); + let (key, value) = random_pair(&mut rng); inserter.insert(&key, &value).unwrap(); drop(inserter); txn.commit().unwrap(); diff --git a/benches/multithreaded_insert_benchmark.rs b/benches/multithreaded_insert_benchmark.rs index 2ad1e5ec..0ea10e19 100644 --- a/benches/multithreaded_insert_benchmark.rs +++ b/benches/multithreaded_insert_benchmark.rs @@ -88,7 +88,7 @@ fn main() { let mut rng = StdRng::seed_from_u64(RNG_SEED); let mut values = vec![]; for _ in 0..ELEMENTS { - values.push(rng.gen()); + values.push(rng.random()); } let tmpdir = current_dir().unwrap().join(".benchmark"); diff --git a/benches/savepoint_benchmark.rs b/benches/savepoint_benchmark.rs index 0c408bac..ef662436 100644 --- a/benches/savepoint_benchmark.rs +++ b/benches/savepoint_benchmark.rs @@ -19,12 +19,12 @@ struct Timing { } /// Returns pairs of key, value -fn gen_data(count: usize, key_size: usize, value_size: usize) -> Vec<(Vec, Vec)> { +fn random_data(count: usize, key_size: usize, value_size: usize) -> Vec<(Vec, Vec)> { let mut pairs = vec![]; for _ in 0..count { - let key: Vec = (0..key_size).map(|_| rand::thread_rng().gen()).collect(); - let value: Vec = (0..value_size).map(|_| rand::thread_rng().gen()).collect(); + let key: Vec = (0..key_size).map(|_| rand::rng().random()).collect(); + let value: Vec = (0..value_size).map(|_| rand::rng().random()).collect(); pairs.push((key, value)); } @@ -32,7 +32,7 @@ fn gen_data(count: usize, key_size: usize, value_size: usize) -> Vec<(Vec, V } fn benchmark(db: &Database, insertions: usize) -> Timing { - let mut pairs = gen_data(insertions, 24, VALUE_SIZE); + let mut pairs = random_data(insertions, 24, VALUE_SIZE); let mut written = 0; let mut total_savepoint_creation = Duration::from_micros(0); diff --git a/benches/syscall_benchmark.rs b/benches/syscall_benchmark.rs index ae06837d..832ced72 100644 --- a/benches/syscall_benchmark.rs +++ b/benches/syscall_benchmark.rs @@ -1,7 +1,7 @@ use tempfile::{NamedTempFile, TempDir}; -use rand::prelude::SliceRandom; use rand::Rng; +use rand::prelude::SliceRandom; use std::env::current_dir; use std::fs::OpenOptions; use std::io::{IoSlice, Read, Seek, SeekFrom, Write}; @@ -42,12 +42,12 @@ fn print_load_time(name: &'static str, duration: Duration) { } /// Returns pairs of key, value -fn gen_data(count: usize, key_size: usize, value_size: usize) -> Vec<(Vec, Vec)> { +fn random_data(count: usize, key_size: usize, value_size: usize) -> Vec<(Vec, Vec)> { let mut pairs = vec![]; for _ in 0..count { - let key: Vec = (0..key_size).map(|_| rand::thread_rng().gen()).collect(); - let value: Vec = (0..value_size).map(|_| rand::thread_rng().gen()).collect(); + let key: Vec = (0..key_size).map(|_| rand::rng().random()).collect(); + let value: Vec = (0..value_size).map(|_| rand::rng().random()).collect(); pairs.push((key, value)); } @@ -62,7 +62,7 @@ fn lmdb_bench(path: &Path) { .unwrap() }; - let mut pairs = gen_data(1000, KEY_SIZE, VALUE_SIZE); + let mut pairs = random_data(1000, KEY_SIZE, VALUE_SIZE); let pairs_len = pairs.len(); let db: heed::Database = env @@ -86,7 +86,7 @@ fn lmdb_bench(path: &Path) { print_load_time("lmdb-zero", duration); let mut key_order: Vec = (0..ELEMENTS).collect(); - key_order.shuffle(&mut rand::thread_rng()); + key_order.shuffle(&mut rand::rng()); let txn = env.read_txn().unwrap(); { @@ -124,7 +124,7 @@ fn uring_bench(path: &Path) { .open(path) .unwrap(); - let mut pairs = gen_data(1000, KEY_SIZE, VALUE_SIZE); + let mut pairs = random_data(1000, KEY_SIZE, VALUE_SIZE); let pairs_len = pairs.len(); let start = SystemTime::now(); @@ -147,7 +147,7 @@ fn uring_bench(path: &Path) { print_load_time("uring_read()/write()", duration); let mut key_order: Vec = (0..ELEMENTS).collect(); - key_order.shuffle(&mut rand::thread_rng()); + key_order.shuffle(&mut rand::rng()); { for _ in 0..ITERATIONS { @@ -212,7 +212,7 @@ fn readwrite_bench(path: &Path) { .open(path) .unwrap(); - let mut pairs = gen_data(1000, KEY_SIZE, VALUE_SIZE); + let mut pairs = random_data(1000, KEY_SIZE, VALUE_SIZE); let pairs_len = pairs.len(); let start = SystemTime::now(); @@ -235,7 +235,7 @@ fn readwrite_bench(path: &Path) { print_load_time("read()/write()", duration); let mut key_order: Vec = (0..ELEMENTS).collect(); - key_order.shuffle(&mut rand::thread_rng()); + key_order.shuffle(&mut rand::rng()); { for _ in 0..ITERATIONS { @@ -291,7 +291,7 @@ fn mmap_bench(path: &Path) { assert_ne!(mmap_raw, libc::MAP_FAILED); let mmap = unsafe { slice::from_raw_parts_mut(mmap_raw as *mut u8, len as usize) }; - let mut pairs = gen_data(1000, KEY_SIZE, VALUE_SIZE); + let mut pairs = random_data(1000, KEY_SIZE, VALUE_SIZE); let pairs_len = pairs.len(); let mut write_index = 0; @@ -314,7 +314,7 @@ fn mmap_bench(path: &Path) { print_load_time("mmap()", duration); let mut key_order: Vec = (0..ELEMENTS).collect(); - key_order.shuffle(&mut rand::thread_rng()); + key_order.shuffle(&mut rand::rng()); { for _ in 0..ITERATIONS { @@ -358,7 +358,7 @@ fn mmap_anon_bench() { assert_ne!(mmap_raw, libc::MAP_FAILED); let mmap = unsafe { slice::from_raw_parts_mut(mmap_raw as *mut u8, len) }; - let mut pairs = gen_data(1000, KEY_SIZE, VALUE_SIZE); + let mut pairs = random_data(1000, KEY_SIZE, VALUE_SIZE); let pairs_len = pairs.len(); let mut write_index = 0; @@ -379,7 +379,7 @@ fn mmap_anon_bench() { print_load_time("mmap(ANON)", duration); let mut key_order: Vec = (0..ELEMENTS).collect(); - key_order.shuffle(&mut rand::thread_rng()); + key_order.shuffle(&mut rand::rng()); { for _ in 0..ITERATIONS { @@ -411,7 +411,7 @@ fn vec_bench() { let mut mmap = vec![0; len]; - let mut pairs = gen_data(1000, KEY_SIZE, VALUE_SIZE); + let mut pairs = random_data(1000, KEY_SIZE, VALUE_SIZE); let pairs_len = pairs.len(); let mut write_index = 0; @@ -432,7 +432,7 @@ fn vec_bench() { print_load_time("vec[]", duration); let mut key_order: Vec = (0..ELEMENTS).collect(); - key_order.shuffle(&mut rand::thread_rng()); + key_order.shuffle(&mut rand::rng()); { for _ in 0..ITERATIONS { diff --git a/benches/userspace_cache_benchmark.rs b/benches/userspace_cache_benchmark.rs index a1335586..fb96bcb5 100644 --- a/benches/userspace_cache_benchmark.rs +++ b/benches/userspace_cache_benchmark.rs @@ -5,8 +5,8 @@ use tempfile::NamedTempFile; #[cfg(target_os = "linux")] mod unix { - use rand::prelude::SliceRandom; use rand::Rng; + use rand::prelude::SliceRandom; use std::collections::BTreeMap; use std::fs::{File, OpenOptions}; use std::io::{IoSlice, Seek, SeekFrom, Write}; @@ -52,18 +52,18 @@ mod unix { ); } - fn gen_data(count: usize, value_size: usize) -> Vec> { + fn random_data(count: usize, value_size: usize) -> Vec> { let mut values = vec![]; for _ in 0..count { - let value: Vec = (0..value_size).map(|_| rand::thread_rng().gen()).collect(); + let value: Vec = (0..value_size).map(|_| rand::rng().random()).collect(); values.push(value); } values } - fn gen_entry_indices() -> Vec { + fn random_entry_indices() -> Vec { let mut page_numbers: Vec = (0..ELEMENTS_SPACE).collect(); - page_numbers.shuffle(&mut rand::thread_rng()); + page_numbers.shuffle(&mut rand::rng()); page_numbers.drain(ELEMENTS..); page_numbers } @@ -74,21 +74,22 @@ mod unix { data: Vec, } - impl<'a> WritablePage<'a> { + impl WritablePage<'_> { fn mut_data(&mut self) -> &mut [u8] { &mut self.data } } - impl<'a> Drop for WritablePage<'a> { + impl Drop for WritablePage<'_> { fn drop(&mut self) { let data = mem::take(&mut self.data); - assert!(self - .buffer - .lock() - .unwrap() - .insert(self.page, Arc::new(data)) - .is_none()); + assert!( + self.buffer + .lock() + .unwrap() + .insert(self.page, Arc::new(data)) + .is_none() + ); } } @@ -374,10 +375,10 @@ mod unix { let result = unsafe { libc::madvise(mmap_raw, len as libc::size_t, libc::MADV_RANDOM) }; assert_eq!(result, 0); - let pairs = Arc::new(gen_data(1000, VALUE_SIZE)); + let pairs = Arc::new(random_data(1000, VALUE_SIZE)); let pairs_len = pairs.len(); - let entry_indices = gen_entry_indices(); + let entry_indices = random_entry_indices(); let mut chunks: Vec> = vec![]; for chunk in entry_indices.chunks_exact(ELEMENTS / threads) { chunks.push(chunk.to_vec()); @@ -549,10 +550,10 @@ mod unix { // We assume two values fit into a single page assert_eq!(VALUE_SIZE, PagedCachedFile::page_size()); - let pairs = Arc::new(gen_data(1000, VALUE_SIZE)); + let pairs = Arc::new(random_data(1000, VALUE_SIZE)); let pairs_len = pairs.len(); - let entry_indices = gen_entry_indices(); + let entry_indices = random_entry_indices(); let mut chunks: Vec> = vec![]; for chunk in entry_indices.chunks_exact(ELEMENTS / threads) { chunks.push(chunk.to_vec()); diff --git a/examples/bincode_keys.rs b/examples/bincode_keys.rs index 8f4b5c52..2d8a090b 100644 --- a/examples/bincode_keys.rs +++ b/examples/bincode_keys.rs @@ -4,7 +4,7 @@ use std::fmt::Debug; use bincode::{deserialize, serialize}; use redb::{Database, Error, Key, Range, TableDefinition, TypeName, Value}; -use serde::{de::DeserializeOwned, Deserialize, Serialize}; +use serde::{Deserialize, Serialize, de::DeserializeOwned}; #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)] struct SomeKey { @@ -66,11 +66,13 @@ impl Value for Bincode where T: Debug + Serialize + for<'a> Deserialize<'a>, { - type SelfType<'a> = T + type SelfType<'a> + = T where Self: 'a; - type AsBytes<'a> = Vec + type AsBytes<'a> + = Vec where Self: 'a; diff --git a/examples/special_values.rs b/examples/special_values.rs index b4191339..068f63bf 100644 --- a/examples/special_values.rs +++ b/examples/special_values.rs @@ -40,7 +40,7 @@ struct SpecialValuesTransaction<'db> { file: &'db mut File, } -impl<'db> SpecialValuesTransaction<'db> { +impl SpecialValuesTransaction<'_> { fn open_table( &mut self, table: TableDefinition, @@ -65,7 +65,7 @@ struct SpecialValuesTable<'txn, K: Key + 'static, V: Value + 'static> { _value_type: PhantomData, } -impl<'txn, K: Key + 'static, V: Value + 'static> SpecialValuesTable<'txn, K, V> { +impl SpecialValuesTable<'_, K, V> { fn insert(&mut self, key: K::SelfType<'_>, value: V::SelfType<'_>) { // Append to end of file let offset = self.file.seek(SeekFrom::End(0)).unwrap(); diff --git a/rust-toolchain b/rust-toolchain index ea3769f2..c4f7465a 100644 --- a/rust-toolchain +++ b/rust-toolchain @@ -1 +1 @@ -1.81 +1.85 diff --git a/src/backends.rs b/src/backends.rs index bdbf2e57..d6b6a289 100644 --- a/src/backends.rs +++ b/src/backends.rs @@ -1,2 +1,2 @@ -pub use crate::tree_store::file_backend::FileBackend; pub use crate::tree_store::InMemoryBackend; +pub use crate::tree_store::file_backend::FileBackend; diff --git a/src/complex_types.rs b/src/complex_types.rs index 836c1f2e..74fe9cbe 100644 --- a/src/complex_types.rs +++ b/src/complex_types.rs @@ -32,10 +32,12 @@ fn decode_varint_len(data: &[u8]) -> (usize, usize) { } impl Value for Vec { - type SelfType<'a> = Vec> + type SelfType<'a> + = Vec> where Self: 'a; - type AsBytes<'a> = Vec + type AsBytes<'a> + = Vec where Self: 'a; diff --git a/src/db.rs b/src/db.rs index ed1a2ebd..03f9261a 100644 --- a/src/db.rs +++ b/src/db.rs @@ -1,8 +1,8 @@ use crate::transaction_tracker::{SavepointId, TransactionId, TransactionTracker}; use crate::tree_store::{ AllPageNumbersBtreeIter, BtreeHeader, BtreeRangeIter, FreedPageList, FreedTableKey, - InternalTableDefinition, PageHint, PageNumber, RawBtree, SerializedSavepoint, TableTreeMut, - TableType, TransactionalMemory, PAGE_SIZE, + InternalTableDefinition, PAGE_SIZE, PageHint, PageNumber, RawBtree, SerializedSavepoint, + TableTreeMut, TableType, TransactionalMemory, }; use crate::types::{Key, Value}; use crate::{CompactionError, DatabaseError, Error, ReadOnlyTable, SavepointError, StorageError}; @@ -19,7 +19,7 @@ use std::{io, thread}; use crate::error::TransactionError; use crate::sealed::Sealed; use crate::transactions::{ - AllocatorStateKey, AllocatorStateTree, ALLOCATOR_STATE_TABLE_NAME, SAVEPOINT_TABLE, + ALLOCATOR_STATE_TABLE_NAME, AllocatorStateKey, AllocatorStateTree, SAVEPOINT_TABLE, }; use crate::tree_store::file_backend::FileBackend; #[cfg(feature = "logging")] @@ -128,7 +128,7 @@ impl<'a, K: Key + 'static, V: Value + 'static> TableDefinition<'a, K, V> { } } -impl<'a, K: Key + 'static, V: Value + 'static> TableHandle for TableDefinition<'a, K, V> { +impl TableHandle for TableDefinition<'_, K, V> { fn name(&self) -> &str { self.name } @@ -136,15 +136,15 @@ impl<'a, K: Key + 'static, V: Value + 'static> TableHandle for TableDefinition<' impl Sealed for TableDefinition<'_, K, V> {} -impl<'a, K: Key + 'static, V: Value + 'static> Clone for TableDefinition<'a, K, V> { +impl Clone for TableDefinition<'_, K, V> { fn clone(&self) -> Self { *self } } -impl<'a, K: Key + 'static, V: Value + 'static> Copy for TableDefinition<'a, K, V> {} +impl Copy for TableDefinition<'_, K, V> {} -impl<'a, K: Key + 'static, V: Value + 'static> Display for TableDefinition<'a, K, V> { +impl Display for TableDefinition<'_, K, V> { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!( f, @@ -181,9 +181,7 @@ impl<'a, K: Key + 'static, V: Key + 'static> MultimapTableDefinition<'a, K, V> { } } -impl<'a, K: Key + 'static, V: Key + 'static> MultimapTableHandle - for MultimapTableDefinition<'a, K, V> -{ +impl MultimapTableHandle for MultimapTableDefinition<'_, K, V> { fn name(&self) -> &str { self.name } @@ -191,15 +189,15 @@ impl<'a, K: Key + 'static, V: Key + 'static> MultimapTableHandle impl Sealed for MultimapTableDefinition<'_, K, V> {} -impl<'a, K: Key + 'static, V: Key + 'static> Clone for MultimapTableDefinition<'a, K, V> { +impl Clone for MultimapTableDefinition<'_, K, V> { fn clone(&self) -> Self { *self } } -impl<'a, K: Key + 'static, V: Key + 'static> Copy for MultimapTableDefinition<'a, K, V> {} +impl Copy for MultimapTableDefinition<'_, K, V> {} -impl<'a, K: Key + 'static, V: Key + 'static> Display for MultimapTableDefinition<'a, K, V> { +impl Display for MultimapTableDefinition<'_, K, V> { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!( f, @@ -1105,8 +1103,8 @@ mod test { }; use std::fs::File; use std::io::{ErrorKind, Read, Seek, SeekFrom}; - use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::Arc; + use std::sync::atomic::{AtomicU64, Ordering}; #[derive(Debug)] struct FailingBackend { @@ -1134,11 +1132,7 @@ mod test { if self .countdown .fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| { - if x > 0 { - Some(x - 1) - } else { - None - } + if x > 0 { Some(x - 1) } else { None } }) .is_err() { diff --git a/src/error.rs b/src/error.rs index bf0b3c74..fbfeef6d 100644 --- a/src/error.rs +++ b/src/error.rs @@ -237,7 +237,10 @@ impl Display for DatabaseError { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { match self { DatabaseError::UpgradeRequired(actual) => { - write!(f, "Manual upgrade required. Expected file format version {FILE_FORMAT_VERSION2}, but file is version {actual}") + write!( + f, + "Manual upgrade required. Expected file format version {FILE_FORMAT_VERSION2}, but file is version {actual}" + ) } DatabaseError::RepairAborted => { write!(f, "Database repair aborted.") @@ -515,7 +518,10 @@ impl Display for Error { write!(f, "DB corrupted: {msg}") } Error::UpgradeRequired(actual) => { - write!(f, "Manual upgrade required. Expected file format version {FILE_FORMAT_VERSION2}, but file is version {actual}") + write!( + f, + "Manual upgrade required. Expected file format version {FILE_FORMAT_VERSION2}, but file is version {actual}" + ) } Error::ValueTooLarge(len) => { write!( diff --git a/src/multimap_table.rs b/src/multimap_table.rs index ac42a7cc..19f42aef 100644 --- a/src/multimap_table.rs +++ b/src/multimap_table.rs @@ -3,10 +3,10 @@ use crate::multimap_table::DynamicCollectionType::{Inline, SubtreeV2}; use crate::sealed::Sealed; use crate::table::{ReadableTableMetadata, TableStats}; use crate::tree_store::{ - btree_stats, AllPageNumbersBtreeIter, BranchAccessor, BranchMutator, Btree, BtreeHeader, - BtreeMut, BtreeRangeIter, BtreeStats, Checksum, LeafAccessor, LeafMutator, Page, PageHint, - PageNumber, PagePath, RawBtree, RawLeafBuilder, TransactionalMemory, UntypedBtree, - UntypedBtreeMut, BRANCH, DEFERRED, LEAF, MAX_PAIR_LENGTH, MAX_VALUE_LENGTH, + AllPageNumbersBtreeIter, BRANCH, BranchAccessor, BranchMutator, Btree, BtreeHeader, BtreeMut, + BtreeRangeIter, BtreeStats, Checksum, DEFERRED, LEAF, LeafAccessor, LeafMutator, + MAX_PAIR_LENGTH, MAX_VALUE_LENGTH, Page, PageHint, PageNumber, PagePath, RawBtree, + RawLeafBuilder, TransactionalMemory, UntypedBtree, UntypedBtreeMut, btree_stats, }; use crate::types::{Key, TypeName, Value}; use crate::{AccessGuard, MultimapTableHandle, Result, StorageError, WriteTransaction}; @@ -542,10 +542,12 @@ impl std::fmt::Debug for DynamicCollection { } impl Value for &DynamicCollection { - type SelfType<'a> = &'a DynamicCollection + type SelfType<'a> + = &'a DynamicCollection where Self: 'a; - type AsBytes<'a> = &'a [u8] + type AsBytes<'a> + = &'a [u8] where Self: 'a; @@ -814,36 +816,36 @@ impl<'a, V: Key + 'static> Iterator for MultimapValue<'a, V> { fn next(&mut self) -> Option { // TODO: optimize out this copy let bytes = match self.inner.as_mut().unwrap() { - ValueIterState::Subtree(ref mut iter) => match iter.next()? { + ValueIterState::Subtree(iter) => match iter.next()? { Ok(e) => e.key_data(), Err(err) => { return Some(Err(err)); } }, - ValueIterState::InlineLeaf(ref mut iter) => iter.next_key()?.to_vec(), + ValueIterState::InlineLeaf(iter) => iter.next_key()?.to_vec(), }; self.remaining -= 1; Some(Ok(AccessGuard::with_owned_value(bytes))) } } -impl<'a, V: Key + 'static> DoubleEndedIterator for MultimapValue<'a, V> { +impl DoubleEndedIterator for MultimapValue<'_, V> { fn next_back(&mut self) -> Option { // TODO: optimize out this copy let bytes = match self.inner.as_mut().unwrap() { - ValueIterState::Subtree(ref mut iter) => match iter.next_back()? { + ValueIterState::Subtree(iter) => match iter.next_back()? { Ok(e) => e.key_data(), Err(err) => { return Some(Err(err)); } }, - ValueIterState::InlineLeaf(ref mut iter) => iter.next_key_back()?.to_vec(), + ValueIterState::InlineLeaf(iter) => iter.next_key_back()?.to_vec(), }; Some(Ok(AccessGuard::with_owned_value(bytes))) } } -impl<'a, V: Key + 'static> Drop for MultimapValue<'a, V> { +impl Drop for MultimapValue<'_, V> { fn drop(&mut self) { // Drop our references to the pages that are about to be freed drop(mem::take(&mut self.inner)); @@ -867,7 +869,7 @@ pub struct MultimapRange<'a, K: Key + 'static, V: Key + 'static> { _lifetime: PhantomData<&'a ()>, } -impl<'a, K: Key + 'static, V: Key + 'static> MultimapRange<'a, K, V> { +impl MultimapRange<'_, K, V> { fn new( inner: BtreeRangeIter>, guard: Arc, @@ -907,7 +909,7 @@ impl<'a, K: Key + 'static, V: Key + 'static> Iterator for MultimapRange<'a, K, V } } -impl<'a, K: Key + 'static, V: Key + 'static> DoubleEndedIterator for MultimapRange<'a, K, V> { +impl DoubleEndedIterator for MultimapRange<'_, K, V> { fn next_back(&mut self) -> Option { match self.inner.next_back()? { Ok(entry) => { @@ -1318,7 +1320,7 @@ impl<'txn, K: Key + 'static, V: Key + 'static> MultimapTable<'txn, K, V> { } } -impl<'txn, K: Key + 'static, V: Key + 'static> ReadableTableMetadata for MultimapTable<'txn, K, V> { +impl ReadableTableMetadata for MultimapTable<'_, K, V> { fn stats(&self) -> Result { let tree_stats = multimap_btree_stats( self.tree.get_root().map(|x| x.root), @@ -1343,9 +1345,7 @@ impl<'txn, K: Key + 'static, V: Key + 'static> ReadableTableMetadata for Multima } } -impl<'txn, K: Key + 'static, V: Key + 'static> ReadableMultimapTable - for MultimapTable<'txn, K, V> -{ +impl ReadableMultimapTable for MultimapTable<'_, K, V> { /// Returns an iterator over all values for the given key. Values are in ascending order. fn get<'a>(&self, key: impl Borrow>) -> Result> { let guard = self.transaction.transaction_guard(); @@ -1378,7 +1378,7 @@ impl<'txn, K: Key + 'static, V: Key + 'static> ReadableMultimapTable impl Sealed for MultimapTable<'_, K, V> {} -impl<'txn, K: Key + 'static, V: Key + 'static> Drop for MultimapTable<'txn, K, V> { +impl Drop for MultimapTable<'_, K, V> { fn drop(&mut self) { self.transaction .close_table(&self.name, &self.tree, self.num_values); diff --git a/src/table.rs b/src/table.rs index 428df95b..9de6ae77 100644 --- a/src/table.rs +++ b/src/table.rs @@ -1,8 +1,8 @@ use crate::db::TransactionGuard; use crate::sealed::Sealed; use crate::tree_store::{ - AccessGuardMut, Btree, BtreeExtractIf, BtreeHeader, BtreeMut, BtreeRangeIter, PageHint, - PageNumber, RawBtree, TransactionalMemory, MAX_PAIR_LENGTH, MAX_VALUE_LENGTH, + AccessGuardMut, Btree, BtreeExtractIf, BtreeHeader, BtreeMut, BtreeRangeIter, MAX_PAIR_LENGTH, + MAX_VALUE_LENGTH, PageHint, PageNumber, RawBtree, TransactionalMemory, }; use crate::types::{Key, MutInPlaceValue, Value}; use crate::{AccessGuard, StorageError, WriteTransaction}; @@ -218,7 +218,7 @@ impl<'txn, K: Key + 'static, V: Value + 'static> Table<'txn, K, V> { } } -impl<'txn, K: Key + 'static, V: MutInPlaceValue + 'static> Table<'txn, K, V> { +impl Table<'_, K, V> { /// Reserve space to insert a key-value pair /// /// If key is already present it is replaced @@ -243,7 +243,7 @@ impl<'txn, K: Key + 'static, V: MutInPlaceValue + 'static> Table<'txn, K, V> { } } -impl<'txn, K: Key + 'static, V: Value + 'static> ReadableTableMetadata for Table<'txn, K, V> { +impl ReadableTableMetadata for Table<'_, K, V> { fn stats(&self) -> Result { let tree_stats = self.tree.stats()?; @@ -262,7 +262,7 @@ impl<'txn, K: Key + 'static, V: Value + 'static> ReadableTableMetadata for Table } } -impl<'txn, K: Key + 'static, V: Value + 'static> ReadableTable for Table<'txn, K, V> { +impl ReadableTable for Table<'_, K, V> { fn get<'a>(&self, key: impl Borrow>) -> Result>> { self.tree.get(key.borrow()) } @@ -287,7 +287,7 @@ impl<'txn, K: Key + 'static, V: Value + 'static> ReadableTable for Table<' impl Sealed for Table<'_, K, V> {} -impl<'txn, K: Key + 'static, V: Value + 'static> Drop for Table<'txn, K, V> { +impl Drop for Table<'_, K, V> { fn drop(&mut self) { self.transaction.close_table( &self.name, @@ -558,11 +558,11 @@ pub struct ExtractIf< } impl< - 'a, - K: Key + 'static, - V: Value + 'static, - F: for<'f> FnMut(K::SelfType<'f>, V::SelfType<'f>) -> bool, - > ExtractIf<'a, K, V, F> + 'a, + K: Key + 'static, + V: Value + 'static, + F: for<'f> FnMut(K::SelfType<'f>, V::SelfType<'f>) -> bool, +> ExtractIf<'a, K, V, F> { fn new(inner: BtreeExtractIf<'a, K, V, F>) -> Self { Self { inner } @@ -570,11 +570,11 @@ impl< } impl< - 'a, - K: Key + 'static, - V: Value + 'static, - F: for<'f> FnMut(K::SelfType<'f>, V::SelfType<'f>) -> bool, - > Iterator for ExtractIf<'a, K, V, F> + 'a, + K: Key + 'static, + V: Value + 'static, + F: for<'f> FnMut(K::SelfType<'f>, V::SelfType<'f>) -> bool, +> Iterator for ExtractIf<'a, K, V, F> { type Item = Result<(AccessGuard<'a, K>, AccessGuard<'a, V>)>; @@ -590,11 +590,10 @@ impl< } impl< - 'a, - K: Key + 'static, - V: Value + 'static, - F: for<'f> FnMut(K::SelfType<'f>, V::SelfType<'f>) -> bool, - > DoubleEndedIterator for ExtractIf<'a, K, V, F> + K: Key + 'static, + V: Value + 'static, + F: for<'f> FnMut(K::SelfType<'f>, V::SelfType<'f>) -> bool, +> DoubleEndedIterator for ExtractIf<'_, K, V, F> { fn next_back(&mut self) -> Option { let entry = self.inner.next_back()?; @@ -615,7 +614,7 @@ pub struct Range<'a, K: Key + 'static, V: Value + 'static> { _lifetime: PhantomData<&'a ()>, } -impl<'a, K: Key + 'static, V: Value + 'static> Range<'a, K, V> { +impl Range<'_, K, V> { pub(super) fn new(inner: BtreeRangeIter, guard: Arc) -> Self { Self { inner, @@ -640,7 +639,7 @@ impl<'a, K: Key + 'static, V: Value + 'static> Iterator for Range<'a, K, V> { } } -impl<'a, K: Key + 'static, V: Value + 'static> DoubleEndedIterator for Range<'a, K, V> { +impl DoubleEndedIterator for Range<'_, K, V> { fn next_back(&mut self) -> Option { self.inner.next_back().map(|x| { x.map(|entry| { diff --git a/src/transactions.rs b/src/transactions.rs index e0b098ad..2b62b153 100644 --- a/src/transactions.rs +++ b/src/transactions.rs @@ -6,8 +6,8 @@ use crate::table::ReadOnlyUntypedTable; use crate::transaction_tracker::{SavepointId, TransactionId, TransactionTracker}; use crate::tree_store::{ Btree, BtreeHeader, BtreeMut, BuddyAllocator, FreedPageList, FreedTableKey, - InternalTableDefinition, Page, PageHint, PageNumber, SerializedSavepoint, TableTree, - TableTreeMut, TableType, TransactionalMemory, MAX_PAIR_LENGTH, MAX_VALUE_LENGTH, + InternalTableDefinition, MAX_PAIR_LENGTH, MAX_VALUE_LENGTH, Page, PageHint, PageNumber, + SerializedSavepoint, TableTree, TableTreeMut, TableType, TransactionalMemory, }; use crate::types::{Key, Value}; use crate::{ @@ -117,7 +117,7 @@ impl<'a, K: Key + 'static, V: Value + 'static> SystemTableDefinition<'a, K, V> { } } -impl<'a, K: Key + 'static, V: Value + 'static> TableHandle for SystemTableDefinition<'a, K, V> { +impl TableHandle for SystemTableDefinition<'_, K, V> { fn name(&self) -> &str { self.name } @@ -125,15 +125,15 @@ impl<'a, K: Key + 'static, V: Value + 'static> TableHandle for SystemTableDefini impl Sealed for SystemTableDefinition<'_, K, V> {} -impl<'a, K: Key + 'static, V: Value + 'static> Clone for SystemTableDefinition<'a, K, V> { +impl Clone for SystemTableDefinition<'_, K, V> { fn clone(&self) -> Self { *self } } -impl<'a, K: Key + 'static, V: Value + 'static> Copy for SystemTableDefinition<'a, K, V> {} +impl Copy for SystemTableDefinition<'_, K, V> {} -impl<'a, K: Key + 'static, V: Value + 'static> Display for SystemTableDefinition<'a, K, V> { +impl Display for SystemTableDefinition<'_, K, V> { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { write!( f, @@ -303,7 +303,7 @@ impl<'db, 's, K: Key + 'static, V: Value + 'static> SystemTable<'db, 's, K, V> { } } -impl<'db, 's, K: Key + 'static, V: Value + 'static> Drop for SystemTable<'db, 's, K, V> { +impl Drop for SystemTable<'_, '_, K, V> { fn drop(&mut self) { self.namespace.close_table( &self.name, @@ -360,7 +360,7 @@ struct TableNamespace<'db> { table_tree: TableTreeMut<'db>, } -impl<'db> TableNamespace<'db> { +impl TableNamespace<'_> { #[track_caller] fn inner_open( &mut self, @@ -1016,8 +1016,10 @@ impl WriteTransaction { let pages: FreedPageList = item.value(); for i in 0..pages.len() { let page = pages.get(i); - assert!(old_allocators[page.region as usize] - .is_allocated(page.page_index, page.page_order)); + assert!( + old_allocators[page.region as usize] + .is_allocated(page.page_index, page.page_order) + ); old_allocators[page.region as usize].free(page.page_index, page.page_order); } } diff --git a/src/tree_store/btree.rs b/src/tree_store/btree.rs index 05c1d7f6..f69fcb45 100644 --- a/src/tree_store/btree.rs +++ b/src/tree_store/btree.rs @@ -1,7 +1,7 @@ use crate::db::TransactionGuard; use crate::tree_store::btree_base::{ - branch_checksum, leaf_checksum, BranchAccessor, BranchMutator, BtreeHeader, Checksum, - LeafAccessor, BRANCH, DEFERRED, LEAF, + BRANCH, BranchAccessor, BranchMutator, BtreeHeader, Checksum, DEFERRED, LEAF, LeafAccessor, + branch_checksum, leaf_checksum, }; use crate::tree_store::btree_iters::BtreeExtractIf; use crate::tree_store::btree_mutator::MutateHelper; @@ -578,9 +578,7 @@ impl<'a, K: Key + 'a, V: MutInPlaceValue + 'a> BtreeMut<'a, K, V> { #[cfg(feature = "logging")] trace!( "Btree(root={:?}): Inserting {:?} with {} reserved bytes for the value", - &self.root, - key, - value_length + &self.root, key, value_length ); let mut freed_pages = self.freed_pages.lock().unwrap(); let mut value = vec![0u8; value_length as usize]; diff --git a/src/tree_store/btree_base.rs b/src/tree_store/btree_base.rs index 8bcca720..f6b50598 100644 --- a/src/tree_store/btree_base.rs +++ b/src/tree_store/btree_base.rs @@ -1,5 +1,5 @@ -use crate::tree_store::page_store::{xxh3_checksum, Page, PageImpl, PageMut, TransactionalMemory}; use crate::tree_store::PageNumber; +use crate::tree_store::page_store::{Page, PageImpl, PageMut, TransactionalMemory, xxh3_checksum}; use crate::types::{Key, MutInPlaceValue, Value}; use crate::{Result, StorageError}; use std::cmp::Ordering; @@ -169,7 +169,7 @@ pub struct AccessGuard<'a, V: Value + 'static> { _lifetime: PhantomData<&'a ()>, } -impl<'a, V: Value + 'static> AccessGuard<'a, V> { +impl AccessGuard<'_, V> { pub(crate) fn with_page(page: PageImpl, range: Range) -> Self { Self { page: EitherPage::Immutable(page), @@ -229,7 +229,7 @@ impl<'a, V: Value + 'static> AccessGuard<'a, V> { } } -impl<'a, V: Value + 'static> Drop for AccessGuard<'a, V> { +impl Drop for AccessGuard<'_, V> { fn drop(&mut self) { match self.on_drop { OnDrop::None => {} @@ -257,7 +257,7 @@ pub struct AccessGuardMut<'a, V: Value + 'static> { _lifetime: PhantomData<&'a ()>, } -impl<'a, V: Value + 'static> AccessGuardMut<'a, V> { +impl AccessGuardMut<'_, V> { pub(crate) fn new(page: PageMut, offset: usize, len: usize) -> Self { AccessGuardMut { page, @@ -269,7 +269,7 @@ impl<'a, V: Value + 'static> AccessGuardMut<'a, V> { } } -impl<'a, V: MutInPlaceValue + 'static> AsMut for AccessGuardMut<'a, V> { +impl AsMut for AccessGuardMut<'_, V> { fn as_mut(&mut self) -> &mut V::BaseRefType { V::from_bytes_mut(&mut self.page.memory_mut()[self.offset..(self.offset + self.len)]) } @@ -358,11 +358,7 @@ impl<'a> LeafAccessor<'a> { pub(crate) fn find_key(&self, query: &[u8]) -> Option { let (entry, found) = self.position::(query); - if found { - Some(entry) - } else { - None - } + if found { Some(entry) } else { None } } fn key_section_start(&self) -> usize { @@ -795,7 +791,7 @@ impl<'a> RawLeafBuilder<'a> { } } -impl<'a> Drop for RawLeafBuilder<'a> { +impl Drop for RawLeafBuilder<'_> { fn drop(&mut self) { if !thread::panicking() { assert_eq!(self.pairs_written, self.num_pairs); @@ -1544,7 +1540,7 @@ impl<'b> RawBranchBuilder<'b> { } } -impl<'b> Drop for RawBranchBuilder<'b> { +impl Drop for RawBranchBuilder<'_> { fn drop(&mut self) { if !thread::panicking() { assert_eq!(self.keys_written, self.num_keys); diff --git a/src/tree_store/btree_iters.rs b/src/tree_store/btree_iters.rs index 788c8564..af766644 100644 --- a/src/tree_store/btree_iters.rs +++ b/src/tree_store/btree_iters.rs @@ -1,11 +1,11 @@ -use crate::tree_store::btree_base::{BranchAccessor, LeafAccessor}; +use crate::Result; use crate::tree_store::btree_base::{BRANCH, LEAF}; +use crate::tree_store::btree_base::{BranchAccessor, LeafAccessor}; use crate::tree_store::btree_iters::RangeIterState::{Internal, Leaf}; use crate::tree_store::btree_mutator::MutateHelper; use crate::tree_store::page_store::{Page, PageImpl, TransactionalMemory}; use crate::tree_store::{BtreeHeader, PageNumber}; use crate::types::{Key, Value}; -use crate::Result; use std::borrow::Borrow; use std::collections::Bound; use std::marker::PhantomData; diff --git a/src/tree_store/btree_mutator.rs b/src/tree_store/btree_mutator.rs index 3d1790cd..9a27c722 100644 --- a/src/tree_store/btree_mutator.rs +++ b/src/tree_store/btree_mutator.rs @@ -1,6 +1,6 @@ use crate::tree_store::btree_base::{ - BranchAccessor, BranchBuilder, BranchMutator, Checksum, LeafAccessor, LeafBuilder, LeafMutator, - BRANCH, DEFERRED, LEAF, + BRANCH, BranchAccessor, BranchBuilder, BranchMutator, Checksum, DEFERRED, LEAF, LeafAccessor, + LeafBuilder, LeafMutator, }; use crate::tree_store::btree_mutator::DeletionResult::{ DeletedBranch, DeletedLeaf, PartialBranch, PartialLeaf, Subtree, diff --git a/src/tree_store/mod.rs b/src/tree_store/mod.rs index d8fb81d6..cbdc7906 100644 --- a/src/tree_store/mod.rs +++ b/src/tree_store/mod.rs @@ -7,18 +7,18 @@ mod table_tree; mod table_tree_base; pub(crate) use btree::{ - btree_stats, Btree, BtreeMut, BtreeStats, PagePath, RawBtree, UntypedBtree, UntypedBtreeMut, + Btree, BtreeMut, BtreeStats, PagePath, RawBtree, UntypedBtree, UntypedBtreeMut, btree_stats, }; pub use btree_base::{AccessGuard, AccessGuardMut}; pub(crate) use btree_base::{ - BranchAccessor, BranchMutator, BtreeHeader, Checksum, LeafAccessor, LeafMutator, - RawLeafBuilder, BRANCH, DEFERRED, LEAF, + BRANCH, BranchAccessor, BranchMutator, BtreeHeader, Checksum, DEFERRED, LEAF, LeafAccessor, + LeafMutator, RawLeafBuilder, }; pub(crate) use btree_iters::{AllPageNumbersBtreeIter, BtreeExtractIf, BtreeRangeIter}; -pub use page_store::{file_backend, InMemoryBackend, Savepoint}; pub(crate) use page_store::{ - BuddyAllocator, Page, PageHint, PageNumber, SerializedSavepoint, TransactionalMemory, - FILE_FORMAT_VERSION2, MAX_PAIR_LENGTH, MAX_VALUE_LENGTH, PAGE_SIZE, + BuddyAllocator, FILE_FORMAT_VERSION2, MAX_PAIR_LENGTH, MAX_VALUE_LENGTH, PAGE_SIZE, Page, + PageHint, PageNumber, SerializedSavepoint, TransactionalMemory, }; +pub use page_store::{InMemoryBackend, Savepoint, file_backend}; pub(crate) use table_tree::{FreedPageList, FreedTableKey, TableTree, TableTreeMut}; pub(crate) use table_tree_base::{InternalTableDefinition, TableType}; diff --git a/src/tree_store/page_store/bitmap.rs b/src/tree_store/page_store/bitmap.rs index ab64bc5a..ff05313e 100644 --- a/src/tree_store/page_store/bitmap.rs +++ b/src/tree_store/page_store/bitmap.rs @@ -195,7 +195,7 @@ impl<'a> U64GroupedBitmapIter<'a> { } } -impl<'a> Iterator for U64GroupedBitmapIter<'a> { +impl Iterator for U64GroupedBitmapIter<'_> { type Item = u32; fn next(&mut self) -> Option { @@ -248,7 +248,7 @@ impl<'a, 'b> U64GroupedBitmapDifference<'a, 'b> { } } -impl<'a, 'b> Iterator for U64GroupedBitmapDifference<'a, 'b> { +impl Iterator for U64GroupedBitmapDifference<'_, '_> { type Item = u32; fn next(&mut self) -> Option { @@ -513,12 +513,12 @@ mod test { #[test] fn random_pattern() { - let seed = rand::thread_rng().gen(); + let seed = rand::rng().random(); // Print the seed to debug for reproducibility, in case this test fails println!("seed={seed}"); let mut rng = StdRng::seed_from_u64(seed); - let num_pages = rng.gen_range(2..10000); + let num_pages = rng.random_range(2..10000); let mut allocator = BtreeBitmap::new(num_pages); for i in 0..num_pages { allocator.clear(i); @@ -526,7 +526,7 @@ mod test { let mut allocated = HashSet::new(); for _ in 0..(num_pages * 2) { - if rng.gen_bool(0.75) { + if rng.random_bool(0.75) { if let Some(page) = allocator.alloc() { allocated.insert(page); } else { diff --git a/src/tree_store/page_store/buddy_allocator.rs b/src/tree_store/page_store/buddy_allocator.rs index a2a31cb2..88913c46 100644 --- a/src/tree_store/page_store/buddy_allocator.rs +++ b/src/tree_store/page_store/buddy_allocator.rs @@ -1,6 +1,6 @@ +use crate::tree_store::PageNumber; use crate::tree_store::page_store::bitmap::{BtreeBitmap, U64GroupedBitmap}; use crate::tree_store::page_store::page_manager::MAX_MAX_PAGE_ORDER; -use crate::tree_store::PageNumber; use std::cmp::min; #[cfg(test)] use std::collections::HashSet; diff --git a/src/tree_store/page_store/cached_file.rs b/src/tree_store/page_store/cached_file.rs index 45cc9d2f..dbd423ff 100644 --- a/src/tree_store/page_store/cached_file.rs +++ b/src/tree_store/page_store/cached_file.rs @@ -463,12 +463,12 @@ impl PagedCachedFile { #[cfg(test)] mod test { + use crate::StorageBackend; use crate::backends::InMemoryBackend; - use crate::tree_store::page_store::cached_file::PagedCachedFile; use crate::tree_store::PageHint; - use crate::StorageBackend; - use std::sync::atomic::Ordering; + use crate::tree_store::page_store::cached_file::PagedCachedFile; use std::sync::Arc; + use std::sync::atomic::Ordering; // TODO: Switch to threaded wasi build for the tests #[cfg(not(target_os = "wasi"))] diff --git a/src/tree_store/page_store/file_backend/windows.rs b/src/tree_store/page_store/file_backend/windows.rs index 0a2c263f..dac1dca4 100644 --- a/src/tree_store/page_store/file_backend/windows.rs +++ b/src/tree_store/page_store/file_backend/windows.rs @@ -10,7 +10,7 @@ use std::os::windows::io::RawHandle; const ERROR_LOCK_VIOLATION: i32 = 0x21; const ERROR_IO_PENDING: i32 = 997; -extern "system" { +unsafe extern "system" { /// fn LockFile( file: RawHandle, diff --git a/src/tree_store/page_store/header.rs b/src/tree_store/page_store/header.rs index 891f75e8..f2336109 100644 --- a/src/tree_store/page_store/header.rs +++ b/src/tree_store/page_store/header.rs @@ -2,7 +2,7 @@ use crate::transaction_tracker::TransactionId; use crate::tree_store::btree_base::BtreeHeader; use crate::tree_store::page_store::layout::{DatabaseLayout, RegionLayout}; use crate::tree_store::page_store::page_manager::{ - xxh3_checksum, FILE_FORMAT_VERSION1, FILE_FORMAT_VERSION2, + FILE_FORMAT_VERSION1, FILE_FORMAT_VERSION2, xxh3_checksum, }; use crate::tree_store::{Checksum, PageNumber}; use crate::{DatabaseError, Result, StorageError}; @@ -356,7 +356,7 @@ impl TransactionHeader { return Err(StorageError::Corrupted(format!( "Expected file format version <= {FILE_FORMAT_VERSION2}, found {version}", )) - .into()) + .into()); } } let checksum = Checksum::from_le_bytes( @@ -437,15 +437,15 @@ impl TransactionHeader { #[cfg(test)] mod test { + #[cfg(not(target_os = "windows"))] + use crate::StorageError; use crate::backends::FileBackend; use crate::db::TableDefinition; + use crate::tree_store::page_store::TransactionalMemory; use crate::tree_store::page_store::header::{ GOD_BYTE_OFFSET, MAGICNUMBER, PAGE_SIZE, PRIMARY_BIT, RECOVERY_REQUIRED, TRANSACTION_0_OFFSET, TRANSACTION_1_OFFSET, TWO_PHASE_COMMIT, USER_ROOT_OFFSET, }; - use crate::tree_store::page_store::TransactionalMemory; - #[cfg(not(target_os = "windows"))] - use crate::StorageError; use crate::{Database, DatabaseError, ReadableTable}; use std::fs::OpenOptions; use std::io::{Read, Seek, SeekFrom, Write}; @@ -506,17 +506,19 @@ mod test { .unwrap(); file.write_all(&[0; size_of::()]).unwrap(); - assert!(TransactionalMemory::new( - Box::new(FileBackend::new(file).unwrap()), - false, - PAGE_SIZE, - None, - 0, - 0 - ) - .unwrap() - .needs_repair() - .unwrap()); + assert!( + TransactionalMemory::new( + Box::new(FileBackend::new(file).unwrap()), + false, + PAGE_SIZE, + None, + 0, + 0 + ) + .unwrap() + .needs_repair() + .unwrap() + ); #[allow(unused_mut)] let mut db2 = Database::create(tmpfile.path()).unwrap(); @@ -596,17 +598,19 @@ mod test { buffer[0] |= RECOVERY_REQUIRED; file.write_all(&buffer).unwrap(); - assert!(TransactionalMemory::new( - Box::new(FileBackend::new(file).unwrap()), - false, - PAGE_SIZE, - None, - 0, - 0 - ) - .unwrap() - .needs_repair() - .unwrap()); + assert!( + TransactionalMemory::new( + Box::new(FileBackend::new(file).unwrap()), + false, + PAGE_SIZE, + None, + 0, + 0 + ) + .unwrap() + .needs_repair() + .unwrap() + ); Database::open(tmpfile.path()).unwrap(); } @@ -631,17 +635,19 @@ mod test { buffer[0] &= !TWO_PHASE_COMMIT; file.write_all(&buffer).unwrap(); - assert!(TransactionalMemory::new( - Box::new(FileBackend::new(file).unwrap()), - false, - PAGE_SIZE, - None, - 0, - 0 - ) - .unwrap() - .needs_repair() - .unwrap()); + assert!( + TransactionalMemory::new( + Box::new(FileBackend::new(file).unwrap()), + false, + PAGE_SIZE, + None, + 0, + 0 + ) + .unwrap() + .needs_repair() + .unwrap() + ); let err = Database::builder() .set_repair_callback(|handle| handle.abort()) @@ -688,17 +694,19 @@ mod test { buffer[0] |= RECOVERY_REQUIRED; file.write_all(&buffer).unwrap(); - assert!(TransactionalMemory::new( - Box::new(FileBackend::new(file).unwrap()), - false, - PAGE_SIZE, - None, - 0, - 0 - ) - .unwrap() - .needs_repair() - .unwrap()); + assert!( + TransactionalMemory::new( + Box::new(FileBackend::new(file).unwrap()), + false, + PAGE_SIZE, + None, + 0, + 0 + ) + .unwrap() + .needs_repair() + .unwrap() + ); Database::open(tmpfile.path()).unwrap(); } diff --git a/src/tree_store/page_store/mod.rs b/src/tree_store/page_store/mod.rs index 13362d9e..b6cb6021 100644 --- a/src/tree_store/page_store/mod.rs +++ b/src/tree_store/page_store/mod.rs @@ -13,10 +13,10 @@ mod savepoint; #[allow(clippy::pedantic, dead_code)] mod xxh3; -pub(crate) use base::{Page, PageHint, PageNumber, MAX_PAIR_LENGTH, MAX_VALUE_LENGTH}; +pub(crate) use base::{MAX_PAIR_LENGTH, MAX_VALUE_LENGTH, Page, PageHint, PageNumber}; pub(crate) use header::PAGE_SIZE; pub use in_memory_backend::InMemoryBackend; -pub(crate) use page_manager::{xxh3_checksum, TransactionalMemory, FILE_FORMAT_VERSION2}; +pub(crate) use page_manager::{FILE_FORMAT_VERSION2, TransactionalMemory, xxh3_checksum}; pub use savepoint::Savepoint; pub(crate) use savepoint::SerializedSavepoint; diff --git a/src/tree_store/page_store/page_manager.rs b/src/tree_store/page_store/page_manager.rs index d7073c9b..59b4c7a1 100644 --- a/src/tree_store/page_store/page_manager.rs +++ b/src/tree_store/page_store/page_manager.rs @@ -1,13 +1,13 @@ use crate::transaction_tracker::TransactionId; use crate::transactions::{AllocatorStateKey, AllocatorStateTree}; use crate::tree_store::btree_base::{BtreeHeader, Checksum}; -use crate::tree_store::page_store::base::{PageHint, MAX_PAGE_INDEX}; +use crate::tree_store::page_store::base::{MAX_PAGE_INDEX, PageHint}; use crate::tree_store::page_store::buddy_allocator::BuddyAllocator; use crate::tree_store::page_store::cached_file::PagedCachedFile; -use crate::tree_store::page_store::header::{DatabaseHeader, DB_HEADER_SIZE, MAGICNUMBER}; +use crate::tree_store::page_store::header::{DB_HEADER_SIZE, DatabaseHeader, MAGICNUMBER}; use crate::tree_store::page_store::layout::DatabaseLayout; use crate::tree_store::page_store::region::{Allocators, RegionTracker}; -use crate::tree_store::page_store::{hash128_with_seed, PageImpl, PageMut}; +use crate::tree_store::page_store::{PageImpl, PageMut, hash128_with_seed}; use crate::tree_store::{Page, PageNumber}; use crate::{CacheStats, StorageBackend}; use crate::{DatabaseError, Result, StorageError}; @@ -19,10 +19,10 @@ use std::collections::HashMap; use std::collections::HashSet; use std::convert::TryInto; use std::io::ErrorKind; -use std::sync::atomic::{AtomicBool, Ordering}; #[cfg(debug_assertions)] use std::sync::Arc; use std::sync::Mutex; +use std::sync::atomic::{AtomicBool, Ordering}; use std::thread; // Regions have a maximum size of 4GiB. A `4GiB - overhead` value is the largest that can be represented, @@ -167,7 +167,7 @@ impl TransactionalMemory { page_size as u64 * u64::from(MIN_USABLE_PAGES), ); let tracker_space = - (page_size * ((region_tracker_required_bytes + page_size - 1) / page_size)) as u64; + (page_size * region_tracker_required_bytes.div_ceil(page_size)) as u64; let starting_size = size + tracker_space; let layout = DatabaseLayout::calculate( @@ -191,7 +191,7 @@ impl TransactionalMemory { // Allocate the region tracker in the zeroth region let tracker_page = { let tracker_required_pages = - (allocators.region_tracker.to_vec().len() + page_size - 1) / page_size; + allocators.region_tracker.to_vec().len().div_ceil(page_size); let required_order = ceil_log2(tracker_required_pages); let page_number = allocators.region_allocators[0] .alloc(required_order) @@ -860,11 +860,13 @@ impl TransactionalMemory { pub(crate) fn get_page_mut(&self, page_number: PageNumber) -> Result { #[cfg(debug_assertions)] { - assert!(!self - .read_page_ref_counts - .lock() - .unwrap() - .contains_key(&page_number)); + assert!( + !self + .read_page_ref_counts + .lock() + .unwrap() + .contains_key(&page_number) + ); assert!(!self.open_dirty_pages.lock().unwrap().contains(&page_number)); } @@ -988,7 +990,7 @@ impl TransactionalMemory { lowest: bool, transactional: bool, ) -> Result { - let required_pages = (allocation_size + self.get_page_size() - 1) / self.get_page_size(); + let required_pages = allocation_size.div_ceil(self.get_page_size()); let required_order = ceil_log2(required_pages); let mut state = self.state.lock().unwrap(); diff --git a/src/tree_store/page_store/region.rs b/src/tree_store/page_store/region.rs index e0ea9f42..45c9b544 100644 --- a/src/tree_store/page_store/region.rs +++ b/src/tree_store/page_store/region.rs @@ -1,3 +1,5 @@ +use crate::Result; +use crate::tree_store::PageNumber; use crate::tree_store::page_store::bitmap::BtreeBitmap; use crate::tree_store::page_store::buddy_allocator::BuddyAllocator; use crate::tree_store::page_store::cached_file::PagedCachedFile; @@ -5,8 +7,6 @@ use crate::tree_store::page_store::header::DatabaseHeader; use crate::tree_store::page_store::layout::DatabaseLayout; use crate::tree_store::page_store::page_manager::{INITIAL_REGIONS, MAX_MAX_PAGE_ORDER}; use crate::tree_store::page_store::xxh3_checksum; -use crate::tree_store::PageNumber; -use crate::Result; use std::cmp::{self, max}; use std::mem::size_of; @@ -316,7 +316,7 @@ impl RegionHeader { // TODO: this is kind of expensive. Maybe it should be cached let allocator = BuddyAllocator::new(pages_per_region, pages_per_region); let result = 8u64 + allocator.to_vec().len() as u64; - ((result + page_size - 1) / page_size).try_into().unwrap() + result.div_ceil(page_size).try_into().unwrap() } fn serialize(allocator: &BuddyAllocator, output: &mut [u8]) { diff --git a/src/tree_store/page_store/savepoint.rs b/src/tree_store/page_store/savepoint.rs index 6c42a12d..4b066560 100644 --- a/src/tree_store/page_store/savepoint.rs +++ b/src/tree_store/page_store/savepoint.rs @@ -113,7 +113,7 @@ pub(crate) enum SerializedSavepoint<'a> { Owned(Vec), } -impl<'a> SerializedSavepoint<'a> { +impl SerializedSavepoint<'_> { pub(crate) fn from_savepoint(savepoint: &Savepoint) -> Self { assert_eq!(savepoint.version, FILE_FORMAT_VERSION2); let mut result = vec![savepoint.version]; @@ -272,9 +272,15 @@ impl<'a> SerializedSavepoint<'a> { } } -impl<'data> Value for SerializedSavepoint<'data> { - type SelfType<'a> = SerializedSavepoint<'a> where Self: 'a; - type AsBytes<'a> = &'a [u8] where Self: 'a; +impl Value for SerializedSavepoint<'_> { + type SelfType<'a> + = SerializedSavepoint<'a> + where + Self: 'a; + type AsBytes<'a> + = &'a [u8] + where + Self: 'a; fn fixed_width() -> Option { None diff --git a/src/tree_store/page_store/xxh3.rs b/src/tree_store/page_store/xxh3.rs index c812babe..c943ffec 100644 --- a/src/tree_store/page_store/xxh3.rs +++ b/src/tree_store/page_store/xxh3.rs @@ -20,7 +20,7 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. -// Copied from xxh3 crate, commit hash a2bfd3a +// Copied from xxh3 crate, commit hash e91f09d1e930e179c11d5cfda6d14284bfb006f8 use std::mem::size_of; @@ -56,7 +56,6 @@ const INIT_ACCUMULATORS: [u64; 8] = [ PRIME32[2], PRIME64[0], PRIME64[1], PRIME64[2], PRIME64[3], PRIME32[1], PRIME64[4], PRIME32[0], ]; -#[allow(clippy::needless_return)] pub fn hash64_with_seed(data: &[u8], seed: u64) -> u64 { if data.len() <= 240 { hash64_0to240(data, &DEFAULT_SECRET, seed) @@ -71,9 +70,7 @@ pub fn hash64_with_seed(data: &[u8], seed: u64) -> u64 { } #[cfg(target_arch = "aarch64")] { - unsafe { - return hash64_large_neon(data, seed); - } + unsafe { hash64_large_neon(data, seed) } } #[cfg(not(target_arch = "aarch64"))] hash64_large_generic( @@ -86,7 +83,6 @@ pub fn hash64_with_seed(data: &[u8], seed: u64) -> u64 { } } -#[allow(clippy::needless_return)] pub fn hash128_with_seed(data: &[u8], seed: u64) -> u128 { if data.len() <= 240 { hash128_0to240(data, &DEFAULT_SECRET, seed) @@ -99,7 +95,7 @@ pub fn hash128_with_seed(data: &[u8], seed: u64) -> u128 { } #[cfg(target_arch = "aarch64")] unsafe { - return hash128_large_neon(data, seed); + hash128_large_neon(data, seed) } #[cfg(not(target_arch = "aarch64"))] hash128_large_generic( @@ -167,30 +163,32 @@ unsafe fn scramble_accumulators_avx2( accumulators: &mut [u64; INIT_ACCUMULATORS.len()], secret: &[u8], ) { - #[cfg(target_arch = "x86")] - use std::arch::x86::*; - #[cfg(target_arch = "x86_64")] - use std::arch::x86_64::*; - - #[allow(clippy::cast_possible_truncation)] - let simd_prime = _mm256_set1_epi32(PRIME32[0] as i32); - let secret_ptr = secret.as_ptr(); - let accumulators_ptr = accumulators.as_mut_ptr(); - - for i in 0..(STRIPE_LENGTH / 32) { - let a = _mm256_loadu_si256((accumulators_ptr as *const __m256i).add(i)); - let shifted = _mm256_srli_epi64::<47>(a); - let b = _mm256_xor_si256(a, shifted); - - let s = _mm256_loadu_si256((secret_ptr as *const __m256i).add(i)); - let c = _mm256_xor_si256(b, s); - let c_high = _mm256_shuffle_epi32::<49>(c); - - let low = _mm256_mul_epu32(c, simd_prime); - let high = _mm256_mul_epu32(c_high, simd_prime); - let high = _mm256_slli_epi64::<32>(high); - let result = _mm256_add_epi64(low, high); - _mm256_storeu_si256((accumulators_ptr as *mut __m256i).add(i), result); + unsafe { + #[cfg(target_arch = "x86")] + use std::arch::x86::*; + #[cfg(target_arch = "x86_64")] + use std::arch::x86_64::*; + + #[allow(clippy::cast_possible_truncation)] + let simd_prime = _mm256_set1_epi32(PRIME32[0] as i32); + let secret_ptr = secret.as_ptr(); + let accumulators_ptr = accumulators.as_mut_ptr(); + + for i in 0..(STRIPE_LENGTH / 32) { + let a = _mm256_loadu_si256((accumulators_ptr as *const __m256i).add(i)); + let shifted = _mm256_srli_epi64::<47>(a); + let b = _mm256_xor_si256(a, shifted); + + let s = _mm256_loadu_si256((secret_ptr as *const __m256i).add(i)); + let c = _mm256_xor_si256(b, s); + let c_high = _mm256_shuffle_epi32::<49>(c); + + let low = _mm256_mul_epu32(c, simd_prime); + let high = _mm256_mul_epu32(c_high, simd_prime); + let high = _mm256_slli_epi64::<32>(high); + let result = _mm256_add_epi64(low, high); + _mm256_storeu_si256((accumulators_ptr as *mut __m256i).add(i), result); + } } } @@ -204,27 +202,29 @@ unsafe fn scramble_accumulators_neon( #[cfg(target_arch = "arm")] use std::arch::arm::*; - let prime = vdup_n_u32(PRIME32[0].try_into().unwrap()); - - let accum_ptr = accumulators.as_mut_ptr(); - let secret_ptr = secret.as_ptr(); - assert!(secret.len() >= STRIPE_LENGTH); - for i in 0..(STRIPE_LENGTH / 16) { - // xorshift - let accum = vld1q_u64(accum_ptr.add(i * 2)); - let shifted = vshrq_n_u64(accum, 47); - let accum = veorq_u64(accum, shifted); - - // xor with secret - let s = vld1q_u8(secret_ptr.add(i * 16)); - let accum = veorq_u64(accum, vreinterpretq_u64_u8(s)); - - // mul with prime. Sadly there's no vmulq_u64 - let accum_low = vmovn_u64(accum); - let accum_high = vshrn_n_u64(accum, 32); - let prod_high = vshlq_n_u64(vmull_u32(accum_high, prime), 32); - let accum = vmlal_u32(prod_high, accum_low, prime); - vst1q_u64(accum_ptr.add(i * 2), accum); + unsafe { + let prime = vdup_n_u32(PRIME32[0].try_into().unwrap()); + + let accum_ptr = accumulators.as_mut_ptr(); + let secret_ptr = secret.as_ptr(); + assert!(secret.len() >= STRIPE_LENGTH); + for i in 0..(STRIPE_LENGTH / 16) { + // xorshift + let accum = vld1q_u64(accum_ptr.add(i * 2)); + let shifted = vshrq_n_u64(accum, 47); + let accum = veorq_u64(accum, shifted); + + // xor with secret + let s = vld1q_u8(secret_ptr.add(i * 16)); + let accum = veorq_u64(accum, vreinterpretq_u64_u8(s)); + + // mul with prime. Sadly there's no vmulq_u64 + let accum_low = vmovn_u64(accum); + let accum_high = vshrn_n_u64(accum, 32); + let prod_high = vshlq_n_u64(vmull_u32(accum_high, prime), 32); + let accum = vmlal_u32(prod_high, accum_low, prime); + vst1q_u64(accum_ptr.add(i * 2), accum); + } } } @@ -292,28 +292,30 @@ fn gen_secret_generic(seed: u64) -> [u8; DEFAULT_SECRET.len()] { #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] #[target_feature(enable = "avx2")] unsafe fn gen_secret_avx2(seed: u64) -> [u8; DEFAULT_SECRET.len()] { - #[cfg(target_arch = "x86")] - use std::arch::x86::*; - #[cfg(target_arch = "x86_64")] - use std::arch::x86_64::*; - - #[allow(clippy::cast_possible_wrap)] - let xxh_i64 = 0u64.wrapping_sub(seed) as i64; - #[allow(clippy::cast_possible_wrap)] - let seed = seed as i64; - - let simd_seed = _mm256_set_epi64x(xxh_i64, seed, xxh_i64, seed); - - let mut output = [0u8; DEFAULT_SECRET.len()]; - let output_ptr = output.as_mut_ptr(); - let secret_ptr = DEFAULT_SECRET.as_ptr(); - for i in 0..6 { - let s = _mm256_loadu_si256((secret_ptr as *const __m256i).add(i)); - let x = _mm256_add_epi64(s, simd_seed); - _mm256_storeu_si256((output_ptr as *mut __m256i).add(i), x); - } + unsafe { + #[cfg(target_arch = "x86")] + use std::arch::x86::*; + #[cfg(target_arch = "x86_64")] + use std::arch::x86_64::*; + + #[allow(clippy::cast_possible_wrap)] + let xxh_i64 = 0u64.wrapping_sub(seed) as i64; + #[allow(clippy::cast_possible_wrap)] + let seed = seed as i64; + + let simd_seed = _mm256_set_epi64x(xxh_i64, seed, xxh_i64, seed); + + let mut output = [0u8; DEFAULT_SECRET.len()]; + let output_ptr = output.as_mut_ptr(); + let secret_ptr = DEFAULT_SECRET.as_ptr(); + for i in 0..6 { + let s = _mm256_loadu_si256((secret_ptr as *const __m256i).add(i)); + let x = _mm256_add_epi64(s, simd_seed); + _mm256_storeu_si256((output_ptr as *mut __m256i).add(i), x); + } - output + output + } } #[cfg(target_arch = "aarch64")] @@ -323,57 +325,61 @@ unsafe fn accumulate_stripe_neon(accumulators: &mut [u64; 8], data: &[u8], secre #[cfg(target_arch = "arm")] use std::arch::arm::*; - let accum_ptr = accumulators.as_mut_ptr(); - let data_ptr = data.as_ptr(); - let secret_ptr = secret.as_ptr(); - assert!(data.len() >= STRIPE_LENGTH); - assert!(secret.len() >= STRIPE_LENGTH); - for i in 0..(STRIPE_LENGTH / 16) { - let x = vld1q_u8(data_ptr.add(i * 16)); - let s = vld1q_u8(secret_ptr.add(i * 16)); - let x64 = vreinterpretq_u64_u8(x); - let y = vextq_u64(x64, x64, 1); - - let result = vld1q_u64(accum_ptr.add(i * 2)); - let result = vaddq_u64(result, y); - - let z = vreinterpretq_u64_u8(veorq_u8(x, s)); - let z_low = vmovn_u64(z); - let z_high = vshrn_n_u64(z, 32); - - let result = vmlal_u32(result, z_low, z_high); - vst1q_u64(accum_ptr.add(i * 2), result); + unsafe { + let accum_ptr = accumulators.as_mut_ptr(); + let data_ptr = data.as_ptr(); + let secret_ptr = secret.as_ptr(); + assert!(data.len() >= STRIPE_LENGTH); + assert!(secret.len() >= STRIPE_LENGTH); + for i in 0..(STRIPE_LENGTH / 16) { + let x = vld1q_u8(data_ptr.add(i * 16)); + let s = vld1q_u8(secret_ptr.add(i * 16)); + let x64 = vreinterpretq_u64_u8(x); + let y = vextq_u64(x64, x64, 1); + + let result = vld1q_u64(accum_ptr.add(i * 2)); + let result = vaddq_u64(result, y); + + let z = vreinterpretq_u64_u8(veorq_u8(x, s)); + let z_low = vmovn_u64(z); + let z_high = vshrn_n_u64(z, 32); + + let result = vmlal_u32(result, z_low, z_high); + vst1q_u64(accum_ptr.add(i * 2), result); + } } } #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] #[target_feature(enable = "avx2")] unsafe fn accumulate_stripe_avx2(accumulators: &mut [u64; 8], data: &[u8], secret: &[u8]) { - #[cfg(target_arch = "x86")] - use std::arch::x86::*; - #[cfg(target_arch = "x86_64")] - use std::arch::x86_64::*; - - let data_ptr = data.as_ptr(); - let secret_ptr = secret.as_ptr(); - let accumulator_ptr = accumulators.as_mut_ptr(); - - assert!(data.len() >= STRIPE_LENGTH); - assert!(secret.len() >= STRIPE_LENGTH); - for i in 0..(STRIPE_LENGTH / 32) { - let x = _mm256_loadu_si256((data_ptr as *const __m256i).add(i)); - let s = _mm256_loadu_si256((secret_ptr as *const __m256i).add(i)); - - let z = _mm256_xor_si256(x, s); - let z_low = _mm256_shuffle_epi32::<49>(z); - - let product = _mm256_mul_epu32(z, z_low); - let shuffled = _mm256_shuffle_epi32::<78>(x); - - let result = _mm256_loadu_si256((accumulator_ptr as *const __m256i).add(i)); - let result = _mm256_add_epi64(result, shuffled); - let result = _mm256_add_epi64(result, product); - _mm256_storeu_si256((accumulator_ptr as *mut __m256i).add(i), result); + unsafe { + #[cfg(target_arch = "x86")] + use std::arch::x86::*; + #[cfg(target_arch = "x86_64")] + use std::arch::x86_64::*; + + let data_ptr = data.as_ptr(); + let secret_ptr = secret.as_ptr(); + let accumulator_ptr = accumulators.as_mut_ptr(); + + assert!(data.len() >= STRIPE_LENGTH); + assert!(secret.len() >= STRIPE_LENGTH); + for i in 0..(STRIPE_LENGTH / 32) { + let x = _mm256_loadu_si256((data_ptr as *const __m256i).add(i)); + let s = _mm256_loadu_si256((secret_ptr as *const __m256i).add(i)); + + let z = _mm256_xor_si256(x, s); + let z_low = _mm256_shuffle_epi32::<49>(z); + + let product = _mm256_mul_epu32(z, z_low); + let shuffled = _mm256_shuffle_epi32::<78>(x); + + let result = _mm256_loadu_si256((accumulator_ptr as *const __m256i).add(i)); + let result = _mm256_add_epi64(result, shuffled); + let result = _mm256_add_epi64(result, product); + _mm256_storeu_si256((accumulator_ptr as *mut __m256i).add(i), result); + } } } @@ -580,11 +586,11 @@ unsafe fn hash64_large_avx2(data: &[u8], seed: u64) -> u64 { fn hash64_large_generic( data: &[u8], seed: u64, - gen: unsafe fn(u64) -> [u8; DEFAULT_SECRET.len()], + generate: unsafe fn(u64) -> [u8; DEFAULT_SECRET.len()], scramble: unsafe fn(&mut [u64; 8], &[u8]), accum_stripe: unsafe fn(&mut [u64; 8], &[u8], &[u8]), ) -> u64 { - let secret = unsafe { gen(seed) }; + let secret = unsafe { generate(seed) }; let accumulators = hash_large_helper(data, &secret, scramble, accum_stripe); merge_accumulators( @@ -638,7 +644,7 @@ fn hash128_4to8(data: &[u8], secret: &[u8], mut seed: u64) -> u128 { r_low = xorshift(r_low, 28); r_high = xxh3_avalanche(r_high); - (r_high as u128) << 64 | r_low as u128 + ((r_high as u128) << 64) | r_low as u128 } fn hash128_9to16(data: &[u8], secret: &[u8], seed: u64) -> u128 { @@ -666,7 +672,7 @@ fn hash128_9to16(data: &[u8], secret: &[u8], seed: u64) -> u128 { r2_low = xxh3_avalanche(r2_low); r2_high = xxh3_avalanche(r2_high); - (r2_high as u128) << 64 | r2_low as u128 + ((r2_high as u128) << 64) | r2_low as u128 } fn hash128_0to16(data: &[u8], secret: &[u8], seed: u64) -> u128 { @@ -702,7 +708,7 @@ fn hash128_17to128(data: &[u8], secret: &[u8], seed: u64) -> u128 { r_low = xxh3_avalanche(r_low); r_high = 0u64.wrapping_sub(xxh3_avalanche(r_high)); - (r_high as u128) << 64 | r_low as u128 + ((r_high as u128) << 64) | r_low as u128 } fn hash128_129to240(data: &[u8], secret: &[u8], seed: u64) -> u128 { @@ -746,7 +752,7 @@ fn hash128_129to240(data: &[u8], secret: &[u8], seed: u64) -> u128 { r_low = xxh3_avalanche(r_low); r_high = 0u64.wrapping_sub(xxh3_avalanche(r_high)); - (r_high as u128) << 64 | r_low as u128 + ((r_high as u128) << 64) | r_low as u128 } fn hash128_0to240(data: &[u8], secret: &[u8], seed: u64) -> u128 { @@ -786,11 +792,11 @@ unsafe fn hash128_large_avx2(data: &[u8], seed: u64) -> u128 { fn hash128_large_generic( data: &[u8], seed: u64, - gen: unsafe fn(u64) -> [u8; DEFAULT_SECRET.len()], + generate: unsafe fn(u64) -> [u8; DEFAULT_SECRET.len()], scramble: unsafe fn(&mut [u64; 8], &[u8]), accum_stripe: unsafe fn(&mut [u64; 8], &[u8], &[u8]), ) -> u128 { - let secret = unsafe { gen(seed) }; + let secret = unsafe { generate(seed) }; let accumulators = hash_large_helper(data, &secret, scramble, accum_stripe); let low = merge_accumulators( @@ -804,7 +810,7 @@ fn hash128_large_generic( !(PRIME64[1].wrapping_mul(data.len() as u64)), ); - (high as u128) << 64 | low as u128 + ((high as u128) << 64) | low as u128 } #[cfg(test)] diff --git a/src/tree_store/table_tree.rs b/src/tree_store/table_tree.rs index 817825fc..ce92bfe7 100644 --- a/src/tree_store/table_tree.rs +++ b/src/tree_store/table_tree.rs @@ -3,7 +3,7 @@ use crate::error::TableError; use crate::multimap_table::{ finalize_tree_and_subtree_checksums, multimap_btree_stats, verify_tree_and_subtree_checksums, }; -use crate::tree_store::btree::{btree_stats, UntypedBtreeMut}; +use crate::tree_store::btree::{UntypedBtreeMut, btree_stats}; use crate::tree_store::btree_base::BtreeHeader; use crate::tree_store::{ Btree, BtreeMut, BtreeRangeIter, InternalTableDefinition, PageHint, PageNumber, PagePath, @@ -24,10 +24,12 @@ pub(crate) struct FreedTableKey { } impl Value for FreedTableKey { - type SelfType<'a> = FreedTableKey + type SelfType<'a> + = FreedTableKey where Self: 'a; - type AsBytes<'a> = [u8; 2 * size_of::()] + type AsBytes<'a> + = [u8; 2 * size_of::()] where Self: 'a; @@ -83,7 +85,7 @@ pub(crate) struct FreedPageList<'a> { data: &'a [u8], } -impl<'a> FreedPageList<'a> { +impl FreedPageList<'_> { pub(crate) fn required_bytes(len: usize) -> usize { 2 + PageNumber::serialized_size() * len } @@ -124,12 +126,14 @@ impl FreedPageListMut { } impl Value for FreedPageList<'_> { - type SelfType<'a> = FreedPageList<'a> - where - Self: 'a; - type AsBytes<'a> = &'a [u8] - where - Self: 'a; + type SelfType<'a> + = FreedPageList<'a> + where + Self: 'a; + type AsBytes<'a> + = &'a [u8] + where + Self: 'a; fn fixed_width() -> Option { None @@ -297,7 +301,7 @@ pub(crate) struct TableTreeMut<'txn> { freed_pages: Arc>>, } -impl<'txn> TableTreeMut<'txn> { +impl TableTreeMut<'_> { pub(crate) fn new( master_root: Option, guard: Arc, @@ -767,9 +771,9 @@ impl<'txn> TableTreeMut<'txn> { #[cfg(test)] mod test { + use crate::Value; use crate::tree_store::table_tree_base::InternalTableDefinition; use crate::types::TypeName; - use crate::Value; #[test] fn round_trip() { diff --git a/src/tree_store/table_tree_base.rs b/src/tree_store/table_tree_base.rs index e2bae031..d64e52be 100644 --- a/src/tree_store/table_tree_base.rs +++ b/src/tree_store/table_tree_base.rs @@ -1,4 +1,4 @@ -use crate::multimap_table::{relocate_subtrees, UntypedMultiBtree}; +use crate::multimap_table::{UntypedMultiBtree, relocate_subtrees}; use crate::tree_store::{ BtreeHeader, PageNumber, PagePath, TransactionalMemory, UntypedBtree, UntypedBtreeMut, }; diff --git a/src/types.rs b/src/types.rs index c87548ff..7ab05bd6 100644 --- a/src/types.rs +++ b/src/types.rs @@ -50,7 +50,7 @@ impl TypeName { } pub(crate) fn to_bytes(&self) -> Vec { - let mut result = Vec::with_capacity(self.name.as_bytes().len() + 1); + let mut result = Vec::with_capacity(self.name.len() + 1); result.push(self.classification.to_byte()); result.extend_from_slice(self.name.as_bytes()); result @@ -130,10 +130,12 @@ pub trait Key: Value { } impl Value for () { - type SelfType<'a> = () + type SelfType<'a> + = () where Self: 'a; - type AsBytes<'a> = &'a [u8] + type AsBytes<'a> + = &'a [u8] where Self: 'a; @@ -169,12 +171,14 @@ impl Key for () { } impl Value for bool { - type SelfType<'a> = bool - where - Self: 'a; - type AsBytes<'a> = &'a [u8] - where - Self: 'a; + type SelfType<'a> + = bool + where + Self: 'a; + type AsBytes<'a> + = &'a [u8] + where + Self: 'a; fn fixed_width() -> Option { Some(1) @@ -215,10 +219,12 @@ impl Key for bool { } impl Value for Option { - type SelfType<'a> = Option> + type SelfType<'a> + = Option> where Self: 'a; - type AsBytes<'a> = Vec + type AsBytes<'a> + = Vec where Self: 'a; @@ -276,10 +282,12 @@ impl Key for Option { } impl Value for &[u8] { - type SelfType<'a> = &'a [u8] + type SelfType<'a> + = &'a [u8] where Self: 'a; - type AsBytes<'a> = &'a [u8] + type AsBytes<'a> + = &'a [u8] where Self: 'a; @@ -313,10 +321,12 @@ impl Key for &[u8] { } impl Value for &[u8; N] { - type SelfType<'a> = &'a [u8; N] + type SelfType<'a> + = &'a [u8; N] where Self: 'a; - type AsBytes<'a> = &'a [u8; N] + type AsBytes<'a> + = &'a [u8; N] where Self: 'a; @@ -350,12 +360,14 @@ impl Key for &[u8; N] { } impl Value for [T; N] { - type SelfType<'a> = [T::SelfType<'a>; N] - where - Self: 'a; - type AsBytes<'a> = Vec - where - Self: 'a; + type SelfType<'a> + = [T::SelfType<'a>; N] + where + Self: 'a; + type AsBytes<'a> + = Vec + where + Self: 'a; fn fixed_width() -> Option { T::fixed_width().map(|x| x * N) @@ -444,10 +456,12 @@ impl Key for [T; N] { } impl Value for &str { - type SelfType<'a> = &'a str + type SelfType<'a> + = &'a str where Self: 'a; - type AsBytes<'a> = &'a str + type AsBytes<'a> + = &'a str where Self: 'a; @@ -483,10 +497,12 @@ impl Key for &str { } impl Value for String { - type SelfType<'a> = String + type SelfType<'a> + = String where Self: 'a; - type AsBytes<'a> = &'a str + type AsBytes<'a> + = &'a str where Self: 'a; @@ -523,7 +539,10 @@ impl Key for String { impl Value for char { type SelfType<'a> = char; - type AsBytes<'a> = [u8; 3] where Self: 'a; + type AsBytes<'a> + = [u8; 3] + where + Self: 'a; fn fixed_width() -> Option { Some(3) @@ -559,7 +578,10 @@ macro_rules! le_value { ($t:ty) => { impl Value for $t { type SelfType<'a> = $t; - type AsBytes<'a> = [u8; std::mem::size_of::<$t>()] where Self: 'a; + type AsBytes<'a> + = [u8; std::mem::size_of::<$t>()] + where + Self: 'a; fn fixed_width() -> Option { Some(std::mem::size_of::<$t>()) diff --git a/tests/backward_compatibility.rs b/tests/backward_compatibility.rs index 5eb241a4..f57efd3f 100644 --- a/tests/backward_compatibility.rs +++ b/tests/backward_compatibility.rs @@ -4,177 +4,177 @@ use redb1::ReadableTable as ReadableTable1; const ELEMENTS: usize = 3; trait TestData: redb::Value + redb2::Value { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] where Self: 'a; - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] where Self: 'a; } impl TestData for u8 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [0, 1, 2] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [0, 1, 2] } } impl TestData for u16 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [0, 1, 2] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [0, 1, 2] } } impl TestData for u32 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [0, 1, 2] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [0, 1, 2] } } impl TestData for u64 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [0, 1, 2] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [0, 1, 2] } } impl TestData for u128 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [0, 1, 2] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [0, 1, 2] } } impl TestData for i8 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [-1, 1, 2] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [-1, 1, 2] } } impl TestData for i16 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [-1, 1, 2] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [-1, 1, 2] } } impl TestData for i32 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [-1, 1, 2] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [-1, 1, 2] } } impl TestData for i64 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [-1, 1, 2] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [-1, 1, 2] } } impl TestData for i128 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [-1, 1, 2] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [-1, 1, 2] } } impl TestData for f32 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [f32::NAN, f32::INFINITY, f32::MIN_POSITIVE] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [f32::NAN, f32::INFINITY, f32::MIN_POSITIVE] } } impl TestData for f64 { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [f64::MIN, f64::NEG_INFINITY, f64::MAX] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [f64::MIN, f64::NEG_INFINITY, f64::MAX] } } impl TestData for () { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [(), (), ()] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [(), (), ()] } } impl TestData for &'static str { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { ["hello", "world1", "hi"] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { ["hello", "world1", "hi"] } } impl TestData for &'static [u8] { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [b"test", b"bytes", b"now"] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [b"test", b"bytes", b"now"] } } impl TestData for &'static [u8; 5] { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [b"test1", b"bytes", b"now12"] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [b"test1", b"bytes", b"now12"] } } impl TestData for [&str; 3] { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] where Self: 'a, { @@ -185,7 +185,7 @@ impl TestData for [&str; 3] { ] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] where Self: 'a, { @@ -198,17 +198,17 @@ impl TestData for [&str; 3] { } impl TestData for [u128; 3] { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [[1, 2, 3], [3, 2, 1], [300, 200, 100]] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [[1, 2, 3], [3, 2, 1], [300, 200, 100]] } } impl TestData for Vec<&str> { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] where Self: 'a, { @@ -219,7 +219,7 @@ impl TestData for Vec<&str> { ] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] where Self: 'a, { @@ -232,21 +232,21 @@ impl TestData for Vec<&str> { } impl TestData for Option { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [None, Some(0), Some(7)] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [None, Some(0), Some(7)] } } impl TestData for (u64, &'static str) { - fn gen2<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data_v2<'a>() -> [::SelfType<'a>; ELEMENTS] { [(0, "hi"), (1, "bye"), (2, "byte")] } - fn gen<'a>() -> [::SelfType<'a>; ELEMENTS] { + fn make_data<'a>() -> [::SelfType<'a>; ELEMENTS] { [(0, "hi"), (1, "bye"), (2, "byte")] } } @@ -267,7 +267,9 @@ fn test_helper::as_bytes(&value); - let expected = &V::gen()[i]; + let expected = &V::make_data()[i]; let expected_bytes = ::as_bytes(expected); assert_eq!(bytes.as_ref(), expected_bytes.as_ref()); } diff --git a/tests/basic_tests.rs b/tests/basic_tests.rs index 68154819..b018d4d3 100644 --- a/tests/basic_tests.rs +++ b/tests/basic_tests.rs @@ -1472,12 +1472,14 @@ fn custom_ordering() { struct ReverseKey(Vec); impl Value for ReverseKey { - type SelfType<'a> = ReverseKey + type SelfType<'a> + = ReverseKey where - Self: 'a; - type AsBytes<'a> = &'a [u8] + Self: 'a; + type AsBytes<'a> + = &'a [u8] where - Self: 'a; + Self: 'a; fn fixed_width() -> Option { None diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs index ad24994e..03e17e1d 100644 --- a/tests/integration_tests.rs +++ b/tests/integration_tests.rs @@ -1,5 +1,5 @@ -use rand::prelude::SliceRandom; use rand::Rng; +use rand::prelude::SliceRandom; use redb::backends::FileBackend; use redb::{ AccessGuard, Builder, CompactionError, Database, Durability, Key, MultimapRange, @@ -12,8 +12,8 @@ use std::fs; use std::io::{ErrorKind, Write}; use std::marker::PhantomData; use std::ops::RangeBounds; -use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::Arc; +use std::sync::atomic::{AtomicBool, Ordering}; const ELEMENTS: usize = 100; @@ -31,12 +31,12 @@ fn create_tempfile() -> tempfile::NamedTempFile { } /// Returns pairs of key, value -fn gen_data(count: usize, key_size: usize, value_size: usize) -> Vec<(Vec, Vec)> { +fn random_data(count: usize, key_size: usize, value_size: usize) -> Vec<(Vec, Vec)> { let mut pairs = vec![]; for _ in 0..count { - let key: Vec = (0..key_size).map(|_| rand::thread_rng().gen()).collect(); - let value: Vec = (0..value_size).map(|_| rand::thread_rng().gen()).collect(); + let key: Vec = (0..key_size).map(|_| rand::rng().random()).collect(); + let value: Vec = (0..value_size).map(|_| rand::rng().random()).collect(); pairs.push((key, value)); } @@ -132,7 +132,7 @@ fn non_durable_commit_persistence() { let db = Database::create(tmpfile.path()).unwrap(); let mut txn = db.begin_write().unwrap(); txn.set_durability(Durability::None); - let pairs = gen_data(100, 16, 20); + let pairs = random_data(100, 16, 20); { let mut table = txn.open_table(SLICE_TABLE).unwrap(); for i in 0..ELEMENTS { @@ -149,7 +149,7 @@ fn non_durable_commit_persistence() { let table = txn.open_table(SLICE_TABLE).unwrap(); let mut key_order: Vec = (0..ELEMENTS).collect(); - key_order.shuffle(&mut rand::thread_rng()); + key_order.shuffle(&mut rand::rng()); { for i in &key_order { @@ -165,7 +165,7 @@ fn test_persistence(durability: Durability) { let db = Database::create(tmpfile.path()).unwrap(); let mut txn = db.begin_write().unwrap(); txn.set_durability(durability); - let pairs = gen_data(100, 16, 20); + let pairs = random_data(100, 16, 20); { let mut table = txn.open_table(SLICE_TABLE).unwrap(); for i in 0..ELEMENTS { @@ -181,7 +181,7 @@ fn test_persistence(durability: Durability) { let table = txn.open_table(SLICE_TABLE).unwrap(); let mut key_order: Vec = (0..ELEMENTS).collect(); - key_order.shuffle(&mut rand::thread_rng()); + key_order.shuffle(&mut rand::rng()); { for i in &key_order {