Benchmark flow (reworked)

contrib/dev-tools/benches/run-benches.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+# This script is only intended to be used for local development or testing environments.
+
+cargo bench --package torrust-tracker-torrent-repository
+
+cargo bench --package bittorrent-http-tracker-core
+
+cargo bench --package bittorrent-udp-tracker-core

packages/http-tracker-core/Cargo.toml

@@ -18,6 +18,7 @@ aquatic_udp_protocol = "0"
 bittorrent-http-tracker-protocol = { version = "3.0.0-develop", path = "../http-protocol" }
 bittorrent-primitives = "0.1.0"
 bittorrent-tracker-core = { version = "3.0.0-develop", path = "../tracker-core" }
+criterion = { version = "0.5.1", features = ["async_tokio"] }
 futures = "0"
 thiserror = "2"
 tokio = { version = "1", features = ["macros", "net", "rt-multi-thread", "signal", "sync"] }
@@ -28,3 +29,8 @@ tracing = "0"
 [dev-dependencies]
 mockall = "0"
 torrust-tracker-test-helpers = { version = "3.0.0-develop", path = "../test-helpers" }
+
+[[bench]]
+harness = false
+name = "http_tracker_core_benchmark"
+

packages/http-tracker-core/benches/helpers/mod.rs

@@ -0,0 +1,2 @@
+pub mod sync;
+pub mod util;

packages/http-tracker-core/benches/helpers/sync.rs

@@ -0,0 +1,31 @@
+use std::time::{Duration, Instant};
+
+use bittorrent_http_tracker_core::services::announce::AnnounceService;
+
+use crate::helpers::util::{initialize_core_tracker_services, sample_announce_request_for_peer, sample_peer};
+
+#[must_use]
+pub async fn return_announce_data_once(samples: u64) -> Duration {
+    let (core_tracker_services, core_http_tracker_services) = initialize_core_tracker_services();
+
+    let peer = sample_peer();
+
+    let (announce_request, client_ip_sources) = sample_announce_request_for_peer(peer);
+
+    let announce_service = AnnounceService::new(
+        core_tracker_services.core_config.clone(),
+        core_tracker_services.announce_handler.clone(),
+        core_tracker_services.authentication_service.clone(),
+        core_tracker_services.whitelist_authorization.clone(),
+        core_http_tracker_services.http_stats_event_sender.clone(),
+    );
+
+    let start = Instant::now();
+    for _ in 0..samples {
+        let _announce_data = announce_service
+            .handle_announce(&announce_request, &client_ip_sources, None)
+            .await
+            .unwrap();
+    }
+    start.elapsed()
+}

packages/http-tracker-core/benches/helpers/util.rs

