dev: repository benchmark uses criterion

Author: da2ce7

Cargo.lock

@@ -81,7 +81,7 @@ trace = "0.1.7"
 tracing = "0.1.40"
 
 [dev-dependencies]
-criterion = { version = "0.5.1", features = ["async_tokio"] }
+criterion = { version = "0", features = ["async_tokio"] }
 local-ip-address = "0"
 mockall = "0"
 once_cell = "1.18.0"

Cargo.toml

@@ -23,4 +23,11 @@ torrust-tracker-primitives = { version = "3.0.0-alpha.12-develop", path = "../pr
 torrust-tracker-configuration = { version = "3.0.0-alpha.12-develop", path = "../configuration" }
 serde = { version = "1", features = ["derive"] }
 tdyne-peer-id = "1"
-tdyne-peer-id-registry = "0"
+tdyne-peer-id-registry = "0"
+
+[dev-dependencies]
+criterion = { version = "0", features = ["async_tokio"] }
+
+[[bench]]
+harness = false
+name = "repository_benchmark"

packages/torrent-repository/Cargo.toml

@@ -1,178 +1,147 @@
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
-use clap::Parser;
 use futures::stream::FuturesUnordered;
 use torrust_tracker_primitives::info_hash::InfoHash;
 use torrust_tracker_torrent_repository::repository::UpdateTorrentAsync;
 
-use super::args::Args;
-use super::utils::{generate_unique_info_hashes, get_average_and_adjusted_average_from_results, DEFAULT_PEER};
+use super::utils::{generate_unique_info_hashes, DEFAULT_PEER};
 
-pub async fn add_one_torrent<V>(samples: usize) -> (Duration, Duration)
+pub async fn add_one_torrent<V>(samples: u64) -> Duration
 where
     V: UpdateTorrentAsync + Default,
 {
-    let mut results: Vec<Duration> = Vec::with_capacity(samples);
+    let start = Instant::now();
 
     for _ in 0..samples {
         let torrent_repository = V::default();
 
         let info_hash = InfoHash([0; 20]);
 
-        let start_time = std::time::Instant::now();
-
         torrent_repository
             .update_torrent_with_peer_and_get_stats(&info_hash, &DEFAULT_PEER)
             .await;
-
-        let result = start_time.elapsed();
-
-        results.push(result);
     }
 
-    get_average_and_adjusted_average_from_results(results)
+    start.elapsed()
 }
 
 // Add one torrent ten thousand times in parallel (depending on the set worker threads)
-pub async fn update_one_torrent_in_parallel<V>(runtime: &tokio::runtime::Runtime, samples: usize) -> (Duration, Duration)
+pub async fn update_one_torrent_in_parallel<V>(runtime: &tokio::runtime::Runtime, samples: u64, sleep: Option<u64>) -> Duration
 where
     V: UpdateTorrentAsync + Default + Clone + Send + Sync + 'static,
 {
-    let args = Args::parse();
-    let mut results: Vec<Duration> = Vec::with_capacity(samples);
-
-    for _ in 0..samples {
-        let torrent_repository = V::default();
-        let info_hash: &'static InfoHash = &InfoHash([0; 20]);
-        let handles = FuturesUnordered::new();
-
-        // Add the torrent/peer to the torrent repository
-        torrent_repository
-            .update_torrent_with_peer_and_get_stats(info_hash, &DEFAULT_PEER)
-            .await;
+    let torrent_repository = V::default();
+    let info_hash: &'static InfoHash = &InfoHash([0; 20]);
+    let handles = FuturesUnordered::new();
 
-        let start_time = std::time::Instant::now();
+    // Add the torrent/peer to the torrent repository
+    torrent_repository
+        .update_torrent_with_peer_and_get_stats(info_hash, &DEFAULT_PEER)
+        .await;
 
-        for _ in 0..10_000 {
-            let torrent_repository_clone = torrent_repository.clone();
+    let start = Instant::now();
 
-            let handle = runtime.spawn(async move {
-                torrent_repository_clone
-                    .update_torrent_with_peer_and_get_stats(info_hash, &DEFAULT_PEER)
-                    .await;
-
-                if let Some(sleep_time) = args.sleep {
-                    let start_time = std::time::Instant::now();
-
-                    while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
-                }
-            });
+    for _ in 0..samples {
+        let torrent_repository_clone = torrent_repository.clone();
 
-            handles.push(handle);
-        }
+        let handle = runtime.spawn(async move {
+            torrent_repository_clone
+                .update_torrent_with_peer_and_get_stats(info_hash, &DEFAULT_PEER)
+                .await;
 
-        // Await all tasks
-        futures::future::join_all(handles).await;
+            if let Some(sleep_time) = sleep {
+                let start_time = std::time::Instant::now();
 
-        let result = start_time.elapsed();
+                while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
+            }
+        });
 
-        results.push(result);
+        handles.push(handle);
     }
 
-    get_average_and_adjusted_average_from_results(results)
+    // Await all tasks
+    futures::future::join_all(handles).await;
+
+    start.elapsed()
 }
 
 // Add ten thousand torrents in parallel (depending on the set worker threads)
-pub async fn add_multiple_torrents_in_parallel<V>(runtime: &tokio::runtime::Runtime, samples: usize) -> (Duration, Duration)
+pub async fn add_multiple_torrents_in_parallel<V>(runtime: &tokio::runtime::Runtime, samples: u64, sleep: Option<u64>) -> Duration
 where
     V: UpdateTorrentAsync + Default + Clone + Send + Sync + 'static,
 {
-    let args = Args::parse();
-    let mut results: Vec<Duration> = Vec::with_capacity(samples);
-
-    for _ in 0..samples {
-        let torrent_repository = V::default();
-        let info_hashes = generate_unique_info_hashes(10_000);
-        let handles = FuturesUnordered::new();
+    let torrent_repository = V::default();
+    let info_hashes = generate_unique_info_hashes(samples.try_into().expect("it should fit in a usize"));
+    let handles = FuturesUnordered::new();
 
-        let start_time = std::time::Instant::now();
+    let start = Instant::now();
 
-        for info_hash in info_hashes {
-            let torrent_repository_clone = torrent_repository.clone();
+    for info_hash in info_hashes {
+        let torrent_repository_clone = torrent_repository.clone();
 
-            let handle = runtime.spawn(async move {
-                torrent_repository_clone
-                    .update_torrent_with_peer_and_get_stats(&info_hash, &DEFAULT_PEER)
-                    .await;
-
-                if let Some(sleep_time) = args.sleep {
-                    let start_time = std::time::Instant::now();
-
-                    while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
-                }
-            });
-
-            handles.push(handle);
-        }
+        let handle = runtime.spawn(async move {
+            torrent_repository_clone
+                .update_torrent_with_peer_and_get_stats(&info_hash, &DEFAULT_PEER)
+                .await;
 
-        // Await all tasks
-        futures::future::join_all(handles).await;
+            if let Some(sleep_time) = sleep {
+                let start_time = std::time::Instant::now();
 
-        let result = start_time.elapsed();
+                while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
+            }
+        });
 
-        results.push(result);
+        handles.push(handle);
     }
 
-    get_average_and_adjusted_average_from_results(results)
+    // Await all tasks
+    futures::future::join_all(handles).await;
+
+    start.elapsed()
 }
 
 // Async update ten thousand torrents in parallel (depending on the set worker threads)
-pub async fn update_multiple_torrents_in_parallel<V>(runtime: &tokio::runtime::Runtime, samples: usize) -> (Duration, Duration)
+pub async fn update_multiple_torrents_in_parallel<V>(
+    runtime: &tokio::runtime::Runtime,
+    samples: u64,
+    sleep: Option<u64>,
+) -> Duration
 where
     V: UpdateTorrentAsync + Default + Clone + Send + Sync + 'static,
 {
-    let args = Args::parse();
-    let mut results: Vec<Duration> = Vec::with_capacity(samples);
+    let torrent_repository = V::default();
+    let info_hashes = generate_unique_info_hashes(samples.try_into().expect("it should fit in usize"));
+    let handles = FuturesUnordered::new();
 
-    for _ in 0..samples {
-        let torrent_repository = V::default();
-        let info_hashes = generate_unique_info_hashes(10_000);
-        let handles = FuturesUnordered::new();
-
-        // Add the torrents/peers to the torrent repository
-        for info_hash in &info_hashes {
-            torrent_repository
-                .update_torrent_with_peer_and_get_stats(info_hash, &DEFAULT_PEER)
-                .await;
-        }
-
-        let start_time = std::time::Instant::now();
-
-        for info_hash in info_hashes {
-            let torrent_repository_clone = torrent_repository.clone();
-
-            let handle = runtime.spawn(async move {
-                torrent_repository_clone
-                    .update_torrent_with_peer_and_get_stats(&info_hash, &DEFAULT_PEER)
-                    .await;
+    // Add the torrents/peers to the torrent repository
+    for info_hash in &info_hashes {
+        torrent_repository
+            .update_torrent_with_peer_and_get_stats(info_hash, &DEFAULT_PEER)
+            .await;
+    }
 
-                if let Some(sleep_time) = args.sleep {
-                    let start_time = std::time::Instant::now();
+    let start = Instant::now();
 
-                    while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
-                }
-            });
+    for info_hash in info_hashes {
+        let torrent_repository_clone = torrent_repository.clone();
 
-            handles.push(handle);
-        }
+        let handle = runtime.spawn(async move {
+            torrent_repository_clone
+                .update_torrent_with_peer_and_get_stats(&info_hash, &DEFAULT_PEER)
+                .await;
 
-        // Await all tasks
-        futures::future::join_all(handles).await;
+            if let Some(sleep_time) = sleep {
+                let start_time = std::time::Instant::now();
 
-        let result = start_time.elapsed();
+                while start_time.elapsed().as_nanos() < u128::from(sleep_time) {}
+            }
+        });
 
-        results.push(result);
+        handles.push(handle);
     }
 
-    get_average_and_adjusted_average_from_results(results)
+    // Await all tasks
+    futures::future::join_all(handles).await;
+
+    start.elapsed()
 }

packages/torrent-repository/benches/helpers/args.rs

@@ -1,4 +1,3 @@
-pub mod args;
 pub mod asyn;
 pub mod sync;
 pub mod utils;