first

analysis/visualize.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""MP-QUIC Application & eBPF Results Visualizer.
+
+This script takes the CSV outputs and plots their latency distributions and timelines.
+
+Usage:
+    python visualize.py --app ../server/app_metrics.csv
+    python visualize.py --client ../results/client.csv --server ../results/server.csv
+"""
+
+import argparse
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+
+def load_ebpf_data(csv_path, label):
+    if not os.path.exists(csv_path):
+        print(f"Warning: File {csv_path} not found.")
+        return pd.DataFrame()
+    
+    df = pd.read_csv(csv_path)
+    df['node'] = label
+    df = df.sort_values('timestamp')
+    if not df.empty:
+        first_event_time = df['timestamp'].iloc[0]
+        df['rel_time'] = df['timestamp'] - first_event_time
+    else:
+        df['rel_time'] = 0.0
+    df['value_us'] = df['value_ns'] / 1000.0
+    return df
+
+def plot_app_metrics(csv_path, output_dir):
+    """Plot Application-Level Metrics (Drone -> Ground Station)."""
+    if not os.path.exists(csv_path):
+        print(f"App metrics file {csv_path} not found.")
+        return
+
+    df = pd.read_csv(csv_path)
+    if df.empty:
+        print("App metrics file is empty.")
+        return
+
+    df = df.sort_values('sequence_number')
+    
+    # Calculate Jitter and Rel Latency
+    df['latency_ms'] = df['latency_ns'] / 1000000.0
+    
+    # Relative time from first packet received
+    df['rel_time'] = (df['ground_recv_time'] - df['ground_recv_time'].min()) / 1e9
+
+    plt.figure(figsize=(10, 5))
+    sns.scatterplot(x='rel_time', y='latency_ms', data=df, s=15, alpha=0.6)
+    plt.title('App-Level End-to-End Latency Over Time (Glass-to-Glass)')
+    plt.ylabel('Relative Latency (ms)')
+    plt.xlabel('Time (s)')
+    out_path = os.path.join(output_dir, 'app_latency_timeline.png')
+    plt.savefig(out_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    # Packet Loss Calculation
+    max_seq = df['sequence_number'].max()
+    min_seq = df['sequence_number'].min()
+    expected_packets = max_seq - min_seq + 1
+    received_packets = len(df)
+    lost_packets = expected_packets - received_packets
+    reliability = (received_packets / expected_packets) * 100 if expected_packets > 0 else 0
+
+    print("\n" + "=" * 55)
+    print("  🏆 APP-LEVEL RELIABILITY (Drone -> Ground)")
+    print("=" * 55)
+    print(f"  Packets Sent (Expected): {expected_packets}")
+    print(f"  Packets Received:        {received_packets}")
+    print(f"  Packets Lost:            {lost_packets}")
+    print(f"  Reliability:             {reliability:.5f}%")
+    print("=" * 55)
+    
+    print(f"Saved app-level plot to {out_path}")
+
+
+def plot_latency_distributions(df, output_dir):
+    latency_df = df[df['event_type'].isin(['SEND_LATENCY', 'RECV_LATENCY'])]
+    if latency_df.empty: return
+
+    plt.figure(figsize=(10, 6))
+    sns.violinplot(x='event_type', y='value_us', hue='node', data=latency_df, split=True, inner="quartile")
+    plt.yscale('log')
+    plt.title('Kernel Network Stack Latency Distribution (Log Scale)')
+    plt.ylabel('Latency (µs)')
+    plt.xlabel('Event Type')
+    
+    out_path = os.path.join(output_dir, 'kernel_latency_distribution.png')
+    plt.savefig(out_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f"Saved kernel distribution plot to {out_path}")
+
+def plot_latency_timeline(df, output_dir):
+    latency_df = df[df['event_type'].isin(['SEND_LATENCY', 'RECV_LATENCY'])]
+    if latency_df.empty: return
+
+    g = sns.FacetGrid(latency_df, col="event_type", row="node", margin_titles=True, height=4, aspect=2)
+    g.map(sns.scatterplot, "rel_time", "value_us", alpha=0.5, s=10)
+    g.set_axis_labels("Time (s)", "Latency (µs)")
+    g.set_titles(col_template="{col_name}", row_template="{row_name}")
+    
+    for ax in g.axes.flat:
+        ax.set_yscale('log')
+        
+    g.fig.suptitle('Kernel Latency Over Time', y=1.02)
+    
+    out_path = os.path.join(output_dir, 'kernel_latency_timeline.png')
+    plt.savefig(out_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f"Saved kernel timeline plot to {out_path}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Visualize MP-QUIC data")
+    parser.add_argument("--client", help="Path to client eBPF CSV file")
+    parser.add_argument("--server", help="Path to server eBPF CSV file")
+    parser.add_argument("--app", help="Path to App-Level metrics CSV file (e.g. app_metrics.csv)")
+    parser.add_argument("--outdir", default="plots", help="Directory to save plots")
+    args = parser.parse_args()
+
+    os.makedirs(args.outdir, exist_ok=True)
+
+    if args.app:
+        plot_app_metrics(args.app, args.outdir)
+
+    dfs = []
+    if args.client:
+        dfs.append(load_ebpf_data(args.client, "Client"))
+    if args.server:
+        dfs.append(load_ebpf_data(args.server, "Server"))
+        
+    if dfs:
+        df = pd.concat(dfs, ignore_index=True)
+        sns.set_theme(style="whitegrid")
+        plot_latency_distributions(df, args.outdir)
+        plot_latency_timeline(df, args.outdir)
+        
+    print("\nVisualization complete! Check the '{}' directory.".format(args.outdir))
+
+if __name__ == "__main__":
+    main()