@@ -0,0 +1,118 @@
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::sync::Arc;
+
+use aquatic_udp_protocol::{AnnounceEvent, NumberOfBytes, PeerId};
+use bittorrent_http_tracker_protocol::v1::requests::announce::Announce;
+use bittorrent_http_tracker_protocol::v1::services::peer_ip_resolver::ClientIpSources;
+use bittorrent_primitives::info_hash::InfoHash;
+use bittorrent_tracker_core::announce_handler::AnnounceHandler;
+use bittorrent_tracker_core::authentication::key::repository::in_memory::InMemoryKeyRepository;
+use bittorrent_tracker_core::authentication::service::AuthenticationService;
+use bittorrent_tracker_core::databases::setup::initialize_database;
+use bittorrent_tracker_core::torrent::repository::in_memory::InMemoryTorrentRepository;
+use bittorrent_tracker_core::torrent::repository::persisted::DatabasePersistentTorrentRepository;
+use bittorrent_tracker_core::whitelist::authorization::WhitelistAuthorization;
+use bittorrent_tracker_core::whitelist::repository::in_memory::InMemoryWhitelist;
+use torrust_tracker_configuration::{Configuration, Core};
+use torrust_tracker_primitives::peer::Peer;
+use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};
+use torrust_tracker_test_helpers::configuration;
+
+pub struct CoreTrackerServices {
+    pub core_config: Arc<Core>,
+    pub announce_handler: Arc<AnnounceHandler>,
+    pub authentication_service: Arc<AuthenticationService>,
+    pub whitelist_authorization: Arc<WhitelistAuthorization>,
+}
+
+pub struct CoreHttpTrackerServices {
+    pub http_stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>>,
+}
+
+pub fn initialize_core_tracker_services() -> (CoreTrackerServices, CoreHttpTrackerServices) {
+    initialize_core_tracker_services_with_config(&configuration::ephemeral_public())
+}
+
+pub fn initialize_core_tracker_services_with_config(config: &Configuration) -> (CoreTrackerServices, CoreHttpTrackerServices) {
+    let core_config = Arc::new(config.core.clone());
+    let database = initialize_database(&config.core);
+    let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
+    let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(&database));
+    let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
+    let whitelist_authorization = Arc::new(WhitelistAuthorization::new(&config.core, &in_memory_whitelist.clone()));
+    let in_memory_key_repository = Arc::new(InMemoryKeyRepository::default());
+    let authentication_service = Arc::new(AuthenticationService::new(&core_config, &in_memory_key_repository));
+
+    let announce_handler = Arc::new(AnnounceHandler::new(
+        &config.core,
+        &whitelist_authorization,
+        &in_memory_torrent_repository,
+        &db_torrent_repository,
+    ));
+
+    // HTTP stats
+    let (http_stats_event_sender, http_stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
+    let http_stats_event_sender = Arc::new(http_stats_event_sender);
+    let _http_stats_repository = Arc::new(http_stats_repository);
+
+    (
+        CoreTrackerServices {
+            core_config,
+            announce_handler,
+            authentication_service,
+            whitelist_authorization,
+        },
+        CoreHttpTrackerServices { http_stats_event_sender },
+    )
+}
+
+pub fn sample_peer() -> peer::Peer {
+    peer::Peer {
+        peer_id: PeerId(*b"-qB00000000000000000"),
+        peer_addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)), 8080),
+        updated: DurationSinceUnixEpoch::new(1_669_397_478_934, 0),
+        uploaded: NumberOfBytes::new(0),
+        downloaded: NumberOfBytes::new(0),
+        left: NumberOfBytes::new(0),
+        event: AnnounceEvent::Started,
+    }
+}
+
+pub fn sample_announce_request_for_peer(peer: Peer) -> (Announce, ClientIpSources) {
+    let announce_request = Announce {
+        info_hash: sample_info_hash(),
+        peer_id: peer.peer_id,
+        port: peer.peer_addr.port(),
+        uploaded: Some(peer.uploaded),
+        downloaded: Some(peer.downloaded),
+        left: Some(peer.left),
+        event: Some(peer.event.into()),
+        compact: None,
+        numwant: None,
+    };
+
+    let client_ip_sources = ClientIpSources {
+        right_most_x_forwarded_for: None,
+        connection_info_ip: Some(peer.peer_addr.ip()),
+    };
+
+    (announce_request, client_ip_sources)
+}
+#[must_use]
+pub fn sample_info_hash() -> InfoHash {
+    "3b245504cf5f11bbdbe1201cea6a6bf45aee1bc0" // DevSkim: ignore DS173237
+        .parse::<InfoHash>()
+        .expect("String should be a valid info hash")
+}
+
+use bittorrent_http_tracker_core::statistics;
+use futures::future::BoxFuture;
+use mockall::mock;
+use tokio::sync::mpsc::error::SendError;
+
+mock! {
+    HttpStatsEventSender {}
+    impl statistics::event::sender::Sender for HttpStatsEventSender {
+         fn send_event(&self, event: statistics::event::Event) -> BoxFuture<'static,Option<Result<(),SendError<statistics::event::Event> > > > ;
+    }
+}

packages/http-tracker-core/benches/http_tracker_core_benchmark.rs

