tests: unify memcached memory/query config

Signed-off-by: Reto Achermann <[email protected]>

Author: achreto

kernel/tests/s10_benchmarks.rs

@@ -872,6 +872,9 @@ fn s10_leveldb_benchmark() {
     }
 }
 
+use testutils::configs::MEMCACHED_MEM_SIZE_MB;
+use testutils::configs::MEMCACHED_NUM_QUERIES;
+
 #[test]
 fn s10_memcached_benchmark_internal() {
     setup_network(1);
@@ -899,9 +902,10 @@ fn s10_memcached_benchmark_internal() {
         (16 * 1024 /* MB */, 16 /* MB */, 2000000, 300_000)
     } else {
         (
-            256 * 1024, /* MB */
-            16,         // 64 * 1024, /* MB */
-            100_000_000,
+            // keep in sync with the s11_ra
+            32 * 1024, /* MB */
+            MEMCACHED_MEM_SIZE_MB,
+            MEMCACHED_NUM_QUERIES,
             600_000,
         )
     };

kernel/tests/s11_rackscale_benchmarks.rs

@@ -24,6 +24,9 @@ use testutils::builder::Machine;
 use testutils::rackscale_runner::{RackscaleBench, RackscaleRun};
 use testutils::runner_args::RackscaleTransport;
 
+use testutils::configs::MEMCACHED_MEM_SIZE_MB;
+use testutils::configs::MEMCACHED_NUM_QUERIES;
+
 #[test]
 #[cfg(not(feature = "baremetal"))]
 fn s11_rackscale_shmem_fxmark_benchmark() {
@@ -138,7 +141,7 @@ fn rackscale_fxmark_benchmark(transport: RackscaleTransport) {
     fn timeout_fn(num_cores: usize) -> u64 {
         180_000 + 5_000 * num_cores as u64
     }
-    fn mem_fn(num_cores: usize, is_smoke: bool) -> usize {
+    fn mem_fn(num_cores: usize, _num_clients: usize, is_smoke: bool) -> usize {
         if is_smoke {
             8192
         } else {
@@ -302,7 +305,7 @@ fn rackscale_vmops_benchmark(transport: RackscaleTransport, benchtype: VMOpsBenc
     fn rackscale_timeout_fn(num_cores: usize) -> u64 {
         240_000 + 1_000 * num_cores as u64
     }
-    fn mem_fn(num_cores: usize, is_smoke: bool) -> usize {
+    fn mem_fn(num_cores: usize, _num_clients: usize, is_smoke: bool) -> usize {
         if is_smoke {
             8192
         } else {
@@ -440,7 +443,7 @@ fn s11_rackscale_shmem_leveldb_benchmark() {
         240_000 + 500 * num_cores as u64
     }
 
-    fn mem_fn(num_cores: usize, is_smoke: bool) -> usize {
+    fn mem_fn(num_cores: usize, _num_clients: usize, is_smoke: bool) -> usize {
         if is_smoke {
             8192
         } else {
@@ -463,9 +466,6 @@ fn s11_rackscale_shmem_leveldb_benchmark() {
     bench.run_bench(false, is_smoke);
 }
 
-const MEMCACHED_MEM_SIZE_MB: usize = 16;
-const MEMCACHED_NUM_QUERIES: usize = 1000_000;
-
 #[derive(Clone)]
 struct MemcachedInternalConfig {
     pub num_queries: usize,
@@ -625,8 +625,8 @@ fn rackscale_memcached_benchmark(transport: RackscaleTransport) {
 
     if !is_smoke {
         test.shmem_size = std::cmp::max(
-            MEMCACHED_MEM_SIZE_MB * 8,
-            testutils::helpers::SHMEM_SIZE * 4,
+            MEMCACHED_MEM_SIZE_MB * 2,
+            testutils::helpers::SHMEM_SIZE * 2,
         );
     }
 
@@ -646,18 +646,20 @@ fn rackscale_memcached_benchmark(transport: RackscaleTransport) {
         500_000 + 5_000 * num_cores as u64
     }
 
-    fn mem_fn(num_cores: usize, is_smoke: bool) -> usize {
+    fn mem_fn(num_cores: usize, num_clients: usize, is_smoke: bool) -> usize {
+        let base_memory = if num_cores > 64 { 8192 } else { 4096 };
+
         if is_smoke {
-            8192
+            base_memory
         } else {
             // Memory must also be divisible by number of nodes, which could be 1, 2, 3, or 4
             // memory = result of this function / num_clients  - shmem_size
-            (8192
+            (base_memory
                 + std::cmp::max(
-                    MEMCACHED_MEM_SIZE_MB * 8,
-                    testutils::helpers::SHMEM_SIZE * 4,
+                    MEMCACHED_MEM_SIZE_MB * 2,
+                    testutils::helpers::SHMEM_SIZE * 2,
                 ))
-                * (((((num_cores + 1) / 2) + 3 - 1) / 3) * 3)
+                * num_clients
         }
     }
 
@@ -852,7 +854,7 @@ fn s11_rackscale_memcached_benchmark_sharded_linux() {
             mem_size: 16,
             protocol: "tcp",
             is_local_host: true,
-            num_threads: 4,
+            num_threads: 8,
             path: out_dir_path,
         }
     } else {
@@ -863,7 +865,7 @@ fn s11_rackscale_memcached_benchmark_sharded_linux() {
             mem_size: MEMCACHED_MEM_SIZE_MB,
             protocol: "tcp",
             is_local_host: true,
-            num_threads: 4,
+            num_threads: 8,
             path: out_dir_path,
         }
     };
@@ -984,7 +986,7 @@ fn s11_rackscale_memcached_benchmark_sharded_linux() {
         config.num_servers = num_nodes;
 
         for num_threads in 1..=max_threads_per_node {
-            if (num_threads != 1 || num_threads != max_threads_per_node) && (num_threads % 4 != 0) {
+            if (num_threads != 1 || num_threads != max_threads_per_node) && (num_threads % 8 != 0) {
                 continue;
             }
 
@@ -1335,7 +1337,7 @@ fn s11_rackscale_memcached_benchmark_sharded_nros() {
         600_000 + 60_000 * num_cores as u64
     }
 
-    fn mem_fn(num_cores: usize, is_smoke: bool) -> usize {
+    fn mem_fn(num_cores: usize, _num_clients: usize, is_smoke: bool) -> usize {
         if is_smoke {
             8192
         } else {
@@ -1423,7 +1425,7 @@ fn rackscale_monetdb_benchmark(transport: RackscaleTransport) {
         180_000 + 500 * num_cores as u64
     }
 
-    fn mem_fn(num_cores: usize, is_smoke: bool) -> usize {
+    fn mem_fn(num_cores: usize, _num_clients: usize, is_smoke: bool) -> usize {
         if is_smoke {
             8192
         } else {

kernel/testutils/src/configs.rs

@@ -0,0 +1,5 @@
+// Copyright © 2021 VMware, Inc. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+pub const MEMCACHED_MEM_SIZE_MB: usize = 8 * 1024;
+pub const MEMCACHED_NUM_QUERIES: usize = 1_000_000;

kernel/testutils/src/lib.rs

@@ -9,6 +9,7 @@ extern crate rexpect;
 extern crate serde;
 
 pub mod builder;
+pub mod configs;
 pub mod helpers;
 pub mod rackscale_runner;
 pub mod redis;

kernel/testutils/src/rackscale_runner.rs

@@ -786,7 +786,7 @@ pub struct RackscaleBench<T: Clone + Send + 'static> {
     // Function to calculate the timeout. Takes as argument number of application cores
     pub baseline_timeout_fn: fn(usize) -> u64,
     // Function to calculate memory (excpeting controller memory). Takes as argument number of application cores and is_smoke
-    pub mem_fn: fn(usize, bool) -> usize,
+    pub mem_fn: fn(usize, usize, bool) -> usize,
 }
 
 impl<T: Clone + Send + 'static> RackscaleBench<T> {
@@ -877,11 +877,12 @@ impl<T: Clone + Send + 'static> RackscaleBench<T> {
 
             // Caclulate memory for each component
             if !is_baseline {
-                test_run.memory = ((self.mem_fn)(total_cores, is_smoke) / test_run.num_clients)
+                test_run.memory = ((self.mem_fn)(total_cores, test_run.num_clients, is_smoke)
+                    / test_run.num_clients)
                     - test_run.shmem_size;
                 assert!(test_run.memory > 0);
             } else {
-                test_run.memory = (self.mem_fn)(total_cores, is_smoke);
+                test_run.memory = (self.mem_fn)(total_cores, test_run.num_clients, is_smoke);
             }
 
             if is_baseline {