bench: adding sharded memcached benchmark

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

Author: achreto

kernel/tests/s11_rackscale_benchmarks.rs

@@ -339,7 +339,7 @@ struct LevelDBConfig {
 fn s11_rackscale_shmem_leveldb_benchmark() {
     // TODO(rackscale): because this test is flaky, always just run smoke test.
     // Seen bugs include mutex locking against itself, _lwp_exit returning after a thread has blocked.
-    let is_smoke = cfg!(feature = "smoke");
+    let is_smoke = true; // cfg!(feature = "smoke");
 
     let file_name = "rackscale_shmem_leveldb_benchmark.csv";
     let _ignore = std::fs::remove_file(file_name);
@@ -661,12 +661,13 @@ fn rackscale_memcached_benchmark(transport: RackscaleTransport) {
 }
 
 #[derive(Clone)]
-struct MemcachedShardedConfig<'a> {
+struct MemcachedShardedConfig {
+    pub num_servers: usize,
     pub num_queries: usize,
     pub mem_size: usize,
     pub protocol: &'static str,
     pub num_threads: usize,
-    pub path: &'a Path,
+    pub path: PathBuf,
 }
 
 #[derive(Clone, Debug)]
@@ -810,20 +811,22 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
     // stuff has been built, now we can run the benchmark
     let mut config = if is_smoke {
         MemcachedShardedConfig {
+            num_servers:1,
             num_queries: 100_000,
             mem_size: 16,
             protocol: "tcp",
             num_threads: 4,
-            path: out_dir_path.as_path(),
+            path: out_dir_path,
         }
     } else {
         // keep in sync with the s10_memcached_benchmark_internal configuration
         MemcachedShardedConfig {
+            num_servers:1,
             num_queries: 100_000_000,
             mem_size: 128 * 1024,
             protocol: "tcp",
             num_threads: 4,
-            path: out_dir_path.as_path(),
+            path: out_dir_path,
         }
     };
 
@@ -838,7 +841,7 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
         command.arg("./build/bin/memcached");
         command.arg(format!("--x-benchmark-queries={}", config.num_queries).as_str());
         command.arg(format!("--x-benchmark-mem={}", config.mem_size).as_str());
-        command.current_dir(config.path);
+        command.current_dir(config.path.as_path());
         spawn_command(command, Some(timeout_ms)).expect("failed to spawn memcached")
     }
 
@@ -851,24 +854,24 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
             config.mem_size.to_string().as_str(),
             config.num_threads.to_string().as_str(),
         ]);
-        command.current_dir(config.path);
+        command.current_dir(config.path.as_path());
         let mut memcached =
             spawn_command(command, Some(timeout_ms)).expect("failed to spawn memcached");
         std::thread::sleep(Duration::from_secs(2));
     }
 
     fn spawn_loadbalancer(
-        num_servers: usize,
-        config: &MemcachedShardedConfig,
+        config: Option<&MemcachedShardedConfig>,
         timeout_ms: u64,
     ) -> PtySession {
+        let config = config.unwrap();
         let mut command = Command::new("./loadbalancer/loadbalancer");
         command.args(&["--binary"]);
         command.arg(format!("--num-queries={}", config.num_queries).as_str());
         command.arg(format!("--num-threads={}", config.num_threads).as_str());
         command.arg(format!("--max-memory={}", config.mem_size).as_str());
         let mut servers = String::from("--servers=");
-        for i in 0..num_servers {
+        for i in 0..config.num_servers {
             if i > 0 {
                 servers.push_str(",");
             }
@@ -879,7 +882,7 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
             }
         }
         command.arg(servers.as_str());
-        command.current_dir(config.path);
+        command.current_dir(config.path.as_path());
 
         spawn_command(command, Some(timeout_ms)).expect("failed to spawn load balancer")
     }
@@ -901,6 +904,8 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
     for num_nodes in 1..=machine.max_numa_nodes() {
         let threads_per_node = max_threads_per_node / num_nodes;
 
+        config.num_servers = num_nodes;
+
         for num_threads in 1..=threads_per_node {
             config.num_threads = num_threads;
 
@@ -929,7 +934,7 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
                     spawn_memcached(i.to_string().as_str(), &config, timeout_ms);
                 }
 
-                let mut pty = spawn_loadbalancer(num_nodes, &config, timeout_ms);
+                let mut pty = spawn_loadbalancer(Some(&config), timeout_ms);
                 let mut output = String::new();
                 let res = parse_memcached_output(&mut pty, &mut output);
 
@@ -949,6 +954,70 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
 
     // terminate the memcached instance
     Command::new("killall").args(&["memcached"]).status();
+
+    // run with NrOS as host
+    let built = BuildArgs::default()
+        .module("rkapps")
+        .user_feature("rkapps:memcached-bench")
+        .kernel_feature("pages-4k")
+        .release()
+        .build();
+
+    fn controller_match_fn(
+        proc: &mut PtySession,
+        output: &mut String,
+        _cores_per_client: usize,
+        num_clients: usize,
+        file_name: &str,
+        is_baseline: bool,
+        arg: Option<MemcachedShardedConfig>,
+    ) -> Result<()> {
+        // here we should wait
+        Ok(())
+    }
+
+    let mut test = RackscaleRun::new("userspace-smp".to_string(), built);
+    test.controller_match_fn = controller_match_fn;
+    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;
+    test.is_multi_node = true;
+
+    fn cmd_fn(num_cores: usize, arg: Option<MemcachedShardedConfig>) -> String {
+        let config = arg.expect("missing configuration");
+        format!(
+            r#"init=memcachedbench.bin initargs={} appcmd='--x-benchmark-no-run --disable-evictions --threads={} --x-benchmark-mem={} --memory-limit={} "#,
+            num_cores, num_cores, config.mem_size, config.mem_size
+        )
+    }
+
+    fn baseline_timeout_fn(num_cores: usize) -> u64 {
+        120_000 + 500 * num_cores as u64
+    }
+
+    fn rackscale_timeout_fn(num_cores: usize) -> u64 {
+        180_000 + 1_500 * num_cores as u64
+    }
+
+    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)
+        }
+    }
+
+    // construct bench and run it!
+    let bench = RackscaleBench {
+        test,
+        cmd_fn,
+        baseline_timeout_fn,
+        rackscale_timeout_fn,
+        mem_fn,
+    };
+    bench.run_bench(false, is_smoke);
 }
 
 #[test]
@@ -963,7 +1032,7 @@ fn rackscale_monetdb_benchmark(transport: RackscaleTransport) {
 
     // TODO(rackscale): because this test is flaky, always just run smoke test.
     // Seen bugs include mutex locking against itself, _lwp_exit returning after a thread has blocked.
-    let is_smoke = cfg!(feature = "smoke");
+    let is_smoke = true; // cfg!(feature = "smoke");
 
     let file_name = format!("rackscale_{}_monetdb_benchmark.csv", transport.to_string(),);
     let _ignore = std::fs::remove_file(file_name.clone());