Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/XiangpengHao/congee
Concurrent ART (adaptive radix tree)
https://github.com/XiangpengHao/congee
adaptive-radix-tree concurrent containers database high-performance index range-index rust
Last synced: about 1 month ago
JSON representation
Concurrent ART (adaptive radix tree)
- Host: GitHub
- URL: https://github.com/XiangpengHao/congee
- Owner: XiangpengHao
- License: mit
- Created: 2022-01-04T02:03:11.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2024-08-14T10:15:01.000Z (about 1 month ago)
- Last Synced: 2024-08-14T11:54:01.201Z (about 1 month ago)
- Topics: adaptive-radix-tree, concurrent, containers, database, high-performance, index, range-index, rust
- Language: Rust
- Homepage:
- Size: 603 KB
- Stars: 82
- Watchers: 2
- Forks: 6
- Open Issues: 6
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Congee
[](https://github.com/XiangpengHao/congee/actions/workflows/ci.yml)
[](
https://crates.io/crates/congee)
[](https://deps.rs/crate/congee)
[](https://codecov.io/gh/XiangpengHao/congee)
[](https://docs.rs/congee)
A Rust implementation of ART-OLC [concurrent adaptive radix tree](https://db.in.tum.de/~leis/papers/artsync.pdf).
It implements the optimistic lock coupling with proper SIMD support.
It only supports (and is optimized for) fixed sized 8 byte key;
due to this specialization, congee has great performance -- basic operations are faster than most hash tables, range scan is an order of magnitude faster.
The codebase is extensively tested with [{address|leak} sanitizer](https://doc.rust-lang.org/beta/unstable-book/compiler-flags/sanitizer.html) as well as [libfuzzer](https://llvm.org/docs/LibFuzzer.html).
Congee's performance is continuously tracked [here](https://xiangpenghao.github.io/congee/dev/bench/).
### Why Congee?
- Fast performance, faster than most hash tables.
- Concurrent, super scalable, it reaches 150Mop/s on 32 cores.
- Super low memory consumption. Hash tables often have exponential bucket size growth, which often lead to low load factors. ART is more space efficient.
### Why not Congee?
- Not for arbitrary key size. This library only supports 8 byte key.
### Design principles
Congee aims to be a simple and reliable **primitive** for building database systems.
### Example:
```rust
use congee::Art;
let art = Art::default();
let guard = art.pin(); // enter an epoch
art.insert(0, 42, &guard); // insert a value
let val = art.get(&0, &guard).unwrap(); // read the value
assert_eq!(val, 42);
let mut scan_buffer = vec![(0, 0); 8];
let scan_result = art.range(&0, &10, &mut scan_buffer, &guard); // scan values
assert_eq!(scan_result, 1);
assert_eq!(scan_buffer[0], (0, 42));
```
### Performance
Benchmarked with the [`conc-map-bench`](https://github.com/xacrimon/conc-map-bench)
