experiments: add large-scale memcached experiment

experiments/pyexps/dist_memcache.py

+# Copyright 2021 Max Planck Institute for Software Systems, and
+# National University of Singapore
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import math
+import random
+import simbricks.experiments as exp
+import simbricks.simulators as sim
+import simbricks.proxy as proxy
+import simbricks.nodeconfig as node
+
+host_types = ['qemu', 'gem5', 'qt']
+n_nets = [1, 2, 3, 4]
+n_hosts = [2, 10, 20, 30, 40, 50]
+experiments = []
+separate_net = False
+
+def select_servers(i, j, racks, n, n_host):
+    nc = int(n_host / 2)
+
+    if n == 1:
+        # only one network, just connect to all servers
+        return racks[i][0]
+
+    all_other_servers = []
+    for k in range(0, n):
+        if k == i:
+            continue
+        all_other_servers += racks[k][0]
+
+    n_local = math.ceil(nc / 2)
+    n_remote = math.floor(nc / 2)
+
+    servers_local = random.sample(racks[i][0], k=n_local)
+    servers_other = random.sample(all_other_servers, k=n_remote)
+    return servers_local + servers_other
+
+for host_type in host_types:
+  for n in n_nets:
+    for n_host in n_hosts:
+        random.seed(n + 1000 * n_host)
+
+        nh = n if not separate_net else n + 1
+        e = exp.DistributedExperiment(f'dist_memcache-{host_type}-{n}-{n_host}', nh)
+
+        # host
+        if host_type == 'qemu':
+            host_class = sim.QemuHost
+        elif host_type == 'qt':
+            def qemu_timing():
+                h = sim.QemuHost()
+                h.sync = True
+                return h
+            host_class = qemu_timing
+        elif host_type == 'gem5':
+            host_class = sim.Gem5Host
+            e.checkpoint = True
+        else:
+            raise NameError(host_type)
+
+        switch_top = sim.SwitchNet()
+        switch_top.name = 'switch_top'
+        if host_type == 'qemu':
+            switch_top.sync = False
+        e.add_network(switch_top)
+        e.assign_sim_host(switch_top, 0)
+
+        racks = []
+        for i in range(0, n):
+            h_i = i if not separate_net else i + 1
+            switch = sim.SwitchNet()
+            switch.name = 'switch_%d' % (i,)
+            if host_type == 'qemu':
+                switch.sync = False
+            e.add_network(switch)
+            e.assign_sim_host(switch, h_i)
+
+            switch_top.connect_network(switch)
+
+            # create servers and clients
+            m = int(n_host / 2)
+            servers = sim.create_basic_hosts(e, m, 'server_%d' % (i,),
+                    switch, sim.I40eNIC, host_class, node.I40eLinuxNode,
+                    node.MemcachedServer, ip_start = i * n_host + 1)
+            for s in servers:
+                e.assign_sim_host(s, h_i)
+                e.assign_sim_host(s.nics[0], h_i)
+
+            clients = sim.create_basic_hosts(e, m, 'client_%d' % (i,),
+                    switch, sim.I40eNIC, host_class, node.I40eLinuxNode,
+                    node.MemcachedClient, ip_start = i * n_host + 1 + m)
+            for c in clients:
+                c.wait = True
+                e.assign_sim_host(c, h_i)
+                e.assign_sim_host(c.nics[0], h_i)
+
+            racks.append((servers, clients))
+
+            if h_i != 0:
+                lp = proxy.SocketsNetProxyListener()
+                lp.name = 'listener-%d' % (i,)
+                e.add_proxy(lp)
+                e.assign_sim_host(lp, h_i)
+
+                cp = proxy.SocketsNetProxyConnecter(lp)
+                cp.name = 'connecter-%d' % (i,)
+                e.add_proxy(cp)
+                e.assign_sim_host(cp, 0)
+
+                lp.add_n2n(switch_top, switch)
+
+            for c in clients + servers:
+                c.nics[0].start_tick = 580000000000
+                c.extra_deps.append(switch_top)
+
+        all_servers = []
+        for  (s,_) in racks:
+            all_servers += s
+
+        # set up client -> server connections
+        for i in range(0, n):
+            for j in range(0, int(n_host / 2)):
+                c = racks[i][1][j]
+                servers = select_servers(i, j, racks, n, n_host)
+                server_ips = [s.node_config.ip for s in servers]
+
+                c.node_config.app.server_ips = server_ips
+                c.node_config.app.threads = len(server_ips)
+                c.node_config.app.concurrency = len(server_ips)
+                c.extra_deps += all_servers
+
+        # add to experiments
+        experiments.append(e)

experiments/simbricks/nodeconfig.py

@@ -527,3 +527,16 @@ class HTTPCMtcp(HTTPC):
         ]
 
 
+class MemcachedServer(AppConfig):
+    def run_cmds(self, node):
+        return ['memcached -u root -t 1 -c 4096']
+
+class MemcachedClient(AppConfig):
+    server_ips = ['10.0.0.1']
+    threads = 1
+    concurrency = 1
+    throughput = '1k'
+    def run_cmds(self, node):
+        servers = [ip + ':11211' for ip in self.server_ips]
+        servers = ','.join(servers)
+        return [f'memaslap --binary --time 10s --server={servers} --thread={self.threads} --concurrency={self.concurrency} --tps={self.throughput}']
\ No newline at end of file