Merge pull request #2025 from mintlayer/p2p_pass_rng_to_peer_manager

Make peer manager use a provided RNG instead of creating a new one each time

Author: ImplOfAnImpl

Cargo.lock

@@ -31,8 +31,14 @@ pub fn peer_db(c: &mut Criterion) {
     let db_store = peerdb_inmemory_store();
     let chain_config = create_unit_test_config();
     let p2p_config = Arc::new(test_p2p_config());
-    let mut peerdb =
-        PeerDb::<_>::new(&chain_config, p2p_config, Default::default(), db_store).unwrap();
+    let mut peerdb = PeerDb::<_>::new(
+        &chain_config,
+        p2p_config,
+        Default::default(),
+        db_store,
+        &mut rng,
+    )
+    .unwrap();
 
     for _ in 0..100000 {
         peerdb.peer_discovered(TestAddressMaker::new_random_address(&mut rng).into());
@@ -54,7 +60,12 @@ pub fn peer_db(c: &mut Criterion) {
 
     c.bench_function("PeerDb", |b| {
         b.iter(|| {
-            peerdb.select_non_reserved_outbound_addresses(&outbound_addr_groups, &|_| true, 11)
+            peerdb.select_non_reserved_outbound_addresses(
+                &outbound_addr_groups,
+                &|_| true,
+                11,
+                &mut rng,
+            )
         })
     });
 }

p2p/benches/benches.rs

@@ -57,6 +57,7 @@ use networking::transport::{
     TcpTransportSocket,
 };
 use peer_manager::peerdb::storage::PeerDbStorage;
+use randomness::make_true_rng;
 use types::socket_address::SocketAddress;
 
 use crate::{
@@ -155,6 +156,8 @@ where
             peer_mgr_event_receiver,
             time_getter.clone(),
             peerdb_storage,
+            // Note: a "true" rng is not really needed here, but `make_pseudo_rng`'s result is not `Send`.
+            make_true_rng(),
         )?;
         let shutdown_ = Arc::clone(&shutdown);
         let peer_manager_task = tokio_spawn_in_current_tracing_span(

p2p/src/lib.rs

@@ -20,7 +20,7 @@ use std::{
 };
 
 use common::primitives::time::Time;
-use randomness::{make_pseudo_rng, Rng};
+use randomness::Rng;
 
 use super::{peer_context::PeerContext, peerdb::salt::Salt};
 
@@ -50,7 +50,13 @@ impl AddrListResponseCache {
         }
     }
 
-    pub fn get_or_create<F>(&mut self, peer_ctx: &PeerContext, now: Time, create: F) -> &Addresses
+    pub fn get_or_create<F>(
+        &mut self,
+        peer_ctx: &PeerContext,
+        now: Time,
+        create: F,
+        rng: &mut impl Rng,
+    ) -> &Addresses
     where
         F: FnOnce() -> Addresses,
     {
@@ -61,13 +67,13 @@ impl AddrListResponseCache {
         let cache_entry = match self.cache.entry(id) {
             Entry::Vacant(entry) => entry.insert(CacheEntry {
                 addresses: create(),
-                expiration_time: Self::new_expiration_time_from_now(now),
+                expiration_time: Self::new_expiration_time_from_now(now, rng),
             }),
             Entry::Occupied(mut entry) => {
                 if entry.get().expiration_time <= now {
                     *entry.get_mut() = CacheEntry {
                         addresses: create(),
-                        expiration_time: Self::new_expiration_time_from_now(now),
+                        expiration_time: Self::new_expiration_time_from_now(now, rng),
                     };
                 }
                 entry.into_mut()
@@ -101,10 +107,10 @@ impl AddrListResponseCache {
         hasher.finish()
     }
 
-    fn new_expiration_time_from_now(now: Time) -> Time {
+    fn new_expiration_time_from_now(now: Time, rng: &mut impl Rng) -> Time {
         let min_secs = EXPIRATION_INTERVAL_MIN.as_secs();
         let max_secs = EXPIRATION_INTERVAL_MAX.as_secs();
-        let secs = make_pseudo_rng().gen_range(min_secs..=max_secs);
+        let secs = rng.gen_range(min_secs..=max_secs);
         (now + Duration::from_secs(secs)).expect("Unexpected time overflow")
     }
 }

p2p/src/peer_manager/addr_list_response_cache.rs

@@ -16,16 +16,17 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
+
 use common::chain::ChainConfig;
 use logging::log;
 use p2p_types::{peer_address::PeerAddress, socket_address::SocketAddress};
-use randomness::{make_pseudo_rng, seq::IteratorRandom};
+use randomness::{seq::IteratorRandom, RngCore};
 
 use crate::config::P2pConfig;
 
 #[async_trait]
 pub trait DnsSeed: Send + Sync {
-    async fn obtain_addresses(&self) -> Vec<SocketAddress>;
+    async fn obtain_addresses(&self, rng: &mut (dyn RngCore + Send)) -> Vec<SocketAddress>;
 }
 
 pub struct DefaultDnsSeed {
@@ -47,7 +48,7 @@ const MAX_DNS_RECORDS: usize = 10;
 
 #[async_trait]
 impl DnsSeed for DefaultDnsSeed {
-    async fn obtain_addresses(&self) -> Vec<SocketAddress> {
+    async fn obtain_addresses(&self, rng: &mut (dyn RngCore + Send)) -> Vec<SocketAddress> {
         let dns_seeds = self.chain_config.dns_seeds();
 
         if dns_seeds.is_empty() {
@@ -73,7 +74,7 @@ impl DnsSeed for DefaultDnsSeed {
                         )
                     })
                     // Randomize selection because records can be sorted by type (A and AAAA)
-                    .choose_multiple(&mut make_pseudo_rng(), MAX_DNS_RECORDS)
+                    .choose_multiple(rng, MAX_DNS_RECORDS)
                     .into_iter()
                     .for_each(|addr| {
                         addresses.push(addr);