Merge pull request #187 from greatest-ape/work-2024-02-08

add bencher CpuModes; change some udp and udp load test default settings

TODO.md

@@ -2,10 +2,10 @@
 
 ## High priority
 
-* aquatic_bench
-  * Opentracker "slow to get up to speed", is it due to getting faster once
-    inserts are rarely needed since most ip-port combinations have been sent?
-    In that case, a shorter duration (e.g., 30 seconds) would be a good idea.
+* aquatic_bencher
+  * bench aquatic_udp with io_uring too
+  * test with SubsequentOnePerPair
+  * include chihaya with higher core counts?
 
 ## Medium priority
 

crates/bencher/src/common.rs

@@ -57,7 +57,12 @@ impl TaskSetCpuList {
     ) -> Self {
         match direction {
             CpuDirection::Asc => match mode {
-                CpuMode::Split => {
+                CpuMode::Subsequent => {
+                    let range = 0..(available_parallelism.min(requested_cpus));
+
+                    Self(vec![range.try_into().unwrap()])
+                }
+                CpuMode::SplitPairs => {
                     let middle = available_parallelism / 2;
 
                     let range_a = 0..(middle.min(requested_cpus));
@@ -68,14 +73,31 @@ impl TaskSetCpuList {
                         range_b.try_into().unwrap(),
                     ])
                 }
-                CpuMode::All => {
-                    let range = 0..(available_parallelism.min(requested_cpus));
+                CpuMode::SubsequentPairs => {
+                    let range = 0..(available_parallelism.min(requested_cpus * 2));
 
                     Self(vec![range.try_into().unwrap()])
                 }
+                CpuMode::SubsequentOnePerPair => {
+                    let range = 0..(available_parallelism.min(requested_cpus * 2));
+
+                    Self(
+                        range
+                            .chunks(2)
+                            .into_iter()
+                            .map(|mut chunk| TaskSetCpuIndicator::Single(chunk.next().unwrap()))
+                            .collect(),
+                    )
+                }
             },
             CpuDirection::Desc => match mode {
-                CpuMode::Split => {
+                CpuMode::Subsequent => {
+                    let range =
+                        available_parallelism.saturating_sub(requested_cpus)..available_parallelism;
+
+                    Self(vec![range.try_into().unwrap()])
+                }
+                CpuMode::SplitPairs => {
                     let middle = available_parallelism / 2;
 
                     let range_a = middle.saturating_sub(requested_cpus)..middle;
@@ -88,12 +110,24 @@ impl TaskSetCpuList {
                         range_b.try_into().unwrap(),
                     ])
                 }
-                CpuMode::All => {
-                    let range =
-                        available_parallelism.saturating_sub(requested_cpus)..available_parallelism;
+                CpuMode::SubsequentPairs => {
+                    let range = available_parallelism.saturating_sub(requested_cpus * 2)
+                        ..available_parallelism;
 
                     Self(vec![range.try_into().unwrap()])
                 }
+                CpuMode::SubsequentOnePerPair => {
+                    let range = available_parallelism.saturating_sub(requested_cpus * 2)
+                        ..available_parallelism;
+
+                    Self(
+                        range
+                            .chunks(2)
+                            .into_iter()
+                            .map(|mut chunk| TaskSetCpuIndicator::Single(chunk.next().unwrap()))
+                            .collect(),
+                    )
+                }
             },
         }
     }
@@ -133,15 +167,23 @@ impl TryFrom<Range<usize>> for TaskSetCpuIndicator {
 
 #[derive(Debug, Clone, Copy, clap::ValueEnum)]
 pub enum CpuMode {
-    Split,
-    All,
+    /// For 8 vCPU processor, use vCPU groups 0, 1, 2, 3, 4, 5, 6 and 7
+    Subsequent,
+    /// For 8 vCPU processor, use vCPU groups 0 & 4, 1 & 5, 2 & 6 and 3 & 7
+    SplitPairs,
+    /// For 8 vCPU processor, use vCPU groups 0 & 1, 2 & 3, 4 & 5 and 6 & 7
+    SubsequentPairs,
+    /// For 8 vCPU processor, use vCPU groups 0, 2, 4 and 6
+    SubsequentOnePerPair,
 }
 
 impl Display for CpuMode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::All => f.write_str("all"),
-            Self::Split => f.write_str("split"),
+            Self::Subsequent => f.write_str("subsequent"),
+            Self::SplitPairs => f.write_str("split-pairs"),
+            Self::SubsequentPairs => f.write_str("subsequent-pairs"),
+            Self::SubsequentOnePerPair => f.write_str("subsequent-one-per-pair"),
         }
     }
 }
