tests: wait until clients are up before spawning servers

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

Author: achreto

kernel/tests/s11_rackscale_benchmarks.rs

@@ -664,6 +664,7 @@ fn rackscale_memcached_benchmark(transport: RackscaleTransport) {
 struct MemcachedShardedConfig {
     pub num_servers: usize,
     pub num_queries: usize,
+    pub is_local_host: bool,
     pub mem_size: usize,
     pub protocol: &'static str,
     pub num_threads: usize,
@@ -815,6 +816,7 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
             num_queries: 100_000,
             mem_size: 16,
             protocol: "tcp",
+            is_local_host: true,
             num_threads: 4,
             path: out_dir_path,
         }
@@ -825,6 +827,7 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
             num_queries: 100_000_000,
             mem_size: 128 * 1024,
             protocol: "tcp",
+            is_local_host: true,
             num_threads: 4,
             path: out_dir_path,
         }
@@ -863,7 +866,8 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
     fn spawn_loadbalancer(
         config: Option<&MemcachedShardedConfig>,
         timeout_ms: u64,
-    ) -> PtySession {
+    ) -> Result<PtySession> {
+        println!("SPAWN LOADBALANCER!");
         let config = config.unwrap();
         let mut command = Command::new("./loadbalancer/loadbalancer");
         command.args(&["--binary"]);
@@ -876,15 +880,24 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
                 servers.push_str(",");
             }
             if config.protocol == "tcp" {
-                servers.push_str(format!("tcp://localhost:{}", 11211 + i).as_str());
+                if config.is_local_host {
+                    servers.push_str(format!("tcp://localhost:{}", 11211 + i).as_str());
+                } else {
+                    let ip = 10 + i;
+                    servers.push_str(format!("tcp://172.31.0.{}:{}", ip, 11211).as_str());
+                }
+
             } else {
                 servers.push_str(format!("unix://memcached{}.sock", i).as_str());
             }
         }
         command.arg(servers.as_str());
         command.current_dir(config.path.as_path());
 
-        spawn_command(command, Some(timeout_ms)).expect("failed to spawn load balancer")
+        // give the servers some time to be spawned
+        std::thread::sleep(Duration::from_secs(2 * config.num_servers as u64));
+
+        spawn_command(command, Some(timeout_ms))
     }
 
     let file_name = "memcached_benchmark_sharded.csv";
@@ -896,7 +909,7 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
         .open(file_name)
         .expect("Can't open file");
 
-    let row = "git_rev,benchmark,nthreads,protocol,mem,queries,time,thpt\n";
+    let row = "git_rev,benchmark,os,nthreads,protocol,mem,queries,time,thpt\n";
     let r = csv_file.write(row.as_bytes());
     assert!(r.is_ok());
 
@@ -915,7 +928,7 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
             let r = csv_file.write(format!("{},", env!("GIT_HASH")).as_bytes());
             assert!(r.is_ok());
             let out = format!(
-                "memcached_sharded,{},{},{},{},{},{}\n",
+                "memcached_sharded,linux,{},{},{},{},{},{}\n",
                 res.b_threads, "internal", res.b_mem, res.b_queries, res.b_time, res.b_thpt,
             );
             let r = csv_file.write(out.as_bytes());
@@ -934,14 +947,14 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
                     spawn_memcached(i.to_string().as_str(), &config, timeout_ms);
                 }
 
-                let mut pty = spawn_loadbalancer(Some(&config), timeout_ms);
+                let mut pty = spawn_loadbalancer(Some(&config), timeout_ms).expect("failed to spawn load balancer");
                 let mut output = String::new();
                 let res = parse_memcached_output(&mut pty, &mut output);
 
                 let r = csv_file.write(format!("{},", env!("GIT_HASH")).as_bytes());
                 assert!(r.is_ok());
                 let out = format!(
-                    "memcached_sharded,{},{},{},{},{},{}\n",
+                    "memcached_sharded,linux,{},{},{},{},{},{}\n",
                     res.b_threads, protocol, res.b_mem, res.b_queries, res.b_time, res.b_thpt,
                 );
                 let r = csv_file.write(out.as_bytes());
@@ -963,21 +976,40 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
         .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<()> {
+    fn controller_run_fun(
+        config: Option<&MemcachedShardedConfig>,
+        timeout_ms: u64,
+    ) -> Result<PtySession> {
         // here we should wait
-        Ok(())
+        std::thread::sleep(Duration::from_secs(5));
+        spawn_loadbalancer(config, timeout_ms)
     }
 
+    // fn client_match_fn(
+    //     proc: &mut PtySession,
+    //     output: &mut String,
+    //     cores_per_client: usize,
+    //     num_clients: usize,
+    //     file_name: &str,
+    //     is_baseline: bool,
+    //     arg: Option<T>,
+    // ) -> Result<()>
+    // {
+    //     let (prev, matched) = p.exp_regex(r#"x_benchmark_mem = (\d+) MB"#).unwrap();
+    //     println!("> {}", matched);
+    //     let b_mem = matched.replace("x_benchmark_mem = ", "").replace(" MB", "");
+
+    //     *output += prev.as_str();
+    //     *output += matched.as_str();
+    //     Ok(())
+    // }
+
+    config.is_local_host = false;
+
     let mut test = RackscaleRun::new("userspace-smp".to_string(), built);
     test.controller_match_fn = controller_match_fn;
+    test.controller_run_fn = Some(controller_run_fun);
+    // test.client_match_fn = client_match_fn;
     test.use_qemu_huge_pages = cfg!(feature = "affinity-shmem");
     test.file_name = file_name.to_string();
     test.arg = Some(config);
@@ -1009,6 +1041,8 @@ fn rackscale_memcached_benchmark_sharded(is_shmem: bool) {
         }
     }
 
+    println!("----------------------------------------------------------");
+
     // construct bench and run it!
     let bench = RackscaleBench {
         test,