def master_pattern(request):
_, _, master_release_names, master_release_dates = download.download_benchmark_csv(
40)
none_mtls_base_p90_pattern_master = get_telemetry_mode_y_series(
master_release_names, master_release_dates, '_none_mtls_base', 'p90')
none_mtls_both_p90_pattern_master = get_telemetry_mode_y_series(
master_release_names, master_release_dates, '_none_mtls_both', 'p90')
v2_sd_full_nullvm_both_p90_pattern_master = get_telemetry_mode_y_series(
master_release_names, master_release_dates, '_v2-sd-full-nullvm_both',
'p90')
none_mtls_base_p99_pattern_master = get_telemetry_mode_y_series(
master_release_names, master_release_dates, '_none_mtls_base', 'p99')
none_mtls_both_p99_pattern_master = get_telemetry_mode_y_series(
master_release_names, master_release_dates, '_none_mtls_both', 'p99')
v2_sd_full_nullvm_both_p99_pattern_master = get_telemetry_mode_y_series(
master_release_names, master_release_dates, '_v2-sd-full-nullvm_both',
'p99')
context = {
'none_mtls_base_p90_pattern_master':
none_mtls_base_p90_pattern_master,
'none_mtls_both_p90_pattern_master':
none_mtls_both_p90_pattern_master,
'v2_sd_full_nullvm_both_p90_pattern_master':
v2_sd_full_nullvm_both_p90_pattern_master,
'none_mtls_base_p99_pattern_master':
none_mtls_base_p99_pattern_master,
'none_mtls_both_p99_pattern_master':
none_mtls_both_p99_pattern_master,
'v2_sd_full_nullvm_both_p99_pattern_master':
v2_sd_full_nullvm_both_p99_pattern_master,
}
return render(request, "master_pattern.html", context=context)
def cur_pattern(request):
cur_release_names, cur_release_dates, _, _ = download.download_benchmark_csv(
40)
none_mtls_base_p90_pattern = get_telemetry_mode_y_series(
cur_release_names, cur_release_dates, '_none_mtls_base', 'p90')
none_mtls_both_p90_pattern = get_telemetry_mode_y_series(
cur_release_names, cur_release_dates, '_none_mtls_both', 'p90')
v2_sd_full_nullvm_both_p90_pattern = get_telemetry_mode_y_series(
cur_release_names, cur_release_dates, '_v2-sd-full-nullvm_both', 'p90')
none_mtls_base_p99_pattern = get_telemetry_mode_y_series(
cur_release_names, cur_release_dates, '_none_mtls_base', 'p99')
none_mtls_both_p99_pattern = get_telemetry_mode_y_series(
cur_release_names, cur_release_dates, '_none_mtls_both', 'p99')
v2_sd_full_nullvm_both_p99_pattern = get_telemetry_mode_y_series(
cur_release_names, cur_release_dates, '_v2-sd-full-nullvm_both', 'p99')
context = {
'current_release': current_release,
'none_mtls_base_p90_pattern': none_mtls_base_p90_pattern,
'none_mtls_both_p90_pattern': none_mtls_both_p90_pattern,
'v2_sd_full_nullvm_both_p90_pattern':
v2_sd_full_nullvm_both_p90_pattern,
'none_mtls_base_p99_pattern': none_mtls_base_p99_pattern,
'none_mtls_both_p99_pattern': none_mtls_both_p99_pattern,
'v2_sd_full_nullvm_both_p99_pattern':
v2_sd_full_nullvm_both_p99_pattern,
}
return render(request, "cur_pattern.html", context=context)
def cur_regression(request):
cur_href_links, _, cur_release_dates, _, _, _ = download.download_benchmark_csv(
60)
latency_none_mtls_base_p90 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_none_mtls_baseline', 'p90')
latency_none_mtls_both_p90 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_none_mtls_both', 'p90')
latency_none_plaintext_both_p90 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_none_plaintext_both', 'p90')
latency_v2_stats_nullvm_both_p90 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_v2-stats-nullvm_both', 'p90')
latency_v2_stats_wasm_both_p90 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_v2-stats-wasm_both', 'p90')
latency_v2_sd_nologging_nullvm_both_p90 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_v2-sd-nologging-nullvm_both',
'p90')
latency_v2_sd_full_nullvm_both_p90 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_v2-sd-full-nullvm_both', 'p90')
latency_none_mtls_base_p99 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_none_mtls_baseline', 'p99')
latency_none_mtls_both_p99 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_none_mtls_both', 'p99')
latency_none_plaintext_both_p99 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_none_plaintext_both', 'p99')
latency_v2_stats_nullvm_both_p99 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_v2-stats-nullvm_both', 'p99')
latency_v2_stats_wasm_both_p99 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_v2-stats-wasm_both', 'p99')
latency_v2_sd_nologging_nullvm_both_p99 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_v2-sd-nologging-nullvm_both',
'p99')
latency_v2_sd_full_nullvm_both_p99 = get_telemetry_mode_y_series(
cur_href_links, cur_release_dates, '_v2-sd-full-nullvm_both', 'p99')
context = {
'current_release': current_release,
'latency_none_mtls_base_p90': latency_none_mtls_base_p90,
'latency_none_mtls_both_p90': latency_none_mtls_both_p90,
'latency_none_plaintext_both_p90': latency_none_plaintext_both_p90,
'latency_v2_stats_nullvm_both_p90': latency_v2_stats_nullvm_both_p90,
'latency_v2_stats_wasm_both_p90': latency_v2_stats_wasm_both_p90,
'latency_v2_sd_nologging_nullvm_both_p90':
latency_v2_sd_nologging_nullvm_both_p90,
'latency_v2_sd_full_nullvm_both_p90':
latency_v2_sd_full_nullvm_both_p90,
'latency_none_mtls_base_p99': latency_none_mtls_base_p99,
'latency_none_mtls_both_p99': latency_none_mtls_both_p99,
'latency_none_plaintext_both_p99': latency_none_plaintext_both_p99,
'latency_v2_stats_nullvm_both_p99': latency_v2_stats_nullvm_both_p99,
'latency_v2_stats_wasm_both_p99': latency_v2_stats_wasm_both_p99,
'latency_v2_sd_nologging_nullvm_both_p99':
latency_v2_sd_nologging_nullvm_both_p99,
'latency_v2_sd_full_nullvm_both_p99':
latency_v2_sd_full_nullvm_both_p99,
}
return render(request, "cur_regression.html", context=context)
def latency_vs_conn(request, uploaded_csv_url=None):
if uploaded_csv_url is not None:
uploaded_csv_path = cwd + uploaded_csv_url
df = pd.read_csv(uploaded_csv_path)
context = get_lantency_vs_conn_context(df)
os.remove(uploaded_csv_path)
return context
else:
cur_release_names, cur_release_dates, master_release_names, master_release_dates = download.download_benchmark_csv(20)
if request.method == "POST" and 'current_release_name' in request.POST:
cur_selected_release.append(request.POST['current_release_name'])
df = pd.read_csv(perf_data_path + "cur_temp.csv")
if cur_release_names is not None and len(cur_release_names) > 0:
df = pd.read_csv(perf_data_path + cur_release_names[0] + ".csv")
# Parse data for the current release
if len(cur_selected_release) > 1:
cur_selected_release.pop(0)
if len(cur_selected_release) > 0:
df = pd.read_csv(perf_data_path + cur_selected_release[0] + ".csv")
release_context = get_lantency_vs_conn_context(df)
# Parse data for the master
if request.method == "POST" and 'master_release_name' in request.POST:
master_selected_release.append(request.POST['master_release_name'])
df = pd.read_csv(perf_data_path + "master_temp.csv")
if master_release_names is not None and len(master_release_names) > 0:
df = pd.read_csv(perf_data_path + master_release_names[0] + ".csv")
# Parse data for the current release
if len(master_selected_release) > 1:
master_selected_release.pop(0)
if len(master_selected_release) > 0:
df = pd.read_csv(perf_data_path + master_selected_release[0] + ".csv")
latency_mixer_base_p50_master = get_latency_vs_conn_y_series(df, '_mixer_base', 'p50')
latency_mixer_serveronly_p50_master = get_latency_vs_conn_y_series(df, '_mixer_serveronly', 'p50')
latency_mixer_both_p50_master = get_latency_vs_conn_y_series(df, '_mixer_both', 'p50')
latency_none_serveronly_p50_master = get_latency_vs_conn_y_series(df, '_none_serveronly', 'p50')
latency_none_both_p50_master = get_latency_vs_conn_y_series(df, '_none_both', 'p50')
latency_none_plaintext_both_p50_master = get_latency_vs_conn_y_series(df, '_none_plaintext_both', 'p50')
latency_v2_serveronly_p50_master = get_latency_vs_conn_y_series(df, 'nullvm_serveronly', 'p50')
latency_v2_both_p50_master = get_latency_vs_conn_y_series(df, 'nullvm_both', 'p50')
latency_mixer_base_p90_master = get_latency_vs_conn_y_series(df, '_mixer_base', 'p90')
latency_mixer_serveronly_p90_master = get_latency_vs_conn_y_series(df, '_mixer_serveronly', 'p90')
latency_mixer_both_p90_master = get_latency_vs_conn_y_series(df, '_mixer_both', 'p90')
latency_none_serveronly_p90_master = get_latency_vs_conn_y_series(df, '_none_serveronly', 'p90')
latency_none_both_p90_master = get_latency_vs_conn_y_series(df, '_none_both', 'p90')
latency_none_plaintext_both_p90_master = get_latency_vs_conn_y_series(df, '_none_plaintext_both', 'p90')
latency_v2_serveronly_p90_master = get_latency_vs_conn_y_series(df, 'nullvm_serveronly', 'p90')
latency_v2_both_p90_master = get_latency_vs_conn_y_series(df, 'nullvm_both', 'p90')
latency_mixer_base_p99_master = get_latency_vs_conn_y_series(df, '_mixer_base', 'p99')
latency_mixer_serveronly_p99_master = get_latency_vs_conn_y_series(df, '_mixer_serveronly', 'p99')
latency_mixer_both_p99_master = get_latency_vs_conn_y_series(df, '_mixer_both', 'p99')
latency_none_serveronly_p99_master = get_latency_vs_conn_y_series(df, '_none_serveronly', 'p99')
latency_none_both_p99_master = get_latency_vs_conn_y_series(df, '_none_both', 'p99')
latency_none_plaintext_both_p99_master = get_latency_vs_conn_y_series(df, '_none_plaintext_both', 'p99')
latency_v2_serveronly_p99_master = get_latency_vs_conn_y_series(df, 'nullvm_serveronly', 'p99')
latency_v2_both_p99_master = get_latency_vs_conn_y_series(df, 'nullvm_both', 'p99')
other_context = {'current_release': current_release,
'cur_selected_release': cur_selected_release,
'master_selected_release': master_selected_release,
'cur_release_names': cur_release_names,
'master_release_names': master_release_names,
}
master_context = {'latency_mixer_base_p50_master': latency_mixer_base_p50_master,
'latency_mixer_serveronly_p50_master': latency_mixer_serveronly_p50_master,
'latency_mixer_both_p50_master': latency_mixer_both_p50_master,
'latency_none_serveronly_p50_master': latency_none_serveronly_p50_master,
'latency_none_both_p50_master': latency_none_both_p50_master,
'latency_none_plaintext_both_p50_master': latency_none_plaintext_both_p50_master,
'latency_v2_serveronly_p50_master': latency_v2_serveronly_p50_master,
'latency_v2_both_p50_master': latency_v2_both_p50_master,
'latency_mixer_base_p90_master': latency_mixer_base_p90_master,
'latency_mixer_serveronly_p90_master': latency_mixer_serveronly_p90_master,
'latency_mixer_both_p90_master': latency_mixer_both_p90_master,
'latency_none_serveronly_p90_master': latency_none_serveronly_p90_master,
'latency_none_both_p90_master': latency_none_both_p90_master,
'latency_none_plaintext_both_p90_master': latency_none_plaintext_both_p90_master,
'latency_v2_serveronly_p90_master': latency_v2_serveronly_p90_master,
'latency_v2_both_p90_master': latency_v2_both_p90_master,
'latency_mixer_base_p99_master': latency_mixer_base_p99_master,
'latency_mixer_serveronly_p99_master': latency_mixer_serveronly_p99_master,
'latency_mixer_both_p99_master': latency_mixer_both_p99_master,
'latency_none_serveronly_p99_master': latency_none_serveronly_p99_master,
'latency_none_both_p99_master': latency_none_both_p99_master,
'latency_none_plaintext_both_p99_master': latency_none_plaintext_both_p99_master,
'latency_v2_serveronly_p99_master': latency_v2_serveronly_p99_master,
'latency_v2_both_p99_master': latency_v2_both_p99_master,
}
context = reduce(lambda x, y: dict(x, **y), (other_context, release_context, master_context))
return render(request, "latency_vs_conn.html", context=context)
def latency(request):
cur_release_names, cur_release_dates, master_release_names, master_release_dates = download.download_benchmark_csv(
20)
if request.method == "POST" and 'current_release_name' in request.POST:
cur_selected_release.append(request.POST['current_release_name'])
df = pd.read_csv(perf_data_path + cur_release_names[0] + ".csv")
# Parse data for the current release
if len(cur_selected_release) > 1:
cur_selected_release.pop(0)
if len(cur_selected_release) > 0:
df = pd.read_csv(perf_data_path + cur_selected_release[0] + ".csv")
latency_mixer_base_p50 = get_latency_y_series(df, '_mixer_base', 'p50')
latency_mixer_serveronly_p50 = get_latency_y_series(
df, '_mixer_serveronly', 'p50')
latency_mixer_both_p50 = get_latency_y_series(df, '_mixer_both', 'p50')
latency_nomixer_serveronly_p50 = get_latency_y_series(
df, '_nomixer_serveronly', 'p50')
latency_nomixer_both_p50 = get_latency_y_series(df, '_nomixer_both', 'p50')
latency_v2_serveronly_p50 = get_latency_y_series(df, 'nullvm_serveronly',
'p50')
latency_v2_both_p50 = get_latency_y_series(df, 'nullvm_both', 'p50')
latency_mixer_base_p90 = get_latency_y_series(df, '_mixer_base', 'p90')
latency_mixer_serveronly_p90 = get_latency_y_series(
df, '_mixer_serveronly', 'p90')
latency_mixer_both_p90 = get_latency_y_series(df, '_mixer_both', 'p90')
latency_nomixer_serveronly_p90 = get_latency_y_series(
df, '_nomixer_serveronly', 'p90')
latency_nomixer_both_p90 = get_latency_y_series(df, '_nomixer_both', 'p90')
latency_v2_serveronly_p90 = get_latency_y_series(df, 'nullvm_serveronly',
'p90')
latency_v2_both_p90 = get_latency_y_series(df, 'nullvm_both', 'p90')
latency_mixer_base_p99 = get_latency_y_series(df, '_mixer_base', 'p99')
latency_mixer_serveronly_p99 = get_latency_y_series(
df, '_mixer_serveronly', 'p99')
latency_mixer_both_p99 = get_latency_y_series(df, '_mixer_both', 'p99')
latency_nomixer_serveronly_p99 = get_latency_y_series(
df, '_nomixer_serveronly', 'p99')
latency_nomixer_both_p99 = get_latency_y_series(df, '_nomixer_both', 'p99')
latency_v2_serveronly_p99 = get_latency_y_series(df, 'nullvm_serveronly',
'p99')
latency_v2_both_p99 = get_latency_y_series(df, 'nullvm_both', 'p99')
# Parse data for the master
if request.method == "POST" and 'master_release_name' in request.POST:
master_selected_release.append(request.POST['master_release_name'])
df = pd.read_csv(perf_data_path + master_release_names[0] + ".csv")
# Parse data for the current release
if len(master_selected_release) > 1:
master_selected_release.pop(0)
if len(master_selected_release) > 0:
df = pd.read_csv(perf_data_path + master_selected_release[0] + ".csv")
latency_mixer_base_p50_master = get_latency_y_series(
df, '_mixer_base', 'p50')
latency_mixer_serveronly_p50_master = get_latency_y_series(
df, '_mixer_serveronly', 'p50')
latency_mixer_both_p50_master = get_latency_y_series(
df, '_mixer_both', 'p50')
latency_nomixer_serveronly_p50_master = get_latency_y_series(
df, '_nomixer_serveronly', 'p50')
latency_nomixer_both_p50_master = get_latency_y_series(
df, '_nomixer_both', 'p50')
latency_v2_serveronly_p50_master = get_latency_y_series(
df, 'nullvm_serveronly', 'p50')
latency_v2_both_p50_master = get_latency_y_series(df, 'nullvm_both', 'p50')
latency_mixer_base_p90_master = get_latency_y_series(
df, '_mixer_base', 'p90')
latency_mixer_serveronly_p90_master = get_latency_y_series(
df, '_mixer_serveronly', 'p90')
latency_mixer_both_p90_master = get_latency_y_series(
df, '_mixer_both', 'p90')
latency_nomixer_serveronly_p90_master = get_latency_y_series(
df, '_nomixer_serveronly', 'p90')
latency_nomixer_both_p90_master = get_latency_y_series(
df, '_nomixer_both', 'p90')
latency_v2_serveronly_p90_master = get_latency_y_series(
df, 'nullvm_serveronly', 'p90')
latency_v2_both_p90_master = get_latency_y_series(df, 'nullvm_both', 'p90')
latency_mixer_base_p99_master = get_latency_y_series(
df, '_mixer_base', 'p99')
latency_mixer_serveronly_p99_master = get_latency_y_series(
df, '_mixer_serveronly', 'p99')
latency_mixer_both_p99_master = get_latency_y_series(
df, '_mixer_both', 'p99')
latency_nomixer_serveronly_p99_master = get_latency_y_series(
df, '_nomixer_serveronly', 'p99')
latency_nomixer_both_p99_master = get_latency_y_series(
df, '_nomixer_both', 'p99')
latency_v2_serveronly_p99_master = get_latency_y_series(
df, 'nullvm_serveronly', 'p99')
latency_v2_both_p99_master = get_latency_y_series(df, 'nullvm_both', 'p99')
context = {
'cur_selected_release': cur_selected_release,
'master_selected_release': master_selected_release,
'cur_release_names': cur_release_names,
'master_release_names': master_release_names,
'latency_mixer_base_p50': latency_mixer_base_p50,
'latency_mixer_serveronly_p50': latency_mixer_serveronly_p50,
'latency_mixer_both_p50': latency_mixer_both_p50,
'latency_nomixer_serveronly_p50': latency_nomixer_serveronly_p50,
'latency_nomixer_both_p50': latency_nomixer_both_p50,
'latency_v2_serveronly_p50': latency_v2_serveronly_p50,
'latency_v2_both_p50': latency_v2_both_p50,
'latency_mixer_base_p90': latency_mixer_base_p90,
'latency_mixer_serveronly_p90': latency_mixer_serveronly_p90,
'latency_mixer_both_p90': latency_mixer_both_p90,
'latency_nomixer_serveronly_p90': latency_nomixer_serveronly_p90,
'latency_nomixer_both_p90': latency_nomixer_both_p90,
'latency_v2_serveronly_p90': latency_v2_serveronly_p90,
'latency_v2_both_p90': latency_v2_both_p90,
'latency_mixer_base_p99': latency_mixer_base_p99,
'latency_mixer_serveronly_p99': latency_mixer_serveronly_p99,
'latency_mixer_both_p99': latency_mixer_both_p99,
'latency_nomixer_serveronly_p99': latency_nomixer_serveronly_p99,
'latency_nomixer_both_p99': latency_nomixer_both_p99,
'latency_v2_serveronly_p99': latency_v2_serveronly_p99,
'latency_v2_both_p99': latency_v2_both_p99,
'latency_mixer_base_p50_master': latency_mixer_base_p50_master,
'latency_mixer_serveronly_p50_master':
latency_mixer_serveronly_p50_master,
'latency_mixer_both_p50_master': latency_mixer_both_p50_master,
'latency_nomixer_serveronly_p50_master':
latency_nomixer_serveronly_p50_master,
'latency_nomixer_both_p50_master': latency_nomixer_both_p50_master,
'latency_v2_serveronly_p50_master': latency_v2_serveronly_p50_master,
'latency_v2_both_p50_master': latency_v2_both_p50_master,
'latency_mixer_base_p90_master': latency_mixer_base_p90_master,
'latency_mixer_serveronly_p90_master':
latency_mixer_serveronly_p90_master,
'latency_mixer_both_p90_master': latency_mixer_both_p90_master,
'latency_nomixer_serveronly_p90_master':
latency_nomixer_serveronly_p90_master,
'latency_nomixer_both_p90_master': latency_nomixer_both_p90_master,
'latency_v2_serveronly_p90_master': latency_v2_serveronly_p90_master,
'latency_v2_both_p90_master': latency_v2_both_p90_master,
'latency_mixer_base_p99_master': latency_mixer_base_p99_master,
'latency_mixer_serveronly_p99_master':
latency_mixer_serveronly_p99_master,
'latency_mixer_both_p99_master': latency_mixer_both_p99_master,
'latency_nomixer_serveronly_p99_master':
latency_nomixer_serveronly_p99_master,
'latency_nomixer_both_p99_master': latency_nomixer_both_p99_master,
'latency_v2_serveronly_p99_master': latency_v2_serveronly_p99_master,
'latency_v2_both_p99_master': latency_v2_both_p99_master,
}
return render(request, "latency.html", context=context)
def cpu_memory(request):
cur_release_names, cur_release_dates, master_release_names, master_release_dates = download.download_benchmark_csv(
20)
if request.method == "POST" and 'current_release_name' in request.POST:
cpu_cur_selected_release.append(request.POST['current_release_name'])
df = pd.read_csv(perf_data_path + cur_release_names[0] + ".csv")
# Parse data for the current release
if len(cpu_cur_selected_release) > 1:
cpu_cur_selected_release.pop(0)
if len(cpu_cur_selected_release) > 0:
df = pd.read_csv(perf_data_path + cpu_cur_selected_release[0] + ".csv")
cpu_mixer_base = get_cpu_y_series(df, '_mixer_base')
cpu_mixer_serveronly = get_cpu_y_series(df, '_mixer_serveronly')
cpu_mixer_both = get_cpu_y_series(df, '_mixer_both')
cpu_nomixer_serveronly = get_cpu_y_series(df, '_nomixer_serveronly')
cpu_nomixer_both = get_cpu_y_series(df, '_nomixer_both')
cpu_v2_serveronly = get_cpu_y_series(df, 'nullvm_serveronly')
cpu_v2_both = get_cpu_y_series(df, 'nullvm_both')
mem_mixer_base = get_mem_y_series(df, '_mixer_base')
mem_mixer_serveronly = get_mem_y_series(df, '_mixer_serveronly')
mem_mixer_both = get_mem_y_series(df, '_mixer_both')
mem_nomixer_serveronly = get_mem_y_series(df, '_nomixer_serveronly')
mem_nomixer_both = get_mem_y_series(df, '_nomixer_both')
mem_v2_serveronly = get_mem_y_series(df, 'nullvm_serveronly')
mem_v2_both = get_mem_y_series(df, 'nullvm_both')
# Parse data for the master
if request.method == "POST" and 'master_release_name' in request.POST:
cpu_master_selected_release.append(request.POST['master_release_name'])
df = pd.read_csv(perf_data_path + master_release_names[0] + ".csv")
# Parse data for the current release
if len(cpu_master_selected_release) > 1:
cpu_master_selected_release.pop(0)
if len(cpu_master_selected_release) > 0:
df = pd.read_csv(perf_data_path + cpu_master_selected_release[0] +
".csv")
cpu_mixer_base_master = get_cpu_y_series(df, '_mixer_base')
cpu_mixer_serveronly_master = get_cpu_y_series(df, '_mixer_serveronly')
cpu_mixer_both_master = get_cpu_y_series(df, '_mixer_both')
cpu_nomixer_serveronly_master = get_cpu_y_series(df, '_nomixer_serveronly')
cpu_nomixer_both_master = get_cpu_y_series(df, '_nomixer_both')
cpu_v2_serveronly_master = get_cpu_y_series(df, 'nullvm_serveronly')
cpu_v2_both_master = get_cpu_y_series(df, 'nullvm_both')
mem_mixer_base_master = get_mem_y_series(df, '_mixer_base')
mem_mixer_serveronly_master = get_mem_y_series(df, '_mixer_serveronly')
mem_mixer_both_master = get_mem_y_series(df, '_mixer_both')
mem_nomixer_serveronly_master = get_mem_y_series(df, '_nomixer_serveronly')
mem_nomixer_both_master = get_mem_y_series(df, '_nomixer_both')
mem_v2_serveronly_master = get_mem_y_series(df, 'nullvm_serveronly')
mem_v2_both_master = get_mem_y_series(df, 'nullvm_both')
context = {
'cpu_cur_selected_release': cpu_cur_selected_release,
'cpu_master_selected_release': cpu_master_selected_release,
'cur_release_names': cur_release_names,
'master_release_names': master_release_names,
'cpu_mixer_base': cpu_mixer_base,
'cpu_mixer_serveronly': cpu_mixer_serveronly,
'cpu_mixer_both': cpu_mixer_both,
'cpu_nomixer_serveronly': cpu_nomixer_serveronly,
'cpu_nomixer_both': cpu_nomixer_both,
'cpu_v2_serveronly': cpu_v2_serveronly,
'cpu_v2_both': cpu_v2_both,
'cpu_mixer_base_master': cpu_mixer_base_master,
'cpu_mixer_serveronly_master': cpu_mixer_serveronly_master,
'cpu_mixer_both_master': cpu_mixer_both_master,
'cpu_nomixer_serveronly_master': cpu_nomixer_serveronly_master,
'cpu_nomixer_both_master': cpu_nomixer_both_master,
'cpu_v2_serveronly_master': cpu_v2_serveronly_master,
'cpu_v2_both_master': cpu_v2_both_master,
'mem_mixer_base': mem_mixer_base,
'mem_mixer_serveronly': mem_mixer_serveronly,
'mem_mixer_both': mem_mixer_both,
'mem_nomixer_serveronly': mem_nomixer_serveronly,
'mem_nomixer_both': mem_nomixer_both,
'mem_v2_serveronly': mem_v2_serveronly,
'mem_v2_both': mem_v2_both,
'mem_mixer_base_master': mem_mixer_base_master,
'mem_mixer_serveronly_master': mem_mixer_serveronly_master,
'mem_mixer_both_master': mem_mixer_both_master,
'mem_nomixer_serveronly_master': mem_nomixer_serveronly_master,
'mem_nomixer_both_master': mem_nomixer_both_master,
'mem_v2_serveronly_master': mem_v2_serveronly_master,
'mem_v2_both_master': mem_v2_both_master,
}
return render(request, "cpu-memory.html", context=context)
def master_regression(request):
_, _, _, master_href_links, _, master_release_dates = download.download_benchmark_csv(
60)
latency_none_mtls_base_p90_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_none_mtls_baseline', 'p90')
latency_none_mtls_both_p90_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_none_mtls_both', 'p90')
latency_none_plaintext_both_p90_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_none_plaintext_both', 'p90')
latency_v2_stats_nullvm_both_p90_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_v2-stats-nullvm_both',
'p90')
latency_v2_stats_wasm_both_p90_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_v2-stats-wasm_both', 'p90')
latency_v2_sd_nologging_nullvm_both_p90_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates,
'_v2-sd-nologging-nullvm_both', 'p90')
latency_v2_sd_full_nullvm_both_p90_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_v2-sd-full-nullvm_both',
'p90')
latency_none_security_authz_ip_both_p90_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates,
'_none_security_authz_ip_both', 'p90')
latency_none_security_authz_path_both_p90_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates,
'_none_security_authz_path_both', 'p90')
latency_none_security_authz_jwt_both_p90_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates,
'_none_security_authz_jwt_both', 'p90')
latency_none_security_peer_authn_both_p90_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates,
'_none_security_peer_authn_both', 'p90')
latency_none_mtls_base_p99_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_none_mtls_baseline', 'p99')
latency_none_mtls_both_p99_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_none_mtls_both', 'p99')
latency_none_plaintext_both_p99_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_none_plaintext_both', 'p99')
latency_v2_stats_nullvm_both_p99_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_v2-stats-nullvm_both',
'p99')
latency_v2_stats_wasm_both_p99_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_v2-stats-wasm_both', 'p99')
latency_v2_sd_nologging_nullvm_both_p99_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates,
'_v2-sd-nologging-nullvm_both', 'p99')
latency_v2_sd_full_nullvm_both_p99_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates, '_v2-sd-full-nullvm_both',
'p99')
latency_none_security_authz_ip_both_p99_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates,
'_none_security_authz_ip_both', 'p99')
latency_none_security_authz_path_both_p99_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates,
'_none_security_authz_path_both', 'p99')
latency_none_security_authz_jwt_both_p99_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates,
'_none_security_authz_jwt_both', 'p99')
latency_none_security_peer_authn_both_p99_master = get_telemetry_mode_y_series(
master_href_links, master_release_dates,
'_none_security_peer_authn_both', 'p99')
context = {
'latency_none_mtls_base_p90_master':
latency_none_mtls_base_p90_master,
'latency_none_mtls_both_p90_master':
latency_none_mtls_both_p90_master,
'latency_none_plaintext_both_p90_master':
latency_none_plaintext_both_p90_master,
'latency_v2_stats_nullvm_both_p90_master':
latency_v2_stats_nullvm_both_p90_master,
'latency_v2_stats_wasm_both_p90_master':
latency_v2_stats_wasm_both_p90_master,
'latency_v2_sd_nologging_nullvm_both_p90_master':
latency_v2_sd_nologging_nullvm_both_p90_master,
'latency_v2_sd_full_nullvm_both_p90_master':
latency_v2_sd_full_nullvm_both_p90_master,
'latency_none_security_authz_ip_both_p90_master':
latency_none_security_authz_ip_both_p90_master,
'latency_none_security_authz_path_both_p90_master':
latency_none_security_authz_path_both_p90_master,
'latency_none_security_authz_jwt_both_p90_master':
latency_none_security_authz_jwt_both_p90_master,
'latency_none_security_peer_authn_both_p90_master':
latency_none_security_peer_authn_both_p90_master,
'latency_none_mtls_base_p99_master':
latency_none_mtls_base_p99_master,
'latency_none_mtls_both_p99_master':
latency_none_mtls_both_p99_master,
'latency_none_plaintext_both_p99_master':
latency_none_plaintext_both_p99_master,
'latency_v2_stats_nullvm_both_p99_master':
latency_v2_stats_nullvm_both_p99_master,
'latency_v2_stats_wasm_both_p99_master':
latency_v2_stats_wasm_both_p99_master,
'latency_v2_sd_nologging_nullvm_both_p99_master':
latency_v2_sd_nologging_nullvm_both_p99_master,
'latency_v2_sd_full_nullvm_both_p99_master':
latency_v2_sd_full_nullvm_both_p99_master,
'latency_none_security_authz_ip_both_p99_master':
latency_none_security_authz_ip_both_p99_master,
'latency_none_security_authz_path_both_p99_master':
latency_none_security_authz_path_both_p99_master,
'latency_none_security_authz_jwt_both_p99_master':
latency_none_security_authz_jwt_both_p99_master,
'latency_none_security_peer_authn_both_p99_master':
latency_none_security_peer_authn_both_p99_master,
}
return render(request, "master_regression.html", context=context)
def latency_vs_conn(request, uploaded_csv_url=None):
if uploaded_csv_url is not None:
uploaded_csv_path = cwd + uploaded_csv_url
df = pd.read_csv(uploaded_csv_path)
context = get_lantency_vs_conn_context(df)
os.remove(uploaded_csv_path)
return context
else:
cur_href_links, cur_release_names, cur_release_dates, master_href_links, master_release_names, \
master_release_dates = download.download_benchmark_csv(60)
cur_benchmark_test_ids = get_benchmark_test_ids(cur_href_links)
master_benchmark_test_ids = get_benchmark_test_ids(master_href_links)
if request.method == "POST" and 'current_release_name' in request.POST:
cur_selected_release.append(request.POST['current_release_name'])
df = pd.read_csv(perf_data_path + "cur_temp.csv")
if cur_release_names is not None and len(cur_release_names) > 0:
df = pd.read_csv(perf_data_path + cur_href_links[0].split("/")[4] + "_benchmark.csv")
# Parse data for the current release
if len(cur_selected_release) > 1:
cur_selected_release.pop(0)
if len(cur_selected_release) > 0:
df = pd.read_csv(perf_data_path + cur_href_links[0].split("/")[4] + "_benchmark.csv")
release_context = get_lantency_vs_conn_context(df)
# Parse data for the master
if request.method == "POST" and 'master_release_name' in request.POST:
master_selected_release.append(request.POST['master_release_name'])
df = pd.read_csv(perf_data_path + "master_temp.csv")
if master_release_names is not None and len(master_release_names) > 0:
df = pd.read_csv(perf_data_path + master_href_links[0].split("/")[4] + "_benchmark.csv")
# Parse data for the current release
if len(master_selected_release) > 1:
master_selected_release.pop(0)
if len(master_selected_release) > 0:
df = pd.read_csv(perf_data_path + master_href_links[0].split("/")[4] + "_benchmark.csv")
latency_none_mtls_base_p50_master = get_latency_vs_conn_y_series(df, '_none_mtls_baseline', 'p50')
latency_none_mtls_both_p50_master = get_latency_vs_conn_y_series(df, '_none_mtls_both', 'p50')
latency_none_plaintext_both_p50_master = get_latency_vs_conn_y_series(df, '_none_plaintext_both', 'p50')
latency_v2_stats_nullvm_both_p50_master = get_latency_vs_conn_y_series(df, '_v2-stats-nullvm_both', 'p50')
latency_v2_sd_nologging_nullvm_both_p50_master = get_latency_vs_conn_y_series(df,
'_v2-sd-nologging-nullvm_both',
'p50')
latency_v2_sd_full_nullvm_both_p50_master = get_latency_vs_conn_y_series(df, '_v2-sd-full-nullvm_both', 'p50')
latency_none_mtls_base_p90_master = get_latency_vs_conn_y_series(df, '_none_mtls_baseline', 'p90')
latency_none_mtls_both_p90_master = get_latency_vs_conn_y_series(df, '_none_mtls_both', 'p90')
latency_none_plaintext_both_p90_master = get_latency_vs_conn_y_series(df, '_none_plaintext_both', 'p90')
latency_v2_stats_nullvm_both_p90_master = get_latency_vs_conn_y_series(df, '_v2-stats-nullvm_both', 'p90')
latency_v2_sd_nologging_nullvm_both_p90_master = get_latency_vs_conn_y_series(df,
'_v2-sd-nologging-nullvm_both',
'p90')
latency_v2_sd_full_nullvm_both_p90_master = get_latency_vs_conn_y_series(df, '_v2-sd-full-nullvm_both', 'p90')
latency_none_mtls_base_p99_master = get_latency_vs_conn_y_series(df, '_none_mtls_baseline', 'p99')
latency_none_mtls_both_p99_master = get_latency_vs_conn_y_series(df, '_none_mtls_both', 'p99')
latency_none_plaintext_both_p99_master = get_latency_vs_conn_y_series(df, '_none_plaintext_both', 'p99')
latency_v2_stats_nullvm_both_p99_master = get_latency_vs_conn_y_series(df, '_v2-stats-nullvm_both', 'p99')
latency_v2_sd_nologging_nullvm_both_p99_master = get_latency_vs_conn_y_series(df,
'_v2-sd-nologging-nullvm_both',
'p99')
latency_v2_sd_full_nullvm_both_p99_master = get_latency_vs_conn_y_series(df, '_v2-sd-full-nullvm_both', 'p99')
other_context = {'current_release': current_release,
'cur_selected_release': cur_selected_release,
'master_selected_release': master_selected_release,
'cur_release_names': cur_benchmark_test_ids,
'master_release_names': master_benchmark_test_ids,
}
master_context = {'latency_none_mtls_base_p50_master': latency_none_mtls_base_p50_master,
'latency_none_mtls_both_p50_master': latency_none_mtls_both_p50_master,
'latency_none_plaintext_both_p50_master': latency_none_plaintext_both_p50_master,
'latency_v2_stats_nullvm_both_p50_master': latency_v2_stats_nullvm_both_p50_master,
'latency_v2_sd_nologging_nullvm_both_p50_master': latency_v2_sd_nologging_nullvm_both_p50_master,
'latency_v2_sd_full_nullvm_both_p50_master': latency_v2_sd_full_nullvm_both_p50_master,
'latency_none_mtls_base_p90_master': latency_none_mtls_base_p90_master,
'latency_none_mtls_both_p90_master': latency_none_mtls_both_p90_master,
'latency_none_plaintext_both_p90_master': latency_none_plaintext_both_p90_master,
'latency_v2_stats_nullvm_both_p90_master': latency_v2_stats_nullvm_both_p90_master,
'latency_v2_sd_nologging_nullvm_both_p90_master': latency_v2_sd_nologging_nullvm_both_p90_master,
'latency_v2_sd_full_nullvm_both_p90_master': latency_v2_sd_full_nullvm_both_p90_master,
'latency_none_mtls_base_p99_master': latency_none_mtls_base_p99_master,
'latency_none_mtls_both_p99_master': latency_none_mtls_both_p99_master,
'latency_none_plaintext_both_p99_master': latency_none_plaintext_both_p99_master,
'latency_v2_stats_nullvm_both_p99_master': latency_v2_stats_nullvm_both_p99_master,
'latency_v2_sd_nologging_nullvm_both_p99_master': latency_v2_sd_nologging_nullvm_both_p99_master,
'latency_v2_sd_full_nullvm_both_p99_master': latency_v2_sd_full_nullvm_both_p99_master,
}
context = reduce(lambda x, y: dict(x, **y), (other_context, release_context, master_context))
return render(request, "latency_vs_conn.html", context=context)
def artifact(request):
cur_release_names, cur_release_dates, master_release_names, master_release_dates = download.download_benchmark_csv(
30)
gcs_prefix = "https://gcsweb.istio.io/gcs/istio-build/perf/benchmark_data-"
cur_release_bundle = [[]] * len(cur_release_names)
master_release_bundle = [[]] * len(master_release_names)
for i in range(len(cur_release_names)):
cur_release_bundle[i] = [0] * 2
cur_release_bundle[i][0] = cur_release_names[i]
cur_release_bundle[i][1] = gcs_prefix + cur_release_names[i]
for i in range(len(master_release_names)):
master_release_bundle[i] = [0] * 2
master_release_bundle[i][0] = master_release_names[i]
master_release_bundle[i][1] = gcs_prefix + master_release_names[i]
context = {
'current_release': current_release,
'cur_release_bundle': cur_release_bundle,
'master_release_bundle': master_release_bundle
}
return render(request, "artifact.html", context=context)
def artifact(request):
cur_href_links, cur_release_names, cur_release_dates, master_href_links, master_release_names, master_release_dates = download.download_benchmark_csv(
60)
cur_release_bundle = get_artifacts_release_bundle(cur_release_dates,
cur_release_names,
cur_href_links)
master_release_bundle = get_artifacts_release_bundle(
master_release_dates, master_release_names, master_href_links)
context = {
'current_release': current_release,
'cur_release_bundle': cur_release_bundle,
'master_release_bundle': master_release_bundle
}
return render(request, "artifact.html", context=context)
def master_alert(request):
cur_release_names, cur_release_dates, master_release_names, master_release_dates = download.download_benchmark_csv(
40)
master_pattern_mixer_base_p90 = get_mixer_mode_y_series(
master_release_names, master_release_dates, '_mixer_base', 'p90')
master_pattern_mixer_serveronly_p90 = get_mixer_mode_y_series(
master_release_names, master_release_dates, '_mixer_serveronly', 'p90')
master_pattern_mixer_both_p90 = get_mixer_mode_y_series(
master_release_names, master_release_dates, '_mixer_both', 'p90')
master_pattern_none_serveronly_p90 = get_mixer_mode_y_series(
master_release_names, master_release_dates, '_none_serveronly', 'p90')
master_pattern_none_both_p90 = get_mixer_mode_y_series(
master_release_names, master_release_dates, '_none_both', 'p90')
master_pattern_v2_serveronly_p90 = get_mixer_mode_y_series(
master_release_names, master_release_dates, 'nullvm_serveronly', 'p90')
master_pattern_v2_both_p90 = get_mixer_mode_y_series(
master_release_names, master_release_dates, 'nullvm_both', 'p90')
master_pattern_mixer_base_p99 = get_mixer_mode_y_series(
master_release_names, master_release_dates, '_mixer_base', 'p99')
master_pattern_mixer_serveronly_p99 = get_mixer_mode_y_series(
master_release_names, master_release_dates, '_mixer_serveronly', 'p99')
master_pattern_mixer_both_p99 = get_mixer_mode_y_series(
master_release_names, master_release_dates, '_mixer_both', 'p99')
master_pattern_none_serveronly_p99 = get_mixer_mode_y_series(
master_release_names, master_release_dates, '_none_serveronly', 'p99')
master_pattern_none_both_p99 = get_mixer_mode_y_series(
master_release_names, master_release_dates, '_none_both', 'p99')
master_pattern_v2_serveronly_p99 = get_mixer_mode_y_series(
master_release_names, master_release_dates, 'nullvm_serveronly', 'p99')
master_pattern_v2_both_p99 = get_mixer_mode_y_series(
master_release_names, master_release_dates, 'nullvm_both', 'p99')
context = {
'current_release': current_release,
'master_pattern_mixer_base_p90': master_pattern_mixer_base_p90,
'master_pattern_mixer_serveronly_p90':
master_pattern_mixer_serveronly_p90,
'master_pattern_mixer_both_p90': master_pattern_mixer_both_p90,
'master_pattern_none_serveronly_p90':
master_pattern_none_serveronly_p90,
'master_pattern_none_both_p90': master_pattern_none_both_p90,
'master_pattern_v2_serveronly_p90': master_pattern_v2_serveronly_p90,
'master_pattern_v2_both_p90': master_pattern_v2_both_p90,
'master_pattern_mixer_base_p99': master_pattern_mixer_base_p99,
'master_pattern_mixer_serveronly_p99':
master_pattern_mixer_serveronly_p99,
'master_pattern_mixer_both_p99': master_pattern_mixer_both_p99,
'master_pattern_none_serveronly_p99':
master_pattern_none_serveronly_p99,
'master_pattern_none_both_p99': master_pattern_none_both_p99,
'master_pattern_v2_serveronly_p99': master_pattern_v2_serveronly_p99,
'master_pattern_v2_both_p99': master_pattern_v2_both_p99
}
return render(request, "master_alert.html", context=context)
def cpu_memory(request, uploaded_csv_url=None):
if uploaded_csv_url is not None:
uploaded_csv_path = cwd + uploaded_csv_url
df = pd.read_csv(uploaded_csv_path)
context = get_cpu_mem_context(df)
os.remove(uploaded_csv_path)
return context
else:
cur_release_names, cur_release_dates, master_release_names, master_release_dates = download.download_benchmark_csv(
20)
if request.method == "POST" and 'current_release_name' in request.POST:
cpu_cur_selected_release.append(
request.POST['current_release_name'])
df = pd.read_csv(perf_data_path + "cur_temp.csv")
if cur_release_names is not None and len(cur_release_names) > 0:
df = pd.read_csv(perf_data_path + cur_release_names[0] + ".csv")
# Parse data for the current release
if len(cpu_cur_selected_release) > 1:
cpu_cur_selected_release.pop(0)
if len(cpu_cur_selected_release) > 0:
df = pd.read_csv(perf_data_path + cpu_cur_selected_release[0] +
".csv")
release_context = get_cpu_mem_context(df)
# Parse data for the master
if request.method == "POST" and 'master_release_name' in request.POST:
cpu_master_selected_release.append(
request.POST['master_release_name'])
df = pd.read_csv(perf_data_path + "master_temp.csv")
if master_release_names is not None and len(master_release_names) > 0:
df = pd.read_csv(perf_data_path + master_release_names[0] + ".csv")
# Parse data for the current release
if len(cpu_master_selected_release) > 1:
cpu_master_selected_release.pop(0)
if len(cpu_master_selected_release) > 0:
df = pd.read_csv(perf_data_path + cpu_master_selected_release[0] +
".csv")
cpu_mixer_both_master = get_cpu_y_series(df, '_mixer_both')
cpu_none_mtls_base_master = get_cpu_y_series(df, '_none_mtls_base')
cpu_none_mtls_both_master = get_cpu_y_series(df, '_none_mtls_both')
cpu_none_plaintext_both_master = get_cpu_y_series(
df, '_none_plaintext_both')
cpu_v2_stats_nullvm_both_master = get_cpu_y_series(
df, '_v2-stats-nullvm_both')
cpu_v2_sd_nologging_nullvm_both_master = get_cpu_y_series(
df, '_v2-sd-nologging-nullvm_both')
cpu_v2_sd_full_nullvm_both_master = get_cpu_y_series(
df, '_v2-sd-full-nullvm_both')
mem_mixer_both_master = get_mem_y_series(df, '_mixer_both')
mem_none_mtls_base_master = get_mem_y_series(df, '_none_mtls_base')
mem_none_mtls_both_master = get_mem_y_series(df, '_none_mtls_both')
mem_none_plaintext_both_master = get_mem_y_series(
df, '_none_plaintext_both')
mem_v2_stats_nullvm_both_master = get_mem_y_series(
df, '_v2-stats-nullvm_both')
mem_v2_sd_nologging_nullvm_both_master = get_mem_y_series(
df, '_v2-sd-nologging-nullvm_both')
mem_v2_sd_full_nullvm_both_master = get_mem_y_series(
df, '_v2-sd-full-nullvm_both')
other_context = {
'current_release': current_release,
'cpu_cur_selected_release': cpu_cur_selected_release,
'cpu_master_selected_release': cpu_master_selected_release,
'cur_release_names': cur_release_names,
'master_release_names': master_release_names,
}
master_context = {
'cpu_mixer_both_master': cpu_mixer_both_master,
'cpu_none_mtls_base_master': cpu_none_mtls_base_master,
'cpu_none_mtls_both_master': cpu_none_mtls_both_master,
'cpu_none_plaintext_both_master': cpu_none_plaintext_both_master,
'cpu_v2_stats_nullvm_both_master': cpu_v2_stats_nullvm_both_master,
'cpu_v2_sd_nologging_nullvm_both_master':
cpu_v2_sd_nologging_nullvm_both_master,
'cpu_v2_sd_full_nullvm_both_master':
cpu_v2_sd_full_nullvm_both_master,
'mem_mixer_both_master': mem_mixer_both_master,
'mem_none_mtls_base_master': mem_none_mtls_base_master,
'mem_none_mtls_both_master': mem_none_mtls_both_master,
'mem_none_plaintext_both_master': mem_none_plaintext_both_master,
'mem_v2_stats_nullvm_both_master': mem_v2_stats_nullvm_both_master,
'mem_v2_sd_nologging_nullvm_both_master':
mem_v2_sd_nologging_nullvm_both_master,
'mem_v2_sd_full_nullvm_both_master':
mem_v2_sd_full_nullvm_both_master
}
context = reduce(lambda x, y: dict(x, **y),
(other_context, release_context, master_context))
return render(request, "cpu_memory.html", context=context)
