teems/run_experiments.py

#!/usr/bin/python3

'''
  NOTE: This script is tailored for sizzle!
  Hence it does server thread allocation assuming 2 40-core processors.
  Currently assumes 8 threads (C72-79)  are set aside for client simulator

  Run generate manifest with the maximum number of servers you are going to use
  and generate the keys for this before running experiments
  (Run ./App/getpubkeys to generate keys for the servers)
'''

import subprocess
import os
import sys
import math
from gen_manifest import generate_manifest
from gen_enclave_config import generate_config

###############################################################################

# CONFIGS TO SET:

MANIFEST_FILE = "App/manifest.yaml"
#MANIFESTS_FOLDER = "Manifests/"
LOG_FOLDER = "Experiments_Plot_170424_Final/"
RESULT_FOLDER = "Experiment_results/"

'''
# N = number of clients
N = [1<<16, 1<<17, 1<<18, 1<<19, 1<<20, 1<<21]
# M = number of servers
M = [1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 20, 24, 26, 28, 32, 36, 40, 48, 56, 64, 72]
# T = threads per server instance
T = [2, 4, 8, 16]
'''

N = [1<<16, 1<<17, 1<<18, 1<<19, 1<<20]
M = [72, 64, 48, 36, 24, 16, 8, 4, 2, 1]
T = [16, 8, 4, 2, 1]

# Max servers depending on number of threads
M_MAX = {
    1:72, # 24 in M
    2:36, # 19 in M
    4:18, # 13 in M
    8:9,  # 8 in M
    16:4  # 4 in M
}
# B = msg_size (-u)
B = 256

###############################################################################

def epoch_time(n, m, t, b):
    # Base epoch time is 5 sec
    etime_base = 5
    clients_per_server = math.ceil(n/m)
    # Using 1 sec for ~50K clients in compute time
    # Using 8 sec for 2^20 clients in route_compute time as the base for calculations below
    # (About 1 sec actual route, 6.5 sec for storage generate_tokens
    # and process_msgs)
    etime_route_compute = 0.8 * math.ceil(clients_per_server/100000)
    etime_precompute = 1.5 * math.ceil(clients_per_server/100000)

    # If we have less than 3 threads the precompute happens sequentially
    # so epoch_interval needs to account for all the precompute
    #if(t < 3):
    #    etime_precompute *=3

    # Client time:
    # Takes about 30 sec for handling 2^20 clients
    etime_client = math.ceil(clients_per_server/100000) * 3
    #if(t>3):
    #    etime_client/=(t/4)

    #etime_inc = math.ceil(clients_per_server/25000)
    #etime_client = ((math.ceil(2/t))**2) * etime_inc
    etime = etime_base + etime_precompute + etime_route_compute + etime_client
    return int(etime)


if __name__ == "__main__":

    if not os.path.exists(LOG_FOLDER):
        os.mkdir(LOG_FOLDER)

    for t in T:
        b = B
        m_start = 1
        # Set M_MAX depending on t
        m_end = M_MAX[t]
        for m in M:
            if(m <= m_end):
                for n in N:
                    print("\n\n Running Experiment t = %d, m = %d, n = %d \n\n" % (t, m, n))
                    generate_manifest(n, m, t, b)
                    generate_config(n, m, t, b)
                    epoch_interval = epoch_time(n, m, t, b)
                    print("Epoch_interval = %d" % epoch_interval)

                    log_subfolder = str(n) + "_" + str(m) + "_" + str(t) + "_" + str(b) + "/"
                    log_subfolder = LOG_FOLDER + log_subfolder
                    if not os.path.exists(log_subfolder):
                        os.mkdir(log_subfolder)
                    # Since launch is invoked from App/ ; we add a ../ to subfolder before
                    # passing it to slaunch
                    log_subfolder = "../" + log_subfolder

                    slaunch = []
                    slaunch.append("./launch")
                    slaunch.append("route_clients")
                    slaunch.append("-l")
                    slaunch.append(log_subfolder)
                    slaunch.append("-n")
                    nodes_to_include = ["-n"]
                    for i in range(1, m+1):
                        nodes_to_include.append("s"+str(i))
                        slaunch.append("s"+str(i))
                    slaunch.append("-e")
                    slaunch.append(str(epoch_interval))

                    os.chdir("./App")
                    # Server outputs are captured by log files provided to each of the server
                    # launch calls made by App/launch
                    make = subprocess.call(["make", "-C", "..", "-j"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                    server_process = subprocess.run(slaunch)

                    claunch = []
                    claunch.append("./clientlaunch")
                    claunch.append("-t")
                    claunch.append("8")
                    claunch.append("-l")
                    claunch.append(log_subfolder+"clients.log")
                    os.chdir("./../Client/")
                    client_process = subprocess.call(claunch)

                    os.chdir("./../")