* A lock-by-id future for tokio *
Lock future will return Guard once it gets the mutex.
to hold the lock in subsequent futures, move the Guard inside the future output.
to release the mutex, simply drops the Guard from your future chain.
Each Lock object is assigned an unique id.
The uniqueness is promised until USIZE_MAX of id gets generated.
Make sure old Locks are dropped before you generate new Locks above this amount.
RwLock<HashMap>```rust use dashmap::DashMap; use std::sync::Arc; use std::time::{Duration, Instant}; use tokiolk::*; use futures::prelude::*; use tokio::runtime::Runtime; use tokio::time::delayfor;
let mut rt = Runtime::new().unwrap(); let map = Arc::new(DashMap::new()); let now = Instant::now(); // this task will compete with task2 for lock at id 1 let task1 = async { let guard = Lock::fnew(1, map.clone()).await.await; delayfor(Duration::frommillis(100)).await; }; // this task will compete with task1 for lock at id 1 let task2 = async { let _guard = Lock::fnew(1, map.clone()).await.await; delayfor(Duration::frommillis(100)).await; }; // no other task compete for lock at id 2 let task3 = async { let _guard = Lock::fnew(2, map.clone()).await.await; delayfor(Duration::frommillis(100)).await; }; rt.blockon(async { tokio::join!(task1, task2, task3) }); ```
to run the benchmark, execute the following command in the prompt:
bash
cargo bench -- --nocapture
The lock1000_parallel benchmark is to run 1000 futures locked by a single lock to update the
counter.
The lock1000_serial benchmark is to run run similar operations in a single thread.
Currently our implementation is about 4~5 times slower than the single threaded version.
Licensed under
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, shall be licensed as above, without any additional terms or conditions.