def iterate_through_experiments_exp2_2(): """ Iterates through all the parameter combinations :return: """ create_datadir_if_not_exists(GRAPHPATH) vc_array = [(2**x) for x in range(0, 6)] total_virtual_clients = len(vc_array) client_throughput_means = np.zeros( (total_virtual_clients, 2)) # (virtualclients, number of server, number of read/writes) client_latency_means = np.zeros((total_virtual_clients, 2)) client_throughput_stddev = np.zeros((total_virtual_clients, 2)) client_latency_stddev = np.zeros((total_virtual_clients, 2)) labels = [(2**x) for x in range(0, 6)] for idx, write in enumerate(["0", "1"]): for jdx, virtual_client_threads in enumerate(vc_array): all_throughputs = [] all_latencies = [] for repetition in range(3): for client in ['Client1']: for server in ['Server1', 'Server2']: filename = get_pattern_exp2_2(virtual_client_threads, repetition, client, server, write) throughput, latency = get_throughput_latency_default_memtier( filepath=filename) all_throughputs.append(throughput) all_latencies.append(latency) if write == "1": client_throughput_means[jdx, idx] = np.sum( all_throughputs ) / 3. # Because we have two servers, and the results replicate client_throughput_stddev[jdx, idx] = np.std(all_throughputs) else: client_throughput_means[jdx, idx] = np.sum( all_throughputs ) / 3. # Because we have two servers, and the results replicate client_throughput_stddev[jdx, idx] = np.std(all_throughputs) latency_mean = np.mean( all_latencies) # Divide by 2, because we have two clients latency_stddev = np.std(all_latencies) client_latency_means[jdx, idx] = latency_mean client_latency_stddev[jdx, idx] = latency_stddev print(np.max(client_throughput_means, axis=0)) print(np.max(client_throughput_means, axis=1))
def iterate_through_experiments_exp3_2(): """ Iterates through all the parameter combinations :return: """ create_datadir_if_not_exists(GRAPHPATH) middleware_threads = [(2 ** x) for x in range(3, 7)] virtual_clients = [(2 ** x) for x in range(0, 6)] total_virtual_clients = len([(2 ** x) for x in range(0, 6)]) total_middleware_threads = len([(2 ** x) for x in range(3, 7)]) for write in [0, 1]: max_throughput = 0 max_throughput_client = 0 mw_throughput_means = np.zeros((total_virtual_clients, total_middleware_threads)) mw_throughput_stddev = np.zeros((total_virtual_clients, total_middleware_threads)) mw_latency_means = np.zeros((total_virtual_clients, total_middleware_threads)) mw_latency_stddev = np.zeros((total_virtual_clients, total_middleware_threads)) client_throughput_means = np.zeros((total_virtual_clients, total_middleware_threads)) client_latency_means = np.zeros((total_virtual_clients, total_middleware_threads)) client_throughput_stddev = np.zeros((total_virtual_clients, total_middleware_threads)) client_latency_stddev = np.zeros((total_virtual_clients, total_middleware_threads)) for _vc in range(0, 6): vc = (2 ** _vc) for _mt in range(3 - 3, 7 - 3): mt = (2 ** (_mt + 3)) client_all_throughputs = [] # From here on, we average over all values client_all_latencies = [] mw_all_throughputs = [] mw_all_latencies = [] queuetimes = [] for repetition in range(3): for middleware in [1, 2]: # Get throughput and latency from the file middleware_filename = get_pattern_exp3_2_middleware( virtualclientthreads=vc, middlewarethreads=mt, repetition=repetition, write=write, middleware=middleware ) try: df = parse_log(BASEPATH + middleware_filename) mw_throughput, mw_latency = get_latency_log_dataframe(df) queuetimes.append(df['differenceTimeEnqueuedAndDequeued'].astype(float).mean()) mw_throughput *= mt * 1000 # because we have two middlewares # * (2./3.) # because the load of the clients is distributed on two middlewares print("Throughput is: ", mw_throughput) mw_all_throughputs.append(mw_throughput) mw_all_latencies.append(mw_latency) except Exception as e: print("WRONG WITH THE FOLLOWING CONFIG: ", middleware_filename) print(e) continue for client in ['Client1', 'Client2', 'Client3']: for middleware in [1, 2]: client_filename = get_pattern_exp3_2_client( virtual_client_threads=vc, middlewareworkerthreads=mt, repetition=repetition, client=client, write=write, middleware=middleware ) # Trying to open and read the file! try: client_throughput, client_latency = get_throughput_latency_default_memtier(filepath=BASEPATH + client_filename) client_all_throughputs.append(client_throughput) client_all_latencies.append(client_latency) except Exception as e: print("WRONG WITH THE FOLLOWING CONFIG: ", middleware_filename) print(e) continue print("VC and MT ", (mt, vc)) print("NEW VC and MT ", (_mt, _vc)) mw_mean_latency = np.mean(mw_all_latencies) mw_mean_throughput = np.sum(mw_all_throughputs) / 3. # because we have 3 repeats, and two middlewares (throughput per middleware is calculated as the total throughput) mw_stddev_latency = np.std(mw_all_latencies) mw_stddev_throughput = np.std(mw_all_throughputs) if max_throughput < mw_mean_throughput: max_throughput = mw_mean_throughput print("TTT", write, mw_mean_throughput, mw_mean_latency, np.mean(queuetimes)) # Append to list mw_throughput_means[_vc, _mt] = mw_mean_throughput mw_latency_means[_vc, _mt] = mw_mean_latency mw_throughput_stddev[_vc, _mt] = mw_stddev_throughput mw_latency_stddev[_vc, _mt] = mw_stddev_latency client_mean_latency = np.mean(client_all_latencies) client_mean_throughput = np.sum(client_all_throughputs) / 3. client_stddev_latency = np.std(client_all_latencies) client_stddev_throughput = np.std(client_all_throughputs) if max_throughput_client < client_mean_throughput: max_throughput_client = client_mean_throughput print("TTT CLIENT", write, client_mean_throughput, client_mean_latency) # TTT 0 2978.673972968874 14.885140067475584 588816.9135975742 # TTT CLIENT 0 3010.066666666667 15.961666666666666 # Append to list client_throughput_means[_vc, _mt] = client_mean_throughput client_latency_means[_vc, _mt] = client_mean_latency client_throughput_stddev[_vc, _mt] = client_stddev_throughput client_latency_stddev[_vc, _mt] = client_stddev_latency print(client_throughput_means[:,_mt].flatten()) print(total_virtual_clients) # Assertions len_mt = client_throughput_means[:, _mt].flatten().shape len_vc = client_throughput_means[:, _mt].flatten().shape len1 = virtual_clients print("All lengths are : ") print(len_mt) print(len_vc) print(len1) # THROUGHPUTS print("###write:client ", write, client_throughput_means) print("###write:middleware ", write, mw_throughput_means) ###write:client 0 # [[ 1920.88 1918.63333333 1879.97666667 2040.63666667] # [2948.59 2948.03 2953.48666667 4106.08333333] # [2984.82333333 2906.10666667 2994.25 7329.56] # [2968.63666667 2931.46333333 4117.91 9388.87666667] # [2948.98 2924.93 10709.36 10652.36333333] # [2967.09333333 2988.49 11116.91333333 10953.04]] ###write:middleware 0 # [[ 1823.82088122 1831.66427863 1788.32232092 1963.94693059] # [2894.0011844 2893.19407003 2889.4399206 3919.63102998] # [2904.84043756 2916.86120553 2914.29668445 6350.16067147] # [2919.44080752 2923.44783548 2898.39238625 8313.77410761] # [2916.26533345 2912.31134097 9796.16787827 9657.16189206] # [2923.77401065 2917.48683475 10330.97247506 9984.91367675]] ###write:client 1 # [[1371.69 1433.82666667 1428.60333333 1474.68333333] # [2243.24333333 2678.12 2598.63 2644.23] # [3439.77333333 4868.33 4909.14 3774.43333333] # [5648.88333333 5682.95333333 6149.03 6716.31666667] # [5882.05 7103.95333333 6660.81333333 8108.17] # [5883.05333333 6663.61333333 6983.25666667 4487.62]] ###write:middleware 1 [[1401.75925962 1472.40508414 1479.24123472 1517.59234247] # [2784.22311061 2977.37234977 2626.56406027 2976.11177963] # [5079.75686936 5304.33947114 4915.28801361 4549.81135794] # [6597.81205289 6870.64256402 6942.7881017 6715.72352865] # [6539.19650736 7693.89813362 8053.29642461 8131.41925129] # [6670.31737933 7462.38036606 7429.34669134 7160.16151776]] # LATENCIES print("###write:client ", write, client_latency_means) print("###write:middleware ", write, mw_latency_means) ###write:client 0 # [[ 1.57666667 1.58 1.61333333 1.49777778] # [2.05555556 2.06222222 2.05777778 1.48888889] # [4.05666667 4.17 4.03777778 1.65222222] # [8.10111111 8.21222222 6.61666667 2.57333333] # [16.22222222 16.40888889 4.49777778 4.53666667] # [32.37111111 32.09222222 8.65888889 8.78444444]] ###write:middleware 0 [[ 0.75373062 0.71682754 0.79261609 0.68196475] # [1.14245532 1.15601874 1.12761835 0.6962914] # [3.00268178 3.06263071 3.08864053 0.82161966] # [7.07679403 6.89052932 6.98758393 1.18371943] # [15.26808786 15.11082288 1.48361568 1.50505344] # [31.39592934 31.16684201 1.71758052 1.96693429]] ###write:client 1 [[ 2.18222222 2.08888889 2.09666667 2.03111111] # [1.83222222 1.97444444 1.83111111 2.00444444] # [2.02111111 2.17222222 1.92888889 1.63666667] # [3.78 2.89777778 2.76444444 2.87222222] # [7.29444444 5.97222222 5.64333333 3.69111111] # [12.14444444 10.79 10.41555556 14.27666667]] ###write:middleware 1 # [[ 1.14301648 1.03218857 1.02287563 0.98682917] # [1.02473659 1.01945742 1.08312422 1.00336116] # [1.09529057 1.12426547 1.15199756 1.10026307] # [2.38971881 1.71178708 1.66788647 1.66212348] # [5.65331611 3.1920922 2.80038391 2.75255764] # [11.12888022 4.42134564 2.9218675 2.73590902]] render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=client_throughput_means.T, stddev_array=client_throughput_stddev.T, filepath=GRAPHPATH + "exp3_2__throughput_client_write_{}".format(write), is_latency=False ) render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=client_latency_means.T, stddev_array=client_latency_stddev.T, filepath=GRAPHPATH + "exp3_2__latency_client_write_{}".format(write), is_latency=True ) # Plot the middleware values render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=mw_throughput_means.T, stddev_array=mw_throughput_stddev.T, filepath=GRAPHPATH + "exp3_2__throughput_middleware_write_{}".format(write), is_latency=False ) render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=mw_latency_means.T, stddev_array=mw_latency_stddev.T, filepath=GRAPHPATH + "exp3_2__latency_middleware_write_{}".format(write), is_latency=True )
def iterate_through_experiments_exp2_1(): """ Iterates through all the parameter combinations :return: """ create_datadir_if_not_exists(GRAPHPATH) vc_array = [(2**x) for x in range(0, 6)] total_virtual_clients = len(vc_array) client_throughput_means = np.zeros( (total_virtual_clients, 2)) # (virtualclients, number of server, number of read/writes) client_latency_means = np.zeros((total_virtual_clients, 2)) client_throughput_stddev = np.zeros((total_virtual_clients, 2)) client_latency_stddev = np.zeros((total_virtual_clients, 2)) labels = [(2**x) for x in range(0, 6)] for idx, write in enumerate(["0", "1"]): for jdx, virtual_client_threads in enumerate([(2**x) for x in range(0, 6)]): all_throughputs = [] # From here on, we average over all values all_latencies = [] for repetition in range(3): for client in ['Client1', 'Client2', 'Client3']: filename = get_pattern_exp2_1(virtual_client_threads, repetition, client, write) throughput, latency = get_throughput_latency_default_memtier( filepath=filename) # print("Throughput and latency are: ", throughput, latency) all_throughputs.append(throughput) all_latencies.append(latency) if write == "1": client_throughput_means[jdx, idx] = np.sum( all_throughputs ) / 3. # Because we have two servers, and the results replicate client_throughput_stddev[jdx, idx] = np.std(all_throughputs) else: client_throughput_means[jdx, idx] = np.sum( all_throughputs ) / 3. # Because we have two servers, and the results replicate client_throughput_stddev[jdx, idx] = np.std(all_throughputs) latency_mean = np.mean( all_latencies) # Divide by 2, because we have two clients latency_stddev = np.std(all_latencies) client_latency_means[jdx, idx] = latency_mean client_latency_stddev[jdx, idx] = latency_stddev print(np.max(client_throughput_means, axis=0)) print(np.max(client_throughput_means, axis=1)) # [ 2940.63 17632.95666667] # [ 5791.94333333 11381.43666667 11744.93333333 14595.12333333 17632.55333333 17632.95666667] render_lineargraph_multiple_errorbars( labels=labels, mean_array=client_throughput_means.T, stddev_array=client_throughput_stddev.T, filepath=GRAPHPATH + "exp2_1__throughput_client_read_write", is_latency=False, is_read_write=True) render_lineargraph_multiple_errorbars(labels=labels, mean_array=client_latency_means.T, stddev_array=client_latency_stddev.T, filepath=GRAPHPATH + "exp2_1__latency_client_read_write", is_latency=True, is_read_write=True)
def iterate_through_experiments_exp3_1(): """ Iterates through all the parameter combinations :return: """ create_datadir_if_not_exists(GRAPHPATH) middleware_threads = [(2**x) for x in range(3, 7)] virtual_clients = [(2**x) for x in range(0, 6)] total_virtual_clients = len([(2**x) for x in range(0, 6)]) total_middleware_threads = len([(2**x) for x in range(3, 7)]) for write in [0, 1]: max_throughput = 0 max_throughput_client = 0 mw_throughput_means = np.zeros( (total_virtual_clients, total_middleware_threads)) mw_throughput_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) mw_latency_means = np.zeros( (total_virtual_clients, total_middleware_threads)) mw_latency_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) client_throughput_means = np.zeros( (total_virtual_clients, total_middleware_threads)) client_latency_means = np.zeros( (total_virtual_clients, total_middleware_threads)) client_throughput_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) client_latency_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) for _vc in range(0, 6): vc = (2**_vc) for _mt in range(3 - 3, 7 - 3): mt = (2**(_mt + 3)) client_all_throughputs = [ ] # From here on, we average over all values client_all_latencies = [] mw_all_throughputs = [] mw_all_latencies = [] queuetimes = [] for repetition in range(3): # Get throughput and latency from the file middleware_filename = get_pattern_exp3_1_middleware( virtualclientthreads=vc, middlewarethreads=mt, repetition=repetition, write=write, ) try: df = parse_log(BASEPATH + middleware_filename) mw_throughput, mw_latency = get_latency_log_dataframe( df) mw_throughput *= mt * 1000 # bcs this gives us overall throughput per millisecond, and not per thread anymore queuetimes.append( df['differenceTimeEnqueuedAndDequeued'].astype( float).mean()) mw_all_throughputs.append(mw_throughput) mw_all_latencies.append(mw_latency) except Exception as e: print("WRONG WITH THE FOLLOWING CONFIG: ", middleware_filename) print(e) continue for client in ['Client1', 'Client2', 'Client3']: client_filename = get_pattern_exp3_1_client( virtual_client_threads=vc, middlewareworkerthreads=mt, repetition=repetition, client=client, write=write) # Trying to open and read the file! try: client_throughput, client_latency = get_throughput_latency_default_memtier( filepath=BASEPATH + client_filename) client_all_throughputs.append(client_throughput) client_all_latencies.append(client_latency) print("Client: ", client_throughput, client_latency) except Exception as e: print("WRONG WITH THE FOLLOWING CONFIG: ", middleware_filename) print(e) continue print("VC and MT ", (mt, vc)) print("NEW VC and MT ", (_mt, _vc)) mw_mean_latency = np.mean(mw_all_latencies) mw_mean_throughput = np.sum(mw_all_throughputs) / 3. mw_stddev_latency = np.std(mw_all_latencies) mw_stddev_throughput = np.std(mw_all_throughputs) if max_throughput < mw_mean_throughput: max_throughput = mw_mean_throughput print("TTT", write, mw_mean_throughput, mw_mean_latency, np.mean(queuetimes)) # Append to list mw_throughput_means[_vc, _mt] = mw_mean_throughput mw_latency_means[_vc, _mt] = mw_mean_latency mw_throughput_stddev[_vc, _mt] = mw_stddev_throughput mw_latency_stddev[_vc, _mt] = mw_stddev_latency client_mean_latency = np.mean(client_all_latencies) client_mean_throughput = np.sum(client_all_throughputs) / 3. client_stddev_latency = np.std(client_all_latencies) client_stddev_throughput = np.std(client_all_throughputs) if max_throughput_client < client_mean_throughput: max_throughput_client = client_mean_throughput print("TTT CLIENT", write, client_mean_throughput, client_mean_latency) # Maximal values at: (printouts!) # Append to list client_throughput_means[_vc, _mt] = client_mean_throughput client_latency_means[_vc, _mt] = client_mean_latency client_throughput_stddev[_vc, _mt] = client_stddev_throughput client_latency_stddev[_vc, _mt] = client_stddev_latency print(client_throughput_means[:, _mt].flatten()) print(total_virtual_clients) # Assertions len_mt = client_throughput_means[:, _mt].flatten().shape len_vc = client_throughput_means[:, _mt].flatten().shape len1 = virtual_clients print("All lengths are : ") print(len_mt) print(len_vc) print(len1) # THROUGHPUTS print("###write:client ", write, client_throughput_means) print("###write:middleware ", write, mw_throughput_means) # LATENCIES print("###write:client ", write, client_latency_means) print("###write:middleware ", write, mw_latency_means) ###write:client 0 [[2829.99666667 2828.78 2841.12333333 2832.09666667] # [2914.32 2916.49 2902.36666667 2963.79 ] # [2978.07 2982.04 2926.90666667 2961.14 ] # [2930.64 2996.5 2980.55333333 2971.27666667] # [2920.55666667 2939.13 2975.22333333 2949.03333333] # [2966.08666667 2969.74666667 2933.78 2944.79 ]] # ###write:middleware 0 [[2888.56768177 2872.94686583 2876.40834308 2863.0490837 ] # [2952.04131319 2937.70233791 2918.01762357 2947.80422581] # [2989.20268883 2974.35714111 2912.9803837 2934.38863854] # [2933.52705812 2979.39794505 2961.4934029 2940.88512509] # [2915.57629929 2930.44136708 2952.3195043 2941.34950968] # [2983.28945045 2974.97495859 2925.1779705 2935.00349311]] # ###write:client 0 [[ 2.11333333 2.11222222 2.10555556 2.11111111] # [ 4.12222222 4.11555556 4.14 4.04888889] # [ 8.06 8.05444444 8.19444444 8.10111111] # [16.44666667 16.03333333 16.06111111 16.17111111] # [32.96 32.63777778 32.23333333 32.51333333] # [64.82444444 64.60222222 65.45 65.20888889]] # ###write:middleware 0 [[ 1.3167424 1.18404118 1.19176319 1.17406692] # [ 3.05772075 3.06435006 3.08202826 3.02690768] # [ 7.03875969 6.86615187 6.97812098 6.82174604] # [15.12661499 14.78340234 14.6029601 14.49839125] # [31.04134367 30.77606178 30.94594595 30.51061114] # [64.37984496 63.11079911 63.46138996 62.44980695]] ###write:client 1 [[3271.34 3220.32666667 3215.53333333 3321.11666667] # [5386.31666667 5549.33333333 5136.30666667 5292.51333333] # [6729.64333333 6900.06333333 6690.59666667 6214.48333333] # [7061.56 7363.10333333 7541.20666667 7139.32333333] # [7295.09 7490.80666667 7629.65333333 6914.55 ] # [7228.72 6711.01666667 7753.10333333 7454.68 ]] # ###write:middleware 1 [[3287.41072931 3284.10276218 3236.10885263 3348.17928571] # [5425.01178366 5583.56806439 5174.72885707 5332.7263551 ] # [6667.75480504 6881.43820305 6818.78960064 7011.40707111] # [6968.99163433 7292.81531008 7476.06856816 7092.02329642] # [7199.49091298 7430.69321895 7658.79654156 7739.66985074] # [7369.68367374 7615.74155019 7635.26281836 7333.33824439]] # ###write:client 1 [[ 1.83333333 1.86333333 1.86444444 1.80555556] # [ 2.24777778 2.16444444 2.34555556 2.28 ] # [ 3.58 3.48222222 3.48888889 3.41111111] # [ 6.81444444 6.53555556 6.38222222 6.77 ] # [13.19111111 12.80444444 12.57444444 12.30222222] # [26.64888889 25.42666667 24.74444444 25.82111111]] # ###write:middleware 1 [[ 0.95865633 0.99356499 0.98584299 0.94144144] # [ 1.05426357 1.07722008 1.14740262 1.10841916] # [ 1.73901809 1.4002574 1.41508969 1.48529033] # [ 3.26873385 1.85971686 1.72651223 1.84685326] # [ 5.56330749 2.57014157 2.15837807 2.01412311] # [15.27655236 3.07501152 2.19581187 2.69169728]] render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=client_throughput_means.T, stddev_array=client_throughput_stddev.T, filepath=GRAPHPATH + "exp3_1__throughput_client_write_{}".format(write), is_latency=False) render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=client_latency_means.T, stddev_array=client_latency_stddev.T, filepath=GRAPHPATH + "exp3_1__latency_client_write_{}".format(write), is_latency=True) # Plot the middleware values render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=mw_throughput_means.T, stddev_array=mw_throughput_stddev.T, filepath=GRAPHPATH + "exp3_1__throughput_middleware_write_{}".format(write), is_latency=False) render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=mw_latency_means.T, stddev_array=mw_latency_stddev.T, filepath=GRAPHPATH + "exp3_1__latency_middleware_write_{}".format(write), is_latency=True)
def iterate_through_experiments_exp4_1(): """ Iterates through all the parameter combinations :return: """ create_datadir_if_not_exists(GRAPHPATH) write = 1 # This experiment consists of writes-only! middleware_threads = [(2**x) for x in range(3, 7)] virtual_clients = [(2**x) for x in range(0, 6)] total_virtual_clients = len([(2**x) for x in range(0, 6)]) total_middleware_threads = len([(2**x) for x in range(3, 7)]) mw_throughput_means = np.zeros( (total_virtual_clients, total_middleware_threads)) mw_throughput_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) mw_latency_means = np.zeros( (total_virtual_clients, total_middleware_threads)) mw_latency_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) client_throughput_means = np.zeros( (total_virtual_clients, total_middleware_threads)) client_latency_means = np.zeros( (total_virtual_clients, total_middleware_threads)) client_throughput_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) client_latency_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) queuetime_means = np.zeros( (total_virtual_clients, total_middleware_threads)) queuelength_means = np.zeros( (total_virtual_clients, total_middleware_threads)) waittime_means = np.zeros( (total_virtual_clients, total_middleware_threads)) for _mt in range(3 - 3, 7 - 3): mt = (2**(_mt + 3)) for _vc in range(0, 6): vc = (2**_vc) client_all_throughputs = [ ] # From here on, we average over all values client_all_latencies = [] mw_all_throughputs = [] mw_all_latencies = [] queuetimes = [] queuelengths = [] waittimes = [] for repetition in range(3): for middleware in [1, 2]: # Get throughput and latency from the file middleware_filename = get_pattern_exp4_1_middleware( virtualclientthreads=vc, middlewarethreads=mt, repetition=repetition, write=write, middleware=middleware) try: df = parse_log(BASEPATH + middleware_filename) # Append queuetimes, queuelength and waittime queuetimes.append( df['differenceTimeEnqueuedAndDequeued'].astype( float).mean()) queuelengths.append( df['queueSize'].astype(float).mean()) waittimes.append(df[ 'differenceTimeSentToServerAndReceivedResponseFromServer'] .astype(float).mean()) mw_throughput, mw_latency = get_latency_log_dataframe( df) mw_throughput *= mt * 1000 # bcs this gives us throughput per millisecond # print("THROUGHPUT AND LATENCY ARE: ") # print(mw_throughput) # print(mw_latency) mw_all_throughputs.append(mw_throughput) mw_all_latencies.append(mw_latency) except Exception as e: # print("WRONG WITH THE FOLLOWING CONFIG: ", client_filename) print("WRONG WITH THE FOLLOWING CONFIG: ", middleware_filename) print(e) continue for client in ['Client1', 'Client2', 'Client3']: for middleware in [1, 2]: # Trying to open and read the file! client_filename = get_pattern_exp4_1_client( virtual_client_threads=vc, middleware=middleware, middlewareworkerthreads=mt, repetition=repetition, client=client, write=write) try: client_throughput, client_latency = get_throughput_latency_default_memtier( filepath=BASEPATH + client_filename) client_all_throughputs.append(client_throughput) client_all_latencies.append(client_latency) except Exception as e: # print("WRONG WITH THE FOLLOWING CONFIG: ", client_filename) print("WRONG WITH THE FOLLOWING CONFIG: ", middleware_filename) print(e) continue # Queuetimes etc. queuetime_means[_vc, _mt] = np.mean(queuetimes) queuelength_means[_vc, _mt] = np.mean(queuelengths) waittime_means[_vc, _mt] = np.mean(waittimes) mw_mean_latency = np.mean(mw_all_latencies) mw_mean_throughput = np.sum(mw_all_throughputs) / 3. mw_stddev_latency = np.std(mw_all_latencies) mw_stddev_throughput = np.std(mw_all_throughputs) # Append to list mw_throughput_means[_vc, _mt] = mw_mean_throughput mw_latency_means[_vc, _mt] = mw_mean_latency mw_throughput_stddev[_vc, _mt] = mw_stddev_throughput mw_latency_stddev[_vc, _mt] = mw_stddev_latency client_mean_latency = np.mean(client_all_latencies) client_mean_throughput = np.sum(client_all_throughputs) / 3. client_stddev_latency = np.std(client_all_latencies) client_stddev_throughput = np.std(client_all_throughputs) # Append to list client_throughput_means[_vc, _mt] = client_mean_throughput client_latency_means[_vc, _mt] = client_mean_latency client_throughput_stddev[_vc, _mt] = client_stddev_throughput client_latency_stddev[_vc, _mt] = client_stddev_latency # Assertions len_mt = client_throughput_means[:, _mt].flatten().shape len_vc = client_throughput_means[:, _mt].flatten().shape len1 = virtual_clients argmax_vc = np.argmax(mw_throughput_means, axis=0) print("MW throughputs are: ", mw_throughput_means) print("VC maximizing is: ", argmax_vc) for idx, mt in enumerate([8, 16, 32, 64]): max_vc = argmax_vc[idx] print() print() print() print("MT IS: ", mt) # Section 7 data # print("###write:client ", client_throughput_means[max_vc, idx]) # print("###write:middleware ", mw_throughput_means[max_vc, idx]) print("###write:queuesizes ", queuelength_means[max_vc, idx]) print("###write:latency ", mw_latency_means[max_vc, idx]) print("###write:waittime_means ", waittime_means[max_vc, idx] / 1000000.) ###write:client 1 # [[ 1815.45333333 2321.54 2285.64 2127.40333333] # [ 4608.49 4581.64 4576.45333333 4406.16333333] # [ 6971.06666667 6543.16333333 7374.53333333 6144.32333333] # [ 8698.22666667 8063.80666667 9086.58 9738.00333333] # [ 8995.92 10068.55333333 11404.78 10261.27 ] # [ 7064.09333333 10026.83333333 12586.12 12858.95333333]] # ###write:middleware 1 # [[ 1947.229088 2317.76063679 2322.53675249 2207.33621436] # [ 4591.30620045 4605.04654336 4582.13005631 4509.73165549] # [ 8020.03037995 6967.31991722 7475.40874085 7804.08509258] # [ 8645.69236829 10314.9812626 9302.41430409 9688.76860568] # [ 8833.92859926 10153.21361682 12126.18091513 10299.9702301 ] # [ 7465.56068924 10133.52159323 12503.89763076 13706.73554513]] # Taken out for experiment 7! # Plot the client values render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=client_throughput_means.T, stddev_array=client_throughput_stddev.T, filepath=GRAPHPATH + "exp4_1__vc_{}__throughput_client_write_{}".format(mt, write), is_latency=False) render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=client_latency_means.T, stddev_array=client_latency_stddev.T, filepath=GRAPHPATH + "exp4_1__vc_{}__latency_client_write_{}".format(mt, write), is_latency=True) # print(np.max(mw_throughput_means, axis=0)) # print(np.max(mw_throughput_means, axis=1)) # Plot the middleware values render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=mw_throughput_means.T, stddev_array=mw_throughput_stddev.T, filepath=GRAPHPATH + "exp4_1__vc_{}__throughput_middleware_write_{}".format(mt, write), is_latency=False) render_lineargraph_multiple_errorbars( labels=virtual_clients, mean_array=mw_latency_means.T, stddev_array=mw_latency_stddev.T, filepath=GRAPHPATH + "exp4_1__vc_{}__latency_middleware_write_{}".format(mt, write), is_latency=True)
def iterate_through_experiments_exp4_1(): """ Iterates through all the parameter combinations :return: """ create_datadir_if_not_exists(GRAPHPATH) write = 1 # This experiment consists of writes-only! multikeys = ["1", "3", "6", "9"] shardings = [False, True] _number_keys = len(multikeys) _number_shardings = len(shardings) mw_throughput_means = np.zeros((_number_keys, _number_shardings)) mw_throughput_stddev = np.zeros((_number_keys, _number_shardings)) mw_latency_means = np.zeros((_number_keys, _number_shardings)) mw_latency_stddev = np.zeros((_number_keys, _number_shardings)) client_throughput_means = np.zeros((_number_keys, _number_shardings)) client_latency_means = np.zeros((_number_keys, _number_shardings)) client_throughput_stddev = np.zeros((_number_keys, _number_shardings)) client_latency_stddev = np.zeros((_number_keys, _number_shardings)) # Iterate through keysizes for jdx, sharding in enumerate(shardings): print("Sharding: ", sharding) for idx, keysize in enumerate(multikeys): print("Keysize is: ", keysize) client_all_throughputs = [ ] # From here on, we average over all values client_all_latencies = [] mw_all_throughputs = [] mw_all_latencies = [] for repetition in range(3): for middleware in [1, 2]: # Get throughput and latency from the file middleware_filename = get_pattern_exp5_1_middleware( middleware=middleware, keysize=keysize, repetition=repetition, sharding=sharding) try: df = parse_log(BASEPATH + middleware_filename) mw_throughput, mw_latency = get_latency_log_dataframe( df) mw_throughput *= 64 * 1000 # bcs this gives us throughput per millisecond # print("THROUGHPUT AND LATENCY ARE: ") # print(mw_throughput) # print(mw_latency) mw_all_throughputs.append(mw_throughput) mw_all_latencies.append(mw_latency) except Exception as e: # print("WRONG WITH THE FOLLOWING CONFIG: ", client_filename) print("WRONG WITH THE FOLLOWING CONFIG: ", middleware_filename) print(e) continue for client in ['Client1', 'Client2', 'Client3']: for middleware in [1, 2]: # TODO: Do it for each individual middleware! # Trying to open and read the file! client_filename = get_pattern_exp5_1_client( keysize=keysize, middleware=middleware, repetition=repetition, client=client, sharding=sharding) try: client_throughput, client_latency = get_throughput_latency_default_memtier( filepath=BASEPATH + client_filename) client_all_throughputs.append(client_throughput) client_all_latencies.append(client_latency) except Exception as e: # print("WRONG WITH THE FOLLOWING CONFIG: ", client_filename) print("WRONG WITH THE FOLLOWING CONFIG: ", middleware_filename) print(e) continue mw_mean_latency = np.mean(mw_all_latencies) mw_mean_throughput = np.sum(mw_all_throughputs) / 3. mw_stddev_latency = np.std(mw_all_latencies) mw_stddev_throughput = np.std(mw_all_throughputs) # Append to list mw_throughput_means[idx, jdx] = mw_mean_throughput mw_latency_means[idx, jdx] = mw_mean_latency mw_throughput_stddev[idx, jdx] = mw_stddev_throughput mw_latency_stddev[idx, jdx] = mw_stddev_latency client_mean_latency = np.mean(client_all_latencies) client_mean_throughput = np.sum(client_all_throughputs) / 3. client_stddev_latency = np.std(client_all_latencies) client_stddev_throughput = np.std(client_all_throughputs) # Append to list client_throughput_means[idx, jdx] = client_mean_throughput client_latency_means[idx, jdx] = client_mean_latency client_throughput_stddev[idx, jdx] = client_stddev_throughput client_latency_stddev[idx, jdx] = client_stddev_latency # Middleware render_lineargraph_errorbars( labels=multikeys, mean_array=mw_latency_means[:, jdx], stddev_array=mw_latency_stddev[:, jdx], filepath=GRAPHPATH + "exp5_1__mw_latency_sharding_{}".format(sharding), is_latency=True) # Client render_lineargraph_errorbars( labels=multikeys, mean_array=client_latency_means[:, jdx], stddev_array=client_latency_stddev[:, jdx], filepath=GRAPHPATH + "exp5_1__client_latency_sharding_{}".format(sharding), is_latency=True) # Middleware render_lineargraph_errorbars( labels=multikeys, mean_array=mw_throughput_means[:, jdx], stddev_array=mw_throughput_stddev[:, jdx], filepath=GRAPHPATH + "exp5_1__mw_throughput_sharding_{}".format(sharding), is_latency=False) # Client render_lineargraph_errorbars( labels=multikeys, mean_array=client_throughput_means[:, jdx], stddev_array=client_throughput_stddev[:, jdx], filepath=GRAPHPATH + "exp5_1__client_throughput_sharding_{}".format(sharding), is_latency=False)
def iterate_through_experiments_exp4_1(): """ Iterates through all the parameter combinations :return: """ create_datadir_if_not_exists(GRAPHPATH) write = 1 # This experiment consists of writes-only! middleware_threads = [(2**x) for x in range(3, 7)] virtual_clients = [(2**x) for x in range(0, 6)] total_virtual_clients = len([(2**x) for x in range(0, 6)]) total_middleware_threads = len([(2**x) for x in range(3, 7)]) mw_throughput_means = np.zeros( (total_virtual_clients, total_middleware_threads)) mw_throughput_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) mw_latency_means = np.zeros( (total_virtual_clients, total_middleware_threads)) mw_latency_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) client_throughput_means = np.zeros( (total_virtual_clients, total_middleware_threads)) client_latency_means = np.zeros( (total_virtual_clients, total_middleware_threads)) client_throughput_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) client_latency_stddev = np.zeros( (total_virtual_clients, total_middleware_threads)) for _mt in range(3 - 3, 7 - 3): mt = (2**(_mt + 3)) queuetimes = [] queuesizes = [] waittimes = [] for _vc in range(0, 6): vc = (2**_vc) client_all_throughputs = [ ] # From here on, we average over all values client_all_latencies = [] mw_all_throughputs = [] mw_all_latencies = [] tmp_queuetimes = [] tmp_queuesizes = [] tmp_waittimes = [] for repetition in range(3): for middleware in [1, 2]: # Get throughput and latency from the file middleware_filename = get_pattern_exp4_1_middleware( virtualclientthreads=vc, middlewarethreads=mt, repetition=repetition, write=write, middleware=middleware) try: df = parse_log(BASEPATH + middleware_filename) queuetime = df[ 'differenceTimeEnqueuedAndDequeued'].astype( float).mean() / 1000. tmp_queuetimes.append(queuetime) queuesize = df['queueSize'].astype(float).mean() tmp_queuesizes.append(queuesize) waittime = df[ 'differenceTimeSentToServerAndReceivedResponseFromServer'].astype( float).mean() / 1000. tmp_waittimes.append(waittime) mw_throughput, mw_latency = get_latency_log_dataframe( df) mw_throughput *= mt * 1000 # bcs this gives us throughput per millisecond # print("THROUGHPUT AND LATENCY ARE: ") # print(mw_throughput) # print(mw_latency) mw_all_throughputs.append(mw_throughput) mw_all_latencies.append(mw_latency) except Exception as e: # print("WRONG WITH THE FOLLOWING CONFIG: ", client_filename) print("WRONG WITH THE FOLLOWING CONFIG: ", middleware_filename) print(e) continue for client in ['Client1', 'Client2', 'Client3']: for middleware in [1, 2]: # Trying to open and read the file! client_filename = get_pattern_exp4_1_client( virtual_client_threads=vc, middleware=middleware, middlewareworkerthreads=mt, repetition=repetition, client=client, write=write) try: client_throughput, client_latency = get_throughput_latency_default_memtier( filepath=BASEPATH + client_filename) client_all_throughputs.append(client_throughput) client_all_latencies.append(client_latency) except Exception as e: # print("WRONG WITH THE FOLLOWING CONFIG: ", client_filename) print("WRONG WITH THE FOLLOWING CONFIG: ", middleware_filename) print(e) continue queuetimes.append(np.mean(tmp_queuetimes)) queuesizes.append(np.mean(tmp_queuesizes)) waittimes.append(np.mean(tmp_waittimes)) # print("VC and MT ", (mt, vc)) # print("NEW VC and MT ", (_mt, _vc)) mw_mean_latency = np.mean(mw_all_latencies) mw_mean_throughput = np.sum(mw_all_throughputs) / 3. mw_stddev_latency = np.std(mw_all_latencies) mw_stddev_throughput = np.std(mw_all_throughputs) # Append to list mw_throughput_means[_vc, _mt] = mw_mean_throughput mw_latency_means[_vc, _mt] = mw_mean_latency mw_throughput_stddev[_vc, _mt] = mw_stddev_throughput mw_latency_stddev[_vc, _mt] = mw_stddev_latency client_mean_latency = np.mean(client_all_latencies) client_mean_throughput = np.sum(client_all_throughputs) / 3. client_stddev_latency = np.std(client_all_latencies) client_stddev_throughput = np.std(client_all_throughputs) # Append to list client_throughput_means[_vc, _mt] = client_mean_throughput client_latency_means[_vc, _mt] = client_mean_latency client_throughput_stddev[_vc, _mt] = client_stddev_throughput client_latency_stddev[_vc, _mt] = client_stddev_latency print("MW IS: ", mt) argmax_vc = np.argmax(client_throughput_means[:, _mt].flatten()) print("Argmax vc is: ", 2**argmax_vc) print("Max is: ", ) print("queuesize: ", queuesizes[argmax_vc]) print("waittimes: ", waittimes[argmax_vc]) print("queuetimes: ", queuetimes[argmax_vc]) print("Client troughput mean: ", client_throughput_means[argmax_vc, _mt].flatten()) print("MW troughput mean: ", mw_throughput_means[argmax_vc, _mt].flatten()) print( "MW derived throughput time: ", 2 * 3 * (2**argmax_vc) / mw_latency_means[argmax_vc, _mt].flatten() * 1000)