bench: more tweaks for memcached

Signed-off-by: Reto Achermann <achreto@gmail.com>

Author: achreto

kernel/tests/s11_rackscale_benchmarks.rs

@@ -463,6 +463,9 @@ fn s11_rackscale_shmem_leveldb_benchmark() {
     bench.run_bench(false, is_smoke);
 }
 
+const MEMCACHED_MEM_SIZE_MB: usize = 4 * 1024;
+const MEMCACHED_NUM_QUERIES: usize = 10_000_000;
+
 #[derive(Clone)]
 struct MemcachedInternalConfig {
     pub num_queries: usize,
@@ -606,21 +609,24 @@ fn rackscale_memcached_benchmark(transport: RackscaleTransport) {
         // keep in sync with the s10_memcached_benchmark_internal configuration
         // and the s11_rackscale_memcached_benchmark_sharded configuration
         MemcachedInternalConfig {
-            num_queries: 10_000_000,
-            mem_size: 16, // 64 * 1024,
+            num_queries: MEMCACHED_NUM_QUERIES,
+            mem_size: MEMCACHED_MEM_SIZE_MB,
         }
     };
 
     let mut test = RackscaleRun::new("userspace-smp".to_string(), built);
     test.controller_match_fn = controller_match_fn;
     test.transport = transport;
-    test.shmem_size *= 2;
     test.use_affinity_shmem = cfg!(feature = "affinity-shmem");
     test.use_qemu_huge_pages = cfg!(feature = "affinity-shmem");
     test.file_name = file_name.to_string();
     test.arg = Some(config);
     test.run_dhcpd_for_baseline = true;
 
+    if !is_smoke {
+        test.shmem_size = MEMCACHED_MEM_SIZE_MB * 2;
+    }
+
     fn cmd_fn(num_cores: usize, arg: Option<MemcachedInternalConfig>) -> String {
         let config = arg.expect("missing leveldb config");
         format!(
@@ -642,8 +648,7 @@ fn rackscale_memcached_benchmark(transport: RackscaleTransport) {
             8192
         } else {
             // Memory must also be divisible by number of nodes, which could be 1, 2, 3, or 4
-            // 2048 * (((((num_cores + 1) / 2) + 3 - 1) / 3) * 3)
-            3 * 1024 // 3 * 128 * 1024
+            2048 * (((((num_cores + 1) / 2) + 3 - 1) / 3) * 3)
         }
     }
 
@@ -845,8 +850,8 @@ fn s11_rackscale_memcached_benchmark_sharded_linux() {
         // keep in sync with the s10_memcached_benchmark_internal configuration
         MemcachedShardedConfig {
             num_servers: 1,
-            num_queries: 10_000_000,
-            mem_size: 16, // 64 * 1024,
+            num_queries: MEMCACHED_NUM_QUERIES,
+            mem_size: MEMCACHED_MEM_SIZE_MB,
             protocol: "tcp",
             is_local_host: true,
             num_threads: 4,
@@ -1010,6 +1015,7 @@ fn s11_rackscale_memcached_benchmark_sharded_linux() {
                 let mut pty =
                     spawn_loadbalancer(&config, timeout_ms).expect("failed to spawn load balancer");
                 let mut output = String::new();
+                use rexpect::errors::ErrorKind::Timeout;
                 match parse_memcached_output(&mut pty, &mut output) {
                     Ok(res) => {
                         let r = csv_file.write(format!("{},", env!("GIT_HASH")).as_bytes());
@@ -1028,8 +1034,19 @@ fn s11_rackscale_memcached_benchmark_sharded_linux() {
 
                         println!("{:?}", res);
                     }
+
                     Err(e) => {
-                        println!("error: {}", e);
+                        if let Timeout(expected, got, timeout) = e.0 {
+                            println!("Timeout while waiting for {} ms\n", timeout.as_millis());
+                            println!("Expected: `{expected}`\n");
+                            println!("Got:",);
+                            for l in got.lines().take(5) {
+                                println!(" > {l}");
+                            }
+                        } else {
+                            println!("error: {}", e);
+                        }
+
                         let r = csv_file.write(format!("{},", env!("GIT_HASH")).as_bytes());
                         assert!(r.is_ok());
                         let out = format!(
@@ -1080,8 +1097,8 @@ fn s11_rackscale_memcached_benchmark_sharded_nros() {
         // keep in sync with the s10_memcached_benchmark_internal configuration
         MemcachedShardedConfig {
             num_servers: 1,
-            num_queries: 10_000_000,
-            mem_size: 16, // 64 * 1024,
+            num_queries: MEMCACHED_NUM_QUERIES,
+            mem_size: MEMCACHED_MEM_SIZE_MB,
             protocol: "tcp",
             is_local_host: true,
             num_threads: 4,
@@ -1178,8 +1195,18 @@ fn s11_rackscale_memcached_benchmark_sharded_nros() {
             .open(file_name)
             .expect("Can't open file");
 
+        use rexpect::errors::Error;
+        use rexpect::errors::ErrorKind::Timeout;
         let res = match parse_memcached_output(proc, output) {
             Ok(res) => res,
+            Err(Error(Timeout(expected, got, timeout), st)) => {
+                println!("Expected: `{expected}`\n");
+                println!("Got:",);
+                for l in got.lines().take(5) {
+                    println!(" > {l}");
+                }
+                return Err(Error(Timeout(expected, got, timeout), st));
+            }
             Err(err) => {
                 println!("Failed: {:?}", err);
                 return Err(err);
@@ -1268,6 +1295,10 @@ fn s11_rackscale_memcached_benchmark_sharded_nros() {
     test.run_dhcpd_for_baseline = true;
     test.is_multi_node = true;
 
+    if !is_smoke {
+        test.shmem_size = MEMCACHED_MEM_SIZE_MB * 2;
+    }
+
     fn cmd_fn(num_cores: usize, arg: Option<MemcachedShardedConfig>) -> String {
         let config = arg.expect("missing configuration");
         format!(
@@ -1281,17 +1312,15 @@ fn s11_rackscale_memcached_benchmark_sharded_nros() {
     }
 
     fn rackscale_timeout_fn(num_cores: usize) -> u64 {
-        180_000 + 1_500 * num_cores as u64
+        300_000 + 4_500 * num_cores as u64
     }
 
-    fn mem_fn(_num_cores: usize, is_smoke: bool) -> usize {
+    fn mem_fn(num_cores: usize, is_smoke: bool) -> usize {
         if is_smoke {
             8192
         } else {
             // Memory must also be divisible by number of nodes, which could be 1, 2, 3, or 4
-            // 256 * 1024 //2048 * (((((num_cores + 1) / 2) + 3 - 1) / 3) * 3)
-            // 3 * 128 * 1024
-            3 * 1024
+            2048 * (((((num_cores + 1) / 2) + 3 - 1) / 3) * 3)
         }
     }