@@ -0,0 +1,23 @@
+mod helpers;
+
+use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+
+use crate::helpers::sync;
+
+fn announce_once(c: &mut Criterion) {
+    let _rt = tokio::runtime::Builder::new_multi_thread().worker_threads(4).build().unwrap();
+
+    let mut group = c.benchmark_group("http_tracker_handle_announce_once");
+
+    group.warm_up_time(Duration::from_millis(500));
+    group.measurement_time(Duration::from_millis(1000));
+
+    group.bench_function("handle_announce_data", |b| {
+        b.iter(|| sync::return_announce_data_once(100));
+    });
+}
+
+criterion_group!(benches, announce_once);
+criterion_main!(benches);

packages/udp-tracker-core/Cargo.toml

@@ -21,6 +21,7 @@ bittorrent-udp-tracker-protocol = { version = "3.0.0-develop", path = "../udp-pr
 bloom = "0.3.2"
 blowfish = "0"
 cipher = "0"
+criterion = { version = "0.5.1", features = ["async_tokio"] }
 futures = "0"
 lazy_static = "1"
 rand = "0"
@@ -34,3 +35,8 @@ zerocopy = "0.7"
 [dev-dependencies]
 mockall = "0"
 torrust-tracker-test-helpers = { version = "3.0.0-develop", path = "../test-helpers" }
+
+[[bench]]
+harness = false
+name = "udp_tracker_core_benchmark"
+

packages/udp-tracker-core/benches/helpers/mod.rs

@@ -0,0 +1,2 @@
+pub mod sync;
+mod utils;

packages/udp-tracker-core/benches/helpers/sync.rs

@@ -0,0 +1,21 @@
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+use bittorrent_udp_tracker_core::services::connect::ConnectService;
+use bittorrent_udp_tracker_core::statistics;
+
+use crate::helpers::utils::{sample_ipv4_remote_addr, sample_issue_time};
+
+#[allow(clippy::unused_async)]
+pub async fn connect_once(samples: u64) -> Duration {
+    let (udp_core_stats_event_sender, _udp_core_stats_repository) = statistics::setup::factory(false);
+    let udp_core_stats_event_sender = Arc::new(udp_core_stats_event_sender);
+    let connect_service = Arc::new(ConnectService::new(udp_core_stats_event_sender));
+    let start = Instant::now();
+
+    for _ in 0..samples {
+        let _response = connect_service.handle_connect(sample_ipv4_remote_addr(), sample_issue_time());
+    }
+
+    start.elapsed()
+}

packages/udp-tracker-core/benches/helpers/utils.rs

@@ -0,0 +1,25 @@
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+
+use bittorrent_udp_tracker_core::statistics;
+use futures::future::BoxFuture;
+use mockall::mock;
+use tokio::sync::mpsc::error::SendError;
+
+pub(crate) fn sample_ipv4_remote_addr() -> SocketAddr {
+    sample_ipv4_socket_address()
+}
+
+pub(crate) fn sample_ipv4_socket_address() -> SocketAddr {
+    SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080)
+}
+
+pub(crate) fn sample_issue_time() -> f64 {
+    1_000_000_000_f64
+}
+
+mock! {
+    pub(crate) UdpCoreStatsEventSender {}
+    impl statistics::event::sender::Sender for UdpCoreStatsEventSender {
+         fn send_event(&self, event: statistics::event::Event) -> BoxFuture<'static,Option<Result<(),SendError<statistics::event::Event> > > > ;
+    }
+}

packages/udp-tracker-core/benches/udp_tracker_core_benchmark.rs

@@ -0,0 +1,20 @@
+mod helpers;
+
+use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+
+use crate::helpers::sync;
+
+fn bench_connect_once(c: &mut Criterion) {
+    let mut group = c.benchmark_group("udp_tracker/connect_once");
+    group.warm_up_time(Duration::from_millis(500));
+    group.measurement_time(Duration::from_millis(1000));
+
+    group.bench_function("connect_once", |b| {
+        b.iter(|| sync::connect_once(100));
+    });
+}
+
+criterion_group!(benches, bench_connect_once);
+criterion_main!(benches);