Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Cow snapshots instead of always cloning #161

Merged
merged 2 commits into from
Nov 5, 2019
Merged

Cow snapshots instead of always cloning #161

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
cebde80
Make transaction snapshots cheaper in the general case
victorporof Nov 3, 2019
2bd0ab7
Add tests for intertwined read/write transactions
victorporof Nov 2, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion Cargo.toml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,7 +16,7 @@ exclude = ["/tests/envs/*"]
[features]
default = ["with-safe-mode"]
backtrace = ["failure/backtrace", "failure/std"]
with-safe-mode = ["id-arena", "log", "serde/derive"]
with-safe-mode = ["id-arena", "log", "serde/derive", "serde/rc"]
with-asan = ["lmdb-rkv/with-asan"]
with-fuzzer = ["lmdb-rkv/with-fuzzer"]
with-fuzzer-no-link = ["lmdb-rkv/with-fuzzer-no-link"]
Expand Down
23 changes: 16 additions & 7 deletions src/backend/impl_safe/database.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,7 @@ use std::collections::{
BTreeSet,
HashMap,
};
use std::sync::Arc;

use id_arena::Id;
use serde_derive::{
Expand Down Expand Up @@ -47,17 +48,20 @@ impl DatabaseImpl {
}
}

type Key = Box<[u8]>;
type Value = Box<[u8]>;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Snapshot {
flags: DatabaseFlagsImpl,
map: HashMap<Box<[u8]>, BTreeSet<Box<[u8]>>>,
map: Arc<HashMap<Key, BTreeSet<Value>>>,
}

impl Snapshot {
pub(crate) fn new(flags: Option<DatabaseFlagsImpl>) -> Snapshot {
Snapshot {
flags: flags.unwrap_or_else(DatabaseFlagsImpl::default),
map: HashMap::new(),
map: Default::default(),
}
}

Expand All @@ -70,31 +74,36 @@ impl Snapshot {
}

pub(crate) fn put_one(&mut self, key: &[u8], value: &[u8]) {
let values = self.map.entry(Box::from(key)).or_insert_with(BTreeSet::new);
let map = Arc::make_mut(&mut self.map);
let values = map.entry(Box::from(key)).or_insert_with(BTreeSet::new);
values.clear();
values.insert(Box::from(value));
}

pub(crate) fn put_dup(&mut self, key: &[u8], value: &[u8]) {
let values = self.map.entry(Box::from(key)).or_insert_with(BTreeSet::new);
let map = Arc::make_mut(&mut self.map);
let values = map.entry(Box::from(key)).or_insert_with(BTreeSet::new);
values.insert(Box::from(value));
}

pub(crate) fn del_exact(&mut self, key: &[u8], value: &[u8]) -> Option<()> {
let values = self.map.entry(Box::from(key)).or_insert_with(BTreeSet::new);
let map = Arc::make_mut(&mut self.map);
let values = map.entry(Box::from(key)).or_insert_with(BTreeSet::new);
let was_removed = values.remove(value);
Some(()).filter(|_| was_removed)
}

pub(crate) fn del_all(&mut self, key: &[u8]) -> Option<()> {
let values = self.map.entry(Box::from(key)).or_insert_with(BTreeSet::new);
let map = Arc::make_mut(&mut self.map);
let values = map.entry(Box::from(key)).or_insert_with(BTreeSet::new);
let was_empty = values.is_empty();
values.clear();
Some(()).filter(|_| !was_empty)
}

pub(crate) fn clear(&mut self) {
self.map.clear();
let map = Arc::make_mut(&mut self.map);
map.clear();
}

pub(crate) fn iter(&self) -> impl Iterator<Item = (&[u8], &[u8])> {
Expand Down
120 changes: 120 additions & 0 deletions src/store/integer.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -246,6 +246,66 @@ mod tests {
assert_eq!(s.get(&reader, 3).expect("read"), Some(Value::Str("hello!")));
}
}

#[test]
fn test_intertwine_read_write() {
let root = Builder::new().prefix("test_integer_intertwine_read_write").tempdir().expect("tempdir");
fs::create_dir_all(root.path()).expect("dir created");

let k = Rkv::new::<backend::Lmdb>(root.path()).expect("new succeeded");
let s = k.open_integer("s", StoreOptions::create()).expect("open");

{
let mut writer = k.write().expect("writer");
s.put(&mut writer, 1, &Value::Str("hello!")).expect("write");
assert_eq!(s.get(&writer, 1).expect("read"), Some(Value::Str("hello!")));
assert_eq!(s.get(&writer, 2).expect("read"), None);
assert_eq!(s.get(&writer, 3).expect("read"), None);
writer.commit().expect("committed");
}

let reader = k.read().expect("reader");
let mut writer = k.write().expect("writer");

{
assert_eq!(s.get(&reader, 1).expect("read"), Some(Value::Str("hello!")));
assert_eq!(s.get(&reader, 2).expect("read"), None);
assert_eq!(s.get(&reader, 3).expect("read"), None);
}

{
s.put(&mut writer, 1, &Value::Str("goodbye!")).expect("write");
s.put(&mut writer, 2, &Value::Str("goodbye!")).expect("write");
s.put(&mut writer, 3, &Value::Str("goodbye!")).expect("write");
assert_eq!(s.get(&writer, 1).expect("read"), Some(Value::Str("goodbye!")));
assert_eq!(s.get(&writer, 2).expect("read"), Some(Value::Str("goodbye!")));
assert_eq!(s.get(&writer, 3).expect("read"), Some(Value::Str("goodbye!")));
writer.commit().expect("committed");
}

{
assert_eq!(s.get(&reader, 1).expect("read"), Some(Value::Str("hello!")));
assert_eq!(s.get(&reader, 2).expect("read"), None);
assert_eq!(s.get(&reader, 3).expect("read"), None);
}

{
let mut writer = k.write().expect("writer");
s.put(&mut writer, 1, &Value::Str("hello!")).expect("write");
assert_eq!(s.get(&writer, 1).expect("read"), Some(Value::Str("hello!")));
assert_eq!(s.get(&writer, 2).expect("read"), Some(Value::Str("goodbye!")));
assert_eq!(s.get(&writer, 3).expect("read"), Some(Value::Str("goodbye!")));
writer.commit().expect("committed");
}

{
let reader = k.write().expect("reader");
assert_eq!(s.get(&reader, 1).expect("read"), Some(Value::Str("hello!")));
assert_eq!(s.get(&reader, 2).expect("read"), Some(Value::Str("goodbye!")));
assert_eq!(s.get(&reader, 3).expect("read"), Some(Value::Str("goodbye!")));
reader.commit().expect("committed");
}
}
}

