aquatic: handlers: pass rng's as function arguments

aquatic/src/lib/handlers.rs

@@ -3,7 +3,7 @@ use std::sync::atomic::Ordering;
 use std::time::Instant;
 use std::vec::Drain;
 
-use rand::{Rng, SeedableRng, rngs::SmallRng, thread_rng};
+use rand::{Rng, rngs::{SmallRng, StdRng}};
 
 use bittorrent_udp::types::*;
 
@@ -13,11 +13,11 @@ use crate::config::Config;
 
 pub fn handle_connect_requests(
     state: &State,
+    rng: &mut StdRng,
     responses: &mut Vec<(Response, SocketAddr)>,
     requests: Drain<(ConnectRequest, SocketAddr)>,
 ){
     let now = Time(Instant::now());
-    let mut rng = thread_rng();
 
     responses.extend(requests.map(|(request, src)| {
         let connection_id = ConnectionId(rng.gen());
@@ -44,11 +44,10 @@ pub fn handle_connect_requests(
 pub fn handle_announce_requests(
     state: &State,
     config: &Config,
+    rng: &mut SmallRng,
     responses: &mut Vec<(Response, SocketAddr)>,
     requests: Drain<(AnnounceRequest, SocketAddr)>,
 ){
-    let mut rng = SmallRng::from_rng(thread_rng()).unwrap();
-
     responses.extend(requests.filter_map(|(request, src)| {
         let connection_key = ConnectionKey {
             connection_id: request.connection_id,
@@ -108,7 +107,7 @@ pub fn handle_announce_requests(
             }
 
             let response_peers = extract_response_peers(
-                &mut rng,
+                rng,
                 &torrent_data.peers,
                 max_num_peers_to_take,
             );

aquatic/src/lib/network.rs

@@ -6,6 +6,7 @@ use mio::{Events, Poll, Interest, Token};
 use mio::net::UdpSocket;
 use net2::{UdpSocketExt, UdpBuilder};
 use net2::unix::UnixUdpBuilderExt;
+use rand::{SeedableRng, rngs::{SmallRng, StdRng}};
 
 use bittorrent_udp::types::IpVersion;
 use bittorrent_udp::converters::{response_to_bytes, request_from_bytes};
@@ -38,6 +39,9 @@ pub fn run_event_loop(
     let mut scrape_requests: Vec<(ScrapeRequest, SocketAddr)> = Vec::new();
     let mut responses: Vec<(Response, SocketAddr)> = Vec::new();
 
+    let mut std_rng = StdRng::from_entropy();
+    let mut small_rng = SmallRng::from_rng(&mut std_rng).unwrap();
+
     loop {
         poll.poll(&mut events, None)
             .expect("failed polling");
@@ -51,6 +55,8 @@ pub fn run_event_loop(
                         &state,
                         &config,
                         &mut socket,
+                        &mut std_rng,
+                        &mut small_rng,
                         &mut buffer,
                         &mut responses,
                         &mut connect_requests,
@@ -107,6 +113,8 @@ fn handle_readable_socket(
     state: &State,
     config: &Config,
     socket: &mut UdpSocket,
+    std_rng: &mut StdRng,
+    small_rng: &mut SmallRng,
     buffer: &mut [u8],
     responses: &mut Vec<(Response, SocketAddr)>,
     connect_requests: &mut Vec<(ConnectRequest, SocketAddr)>,
@@ -167,12 +175,14 @@ fn handle_readable_socket(
 
     handle_connect_requests(
         state,
+        std_rng,
         responses,
         connect_requests.drain(..)
     );
     handle_announce_requests(
         state,
         config,
+        small_rng,
         responses,
         announce_requests.drain(..),
     );

aquatic_bench/src/bin/bench_handlers/announce.rs

@@ -2,7 +2,7 @@ use std::io::Cursor;
 use std::time::Instant;
 use std::net::SocketAddr;
 
-use rand::Rng;
+use rand::{Rng, SeedableRng, thread_rng, rngs::SmallRng};
 use rand_distr::Pareto;
 
 use aquatic::handlers::*;
@@ -29,6 +29,8 @@ pub fn bench(
     let mut num_responses: usize = 0;
     let mut dummy = 0u8;
 
+    let mut small_rng = SmallRng::from_rng(thread_rng()).unwrap();
+
     let now = Instant::now();
 
     let mut requests: Vec<(AnnounceRequest, SocketAddr)> = requests.into_iter()
@@ -46,6 +48,7 @@ pub fn bench(
     handle_announce_requests(
         &state,
         config,
+        &mut small_rng,
         &mut responses,
         requests,
     );

aquatic_bench/src/bin/bench_handlers/connect.rs

@@ -2,7 +2,7 @@ use std::io::Cursor;
 use std::time::Instant;
 use std::net::SocketAddr;
 
-use rand::{Rng, thread_rng, rngs::SmallRng, SeedableRng};
+use rand::{Rng, SeedableRng, thread_rng, rngs::{SmallRng, StdRng}};
 
 use aquatic::common::*;
 use aquatic::handlers::handle_connect_requests;
@@ -25,6 +25,8 @@ pub fn bench(
     let mut num_responses: usize = 0;
     let mut dummy = 0u8;
 
+    let mut rng = StdRng::from_rng(thread_rng()).unwrap();
+
     let now = Instant::now();
 
     let mut requests: Vec<(ConnectRequest, SocketAddr)> = requests.into_iter()
@@ -39,7 +41,7 @@ pub fn bench(
     
     let requests = requests.drain(..);
 
-    handle_connect_requests(&state, &mut responses, requests);
+    handle_connect_requests(&state, &mut rng, &mut responses, requests);
 
     for (response, _) in responses.drain(..){
         if let Response::Connect(_) = response {

aquatic_bench/src/bin/bench_handlers/main.rs

@@ -4,9 +4,9 @@
 //! ```
 //! ## Average results over 10 rounds
 //!
-//! Connect handler:   2 330 506 requests/second,   429.30 ns/request
-//! Announce handler:    264 596 requests/second,  3782.88 ns/request
-//! Scrape handler:      461 530 requests/second,  2169.41 ns/request
+//! Connect handler:   2 280 522 requests/second,   439.29 ns/request
+//! Announce handler:    267 790 requests/second,  3736.05 ns/request
+//! Scrape handler:      570 958 requests/second,  1751.89 ns/request
 //! ```
 
 use std::time::{Duration, Instant};