measurement-scripts/plot_single_transmission.py

#!/usr/bin/env python3
import math
import multiprocessing
import os
from argparse import ArgumentParser

import matplotlib
import pandas as pd
import matplotlib.pyplot as plt


if __name__ == "__main__":
    parser = ArgumentParser()
    parser.add_argument("-s", "--serial_file", required=True, help="Serial csv file.")
    parser.add_argument("-p", "--pcap_csv_folder", required=True, help="PCAP csv folder.")
    parser.add_argument("--save", default=None, help="Location to save pdf file.")
    parser.add_argument(
        "-i",
        "--interval",
        default=10,
        type=int,
        help="Time interval for rolling window.",
    )

    args = parser.parse_args()
    manager = multiprocessing.Manager()
    n = manager.Value("i", 0)
    frame_list = manager.list()
    jobs = []

    # load all pcap csv into one dataframe
    pcap_csv_list = list()
    for filename in os.listdir(args.pcap_csv_folder):
        if filename.endswith(".csv") and "tcp" in filename:
            pcap_csv_list.append(filename)

    counter = 1
    if len(pcap_csv_list) == 0:
        print("No CSV files found.")

    pcap_csv_list.sort(key=lambda x: int(x.split("_")[-1].replace(".csv", "")))

    for csv in pcap_csv_list:

        print("\rProcessing {} out of {} CSVs.\t({}%)\t".format(counter, len(pcap_csv_list), math.floor(counter/len(pcap_csv_list))))

        try:
            transmission_df = pd.read_csv(
                "{}{}".format(args.pcap_csv_folder, csv),
                dtype=dict(is_retranmission=bool, is_dup_ack=bool),
            )

            transmission_df["datetime"] = pd.to_datetime(transmission_df["datetime"]) - pd.Timedelta(hours=1)
            transmission_df = transmission_df.set_index("datetime")
            transmission_df.index = pd.to_datetime(transmission_df.index)
            transmission_df = transmission_df.sort_index()

            # srtt to [s]
            transmission_df["srtt"] = transmission_df["srtt"].apply(lambda x: x / 10**6)

            # key for columns and level for index
            transmission_df["goodput"] = transmission_df["payload_size"].groupby(pd.Grouper(level="datetime", freq="{}s".format(args.interval))).transform("sum")
            transmission_df["goodput"] = transmission_df["goodput"].apply(
                lambda x: ((x * 8) / args.interval) / 10**6
            )

            transmission_df["goodput_rolling"] = transmission_df["payload_size"].rolling("{}s".format(args.interval)).sum()
            transmission_df["goodput_rolling"] = transmission_df["goodput_rolling"].apply(
                lambda x: ((x * 8) / args.interval) / 10 ** 6
            )

            # set meta values and remove all not needed columns
            cc_algo = transmission_df["congestion_control"].iloc[0]
            cc_algo = cc_algo.upper()
            transmission_direction = transmission_df["direction"].iloc[0]

            #transmission_df = transmission_df.filter(["goodput", "datetime", "ack_rtt", "goodput_rolling", "snd_cwnd"])

            # read serial csv
            serial_df = pd.read_csv(args.serial_file)
            serial_df["datetime"] = pd.to_datetime(serial_df["datetime"]) - pd.Timedelta(hours=1)
            serial_df = serial_df.set_index("datetime")
            serial_df.index = pd.to_datetime(serial_df.index)
            serial_df.sort_index()

            transmission_df = pd.merge_asof(
                transmission_df,
                serial_df,
                tolerance=pd.Timedelta("1s"),
                right_index=True,
                left_index=True,
            )

            # transmission timeline

            scaley = 1.5
            scalex = 1.0
            ax0 = plt.subplots(211, figsize=[6.4 * scaley, 4.8 * scalex])
            ax1 = ax0.twinx()
            ax2 = ax0.twinx()

            ax00 = plt.subplots(212)
            ax01 = ax00.twinx()

            plt.title("{} with {}".format(transmission_direction, cc_algo))

            # create list fo color indices for lte cells
            color_dict = dict()
            color_list = list()
            i = 0
            for cell_id in transmission_df["PCID"]:
                if cell_id not in color_dict:
                    color_dict[cell_id] = i
                    i += 1
                color_list.append(color_dict[cell_id])

            transmission_df["lte_cell_color"] = color_list
            color_dict = None
            color_list = None

            cmap = matplotlib.cm.get_cmap("Set3")
            unique_cells = transmission_df["lte_cell_color"].unique()
            color_list = cmap.colors * (round(len(unique_cells) / len(cmap.colors)) + 1)

            # create list fo color indices for nr cells
            color_dict = dict()
            color_list = list()
            i = 0
            for cell_id in transmission_df["PCID.1"]:
                if cell_id not in color_dict:
                    color_dict[cell_id] = i
                    i += 1
                color_list.append(color_dict[cell_id])

            transmission_df["nr_cell_color"] = color_list
            color_dict = None
            color_list = None

            cmap = matplotlib.cm.get_cmap("Set3")
            unique_cells = transmission_df["nr_cell_color"].unique()
            color_list = cmap.colors * (round(len(unique_cells) / len(cmap.colors)) + 1)

            transmission_df["index"] = transmission_df.index
            for c in transmission_df["lte_cell_color"].unique():
                bounds = transmission_df[["index", "lte_cell_color"]].groupby("lte_cell_color").agg(["min", "max"]).loc[c]
                ax0.axvspan(bounds.min(), bounds.max(), alpha=0.1, color=color_list[c])
            for c in transmission_df["nr_cell_color"].unique():
                bounds = transmission_df[["index", "nr_cell_color"]].groupby("nr_cell_color").agg(["min", "max"]).loc[c]
                ax00.axvspan(bounds.min(), bounds.max(), alpha=0.1, color=color_list[c])

            ax0.plot(transmission_df["snd_cwnd"].dropna(), color="lime", linestyle="dashed", label="cwnd")
            ax1.plot(transmission_df["srtt"].dropna(), color="red", linestyle="dashdot", label="sRTT")
            ax2.plot(transmission_df["goodput_rolling"], color="blue", linestyle="solid", label="goodput")
            ax00.plot(transmission_df["downlink_cqi"].dropna(), color="magenta", linestyle="dotted", label="CQI")
            ax01.plot(transmission_df["DL_bandwidth"].dropna(), color="peru", linestyle="dotted", label="DL_bandwidth")

            if args.save:
                plt.savefig("{}{}_plot.pdf".format(args.save, csv.replace(".csv", "")))
        except Exception as e:
            print("Error processing file: {}".format(csv))
            print(str(e))
        counter += 1

        plt.clf()