tests: Add tests to exercise max streaming rates and report results

3 files changed, 1008 insertions, 0 deletions

diff --git a/host/tests/streaming_performance/run_E3xx_max_rate_tests.py b/host/tests/streaming_performance/run_E3xx_max_rate_tests.py
new file mode 100755
index 000000000..d53f03a46
--- /dev/null
+++ b/host/tests/streaming_performance/run_E3xx_max_rate_tests.py
@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+Copyright 2019 Ettus Research, A National Instrument Brand
+
+SPDX-License-Identifier: GPL-3.0-or-later
+
+Runs streaming tests for N3xx at rates in the neighborhoood of the maximum
+rate that UHD can sustain. Each test consists of a batch of runs of the
+benchmark rate C++ example with different streaming parameters.
+
+To run all the tests, execute it with all supported options for the test_type
+parameter:
+    E320_XG      Runs E320 tests with single and dual 10 GbE links
+    E120_Liberio Runs E310 tests with Liberio
+
+Example usage:
+run_E3xx_max_rate_tests.py --path <benchmark_rate_dir>/benchmark_rate --addr 192.168.10.2 --second_addr 192.168.20.2 --test_type E320_XG
+"""
+import argparse
+import sys
+import time
+import datetime
+import batch_run_benchmark_rate
+
+Test_Type_E320_XG = "E320_XG"
+Test_Type_E310_Liberio = "E310_Liberio"
+
+test_type_list = [Test_Type_E320_XG, Test_Type_E310_Liberio]
+
+def parse_args():
+    """
+    Parse command line arguments
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--path",
+        type=str,
+        required=True,
+        help="path to benchmark rate example")
+    parser.add_argument(
+        "--test_type",
+        type=str,
+        required=True,
+        choices=test_type_list,
+        help="path to benchmark rate example")
+    parser.add_argument(
+        "--addr",
+        type=str,
+        default = "",
+        help="address of the 10 GbE interface")
+    args = parser.parse_args()
+
+    return args.path, args.test_type, args.addr
+
+def run_test(path, params, iterations, label):
+    """
+    Runs benchmark rate for the number of iterations in the command line arguments
+    """
+    print("-----------------------------------------------------------")
+    print(label + "\n")
+    results = batch_run_benchmark_rate.run(path, iterations, params, False)
+    stats = batch_run_benchmark_rate.calculate_stats(results)
+    print(batch_run_benchmark_rate.get_summary_string(stats))
+
+def run_E320_tests_for_single_10G(path, addr, iterations, duration):
+    """
+    Runs tests that are in the neighborhood of max rate for 10 GbE
+    """
+    def base_params(rate):
+        return {
+            "args" : "addr={},master_clock_rate={}".format(addr, rate),
+            "duration" : duration
+        }
+
+    # Run RX at 61.44 Msps with one channel
+    rate = "61.44e6"
+    rx_params = base_params(rate)
+    rx_params["rx_rate"] = rate
+    rx_params["rx_channels"] = "0"
+    run_test(path, rx_params, iterations, "1xRX @{}".format(rate))
+
+    # Run RX at 61.44 Msps with two channels
+    rate = "61.44e6"
+    rx_params = base_params(rate)
+    rx_params["rx_rate"] = rate
+    rx_params["rx_channels"] = "0,1"
+    run_test(path, rx_params, iterations, "2xRX @{}".format(rate))
+
+    # Run TX at 61.44 Msps with one channel
+    rate = "61.44e6"
+    tx_params = base_params(rate)
+    tx_params["tx_rate"] = rate
+    tx_params["tx_channels"] = "0"
+    run_test(path, tx_params, iterations, "1xTX @{}".format(rate))
+
+    # Run TX at 61.44 Msps with two channels
+    rate = "61.44e6"
+    tx_params = base_params(rate)
+    tx_params["tx_rate"] = rate
+    tx_params["tx_channels"] = "0,1"
+    run_test(path, tx_params, iterations, "2xTX @{}".format(rate))
+
+    # Run TRX at 61.44 Msps with one channels
+    rate = "61.44e6"
+    trx_params = base_params(rate)
+    trx_params["tx_rate"] = rate
+    trx_params["rx_rate"] = rate
+    trx_params["tx_channels"] = "0"
+    trx_params["rx_channels"] = "0"
+    run_test(path, trx_params, iterations, "1xTRX @{}".format(rate))
+
+    # Run TRX at 61.44 Msps with two channels
+    rate = "61.44e6"
+    trx_params = base_params(rate)
+    trx_params["tx_rate"] = rate
+    trx_params["rx_rate"] = rate
+    trx_params["tx_channels"] = "0,1"
+    trx_params["rx_channels"] = "0,1"
+    run_test(path, trx_params, iterations, "2xTRX @{}".format(rate))
+
+def run_E320_tests_for_single_10G_long_duration(path, addr, iterations, duration):
+    """
+    Runs tests that are in the neighborhood of max rate for 10 GbE. Only include
+    a small subset of tests to run for a longer period.
+    """
+    def base_params(rate):
+        return {
+            "args" : "addr={},master_clock_rate={}".format(addr, rate),
+            "duration" : duration
+        }
+
+    # Run TRX at 61.44 Msps with two channels
+    rate = "61.44e6"
+    trx_params = base_params(rate)
+    trx_params["tx_rate"] = rate
+    trx_params["rx_rate"] = rate
+    trx_params["tx_channels"] = "0,1"
+    trx_params["rx_channels"] = "0,1"
+    run_test(path, trx_params, iterations, "2xTRX @{}".format(rate))
+
+def main():
+    path, test_type, addr = parse_args()
+    start_time = time.time()
+
+    if test_type == Test_Type_E320_XG:
+        run_E320_tests_for_single_10G(path, addr, 10, 30)
+        run_E320_tests_for_single_10G_long_duration(path, addr, 2, 600)
+
+    end_time = time.time()
+    elapsed = end_time - start_time
+    print("Elapsed time: {}".format(datetime.timedelta(seconds=elapsed)))
+    return True
+
+if __name__ == "__main__":
+    sys.exit(not main())
diff --git a/host/tests/streaming_performance/run_N3xx_max_rate_tests.py b/host/tests/streaming_performance/run_N3xx_max_rate_tests.py
new file mode 100755
index 000000000..62010e3b8
--- /dev/null
+++ b/host/tests/streaming_performance/run_N3xx_max_rate_tests.py
@@ -0,0 +1,648 @@
+#!/usr/bin/env python3
+"""
+Copyright 2019 Ettus Research, A National Instrument Brand
+
+SPDX-License-Identifier: GPL-3.0-or-later
+
+Runs streaming tests for N3xx at rates in the neighborhoood of the maximum
+rate that UHD can sustain. Each test consists of a batch of runs of the
+benchmark rate C++ example with different streaming parameters.
+
+To run all the tests, execute it with all supported options for the test_type
+parameter:
+    N310_XG      Runs N310 tests with single and dual 10 GbE links
+    N310_Liberio Runs N310 tests with Liberio
+
+Example usage:
+run_N3xx_max_rate_tests.py --path <benchmark_rate_dir>/benchmark_rate --addr 192.168.10.2 --second_addr 192.168.20.2 --test_type N310_XG
+"""
+import argparse
+import sys
+import time
+import datetime
+import batch_run_benchmark_rate
+
+Test_Type_N310_XG = "N310_XG"
+Test_Type_N310_Liberio = "N310_Liberio"
+
+test_type_list = [Test_Type_N310_XG, Test_Type_N310_Liberio]
+
+def parse_args():
+    """
+    Parse command line arguments
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--path",
+        type=str,
+        required=True,
+        help="path to benchmark rate example")
+    parser.add_argument(
+        "--test_type",
+        type=str,
+        required=True,
+        choices=test_type_list,
+        help="path to benchmark rate example")
+    parser.add_argument(
+        "--addr",
+        type=str,
+        default = "",
+        help="address of first 10 GbE interface")
+    parser.add_argument(
+        "--second_addr",
+        type=str,
+        default = "",
+        help="address of second 10 GbE interface")
+    args = parser.parse_args()
+
+    return args.path, args.test_type, args.addr, args.second_addr
+
+def run_test(path, params, iterations, label):
+    """
+    Runs benchmark rate for the number of iterations in the command line arguments
+    """
+    print("-----------------------------------------------------------")
+    print(label + "\n")
+    results = batch_run_benchmark_rate.run(path, iterations, params)
+    stats = batch_run_benchmark_rate.calculate_stats(results)
+    print(batch_run_benchmark_rate.get_summary_string(stats, params))
+
+def run_N310_tests_for_single_10G(path, addr, iterations, duration):
+    """
+    Runs tests that are in the neighborhood of max rate for 10 GbE
+    """
+    def base_params(rate):
+        return {
+            "args" : "addr={},master_clock_rate={}".format(addr, rate),
+            "duration" : duration
+        }
+
+    # Run RX at 153.6 Msps with one channel
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    run_test(path, params, iterations, "1xRX @{}".format(rate))
+
+    # Run RX at 153.6 Msps with two channels
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,1"
+    run_test(path, params, iterations, "2xRX @{}".format(rate))
+
+    # Run TX at 153.6 Msps with one channel
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTX @{}".format(rate))
+
+    # Run TX at 153.6 Msps with two channels
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,1"
+    run_test(path, params, iterations, "2xTX @{}".format(rate))
+
+    # Run TRX at 153.6 Msps with one channel
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0"
+    params["rx_channels"] = "0"
+    run_test(path, params, iterations, "1xTRX @{}".format(rate))
+
+    # Run TRX at 153.6 Msps with two channels
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0,1"
+    params["rx_channels"] = "0,1"
+    run_test(path, params, iterations, "2xTRX @{}".format(rate))
+
+    # Run TRX at 125 Msps with two channels
+    rate = "125e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0,1"
+    params["rx_channels"] = "0,1"
+    run_test(path, params, iterations, "2xTRX @{}".format(rate))
+
+    # Run RX at 62.5 Msps with four channels
+    rate = "62.5e6"
+    params = base_params("125e6")
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xRX @{}".format(rate))
+
+    # Run TX at 62.5 Msps with four channels
+    rate = "62.5e6"
+    params = base_params("125e6")
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTX @{}".format(rate))
+
+    # Run TRX at 62.5 Msps with four channels
+    rate = "62.5e6"
+    params = base_params("125e6")
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    params["rx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTRX @{}".format(rate))
+
+def run_N310_tests_for_single_10G_long_duration(path, addr, iterations, duration):
+    """
+    Runs tests that are in the neighborhood of max rate for 10 GbE. Only include
+    a small subset of tests to run for a longer period.
+    """
+    def base_params(rate):
+        return {
+            "args" : "addr={},master_clock_rate={}".format(addr, rate),
+            "duration" : duration
+        }
+
+    rate = "153.6e6"
+
+    # Run TRX at 125 Msps with two channels
+    rate = "125e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0,1"
+    params["rx_channels"] = "0,1"
+    run_test(path, params, iterations, "2xTRX @{}".format(rate))
+
+    # Run TRX at 62.5 Msps with four channels
+    rate = "62.5e6"
+    params = base_params("125e6")
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    params["rx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTRX @{}".format(rate))
+
+def run_N310_tests_for_dual_10G(path, addr, second_addr, iterations, duration):
+    """
+    Runs tests that are in the neighborhood of max rate for dual 10 GbE
+    """
+    def base_params(rate):
+        return {
+            "args" : "addr={},second_addr={},master_clock_rate={}".format(addr, second_addr, rate),
+            "duration" : duration
+        }
+
+    # Run RX at 153.6 Msps with two channels
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,1"
+    run_test(path, params, iterations, "2xRX @{}".format(rate))
+
+    # Run TX at 153.6 Msps with two channels
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,1"
+    run_test(path, params, iterations, "2xTX @{}".format(rate))
+
+    # Run TRX at 153.6 Msps with two channels
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0,1"
+    params["rx_channels"] = "0,1"
+    run_test(path, params, iterations, "2xTRX @{}".format(rate))
+
+    # Run RX at 153.6 Msps with four channels
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xRX @{}".format(rate))
+
+    # Run TX at 153.6 Msps with four channels
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTX @{}".format(rate))
+
+    # Run TRX at 153.6 Msps with four channels
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    params["rx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTRX @{}".format(rate))
+
+    # Run RX at 125 Msps with four channels
+    rate = "125e6"
+    params = base_params(rate)
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xRX @{}".format(rate))
+
+    # Run TX at 125 Msps with four channels
+    rate = "125e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTX @{}".format(rate))
+
+    # Run TRX at 125 Msps with four channels
+    rate = "125e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    params["rx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTRX @{}".format(rate))
+
+def run_N310_tests_for_dual_10G_long_duration(path, addr, second_addr, iterations, duration):
+    """
+    Runs tests that are in the neighborhood of max rate for dual 10 GbE. Only include
+    a small subset of tests to run for a longer period.
+    """
+    def base_params(rate):
+        return {
+            "args" : "addr={},second_addr={},master_clock_rate={}".format(addr, second_addr, rate),
+            "duration" : duration
+        }
+
+    # Run TRX at 122.88 Msps with four channels
+    rate = "122.88e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    params["rx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTRX @{}".format(rate))
+
+    # Run TRX at 125 Msps with four channels
+    rate = "125e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    params["rx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTRX @{}".format(rate))
+
+    # Run TRX at 153.6 Msps with four channels
+    rate = "153.6e6"
+    params = base_params(rate)
+    params["tx_rate"] = rate
+    params["rx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    params["rx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTRX @{}".format(rate))
+
+def run_N310_tests_for_Liberio_master_next(path, iterations, duration):
+    """
+    Runs tests that are in the neighborhood of max rate for Liberio
+    """
+    def base_params():
+        return {
+            "args" : "master_clock_rate=125e6",
+            "duration" : duration
+        }
+
+    # Run RX at 4.032258 Msps with one channel
+    rate = "4.032258e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    run_test(path, params, iterations, "1xRX @{}".format(rate))
+
+    # Run RX at 4.464286 Msps with one channel
+    rate = "4.464286e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    run_test(path, params, iterations, "1xRX @{}".format(rate))
+
+    # Run RX at 4.807692 Msps with one channel
+    rate = "4.807692e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    run_test(path, params, iterations, "1xRX @{}".format(rate))
+
+    # Run RX at 5.208333 Msps with one channel
+    rate = "5.208333e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    run_test(path, params, iterations, "1xRX @{}".format(rate))
+
+    # Run TX at 11.363636 Msps with one channel
+    rate = "11.363636e6"
+    params = base_params()
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTX @{}".format(rate))
+
+    # Run TX at 12.5Msps with one channel
+    rate = "12.5e6"
+    params = base_params()
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTX @{}".format(rate))
+
+    # Run TX at 13.888889 Msps with one channel
+    rate = "13.888889e6"
+    params = base_params()
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTX @{}".format(rate))
+
+    # Run TX at 15.625000 Msps with one channel
+    rate = "15.625000e6"
+    params = base_params()
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTX @{}".format(rate))
+
+    # Run TX at 17.857143 Msps with one channel
+    rate = "17.857143e6"
+    params = base_params()
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTX @{}".format(rate))
+
+    # Run TRX at 2.976190 Msps with one channel
+    rate = "2.976190e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTRX @{}".format(rate))
+
+    # Run TRX at 3.472222 Msps with one channel
+    rate = "3.472222e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTRX @{}".format(rate))
+
+    # Run TRX at 4.032258 Msps with one channel
+    rate = "4.032258e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTRX @{}".format(rate))
+
+    # Run TRX at 1.404494 Msps with two channels
+    rate = "1.404494e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,2"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,2"
+    run_test(path, params, iterations, "2xTRX @{}".format(rate))
+
+    # Run TRX at 1.760563 Msps with two channels
+    rate = "1.760563e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,2"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,2"
+    run_test(path, params, iterations, "2xTRX @{}".format(rate))
+
+    # Run TRX at 2.016129 Msps with two channels
+    rate = "2.016129e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,2"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,2"
+    run_test(path, params, iterations, "2xTRX @{}".format(rate))
+
+    # Run 4xTRX at 0.899281 Msps with one channel
+    rate = "0.899281e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,1,2,3"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTRX @{}".format(rate))
+
+    # Run 4xTRX at 1.0 Msps with one channel
+    rate = "1.0e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,1,2,3"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTRX @{}".format(rate))
+
+    # Run 4xTRX at 1.25 Msps with one channel
+    rate = "1.25e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,1,2,3"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTRX @{}".format(rate))
+
+def run_N310_tests_for_Liberio_315(path, iterations, duration):
+    """
+    Runs tests that are in the neighborhood of max rate for Liberio
+    """
+    def base_params():
+        return {
+            "args" : "master_clock_rate=125e6",
+            "duration" : duration
+        }
+
+    # Run RX at 8.928571 Msps with one channel
+    rate = "8.928571e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    run_test(path, params, iterations, "1xRX @{}".format(rate))
+
+    # Run RX at 9.615385 Msps with one channel
+    rate = "9.615385e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    run_test(path, params, iterations, "1xRX @{}".format(rate))
+
+    # Run RX at 10.416667 Msps with one channel
+    rate = "10.416667e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    run_test(path, params, iterations, "1xRX @{}".format(rate))
+
+    # Run RX at 11.363636 Msps with one channel
+    rate = "11.363636e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    run_test(path, params, iterations, "1xRX @{}".format(rate))
+
+    # Run TX at 11.363636 Msps with one channel
+    rate = "11.363636e6"
+    params = base_params()
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTX @{}".format(rate))
+
+    # Run TX at 13.888889 Msps with one channel
+    rate = "13.888889e6"
+    params = base_params()
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTX @{}".format(rate))
+
+    # Run TX at 15.625000 Msps with one channel
+    rate = "15.625000e6"
+    params = base_params()
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTX @{}".format(rate))
+
+    # Run TRX at 5.952381 Msps with one channel
+    rate = "5.952381e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTRX @{}".format(rate))
+
+    # Run TRX at 6.578947 Msps with one channel
+    rate = "6.578947e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTRX @{}".format(rate))
+
+    # Run TRX at 6.944444 Msps with one channel
+    rate = "6.944444e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTRX @{}".format(rate))
+
+    # Run TRX at 6.944444 Msps with one channel
+    rate = "6.944444e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTRX @{}".format(rate))
+
+    # Run TRX at 7.812500 Msps with one channel
+    rate = "7.812500e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTRX @{}".format(rate))
+
+    # Run TRX at 8.333333 Msps with one channel
+    rate = "8.333333e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTRX @{}".format(rate))
+
+    # Run TRX at 8.928571 Msps with one channel
+    rate = "8.928571e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0"
+    run_test(path, params, iterations, "1xTRX @{}".format(rate))
+
+    # Run 2xTRX at 0.5 Msps with one channel
+    rate = "0.5e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,2"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,2"
+    run_test(path, params, iterations, "2xTRX @{}".format(rate))
+
+    # Run 2xTRX at 0.600962 Msps with one channel
+    rate = "0.600962e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,2"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,2"
+    run_test(path, params, iterations, "2xTRX @{}".format(rate))
+
+    # Run 2xTRX at 0.702247 Msps with one channel
+    rate = "0.702247e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,2"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,2"
+    run_test(path, params, iterations, "2xTRX @{}".format(rate))
+
+    # Run 2xTRX at 0.801282 Msps with one channel
+    rate = "0.801282e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,2"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,2"
+    run_test(path, params, iterations, "2xTRX @{}".format(rate))
+
+    # Run 4xTRX at 0.244141 Msps with one channel
+    rate = "0.244141e6"
+    params = base_params()
+    params["rx_rate"] = rate
+    params["rx_channels"] = "0,1,2,3"
+    params["tx_rate"] = rate
+    params["tx_channels"] = "0,1,2,3"
+    run_test(path, params, iterations, "4xTRX @{}".format(rate))
+
+def main():
+    path, test_type, addr, second_addr = parse_args()
+    start_time = time.time()
+
+    if test_type == Test_Type_N310_XG:
+        run_N310_tests_for_single_10G(path, addr, 10, 30)
+        run_N310_tests_for_dual_10G(path, addr, second_addr, 10, 30)
+
+        run_N310_tests_for_single_10G_long_duration(path, addr, 2, 600)
+        run_N310_tests_for_dual_10G_long_duration(path, addr, second_addr, 2, 600)
+
+    if test_type == Test_Type_N310_Liberio:
+        #run_N310_tests_for_Liberio_315(path, 10, 30)
+        run_N310_tests_for_Liberio_master_next(path, 10, 30)
+
+    end_time = time.time()
+    elapsed = end_time - start_time
+    print("Elapsed time: {}".format(datetime.timedelta(seconds=elapsed)))
+    return True
+
+if __name__ == "__main__":
+    sys.exit(not main())
diff --git a/host/tests/streaming_performance/run_X3xx_max_rate_tests.py b/host/tests/streaming_performance/run_X3xx_max_rate_tests.py
new file mode 100755
index 000000000..c317ef689
--- /dev/null
+++ b/host/tests/streaming_performance/run_X3xx_max_rate_tests.py
@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""
+Copyright 2019 Ettus Research, A National Instrument Brand
+
+SPDX-License-Identifier: GPL-3.0-or-later
+
+Runs streaming tests for X3xx at rates in the neighborhoood of the maximum
+rate that UHD can sustain. Each test consists of a batch of runs of the
+benchmark rate C++ example with different streaming parameters.
+
+To run all the tests, execute it with all supported options for the test_type
+parameter:
+    X3xx_XG   Runs tests with single and dual 10 GbE links
+    TwinRX_XG Runs TwinRX tests with single and dual 10 GbE links
+
+Example usage:
+run_X3xx_max_rate_tests.py --path <benchmark_rate_dir>/benchmark_rate --addr 192.168.30.2 --second_addr 192.168.40.2 --test_type X3xx_XG
+"""
+import argparse
+import sys
+import time
+import datetime
+import batch_run_benchmark_rate
+
+Test_Type_X3xx_XG = "X3xx_XG"
+Test_Type_TwinRX_XG = "TwinRX_XG"
+
+test_type_list = [Test_Type_X3xx_XG, Test_Type_TwinRX_XG]
+
+def parse_args():
+    """
+    Parse command line arguments
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--path",
+        type=str,
+        required=True,
+        help="path to benchmark rate example")
+    parser.add_argument(
+        "--test_type",
+        type=str,
+        required=True,
+        choices=test_type_list,
+        help="path to benchmark rate example")
+    parser.add_argument(
+        "--addr",
+        type=str,
+        default = "",
+        help="address of first 10 GbE interface")
+    parser.add_argument(
+        "--second_addr",
+        type=str,
+        default = "",
+        help="address of second 10 GbE interface")
+    args = parser.parse_args()
+
+    return args.path, args.test_type, args.addr, args.second_addr
+
+def run_test(path, params, iterations, label):
+    """
+    Runs benchmark rate for the number of iterations in the command line arguments.
+    """
+    print("-----------------------------------------------------------")
+    print(label + "\n")
+    results = batch_run_benchmark_rate.run(path, iterations, params)
+    stats = batch_run_benchmark_rate.calculate_stats(results)
+    print(batch_run_benchmark_rate.get_summary_string(stats))
+
+def run_tests_for_single_10G(path, addr, iterations, duration):
+    base_params = {
+        "args" : "addr={}".format(addr),
+        "duration" : duration
+    }
+
+    rx_params = base_params.copy()
+
+    # Run 200 Msps RX with one channel
+    rx_params["rx_rate"] = "200e6"
+    rx_params["rx_channels"] = "0"
+    run_test(path, rx_params, iterations, "1xRX @200 Msps")
+
+    # Run 100 Msps with two channels
+    rx_params["rx_rate"] = "100e6"
+    rx_params["rx_channels"] = "0,1"
+    run_test(path, rx_params, iterations, "2xRX @100 Msps")
+
+    tx_params = base_params.copy()
+
+    # Run 200 Msps TX with one channel
+    tx_params["tx_rate"] = "200e6"
+    tx_params["tx_channels"] = "0"
+    run_test(path, tx_params, iterations, "1xTX @200 Msps")
+
+    # Run 100 Msps TX with two channels
+    tx_params["tx_rate"] = "100e6"
+    tx_params["tx_channels"] = "0,1"
+    run_test(path, tx_params, iterations, "2xTX @100 Msps")
+
+    trx_params = base_params.copy()
+
+    # Run 200 Msps TRX with one channel
+    trx_params["tx_rate"] = "200e6"
+    trx_params["rx_rate"] = "200e6"
+    trx_params["tx_channels"] = "0"
+    trx_params["rx_channels"] = "0"
+    run_test(path, trx_params, iterations, "1xTRX @200Msps")
+
+    # Run 100 Msps TRX with two channels
+    trx_params["tx_rate"] = "100e6"
+    trx_params["rx_rate"] = "100e6"
+    trx_params["tx_channels"] = "0,1"
+    trx_params["rx_channels"] = "0,1"
+    run_test(path, trx_params, iterations, "2xTRX @100Msps")
+
+def run_tests_for_dual_10G(path, addr, second_addr, iterations, duration):
+    base_params = {
+        "args" : "addr={},second_addr={},skip_dram=1,enable_tx_dual_eth=1".format(addr, second_addr),
+        "duration" : duration
+    }
+
+    rx_params = base_params.copy()
+
+    # Run 200 Msps with two channels
+    rx_params["rx_rate"] = "200e6"
+    rx_params["rx_channels"] = "0,1"
+    run_test(path, rx_params, iterations, "2xRX @200 Msps")
+
+    tx_params = base_params.copy()
+
+    # Run 200 Msps TX with two channels
+    tx_params["tx_rate"] = "200e6"
+    tx_params["tx_channels"] = "0,1"
+    run_test(path, tx_params, iterations, "2xTX @200 Msps")
+
+    trx_params = base_params.copy()
+
+    # Run 100 Msps TRX with two channels
+    trx_params["tx_rate"] = "200e6"
+    trx_params["rx_rate"] = "200e6"
+    trx_params["tx_channels"] = "0,1"
+    trx_params["rx_channels"] = "0,1"
+    run_test(path, trx_params, iterations, "2xTRX @200Msps")
+
+def run_tests_for_single_10G_Twin_RX(path, addr, iterations, duration):
+    base_params = {
+        "args" : "addr={}".format(addr),
+        "duration" : duration
+    }
+
+    rx_params = base_params.copy()
+
+    # Run 100 Msps with three channels
+    rx_params["rx_rate"] = "100e6"
+    rx_params["rx_channels"] = "0,1,2"
+    run_test(path, rx_params, iterations, "3xRX @100 Msps")
+
+    # Run 50 Msps with four channels
+    rx_params["rx_rate"] = "50e6"
+    rx_params["rx_channels"] = "0,1,2,3"
+    run_test(path, rx_params, iterations, "4xRX @50 Msps")
+
+def run_tests_for_dual_10G_Twin_RX(path, addr, second_addr, iterations, duration):
+    base_params = {
+        "args" : "addr={},second_addr={}".format(addr, second_addr),
+        "duration" : duration
+    }
+
+    rx_params = base_params.copy()
+
+    # Run 100 Msps with four channels
+    rx_params["rx_rate"] = "100e6"
+    rx_params["rx_channels"] = "0,1,2,3"
+    run_test(path, rx_params, iterations, "4xRX @100 Msps")
+
+
+def main():
+    path, test_type, addr, second_addr = parse_args()
+    start_time = time.time()
+
+    if test_type == Test_Type_X3xx_XG:
+        # Run 10 test iterations for 60 seconds each
+        run_tests_for_single_10G(path, addr, 10, 60)
+        run_tests_for_dual_10G(path, addr, second_addr, 10, 60)
+
+        # Run 2 test iterations for 600 seconds each
+        run_tests_for_single_10G(path, addr, 2, 600)
+        run_tests_for_dual_10G(path, addr, second_addr, 2, 600)
+
+    if test_type == Test_Type_TwinRX_XG:
+        # Run 10 test iterations for 60 seconds each
+        run_tests_for_single_10G_Twin_RX(path, addr, 10, 60)
+        run_tests_for_dual_10G_Twin_RX(path, addr, second_addr, 10, 60)
+
+        # Run 2 test iterations for 600 seconds each
+        run_tests_for_single_10G_Twin_RX(path, addr, 2, 600)
+        run_tests_for_dual_10G_Twin_RX(path, addr, second_addr, 2, 600)
+
+    end_time = time.time()
+    elapsed = end_time - start_time
+    print("Elapsed time: {}".format(datetime.timedelta(seconds=elapsed)))
+    return True
+
+if __name__ == "__main__":
+    sys.exit(not main())