V4

.github/workflows/ci.yml

@@ -7,6 +7,11 @@ jobs:
     runs-on: ubuntu-18.04
     steps:
     - uses: actions/checkout@v2
+    - name: setup
+      run: |
+        rustup install stable-2020-06-18-x86_64-unknown-linux-gnu
+        rustup component add rustfmt --toolchain stable-2020-06-18-x86_64-unknown-linux-gnu
+        rustup component add clippy --toolchain stable-2020-06-18-x86_64-unknown-linux-gnu
     - name: style
       run: cargo fmt -- --check
     - name: clippy
@@ -21,8 +26,7 @@ jobs:
           i686-unknown-linux-gnu,
           aarch64-unknown-linux-gnu,
           armv7-linux-androideabi,
-          powerpc-unknown-linux-gnu,
-          wasm32-unknown-emscripten
+          powerpc-unknown-linux-gnu
         ]
     steps:
       - uses: actions/checkout@v2
@@ -36,15 +40,6 @@ jobs:
 
           # --
 
-          # add podman ppa
-
-          echo "adding podman ppa"
-          . /etc/os-release
-          echo "deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/xUbuntu_${VERSION_ID}/ /" | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
-          curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/xUbuntu_${VERSION_ID}/Release.key | sudo apt-key add -
-
-          # --
-
           # add docker ppa
 
           echo "adding docker ppa"
@@ -53,11 +48,11 @@ jobs:
 
           # --
 
-          # install docker and podman
+          # install docker
 
-          echo "installing docker and podman"
+          echo "installing docker"
           sudo apt-get update
-          sudo apt-get install docker-ce podman
+          sudo apt-get install docker-ce
 
           # --
 

.gitignore

