Skip to content

Safe, fast, and obvious concurrent collections in Rust.

License

Apache-2.0, MIT licenses found

Licenses found

Apache-2.0
LICENSE-APACHE
MIT
LICENSE-MIT
Notifications You must be signed in to change notification settings

nkconnor/sharded

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Note: This crate is still in early development and undergoing API changes. Contributions, feature requests, and constructive feedback are warmly welcomed.

sharded   Build Crate

Sharded provides safe, fast, and obvious concurrent collections in Rust. This crate splits the underlying collection into N shards each with its own lock.

For further reading on the strategy, see a write up on C++'s parallel-hashmap.

Features

  • Zero unsafe code. This library uses #![forbid(unsafe_code)] and was motivated by the complexity and amount of memory errors present in many alternatives.

  • Tiny footprint. The core logic is <100 lines of code. The two dependencies are hashbrown and parking_lot.

  • Really fast. This implementation may be a more performant choice than some of the most popular concurrent hashmaps out there. Try it on your workload and let us know.

See Also

  • contrie - A concurrent hash-trie map & set.
  • dashmap - Blazing fast concurrent HashMap for Rust.
  • flurry - A port of Java's java.util.concurrent.ConcurrentHashMap to Rust.

Quick Start

[dependencies]
sharded = "0.3"

Examples

Insert and retrieve values

let users = ConcurrentHashMap::new();
users.insert(32, "Henry");
assert_eq!(&"Henry", users.get(32).unwrap());

Performance Comparison

These measurements were generated using jonhoo/bustle. To reproduce the charts, see the benchmarks directory. Benchmarks can be misleading. It is recommended to benchmark using a real application workload.

Average Performance by Implementation

This ran each implementation over the presets in bustle::Mix for 5 iterations / random seeds using a Intel® Core™ i9-9820X. Lower numbers are better. Approaches using a single std::sync Lock and chashmap were discarded for clarity (they are a lot slower). If you know why chashmap is so slow in this test, please help here.

Read Heavy Performance) Write Heavy Performance) Update Heavy Performance) Uniform Performance)

Acknowledgements

Many thanks to

  • Reddit community for a few pointers and some motivation to take this project further.

  • Jon Gjengset for the live streams and utility crates involved

  • and countless OSS contributors that made this work possible

License

Licensed under either of Apache License, Version 2.0 or MIT license at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in sharded by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

License: MIT OR Apache-2.0