#[cfg(test)]
Expand Down Expand Up @@ -419,4 +479,64 @@ mod tests_safe {
assert_eq!(s.get(&reader, 3).expect("read"), Some(Value::Str("hello!")));
}
}

#[test]
fn test_intertwine_read_write() {
let root = Builder::new().prefix("test_integer_intertwine_read_write").tempdir().expect("tempdir");
fs::create_dir_all(root.path()).expect("dir created");

let k = Rkv::new::<backend::SafeMode>(root.path()).expect("new succeeded");
let s = k.open_integer("s", StoreOptions::create()).expect("open");

{
let mut writer = k.write().expect("writer");
s.put(&mut writer, 1, &Value::Str("hello!")).expect("write");
assert_eq!(s.get(&writer, 1).expect("read"), Some(Value::Str("hello!")));
assert_eq!(s.get(&writer, 2).expect("read"), None);
assert_eq!(s.get(&writer, 3).expect("read"), None);
writer.commit().expect("committed");
}

let reader = k.read().expect("reader");
let mut writer = k.write().expect("writer");

{
assert_eq!(s.get(&reader, 1).expect("read"), Some(Value::Str("hello!")));
assert_eq!(s.get(&reader, 2).expect("read"), None);
assert_eq!(s.get(&reader, 3).expect("read"), None);
}

{
s.put(&mut writer, 1, &Value::Str("goodbye!")).expect("write");
s.put(&mut writer, 2, &Value::Str("goodbye!")).expect("write");
s.put(&mut writer, 3, &Value::Str("goodbye!")).expect("write");
assert_eq!(s.get(&writer, 1).expect("read"), Some(Value::Str("goodbye!")));
assert_eq!(s.get(&writer, 2).expect("read"), Some(Value::Str("goodbye!")));
assert_eq!(s.get(&writer, 3).expect("read"), Some(Value::Str("goodbye!")));
writer.commit().expect("committed");
}

{
assert_eq!(s.get(&reader, 1).expect("read"), Some(Value::Str("hello!")));
assert_eq!(s.get(&reader, 2).expect("read"), None);
assert_eq!(s.get(&reader, 3).expect("read"), None);
}

{
let mut writer = k.write().expect("writer");
s.put(&mut writer, 1, &Value::Str("hello!")).expect("write");
assert_eq!(s.get(&writer, 1).expect("read"), Some(Value::Str("hello!")));
assert_eq!(s.get(&writer, 2).expect("read"), Some(Value::Str("goodbye!")));
assert_eq!(s.get(&writer, 3).expect("read"), Some(Value::Str("goodbye!")));
writer.commit().expect("committed");
}

{
let reader = k.write().expect("reader");
assert_eq!(s.get(&reader, 1).expect("read"), Some(Value::Str("hello!")));
assert_eq!(s.get(&reader, 2).expect("read"), Some(Value::Str("goodbye!")));
assert_eq!(s.get(&reader, 3).expect("read"), Some(Value::Str("goodbye!")));
reader.commit().expect("committed");
}
}
}