Merge #800: Torrent repository with parking_lot crate locks

0058e72 feat: new torrent repo implementation using parking_lot Mutex (Jose Celano)
0fa396c chore(deps): add parking_lot to cargo machete (Jose Celano)
9258ac0 feat: new torrent repo implementation using parking_lot RwLock (Jose Celano)
5750e2c chore(deps): add dependency parking_lot (Jose Celano)

Pull request description:

  Relates to: #774

  A new torrent repository implementation with a different lock implementation for the torrent entry.

  The crate is: [parking_lot](https://github.com/Amanieu/parking_lot)

  It's supposed to be faster than the standard implementation of `Mutex` and `RwLock`.

  This PR adds two implementations with `Mutex` and `RwLock`.

  ### Subtasks

  - [x] With `parking_lot::RwLock`
  - [x] With `parking_lot::Mutex`

  ### Performance

  With `parking_lot::RwLock`:

  ```output
  Requests out: 420183.87/second
  Responses in: 356799.49/second
    - Connect responses:  176636.38
    - Announce responses: 176603.09
    - Scrape responses:   3560.02
    - Error responses:    0.00
  Peers per announce response: 0.00
  Announce responses per info hash:
    - p10: 1
    - p25: 1
    - p50: 1
    - p75: 1
    - p90: 2
    - p95: 3
    - p99: 104
    - p99.9: 287
    - p100: 359
  ```

  With `parking_lot::RwLock::Mutex`

  ```output
  Requests out: 405157.91/second
  Responses in: 363773.19/second
    - Connect responses:  180009.24
    - Announce responses: 180202.03
    - Scrape responses:   3561.92
    - Error responses:    0.00
  Peers per announce response: 0.00
  Announce responses per info hash:
    - p10: 1
    - p25: 1
    - p50: 1
    - p75: 1
    - p90: 2
    - p95: 3
    - p99: 105
    - p99.9: 293
    - p100: 367
  ```

  With current implementation (SkipMap and Std Mutex):

  ```output
  Requests out: 415067.21/second
  Responses in: 369397.08/second
    - Connect responses:  183049.81
    - Announce responses: 182717.15
    - Scrape responses:   3630.12
    - Error responses:    0.00
  Peers per announce response: 0.00
  Announce responses per info hash:
    - p10: 1
    - p25: 1
    - p50: 1
    - p75: 1
    - p90: 2
    - p95: 3
    - p99: 104
    - p99.9: 297
    - p100: 375
  ```

  ![image](https://github.com/torrust/torrust-tracker/assets/58816/f3615cce-4a86-4d12-8ca8-eaf7d609f49e)

  ![image](https://github.com/torrust/torrust-tracker/assets/58816/1c7d8b5e-3b3c-4d3c-a8d9-b0d0bbb14976)

  ### Conclusion

  Performance looks similar (the current version is slightly better), so I would keep the current version with the standard Mutex.

ACKs for top commit:
  josecelano:
    ACK 0058e72

Tree-SHA512: 17a906efe39cf3365a0ea2db20f408595acb3ac8e467d8774d4c67afeec107e19889e9e2255cd6296d1f0df2b10a918644b4bc36a38fd9fa5cac9a10beab99c1

Author: josecelano

Cargo.lock

@@ -51,6 +51,7 @@ hyper = "1"
 lazy_static = "1"
 log = { version = "0", features = ["release_max_level_info"] }
 multimap = "0"
+parking_lot = "0.12.1"
 percent-encoding = "2"
 r2d2 = "0"
 r2d2_mysql = "24"
@@ -78,7 +79,7 @@ url = "2"
 uuid = { version = "1", features = ["v4"] }
 
 [package.metadata.cargo-machete]
-ignored = ["serde_bytes", "crossbeam-skiplist", "dashmap"]
+ignored = ["serde_bytes", "crossbeam-skiplist", "dashmap", "parking_lot"]
 
 [dev-dependencies]
 local-ip-address = "0"

Cargo.toml

@@ -19,6 +19,7 @@ version.workspace = true
 crossbeam-skiplist = "0.1"
 dashmap = "5.5.3"
 futures = "0.3.29"
+parking_lot = "0.12.1"
 tokio = { version = "1", features = ["macros", "net", "rt-multi-thread", "signal", "sync"] }
 torrust-tracker-clock = { version = "3.0.0-alpha.12-develop", path = "../clock" }
 torrust-tracker-configuration = { version = "3.0.0-alpha.12-develop", path = "../configuration" }

packages/torrent-repository/Cargo.toml

@@ -5,7 +5,8 @@ mod helpers;
 use criterion::{criterion_group, criterion_main, Criterion};
 use torrust_tracker_torrent_repository::{
     TorrentsDashMapMutexStd, TorrentsRwLockStd, TorrentsRwLockStdMutexStd, TorrentsRwLockStdMutexTokio, TorrentsRwLockTokio,
-    TorrentsRwLockTokioMutexStd, TorrentsRwLockTokioMutexTokio, TorrentsSkipMapMutexStd,
+    TorrentsRwLockTokioMutexStd, TorrentsRwLockTokioMutexTokio, TorrentsSkipMapMutexParkingLot, TorrentsSkipMapMutexStd,
+    TorrentsSkipMapRwLockParkingLot,
 };
 
 use crate::helpers::{asyn, sync};
@@ -49,6 +50,14 @@ fn add_one_torrent(c: &mut Criterion) {
         b.iter_custom(sync::add_one_torrent::<TorrentsSkipMapMutexStd, _>);
     });
 
+    group.bench_function("SkipMapMutexParkingLot", |b| {
+        b.iter_custom(sync::add_one_torrent::<TorrentsSkipMapMutexParkingLot, _>);
+    });
+
+    group.bench_function("SkipMapRwLockParkingLot", |b| {
+        b.iter_custom(sync::add_one_torrent::<TorrentsSkipMapRwLockParkingLot, _>);
+    });
+
     group.bench_function("DashMapMutexStd", |b| {
         b.iter_custom(sync::add_one_torrent::<TorrentsDashMapMutexStd, _>);
     });
@@ -102,6 +111,16 @@ fn add_multiple_torrents_in_parallel(c: &mut Criterion) {
             .iter_custom(|iters| sync::add_multiple_torrents_in_parallel::<TorrentsSkipMapMutexStd, _>(&rt, iters, None));
     });
 
+    group.bench_function("SkipMapMutexParkingLot", |b| {
+        b.to_async(&rt)
+            .iter_custom(|iters| sync::add_multiple_torrents_in_parallel::<TorrentsSkipMapMutexParkingLot, _>(&rt, iters, None));
+    });
+
+    group.bench_function("SkipMapRwLockParkingLot", |b| {
+        b.to_async(&rt)
+            .iter_custom(|iters| sync::add_multiple_torrents_in_parallel::<TorrentsSkipMapRwLockParkingLot, _>(&rt, iters, None));
+    });
+
     group.bench_function("DashMapMutexStd", |b| {
         b.to_async(&rt)
             .iter_custom(|iters| sync::add_multiple_torrents_in_parallel::<TorrentsDashMapMutexStd, _>(&rt, iters, None));
@@ -156,6 +175,16 @@ fn update_one_torrent_in_parallel(c: &mut Criterion) {
             .iter_custom(|iters| sync::update_one_torrent_in_parallel::<TorrentsSkipMapMutexStd, _>(&rt, iters, None));
     });
 
+    group.bench_function("SkipMapMutexParkingLot", |b| {
+        b.to_async(&rt)
+            .iter_custom(|iters| sync::update_one_torrent_in_parallel::<TorrentsSkipMapMutexParkingLot, _>(&rt, iters, None));
+    });
+
+    group.bench_function("SkipMapRwLockParkingLot", |b| {
+        b.to_async(&rt)
+            .iter_custom(|iters| sync::update_one_torrent_in_parallel::<TorrentsSkipMapRwLockParkingLot, _>(&rt, iters, None));
+    });
+
     group.bench_function("DashMapMutexStd", |b| {
         b.to_async(&rt)
             .iter_custom(|iters| sync::update_one_torrent_in_parallel::<TorrentsDashMapMutexStd, _>(&rt, iters, None));
@@ -211,6 +240,18 @@ fn update_multiple_torrents_in_parallel(c: &mut Criterion) {
             .iter_custom(|iters| sync::update_multiple_torrents_in_parallel::<TorrentsSkipMapMutexStd, _>(&rt, iters, None));
     });
 
+    group.bench_function("SkipMapMutexParkingLot", |b| {
+        b.to_async(&rt).iter_custom(|iters| {
+            sync::update_multiple_torrents_in_parallel::<TorrentsSkipMapMutexParkingLot, _>(&rt, iters, None)
+        });
+    });
+
+    group.bench_function("SkipMapRwLockParkingLot", |b| {
+        b.to_async(&rt).iter_custom(|iters| {
+            sync::update_multiple_torrents_in_parallel::<TorrentsSkipMapRwLockParkingLot, _>(&rt, iters, None)
+        });
+    });
+
     group.bench_function("DashMapMutexStd", |b| {
         b.to_async(&rt)
             .iter_custom(|iters| sync::update_multiple_torrents_in_parallel::<TorrentsDashMapMutexStd, _>(&rt, iters, None));

packages/torrent-repository/benches/repository_benchmark.rs

@@ -8,9 +8,11 @@ use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};
 
 use self::peer_list::PeerList;
 
+pub mod mutex_parking_lot;
 pub mod mutex_std;
 pub mod mutex_tokio;
 pub mod peer_list;
+pub mod rw_lock_parking_lot;
 pub mod single;
 
 pub trait Entry {

packages/torrent-repository/src/entry/mod.rs

@@ -0,0 +1,49 @@
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+use torrust_tracker_configuration::TrackerPolicy;
+use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
+use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};
+
+use super::{Entry, EntrySync};
+use crate::{EntryMutexParkingLot, EntrySingle};
+
+impl EntrySync for EntryMutexParkingLot {
+    fn get_swarm_metadata(&self) -> SwarmMetadata {
+        self.lock().get_swarm_metadata()
+    }
+
+    fn is_good(&self, policy: &TrackerPolicy) -> bool {
+        self.lock().is_good(policy)
+    }
+
+    fn peers_is_empty(&self) -> bool {
+        self.lock().peers_is_empty()
+    }
+
+    fn get_peers_len(&self) -> usize {
+        self.lock().get_peers_len()
+    }
+
+    fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
+        self.lock().get_peers(limit)
+    }
+
+    fn get_peers_for_client(&self, client: &SocketAddr, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
+        self.lock().get_peers_for_client(client, limit)
+    }
+
+    fn upsert_peer(&self, peer: &peer::Peer) -> bool {
+        self.lock().upsert_peer(peer)
+    }
+
+    fn remove_inactive_peers(&self, current_cutoff: DurationSinceUnixEpoch) {
+        self.lock().remove_inactive_peers(current_cutoff);
+    }
+}
+
+impl From<EntrySingle> for EntryMutexParkingLot {
+    fn from(entry: EntrySingle) -> Self {
+        Arc::new(parking_lot::Mutex::new(entry))
+    }
+}

packages/torrent-repository/src/entry/mutex_parking_lot.rs

@@ -0,0 +1,49 @@
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+use torrust_tracker_configuration::TrackerPolicy;
+use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
+use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};
+
+use super::{Entry, EntrySync};
+use crate::{EntryRwLockParkingLot, EntrySingle};
+
+impl EntrySync for EntryRwLockParkingLot {
+    fn get_swarm_metadata(&self) -> SwarmMetadata {
+        self.read().get_swarm_metadata()
+    }
+
+    fn is_good(&self, policy: &TrackerPolicy) -> bool {
+        self.read().is_good(policy)
+    }
+
+    fn peers_is_empty(&self) -> bool {
+        self.read().peers_is_empty()
+    }
+
+    fn get_peers_len(&self) -> usize {
+        self.read().get_peers_len()
+    }
+
+    fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
+        self.read().get_peers(limit)
+    }
+
+    fn get_peers_for_client(&self, client: &SocketAddr, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
+        self.read().get_peers_for_client(client, limit)
+    }
+
+    fn upsert_peer(&self, peer: &peer::Peer) -> bool {
+        self.write().upsert_peer(peer)
+    }
+
+    fn remove_inactive_peers(&self, current_cutoff: DurationSinceUnixEpoch) {
+        self.write().remove_inactive_peers(current_cutoff);
+    }
+}
+
+impl From<EntrySingle> for EntryRwLockParkingLot {
+    fn from(entry: EntrySingle) -> Self {
+        Arc::new(parking_lot::RwLock::new(entry))
+    }
+}

packages/torrent-repository/src/entry/rw_lock_parking_lot.rs

@@ -9,9 +9,15 @@ use torrust_tracker_clock::clock;
 pub mod entry;
 pub mod repository;
 
+// Repo Entries
+
 pub type EntrySingle = entry::Torrent;
 pub type EntryMutexStd = Arc<std::sync::Mutex<entry::Torrent>>;
 pub type EntryMutexTokio = Arc<tokio::sync::Mutex<entry::Torrent>>;
+pub type EntryMutexParkingLot = Arc<parking_lot::Mutex<entry::Torrent>>;
+pub type EntryRwLockParkingLot = Arc<parking_lot::RwLock<entry::Torrent>>;
+
+// Repos
 
 pub type TorrentsRwLockStd = RwLockStd<EntrySingle>;
 pub type TorrentsRwLockStdMutexStd = RwLockStd<EntryMutexStd>;
@@ -21,6 +27,9 @@ pub type TorrentsRwLockTokioMutexStd = RwLockTokio<EntryMutexStd>;
 pub type TorrentsRwLockTokioMutexTokio = RwLockTokio<EntryMutexTokio>;
 
 pub type TorrentsSkipMapMutexStd = CrossbeamSkipList<EntryMutexStd>;
+pub type TorrentsSkipMapMutexParkingLot = CrossbeamSkipList<EntryMutexParkingLot>;
+pub type TorrentsSkipMapRwLockParkingLot = CrossbeamSkipList<EntryRwLockParkingLot>;
+
 pub type TorrentsDashMapMutexStd = XacrimonDashMap<EntryMutexStd>;
 
 /// This code needs to be copied into each crate.