@@ -1,3 +1,4 @@
 /target
 **/*.rs.bk
-Cargo.lock
+/Cargo.lock
+/concurrent-test/target

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dashmap"
-version = "3.11.10"
+version = "4.0.0-rc6"
 authors = ["Acrimon <[email protected]>"]
 edition = "2018"
 license = "MIT"
@@ -12,17 +12,5 @@ documentation = "https://docs.rs/dashmap"
 keywords = ["atomic", "concurrent", "hashmap"]
 categories = ["concurrency", "algorithms", "data-structures"]
 
-[features]
-default = []
-raw-api = []
-no_std = ["hashbrown"]
-
 [dependencies]
-num_cpus = "1.13.0"
-ahash = "0.3.8"
-serde = { version = "1.0.114", optional = true, features = ["derive"] }
-cfg-if = "0.1.10"
-hashbrown = { version = "0.8.0", optional = true }
-
-[package.metadata.docs.rs]
-features = ["raw-api", "serde"]
+flize = { version = "2.0.0", default-features = false, features = ["ebr"] }

README.md

@@ -1,17 +1,11 @@
 # DashMap
 
-Blazingly fast concurrent map in Rust.
+DashMap is a blazing fast implementation of a concurrent key -> value map.
 
-DashMap is an implementation of a concurrent associative array/hashmap in Rust.
+DashMap tries to implement an easy to use API while also having more advanced interfaces
+for squeezing out performance.
 
-DashMap tries to implement an easy to use API similar to `std::collections::HashMap`
-with some slight changes to handle concurrency.
-
-DashMap tries to be very simple to use and to be a direct replacement for `RwLock<HashMap<K, V>>`.
-To accomplish these all methods take `&self` instead modifying methods taking `&mut self`.
-This allows you to put a DashMap in an `Arc<T>` and share it between threads while being able to modify it.
-
-DashMap puts great effort into performance and aims to be as fast as possible.
+We put great effort into performance and aims to be as fast as possible.
 If you have any suggestions or tips do not hesitate to open an issue or a PR.
 
 [Documentation](https://docs.rs/dashmap)
@@ -20,35 +14,33 @@ If you have any suggestions or tips do not hesitate to open an issue or a PR.
 
 [![downloads](https://img.shields.io/crates/d/dashmap)](https://crates.io/crates/dashmap)
 
-## Cargo features
+[![minimum rustc version](https://img.shields.io/badge/rustc-1.44.1-orange.svg)](https://github.com/rust-random/rand#rust-version-requirements)
+
+## Serde support
 
-- `no_std` - Enable no_std + alloc support.
+Turn on the `serde` feature and `DashMap` will implement `Serialize` and `Deserialize`.
+
+## Contributing
 
-- `serde` - Enables serde support.
+DashMap is gladly accepts contributions!
+Do not hesitate to open issues or PR's.
+
+## Performance
 
-- `raw-api` - Enables the unstable raw-shard api.
+DashMap is included in a set of benchmarks found [here](https://git.acrimon.dev/Acrimon/conc-map-bench)
+that use [bustle](https://docs.rs/bustle), a port of the libcuckoo benchmark harness.
+Benchmarks are a best effort and we try to make them as unbiased and realistic as possible. Contributions are accepted there too!
 
 ## Support
 
-[![Foo](https://c5.patreon.com/external/logo/[email protected])](https://patreon.com/acrimon)
+[![Patreon](https://c5.patreon.com/external/logo/[email protected])](https://patreon.com/acrimon)
 
 Creating and testing open-source software like DashMap takes up a large portion of my time
 and comes with costs such as test hardware. Please consider supporting me and everything I make for the public
 to enable me to continue doing this.
 
 If you want to support me please head over and take a look at my [patreon](https://www.patreon.com/acrimon).
 
-## Contributing
-
-DashMap is gladly accepts contributions!
-Do not hesitate to open issues or PR's.
-
-I will take a look as soon as I have time for it.
-
-## Performance
-
-A comprehensive benchmark suite including DashMap can be found [here](https://git.acrimon.dev/Acrimon/conc-map-bench).
-
 ## Special thanks
 
 - [Jon Gjengset](https://github.com/jonhoo)

rust-toolchain

@@ -0,0 +1 @@
+stable-2020-06-18

src/alloc.rs

@@ -0,0 +1,84 @@
+//! The `alloc` module contains types and traits for
+//! customizing the memory allocation behaviour of the map.
+
+use std::alloc::{alloc, dealloc, Layout};
+use std::ptr;
+
+/// This trait defines the interface for the object allocator the map uses to allocate buckets.
+/// Bucket allocators should be swappable to the needs of the user.
+/// The `V` type parameter designates the object type.
+pub trait ObjectAllocator<V>: Send + Sync {
+    /// The `Tag` associated type is a unique tag that can be used to identify an allocation.
+    type Tag: Copy + Default;
+
+    /// Allocates a new object and returns a identifying tag and a pointer.
+    /// The pointer must the valid for the lifetime of the allocator.
+    fn allocate(&self, item: V) -> (Self::Tag, *mut V);
+
+    /// Deallocates an object with a specific tag.
+    ///
+    /// # Safety
+    /// An allocation may only be deallocated exactly once, hence this function is unsafe.
+    /// Calling this function multiple times for the same allocation is undefined behaviour.
+    ///
+    /// Note that you may call this function multiple times with the same tag
+    /// if you've received the same tag multiple times from `allocate`.
+    /// This may happen as tag reuse is allowed.
+    unsafe fn deallocate(&self, tag: Self::Tag);
+}
+
+/// The default object allocator. This is merely a typed wrapper around the global allocator.
+/// This shouldn't have any unexpected properties and is a balanced choice,
+/// only crippled by the occasionally mediocre performance of the global allocator.
+pub struct GlobalObjectAllocator;
+
+impl<V> ObjectAllocator<V> for GlobalObjectAllocator {
+    type Tag = usize;
+
+    fn allocate(&self, item: V) -> (Self::Tag, *mut V) {
+        let layout = Layout::new::<V>();
+        let ptr = unsafe { alloc(layout) } as *mut V;
+
+        // # Safety
+        // The block of memory we are writing to is freshly allocated with the correct layout.
+        // Since there is nothing there we can safely perform a raw write.
+        unsafe { ptr::write(ptr, item) }
+
+        (ptr as usize, ptr)
+    }
+
+    unsafe fn deallocate(&self, tag: Self::Tag) {
+        let ptr = tag as *mut V;
+        let layout = Layout::new::<V>();
+
+        // most allocators accept null but we consider it invalid
+        debug_assert!(!ptr.is_null());
+
+        // # Safety
+        // We call `drop_in_place` here to drop the value at this memory location.
+        // This is safe to do since it is guaranteed to be initialized.
+        ptr::drop_in_place(ptr);
+
+        // # Safety
+        // Here we dellocate the memory which is fine to do as it is guaranteed
+        // to be allocated assuming the implementation of `allocate` is valid.
+        // `dealloc` does not perform any drop calls, that's why we did that manually earlier.
+        dealloc(ptr as _, layout);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{GlobalObjectAllocator, ObjectAllocator};
+
+    #[test]
+    fn alloc_dealloc() {
+        let allocator = GlobalObjectAllocator;
+        let (tag, _ptr) =
+            <GlobalObjectAllocator as ObjectAllocator<usize>>::allocate(&allocator, 55);
+
+        unsafe {
+            <GlobalObjectAllocator as ObjectAllocator<usize>>::deallocate(&allocator, tag);
+        }
+    }
+}

src/bucket.rs

@@ -0,0 +1,73 @@
+use crate::alloc::{GlobalObjectAllocator, ObjectAllocator};
+use std::ops::Deref;
+use flize::{ebr::Ebr, function_runner::FunctionRunner, Shield};
+
+/// Represents an occupied slot in a map.
+/// Besides the key and value it contains the allocator tag
+/// so it can deallocate itself when it's lifetime ends.
+pub struct Bucket<K, V, A: ObjectAllocator<Self>> {
+    pub(crate) tag: A::Tag,
+    pub(crate) key: K,
+    pub(crate) value: V,
+}
+
+impl<K, V, A: ObjectAllocator<Self>> Bucket<K, V, A> {
+    /// Create a new bucket with a default tag.
+    /// The tag will need to be set to the correct value before being published to the map.
+    pub fn new(key: K, value: V) -> Self {
+        Self {
+            tag: A::Tag::default(),
+            key,
+            value,
+        }
+    }
+
+    pub fn read<'a>(&'a self, shield: Shield<'a, Ebr<FunctionRunner>>) -> Guard<'a, K, V, A> {
+        Guard::new(self, shield)
+    }
+}
+
+/// A guard is a view of a map entry.
+/// It exists to automatically manage memory behind the scenes.
+pub struct Guard<'a, K, V, A: ObjectAllocator<Bucket<K, V, A>> = GlobalObjectAllocator> {
+    bucket: &'a Bucket<K, V, A>,
+    shield: Shield<'a, Ebr<FunctionRunner>>,
+}
+
+impl<'a, K, V, A: ObjectAllocator<Bucket<K, V, A>>> Guard<'a, K, V, A> {
+    fn new(bucket: &'a Bucket<K, V, A>, shield: Shield<'a, Ebr<FunctionRunner>>) -> Self {
+        Self { bucket, shield }
+    }
+
+    /// Returns the key associated with this entry.
+    pub fn key(&self) -> &K {
+        &self.bucket.key
+    }
+
+    /// Returns the value associated with this entry.
+    pub fn value(&self) -> &V {
+        &self.bucket.value
+    }
+
+    /// Returns both the key and the value associated with this entry.
+    pub fn pair(&self) -> (&K, &V) {
+        (&self.bucket.key, &self.bucket.value)
+    }
+}
+
+impl<'a, K, V, A: ObjectAllocator<Bucket<K, V, A>>> Deref for Guard<'a, K, V, A> {
+    type Target = V;
+
+    fn deref(&self) -> &Self::Target {
+        self.value()
+    }
+}
+
+impl<'a, K, V, A: ObjectAllocator<Bucket<K, V, A>>> Clone for Guard<'a, K, V, A> {
+    fn clone(&self) -> Self {
+        Self {
+            bucket: self.bucket,
+            shield: self.shield.clone(),
+        }
+    }
+}