@@ -174,100 +216,113 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_task_set_cpu_list_split_asc() {
+    fn test_task_set_cpu_list_split_pairs_asc() {
+        let f = TaskSetCpuList::new_with_available_parallelism;
+
+        let mode = CpuMode::SplitPairs;
+        let direction = CpuDirection::Asc;
+
+        assert_eq!(f(8, mode, direction, 1).as_cpu_list(), "0,4");
+        assert_eq!(f(8, mode, direction, 2).as_cpu_list(), "0-1,4-5");
+        assert_eq!(f(8, mode, direction, 4).as_cpu_list(), "0-3,4-7");
+        assert_eq!(f(8, mode, direction, 8).as_cpu_list(), "0-3,4-7");
+        assert_eq!(f(8, mode, direction, 9).as_cpu_list(), "0-3,4-7");
+    }
+
+    #[test]
+    fn test_task_set_cpu_list_split_pairs_desc() {
         let f = TaskSetCpuList::new_with_available_parallelism;
 
-        assert_eq!(
-            f(8, CpuMode::Split, CpuDirection::Asc, 1).as_cpu_list(),
-            "0,4"
-        );
-        assert_eq!(
-            f(8, CpuMode::Split, CpuDirection::Asc, 2).as_cpu_list(),
-            "0-1,4-5"
-        );
-        assert_eq!(
-            f(8, CpuMode::Split, CpuDirection::Asc, 4).as_cpu_list(),
-            "0-3,4-7"
-        );
-        assert_eq!(
-            f(8, CpuMode::Split, CpuDirection::Asc, 8).as_cpu_list(),
-            "0-3,4-7"
-        );
-        assert_eq!(
-            f(8, CpuMode::Split, CpuDirection::Asc, 9).as_cpu_list(),
-            "0-3,4-7"
-        );
+        let mode = CpuMode::SplitPairs;
+        let direction = CpuDirection::Desc;
+
+        assert_eq!(f(8, mode, direction, 1).as_cpu_list(), "3,7");
+        assert_eq!(f(8, mode, direction, 2).as_cpu_list(), "2-3,6-7");
+        assert_eq!(f(8, mode, direction, 4).as_cpu_list(), "0-3,4-7");
+        assert_eq!(f(8, mode, direction, 8).as_cpu_list(), "0-3,4-7");
+        assert_eq!(f(8, mode, direction, 9).as_cpu_list(), "0-3,4-7");
+    }
+
+    #[test]
+    fn test_task_set_cpu_list_subsequent_asc() {
+        let f = TaskSetCpuList::new_with_available_parallelism;
+
+        let mode = CpuMode::Subsequent;
+        let direction = CpuDirection::Asc;
+
+        assert_eq!(f(8, mode, direction, 1).as_cpu_list(), "0");
+        assert_eq!(f(8, mode, direction, 2).as_cpu_list(), "0-1");
+        assert_eq!(f(8, mode, direction, 4).as_cpu_list(), "0-3");
+        assert_eq!(f(8, mode, direction, 8).as_cpu_list(), "0-7");
+        assert_eq!(f(8, mode, direction, 9).as_cpu_list(), "0-7");
+    }
+
+    #[test]
+    fn test_task_set_cpu_list_subsequent_desc() {
+        let f = TaskSetCpuList::new_with_available_parallelism;
+
+        let mode = CpuMode::Subsequent;
+        let direction = CpuDirection::Desc;
+
+        assert_eq!(f(8, mode, direction, 1).as_cpu_list(), "7");
+        assert_eq!(f(8, mode, direction, 2).as_cpu_list(), "6-7");
+        assert_eq!(f(8, mode, direction, 4).as_cpu_list(), "4-7");
+        assert_eq!(f(8, mode, direction, 8).as_cpu_list(), "0-7");
+        assert_eq!(f(8, mode, direction, 9).as_cpu_list(), "0-7");
+    }
+
+    #[test]
+    fn test_task_set_cpu_list_subsequent_pairs_asc() {
+        let f = TaskSetCpuList::new_with_available_parallelism;
+        let mode = CpuMode::SubsequentPairs;
+        let direction = CpuDirection::Asc;
+
+        assert_eq!(f(8, mode, direction, 1).as_cpu_list(), "0-1");
+        assert_eq!(f(8, mode, direction, 2).as_cpu_list(), "0-3");
+        assert_eq!(f(8, mode, direction, 4).as_cpu_list(), "0-7");
+        assert_eq!(f(8, mode, direction, 8).as_cpu_list(), "0-7");
+        assert_eq!(f(8, mode, direction, 9).as_cpu_list(), "0-7");
     }
 
     #[test]
-    fn test_task_set_cpu_list_split_desc() {
+    fn test_task_set_cpu_list_subsequent_pairs_desc() {
         let f = TaskSetCpuList::new_with_available_parallelism;
 
-        assert_eq!(
-            f(8, CpuMode::Split, CpuDirection::Desc, 1).as_cpu_list(),
-            "3,7"
-        );
-        assert_eq!(
-            f(8, CpuMode::Split, CpuDirection::Desc, 2).as_cpu_list(),
-            "2-3,6-7"
-        );
-        assert_eq!(
-            f(8, CpuMode::Split, CpuDirection::Desc, 4).as_cpu_list(),
-            "0-3,4-7"
-        );
-        assert_eq!(
-            f(8, CpuMode::Split, CpuDirection::Desc, 8).as_cpu_list(),
-            "0-3,4-7"
-        );
-        assert_eq!(
-            f(8, CpuMode::Split, CpuDirection::Desc, 9).as_cpu_list(),
-            "0-3,4-7"
-        );
+        let mode = CpuMode::SubsequentPairs;
+        let direction = CpuDirection::Desc;
+
+        assert_eq!(f(8, mode, direction, 1).as_cpu_list(), "6-7");
+        assert_eq!(f(8, mode, direction, 2).as_cpu_list(), "4-7");
+        assert_eq!(f(8, mode, direction, 4).as_cpu_list(), "0-7");
+        assert_eq!(f(8, mode, direction, 8).as_cpu_list(), "0-7");
+        assert_eq!(f(8, mode, direction, 9).as_cpu_list(), "0-7");
     }
 
     #[test]
-    fn test_task_set_cpu_list_all_asc() {
+    fn test_task_set_cpu_list_subsequent_one_per_pair_asc() {
         let f = TaskSetCpuList::new_with_available_parallelism;
 
-        assert_eq!(f(8, CpuMode::All, CpuDirection::Asc, 1).as_cpu_list(), "0");
-        assert_eq!(
-            f(8, CpuMode::All, CpuDirection::Asc, 2).as_cpu_list(),
-            "0-1"
-        );
-        assert_eq!(
-            f(8, CpuMode::All, CpuDirection::Asc, 4).as_cpu_list(),
-            "0-3"
-        );
-        assert_eq!(
-            f(8, CpuMode::All, CpuDirection::Asc, 8).as_cpu_list(),
-            "0-7"
-        );
-        assert_eq!(
-            f(8, CpuMode::All, CpuDirection::Asc, 9).as_cpu_list(),
-            "0-7"
-        );
+        let mode = CpuMode::SubsequentOnePerPair;
+        let direction = CpuDirection::Asc;
+
+        assert_eq!(f(8, mode, direction, 1).as_cpu_list(), "0");
+        assert_eq!(f(8, mode, direction, 2).as_cpu_list(), "0,2");
+        assert_eq!(f(8, mode, direction, 4).as_cpu_list(), "0,2,4,6");
+        assert_eq!(f(8, mode, direction, 8).as_cpu_list(), "0,2,4,6");
+        assert_eq!(f(8, mode, direction, 9).as_cpu_list(), "0,2,4,6");
     }
 
     #[test]
-    fn test_task_set_cpu_list_all_desc() {
+    fn test_task_set_cpu_list_subsequent_one_per_pair_desc() {
         let f = TaskSetCpuList::new_with_available_parallelism;
 
-        assert_eq!(f(8, CpuMode::All, CpuDirection::Desc, 1).as_cpu_list(), "7");
-        assert_eq!(
-            f(8, CpuMode::All, CpuDirection::Desc, 2).as_cpu_list(),
-            "6-7"
-        );
-        assert_eq!(
-            f(8, CpuMode::All, CpuDirection::Desc, 4).as_cpu_list(),
-            "4-7"
-        );
-        assert_eq!(
-            f(8, CpuMode::All, CpuDirection::Desc, 8).as_cpu_list(),
-            "0-7"
-        );
-        assert_eq!(
-            f(8, CpuMode::All, CpuDirection::Desc, 9).as_cpu_list(),
-            "0-7"
-        );
+        let mode = CpuMode::SubsequentOnePerPair;
+        let direction = CpuDirection::Desc;
+
+        assert_eq!(f(8, mode, direction, 1).as_cpu_list(), "6");
+        assert_eq!(f(8, mode, direction, 2).as_cpu_list(), "4,6");
+        assert_eq!(f(8, mode, direction, 4).as_cpu_list(), "0,2,4,6");
+        assert_eq!(f(8, mode, direction, 8).as_cpu_list(), "0,2,4,6");
+        assert_eq!(f(8, mode, direction, 9).as_cpu_list(), "0,2,4,6");
     }
 }

crates/bencher/src/main.rs

@@ -13,7 +13,7 @@ use set::run_sets;
 struct Args {
     /// How to choose which virtual CPUs to allow trackers and load test
     /// executables on
-    #[arg(long, default_value_t = CpuMode::Split)]
+    #[arg(long, default_value_t = CpuMode::SplitPairs)]
     cpu_mode: CpuMode,
     /// Minimum number of tracker cpu cores to run benchmarks for
     #[arg(long)]

crates/udp/src/config.rs

@@ -102,8 +102,7 @@ pub struct NetworkConfig {
     pub poll_timeout_ms: u64,
     /// Number of ring entries (io_uring backend only)
     ///
-    /// Will be rounded to next power of two if not already one. Increasing
-    /// this value can help throughput up to a certain point.
+    /// Will be rounded to next power of two if not already one.
     #[cfg(feature = "io-uring")]
     pub ring_size: u16,
     /// Store this many responses at most for retrying (once) on send failure
@@ -132,7 +131,7 @@ impl Default for NetworkConfig {
             socket_recv_buffer_size: 8_000_000,
             poll_timeout_ms: 50,
             #[cfg(feature = "io-uring")]
-            ring_size: 1024,
+            ring_size: 128,
             resend_buffer_max_len: 0,
         }
     }
@@ -153,7 +152,7 @@ impl Default for ProtocolConfig {
     fn default() -> Self {
         Self {
             max_scrape_torrents: 70,
-            max_response_peers: 50,
+            max_response_peers: 30,
             peer_announce_interval: 60 * 15,
         }
     }

crates/udp_load_test/src/config.rs

@@ -124,8 +124,8 @@ impl Default for RequestConfig {
             number_of_peers: 2_000_000,
             scrape_max_torrents: 10,
             announce_peers_wanted: 30,
-            weight_connect: 1,
-            weight_announce: 100,
+            weight_connect: 50,
+            weight_announce: 50,
             weight_scrape: 1,
             peer_seeder_probability: 0.75,
         }