#!/usr/bin/env python3 """MP-QUIC Application & eBPF Results Visualizer. This script takes the CSV outputs and plots their latency distributions and timelines, with advanced network statistics. 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 import numpy as np 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) / 1e9 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 # Sort by message ID and then chunk index df = df.sort_values(['message_id', 'chunk_index']) # Calculate Latency df['latency_ms'] = df['latency_ns'] / 1000000.0 # Calculate Jitter (absolute difference between consecutive latencies) df['jitter_ms'] = df['latency_ms'].diff().abs() # Relative time from first packet received df['rel_time'] = (df['ground_recv_time'] - df['ground_recv_time'].min()) / 1e9 # Plot 1: Latency and Jitter Over Time fig, ax1 = plt.subplots(figsize=(12, 6)) sns.scatterplot(x='rel_time', y='latency_ms', data=df, s=30, alpha=0.5, color='#1f77b4', label='Latency (ms)', ax=ax1, edgecolor='none') # Rolling average latency df['rolling_latency'] = df['latency_ms'].rolling(window=20, min_periods=1).mean() sns.lineplot(x='rel_time', y='rolling_latency', data=df, color='#d62728', linewidth=2.5, label='Moving Avg Latency', ax=ax1) ax1.set_title('App-Level Network Performance: Latency & Jitter Over Time', fontsize=16, fontweight='bold', pad=20) ax1.set_ylabel('Latency (ms)', fontsize=13, fontweight='bold') ax1.set_xlabel('Time (s)', fontsize=13, fontweight='bold') ax1.grid(True, linestyle='--', alpha=0.7) # Add Jitter on a secondary y-axis ax2 = ax1.twinx() sns.lineplot(x='rel_time', y='jitter_ms', data=df, color='#2ca02c', alpha=0.4, linewidth=1.5, label='Jitter (ms)', ax=ax2) ax2.set_ylabel('Jitter (ms)', fontsize=13, fontweight='bold', color='#2ca02c') ax2.tick_params(axis='y', labelcolor='#2ca02c') # Combine legends lines_1, labels_1 = ax1.get_legend_handles_labels() lines_2, labels_2 = ax2.get_legend_handles_labels() ax1.legend(lines_1 + lines_2, labels_1 + labels_2, loc='upper left', frameon=True, shadow=True) out_path_timeline = os.path.join(output_dir, 'app_performance_timeline.png') plt.tight_layout() plt.savefig(out_path_timeline, dpi=300, bbox_inches='tight') plt.close() # Plot 2: Latency CDF plt.figure(figsize=(9, 6)) sns.ecdfplot(data=df, x='latency_ms', color='#9467bd', linewidth=3) plt.title('CDF of End-to-End App Latency', fontsize=16, fontweight='bold', pad=20) plt.xlabel('Latency (ms)', fontsize=13, fontweight='bold') plt.ylabel('Cumulative Probability', fontsize=13, fontweight='bold') plt.grid(True, linestyle='--', alpha=0.7) # Mark percentiles p50, p90, p95, p99 = df['latency_ms'].quantile([0.5, 0.9, 0.95, 0.99]) plt.axvline(p50, color='r', linestyle=':', linewidth=2, label=f'P50: {p50:.2f} ms') plt.axvline(p90, color='orange', linestyle=':', linewidth=2, label=f'P90: {p90:.2f} ms') plt.axvline(p99, color='green', linestyle=':', linewidth=2, label=f'P99: {p99:.2f} ms') plt.legend(frameon=True, shadow=True, fontsize=11) out_path_cdf = os.path.join(output_dir, 'app_latency_cdf.png') plt.tight_layout() plt.savefig(out_path_cdf, dpi=300, bbox_inches='tight') plt.close() # Packet Loss Calculation with Chunking Support max_msg = df['message_id'].max() min_msg = df['message_id'].min() expected_messages = max_msg - min_msg + 1 chunks_per_msg = df['total_chunks'].max() if 'total_chunks' in df.columns else 1 expected_chunks = expected_messages * chunks_per_msg received_chunks = len(df) lost_chunks = expected_chunks - received_chunks reliability = (received_chunks / expected_chunks) * 100 if expected_chunks > 0 else 0 print("\n" + "=" * 60) print(" 📊 APP-LEVEL NETWORK STATISTICS (Drone -> Ground)") print("=" * 60) print(f" Messages Sent (Expected): {expected_messages}") print(f" Chunks Sent (Expected): {expected_chunks}") print(f" Chunks Received: {received_chunks}") print(f" Chunks Lost: {lost_chunks}") print(f" Reliability: {reliability:.5f}%") print("-" * 60) print(f" Latency P50 (Median): {p50:.2f} ms") print(f" Latency P90: {p90:.2f} ms") print(f" Latency P95: {p95:.2f} ms") print(f" Latency P99 (Tail): {p99:.2f} ms") print(f" Avg Jitter: {df['jitter_ms'].mean():.2f} ms") print("=" * 60) print(f"Saved app-level timeline plot to {out_path_timeline}") print(f"Saved app-level CDF plot to {out_path_cdf}") 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)) # Use a custom color palette palette = {"Client": "#4C72B0", "Server": "#C44E52"} sns.boxplot(x='event_type', y='value_us', hue='node', data=latency_df, palette=palette, showfliers=False, width=0.6) plt.yscale('log') plt.title('Kernel Network Stack Latency Distribution', fontsize=16, fontweight='bold', pad=20) plt.ylabel('Latency (µs) [Log Scale]', fontsize=13, fontweight='bold') plt.xlabel('Event Type', fontsize=13, fontweight='bold') plt.grid(True, axis='y', linestyle='--', alpha=0.7) plt.legend(title='Node', title_fontsize='13', fontsize='11', frameon=True, shadow=True) out_path = os.path.join(output_dir, 'kernel_latency_distribution.png') plt.tight_layout() 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 # Group by Event Type and Node g = sns.FacetGrid(latency_df, col="event_type", row="node", margin_titles=True, height=4.5, aspect=2, sharey=False) # Scatter plot with reduced opacity for density g.map(sns.scatterplot, "rel_time", "value_us", alpha=0.5, s=25, color="#55A868", edgecolor='none') g.set_axis_labels("Time (s)", "Latency (µs)") g.set_titles(col_template="{col_name}", row_template="{row_name}", size=14, weight='bold') for ax in g.axes.flat: ax.set_yscale('log') ax.grid(True, linestyle=':', alpha=0.7) g.fig.suptitle('Kernel Latency Over Time (Log Scale)', y=1.05, fontsize=18, fontweight='bold') out_path = os.path.join(output_dir, 'kernel_latency_timeline.png') plt.tight_layout() 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) # Set global aesthetic for seaborn sns.set_theme(style="whitegrid", context="notebook", font_scale=1.1) 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) plot_latency_distributions(df, args.outdir) plot_latency_timeline(df, args.outdir) print(f"\n✅ Visualization complete! Beautiful plots generated in '{args.outdir}' directory.") if __name__ == "__main__": main()