use rustc-hash

mixnet-rs/dissemination/Cargo.toml

@@ -8,6 +8,7 @@ chrono = "0.4.38"
 clap = { version = "4.5.16", features = ["derive"] }
 csv = "1.3.0"
 rand = "0.8.5"
+rustc-hash = "2.0.0"
 strum = "0.26.3"
 strum_macros = "0.26.4"
 tokio = { version = "1.39.2", features = ["rt", "rt-multi-thread", "sync"] }

mixnet-rs/dissemination/src/iteration.rs

@@ -1,6 +1,7 @@
-use std::{collections::HashMap, error::Error};
+use std::error::Error;
 
 use rand::{rngs::StdRng, RngCore, SeedableRng};
+use rustc_hash::FxHashMap;
 
 use crate::{
     node::{MessageId, Node, NodeId},
@@ -44,7 +45,7 @@ pub fn run_iteration(paramset: ParamSet, seed: u64, out_csv_path: &str, topology
     let mut next_msg_id: MessageId = 0;
     let total_num_msgs: u32 = paramset.num_senders as u32 * paramset.num_sent_msgs as u32;
     // To keep track of when each message was sent and how many nodes received it
-    let mut message_tracker: HashMap<MessageId, (f32, u16)> = HashMap::new();
+    let mut message_tracker: FxHashMap<MessageId, (f32, u16)> = FxHashMap::default();
     // To keep track of how many messages have been disseminated to all nodes
     let mut num_disseminated_msgs = 0;
 
@@ -104,7 +105,7 @@ fn send_messages(
     sender_ids: &[NodeId],
     nodes: &mut [Node],
     next_msg_id: &mut MessageId,
-    message_tracker: &mut HashMap<MessageId, (f32, u16)>,
+    message_tracker: &mut FxHashMap<MessageId, (f32, u16)>,
 ) {
     for &sender_id in sender_ids.iter() {
         nodes[sender_id as usize].send(*next_msg_id);
@@ -116,7 +117,7 @@ fn send_messages(
 fn relay_messages(
     vtime: f32,
     nodes: &mut [Node],
-    message_tracker: &mut HashMap<MessageId, (f32, u16)>,
+    message_tracker: &mut FxHashMap<MessageId, (f32, u16)>,
     num_disseminated_msgs: &mut usize,
     writer: &mut csv::Writer<std::fs::File>,
 ) {

mixnet-rs/dissemination/src/node.rs

@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet};
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::queue::{new_queue, Queue, QueueConfig};
 
@@ -7,13 +7,13 @@ pub type MessageId = u32;
 
 pub struct Node {
     queue_config: QueueConfig,
-    // To have the deterministic result, we use Vec instead of HashMap.
+    // To have the deterministic result, we use Vec instead of FxHashMap.
     // Building `queues` is inefficient, but it's not a problem because it's done only once at the beginning.
     // Instead, use `connected_peers` to build `queues` efficiently.
     queues: Vec<(NodeId, Box<dyn Queue<MessageId>>)>,
-    connected_peers: HashSet<NodeId>,
+    connected_peers: FxHashSet<NodeId>,
     // A cache to avoid relaying the same message multiple times.
-    received_msgs: HashMap<MessageId, u16>,
+    received_msgs: FxHashMap<MessageId, u16>,
     peering_degree: u16,
 }
 
@@ -22,8 +22,8 @@ impl Node {
         Node {
             queue_config,
             queues: Vec::new(),
-            connected_peers: HashSet::new(),
-            received_msgs: HashMap::new(),
+            connected_peers: FxHashSet::default(),
+            received_msgs: FxHashMap::default(),
             peering_degree,
         }
     }