Drone MP-QUIC Measurement Testbed

This testbed is designed to measure highly reliable (99.999%), ultra-low latency MP-QUIC communication between a Drone and a Ground Station over heterogeneous links (5G, Satellite, Mesh).

1. Deployment Guide

The testbed is split into two independent deployable units.

Prerequisites

• Go 1.20+: To build the client and server applications.
• Python 3.x: With pandas, matplotlib, and seaborn installed for analysis.
• Linux (Optional): If you wish to run the eBPF kernel tracing, you must be on a Linux machine with bcc installed and run the scripts as root.

Running the Ground Station (Server)

Deploy the server/ directory to the Ground Station machine.

# This automatically builds the Go code and starts listening on port 4242.
# It logs the application-level delivery metrics (packet loss, latency) to ground_metrics.csv
./server/scripts/run.sh --addr 0.0.0.0:4242 --output ground_metrics.csv

Running the Drone (Client)

Deploy the client/ directory to the Drone machine.

# Blasts framed payloads to the ground station.
# You can specify the scheduler, the duration in seconds, the message size, and an optional chunk size.
./client/scripts/run.sh \
    --addr <GROUND_STATION_IP>:4242 \
    --scheduler minrtt \
    --duration 30 \
    --message-size 2048 \
    --chunk-size 512

Analyzing the Results

Once the test finishes, copy ground_metrics.csv to your laptop and run:

pip install pandas matplotlib seaborn
python3 analysis/visualize.py --app ground_metrics.csv

This will print your exact Reliability % to the terminal and generate scatter plots of the jitter and glass-to-glass latency.

---

2. Developer Guide: Adding Custom Algorithms

This testbed is designed to be highly modular so you can test custom Path Schedulers and Congestion Control algorithms.

How to Add a Custom Path Scheduler

Path Schedulers dictate which link (5G, Mesh, Satellite) a packet should be sent over. The testbed uses a dynamic registry, meaning you never have to modify client/main.go to add a new scheduler.

1. Navigate to the client/scheduler/ directory.
2. Copy the template file: cp custom_example.go my_scheduler.go.
3. Open my_scheduler.go and implement the quic.PathScheduler interface, which requires three methods:
   • SelectPath(...): Contains your custom logic to choose a path.
   • UpdateQuota(...): Tracks how much data was sent.
   • Reset(): Resets your internal metrics.
4. At the bottom of my_scheduler.go, update the init() function to register your new scheduler:

   func init() {
       Register("my_custom_algo", func() quic.PathScheduler {
           return &MyScheduler{}
       })
   }
   

5. Run ./client/scripts/run.sh --list-schedulers and you will see my_custom_algo automatically available!

How to Add Custom Congestion Control

Unlike Schedulers, Congestion Control (CC) algorithms are deeply embedded inside the mp-quic-go library. The library currently supports CUBIC and OLIA.

To write a completely new CC algorithm, you must modify the library itself. Here is the easiest workflow:

Step 1: Fork the Library Locally Clone the underlying library to your machine:

cd ~
git clone https://github.com/AeonDave/mp-quic-go.git

Step 2: Tell Go to use your Local Copy In this drone project, tell Go to use your local copy instead of downloading it from Github:

cd drone
go mod edit -replace github.com/AeonDave/mp-quic-go=/path/to/your/local/mp-quic-go
go mod tidy

Step 3: Write your CC Algorithm Open your local mp-quic-go code and implement the congestion.SendAlgorithm interface. You can look at internal/congestion/cubic_sender.go inside the library as a template.

Step 4: Wire it into the Multipath Controller Inside the library, open multipath_controller.go. You will need to modify the MultipathController to instantiate your new CC algorithm for new paths, similar to how it currently enables OLIA when EnableOLIA() is called.

Once your custom library modifications are done, you simply run ./client/scripts/run.sh inside the drone directory, and Go will automatically compile your local, modified library into the drone client!