diff options
Diffstat (limited to 'benches')
| -rw-r--r-- | benches/Cargo.toml | 11 | ||||
| -rw-r--r-- | benches/sync_rwlock.rs | 147 | ||||
| -rw-r--r-- | benches/sync_semaphore.rs | 130 |
3 files changed, 288 insertions, 0 deletions
diff --git a/benches/Cargo.toml b/benches/Cargo.toml index f4a1d8fb..75723ce2 100644 --- a/benches/Cargo.toml +++ b/benches/Cargo.toml @@ -22,3 +22,14 @@ harness = false name = "scheduler" path = "scheduler.rs" harness = false + + +[[bench]] +name = "sync_rwlock" +path = "sync_rwlock.rs" +harness = false + +[[bench]] +name = "sync_semaphore" +path = "sync_semaphore.rs" +harness = false diff --git a/benches/sync_rwlock.rs b/benches/sync_rwlock.rs new file mode 100644 index 00000000..4eca9807 --- /dev/null +++ b/benches/sync_rwlock.rs @@ -0,0 +1,147 @@ +use bencher::{black_box, Bencher}; +use std::sync::Arc; +use tokio::{sync::RwLock, task}; + +fn read_uncontended(b: &mut Bencher) { + let mut rt = tokio::runtime::Builder::new() + .core_threads(6) + .threaded_scheduler() + .build() + .unwrap(); + + let lock = Arc::new(RwLock::new(())); + b.iter(|| { + let lock = lock.clone(); + rt.block_on(async move { + for _ in 0..6 { + let read = lock.read().await; + black_box(read); + } + }) + }); +} + +fn read_concurrent_uncontended_multi(b: &mut Bencher) { + let mut rt = tokio::runtime::Builder::new() + .core_threads(6) + .threaded_scheduler() + .build() + .unwrap(); + + async fn task(lock: Arc<RwLock<()>>) { + let read = lock.read().await; + black_box(read); + } + + let lock = Arc::new(RwLock::new(())); + b.iter(|| { + let lock = lock.clone(); + rt.block_on(async move { + let j = tokio::try_join! { + task::spawn(task(lock.clone())), + task::spawn(task(lock.clone())), + task::spawn(task(lock.clone())), + task::spawn(task(lock.clone())), + task::spawn(task(lock.clone())), + task::spawn(task(lock.clone())) + }; + j.unwrap(); + }) + }); +} + +fn read_concurrent_uncontended(b: &mut Bencher) { + let mut rt = tokio::runtime::Builder::new() + .basic_scheduler() + .build() + .unwrap(); + + async fn task(lock: Arc<RwLock<()>>) { + let read = lock.read().await; + black_box(read); + } + + let lock = Arc::new(RwLock::new(())); + b.iter(|| { + let lock = lock.clone(); + rt.block_on(async move { + tokio::join! { + task(lock.clone()), + task(lock.clone()), + task(lock.clone()), + task(lock.clone()), + task(lock.clone()), + task(lock.clone()) + }; + }) + }); +} + +fn read_concurrent_contended_multi(b: &mut Bencher) { + let mut rt = tokio::runtime::Builder::new() + .core_threads(6) + .threaded_scheduler() + .build() + .unwrap(); + + async fn task(lock: Arc<RwLock<()>>) { + let read = lock.read().await; + black_box(read); + } + + let lock = Arc::new(RwLock::new(())); + b.iter(|| { + let lock = lock.clone(); + rt.block_on(async move { + let write = lock.write().await; + let j = tokio::try_join! { + async move { drop(write); Ok(()) }, + task::spawn(task(lock.clone())), + task::spawn(task(lock.clone())), + task::spawn(task(lock.clone())), + task::spawn(task(lock.clone())), + task::spawn(task(lock.clone())), + }; + j.unwrap(); + }) + }); +} + +fn read_concurrent_contended(b: &mut Bencher) { + let mut rt = tokio::runtime::Builder::new() + .basic_scheduler() + .build() + .unwrap(); + + async fn task(lock: Arc<RwLock<()>>) { + let read = lock.read().await; + black_box(read); + } + + let lock = Arc::new(RwLock::new(())); + b.iter(|| { + let lock = lock.clone(); + rt.block_on(async move { + let write = lock.write().await; + tokio::join! { + async move { drop(write) }, + task(lock.clone()), + task(lock.clone()), + task(lock.clone()), + task(lock.clone()), + task(lock.clone()), + }; + }) + }); +} + +bencher::benchmark_group!( + sync_rwlock, + read_uncontended, + read_concurrent_uncontended, + read_concurrent_uncontended_multi, + read_concurrent_contended, + read_concurrent_contended_multi +); + +bencher::benchmark_main!(sync_rwlock); diff --git a/benches/sync_semaphore.rs b/benches/sync_semaphore.rs new file mode 100644 index 00000000..c43311c0 --- /dev/null +++ b/benches/sync_semaphore.rs @@ -0,0 +1,130 @@ +use bencher::Bencher; +use std::sync::Arc; +use tokio::{sync::Semaphore, task}; + +fn uncontended(b: &mut Bencher) { + let mut rt = tokio::runtime::Builder::new() + .core_threads(6) + .threaded_scheduler() + .build() + .unwrap(); + + let s = Arc::new(Semaphore::new(10)); + b.iter(|| { + let s = s.clone(); + rt.block_on(async move { + for _ in 0..6 { + let permit = s.acquire().await; + drop(permit); + } + }) + }); +} + +async fn task(s: Arc<Semaphore>) { + let permit = s.acquire().await; + drop(permit); +} + +fn uncontended_concurrent_multi(b: &mut Bencher) { + let mut rt = tokio::runtime::Builder::new() + .core_threads(6) + .threaded_scheduler() + .build() + .unwrap(); + + let s = Arc::new(Semaphore::new(10)); + b.iter(|| { + let s = s.clone(); + rt.block_on(async move { + let j = tokio::try_join! { + task::spawn(task(s.clone())), + task::spawn(task(s.clone())), + task::spawn(task(s.clone())), + task::spawn(task(s.clone())), + task::spawn(task(s.clone())), + task::spawn(task(s.clone())) + }; + j.unwrap(); + }) + }); +} + +fn uncontended_concurrent_single(b: &mut Bencher) { + let mut rt = tokio::runtime::Builder::new() + .basic_scheduler() + .build() + .unwrap(); + + let s = Arc::new(Semaphore::new(10)); + b.iter(|| { + let s = s.clone(); + rt.block_on(async move { + tokio::join! { + task(s.clone()), + task(s.clone()), + task(s.clone()), + task(s.clone()), + task(s.clone()), + task(s.clone()) + }; + }) + }); +} + +fn contended_concurrent_multi(b: &mut Bencher) { + let mut rt = tokio::runtime::Builder::new() + .core_threads(6) + .threaded_scheduler() + .build() + .unwrap(); + + let s = Arc::new(Semaphore::new(5)); + b.iter(|| { + let s = s.clone(); + rt.block_on(async move { + let j = tokio::try_join! { + task::spawn(task(s.clone())), + task::spawn(task(s.clone())), + task::spawn(task(s.clone())), + task::spawn(task(s.clone())), + task::spawn(task(s.clone())), + task::spawn(task(s.clone())) + }; + j.unwrap(); + }) + }); +} + +fn contended_concurrent_single(b: &mut Bencher) { + let mut rt = tokio::runtime::Builder::new() + .basic_scheduler() + .build() + .unwrap(); + + let s = Arc::new(Semaphore::new(5)); + b.iter(|| { + let s = s.clone(); + rt.block_on(async move { + tokio::join! { + task(s.clone()), + task(s.clone()), + task(s.clone()), + task(s.clone()), + task(s.clone()), + task(s.clone()) + }; + }) + }); +} + +bencher::benchmark_group!( + sync_semaphore, + uncontended, + uncontended_concurrent_multi, + uncontended_concurrent_single, + contended_concurrent_multi, + contended_concurrent_single +); + +bencher::benchmark_main!(sync_semaphore); |