lox-troll-patrol-extension/parsing-results/make_tables_tp.py

import csv
import math
import sys
import pandas as pd
import numpy as np

def format(mean, std):
    if std >= 950:
        m = round(mean/1000.0) * 1000
        s = round(std/1000.0) * 1000
        dec = 0
    elif std >= 95:
        m = round(mean/100.0) * 100
        s = round(std/100.0) * 100
        dec = 0
    elif std >= 9.5:
        m = round(mean/10.0) * 10
        s = round(std/10.0) * 10
        dec = 0
    elif std >= 0.95:
        m = round(mean)
        s = round(std)
        dec = 0
    elif std >= 0.095:
        m = round(mean*10) / 10.0
        s = round(std*10) / 10.0
        dec = 1
    elif std >= 0.0095:
        m = round(mean*100) / 100.0
        s = round(std*100) / 100.0
        dec = 2
    elif std >= 0.00095:
        m = round(mean*1000) / 1000.0
        s = round(std*1000) / 1000.0
        dec = 3
    elif std >= 0.000095:
        m = round(mean*10000) / 10000.0
        s = round(std*10000) / 10000.0
        dec = 4
    elif std >= 0.0000095:
        m = round(mean*100000) / 100000.0
        s = round(std*100000) / 100000.0
        dec = 5
    # We measure in ns; if std == 0, this is the case to use
    else:
        m = round(mean*1000000) / 1000000.0
        s = round(std*1000000) / 1000000.0
        dec = 6
    m = str(m)
    s = str(s)

    if dec > 0:
        msplit = m.split('.')
        ssplit = s.split('.')
        if len(msplit) < 2:
            m = msplit[0] + '.' + '0' * dec
        elif len(msplit[1]) < dec:
            m = msplit[0] + '.' + msplit[1] + '0' * (dec - len(msplit[1]))
        if len(ssplit) < 2:
            s = ssplit[0] + '.' + '0' * dec
        elif len(ssplit[1]) < dec:
            s = ssplit[0] + '.' + ssplit[1] + '0' * (dec - len(ssplit[1]))

    return m, s


def main():
    perf = open("performance_stats"+".csv", "w", newline='')
    protocols=["Open Invitation", "Trust Promotion(0->1)",
               "Trust Migration (0->1)", "Level Up (1->4)", "Issue Invitation",
                    "Redeem Invitation", "Check Blockage 5%", "Check Blockage 50%", "Check Blockage 100%", "Blockage Migration",
                    "Report Submit", "Report Status", "Report Resolve"]
    files = ["trust_levels.csv", "trust_promo.csv", "trust_mig.csv", "level2.csv",
             "invitations.csv", "redeem_invites.csv","check_blockage5.csv",
             "check_blockage50.csv","check_blockage100.csv","blockage_migration50.csv",
             "report_submit.csv", "report_status.csv", "report_resolve.csv"]
    csv_cols = ["RequestS", "RequestT","Rtstdev","ResponseS","ResponseT",
                "ReTstdev", "ResponseHT", "RHTstdev"]
    perf_columns = ["Protocol","Request Size", "Request Time", "sigma",
                    "Response Size","Response Time", "sigma",
                    "Response Handling Time", "sigma"]
    worst_resp = 0
    perfwriter = csv.writer(perf, delimiter=',')
    perfwriter.writerow(perf_columns)

    for i, protocol in enumerate(protocols):
        columns = ["Percent","Bridges", "RequestS", "Rsstdev", "RequestT",
                   "Rtstdev", "ResponseS","Restdev","ResponseT",
                   "ReTstdev", "ResponseHT", "RHTstdev"]

        with open(files[i], 'r') as f:
            stats = csv.reader(f, delimiter=',')
            perf_in = []

            perf_in.append(protocol)

            for row in stats:
                if row[1] == "600":
                    req_size = int(row[2])
                    req_size_std = float(row[3])
                    req_time = float(row[4])
                    req_std = float(row[5])
                    # open invitation response size is +/- 1 byte
                    resp_size = int(math.ceil(float(row[6])))
                    resp_size_std = float(row[7])
                    resp_time = float(row[8])
                    resp_std = float(row[9])
                    handle_time = float(row[10])
                    handle_std = float(row[11])

                    req_time, req_std = format (req_time, req_std)
                    resp_time, resp_std = format (resp_time, resp_std)
                    handle_time, handle_std = format (handle_time, handle_std)

                    perf_in.extend([req_size, req_time, req_std, resp_size, resp_time, resp_std, handle_time, handle_std])

                    break

            perfwriter.writerow(perf_in)

    perf.close()
    print("\nDone Tables.\nTable data output to: performance_stats.csv,\n")


if __name__ == "__main__":
    sys.exit(main())