DiskLRU is an experimental LRU store implemented in Rust.
It works as a simple key-value store and is powered by sled which is a lightweight pure-rust high-performance transactional embedded database.
It expires entries automatically passed a given number, following the LRU (least recently used) strategy, which is a quite common cache replacement policy.
It comes with a cost but is sometimes more adapted than just expiring the old keys in FIFO mode (first-in, first-out) as you may have a key-value pair which has been introduced a very long time ago in the store, but is still relevant. With DiskLRU, if your code is reading the value often, it will ensure the key stays alive and does not disappear.
HashLRU is very similar in its design, and acts as an in-memory cache, as opposed to DiskLRU being a persistent store.
For now this is a toy project, clearly NOT suitable for production use.
Here is a quick bench done on a 100k items store:
``` running 8 tests test tests::benchreadusizedisklru ... bench: 18,179 ns/iter (+/- 16,489) test tests::benchreadusizehashlru ... bench: 39 ns/iter (+/- 4) test tests::benchreadusizehashmap ... bench: 13 ns/iter (+/- 0) test tests::benchreadusizelru ... bench: 9 ns/iter (+/- 0) test tests::benchwriteusizedisklru ... bench: 34,290 ns/iter (+/- 26,546) test tests::benchwriteusizehashlru ... bench: 104 ns/iter (+/- 15) test tests::benchwriteusizehashmap ... bench: 67 ns/iter (+/- 13) test tests::benchwriteusizelru ... bench: 22 ns/iter (+/- 5)
test result: ok. 0 passed; 0 failed; 0 ignored; 8 measured; 0 filtered out; finished in 30.12s ```
Those results are not super reliable, just a one-shot test ran on a laptop.
However there is a tendency: disklru is way slower than any real non-persistent
in-memory cache, and it has a high variability in results, very likely due to
the fact some flushes must happen somewhere in the process, acting as outliers.
```rust use disklru::Store;
let mut store = Store::opentemporary(4).unwrap(); store.insert(&1, &10).unwrap(); store.insert(&2, &20).unwrap(); store.insert(&3, &30).unwrap(); store.insert(&4, &40).unwrap(); store.insert(&5, &50).unwrap(); // key1 has been dropped, size is limited to 4 asserteq!(Some(2), store.lru().unwrap()); asserteq!(Some(20), store.get(&2).unwrap()); // getting key2 has made key3 the least recently used item asserteq!(Some(3), store.lru().unwrap()); asserteq!(Some(40), store.get(&4).unwrap()); // getting key4 makes it the most recently used item asserteq!("[3: 30, 5: 50, 2: 20, 4: 40]", format!("{}", store)); store.flush().unwrap(); // commit ```
DiskLRU is licensed under the MIT license.