uhd: Changes to traffic counter register names

This makes the noc traffic counter register actually reflect the
registers in the FPGA. The FPGA register names were changed prior to
merging to master, and the ready count registers were removed.

2 files changed, 62 insertions, 78 deletions

diff --git a/host/examples/benchmark_streamer.cpp b/host/examples/benchmark_streamer.cpp
index 2327b7230..eb0b91d0f 100644
--- a/host/examples/benchmark_streamer.cpp
+++ b/host/examples/benchmark_streamer.cpp
@@ -24,21 +24,17 @@ namespace po = boost::program_options;
 struct traffic_counter_values {
     uint64_t clock_cycles;
 
-    uint64_t xbar_to_shell_last;
-    uint64_t xbar_to_shell_valid;
-    uint64_t xbar_to_shell_ready;
+    uint64_t xbar_to_shell_xfer_count;
+    uint64_t xbar_to_shell_pkt_count;
 
-    uint64_t shell_to_xbar_last;
-    uint64_t shell_to_xbar_valid;
-    uint64_t shell_to_xbar_ready;
+    uint64_t shell_to_xbar_xfer_count;
+    uint64_t shell_to_xbar_pkt_count;
 
-    uint64_t shell_to_ce_last;
-    uint64_t shell_to_ce_valid;
-    uint64_t shell_to_ce_ready;
+    uint64_t shell_to_ce_xfer_count;
+    uint64_t shell_to_ce_pkt_count;
 
-    uint64_t ce_to_shell_last;
-    uint64_t ce_to_shell_valid;
-    uint64_t ce_to_shell_ready;
+    uint64_t ce_to_shell_xfer_count;
+    uint64_t ce_to_shell_pkt_count;
 };
 
 struct host_measurement_values {
@@ -76,21 +72,17 @@ traffic_counter_values read_traffic_counters(
     traffic_counter_values vals;
     vals.clock_cycles = tree->access<uint64_t>(root/"bus_clock_ticks").get();
 
-    vals.xbar_to_shell_last  = tree->access<uint64_t>(root/"xbar_to_shell_last").get();
-    vals.xbar_to_shell_valid = tree->access<uint64_t>(root/"xbar_to_shell_valid").get();
-    vals.xbar_to_shell_ready = tree->access<uint64_t>(root/"xbar_to_shell_ready").get();
+    vals.xbar_to_shell_pkt_count  = tree->access<uint64_t>(root/"xbar_to_shell_pkt_count").get();
+    vals.xbar_to_shell_xfer_count = tree->access<uint64_t>(root/"xbar_to_shell_xfer_count").get();
 
-    vals.shell_to_xbar_last  = tree->access<uint64_t>(root/"shell_to_xbar_last").get();
-    vals.shell_to_xbar_valid = tree->access<uint64_t>(root/"shell_to_xbar_valid").get();
-    vals.shell_to_xbar_ready = tree->access<uint64_t>(root/"shell_to_xbar_ready").get();
+    vals.shell_to_xbar_pkt_count  = tree->access<uint64_t>(root/"shell_to_xbar_pkt_count").get();
+    vals.shell_to_xbar_xfer_count = tree->access<uint64_t>(root/"shell_to_xbar_xfer_count").get();
 
-    vals.shell_to_ce_last  = tree->access<uint64_t>(root/"shell_to_ce_last").get();
-    vals.shell_to_ce_valid = tree->access<uint64_t>(root/"shell_to_ce_valid").get();
-    vals.shell_to_ce_ready = tree->access<uint64_t>(root/"shell_to_ce_ready").get();
+    vals.shell_to_ce_pkt_count  = tree->access<uint64_t>(root/"shell_to_ce_pkt_count").get();
+    vals.shell_to_ce_xfer_count = tree->access<uint64_t>(root/"shell_to_ce_xfer_count").get();
 
-    vals.ce_to_shell_last  = tree->access<uint64_t>(root/"ce_to_shell_last").get();
-    vals.ce_to_shell_valid = tree->access<uint64_t>(root/"ce_to_shell_valid").get();
-    vals.ce_to_shell_ready = tree->access<uint64_t>(root/"ce_to_shell_ready").get();
+    vals.ce_to_shell_pkt_count  = tree->access<uint64_t>(root/"ce_to_shell_pkt_count").get();
+    vals.ce_to_shell_xfer_count = tree->access<uint64_t>(root/"ce_to_shell_xfer_count").get();
 
     return vals;
 }
@@ -100,35 +92,31 @@ void print_traffic_counters(
 ) {
     std::cout << "Clock cycles:        " << vals.clock_cycles << std::endl;
 
-    std::cout << "Xbar to shell last:  " << vals.xbar_to_shell_last << std::endl;
-    std::cout << "Xbar to shell valid: " << vals.xbar_to_shell_valid << std::endl;
-    std::cout << "Xbar to shell ready: " << vals.xbar_to_shell_ready << std::endl;
+    std::cout << "Xbar to shell pkt count:  " << vals.xbar_to_shell_pkt_count << std::endl;
+    std::cout << "Xbar to shell xfer count: " << vals.xbar_to_shell_xfer_count << std::endl;
 
-    std::cout << "Shell to xbar last:  " << vals.shell_to_xbar_last << std::endl;
-    std::cout << "Shell to xbar valid: " << vals.shell_to_xbar_valid << std::endl;
-    std::cout << "Shell to xbar ready: " << vals.shell_to_xbar_ready << std::endl;
+    std::cout << "Shell to xbar pkt count:  " << vals.shell_to_xbar_pkt_count << std::endl;
+    std::cout << "Shell to xbar xfer count: " << vals.shell_to_xbar_xfer_count << std::endl;
 
-    std::cout << "Shell to CE last:    " << vals.shell_to_ce_last << std::endl;
-    std::cout << "Shell to CE valid:   " << vals.shell_to_ce_valid << std::endl;
-    std::cout << "Shell to CE ready:   " << vals.shell_to_ce_ready << std::endl;
+    std::cout << "Shell to CE pkt count:    " << vals.shell_to_ce_pkt_count << std::endl;
+    std::cout << "Shell to CE xfer count:   " << vals.shell_to_ce_xfer_count << std::endl;
 
-    std::cout << "CE to shell last:    " << vals.ce_to_shell_last << std::endl;
-    std::cout << "CE to shell valid:   " << vals.ce_to_shell_valid << std::endl;
-    std::cout << "CE to shell ready:   " << vals.ce_to_shell_ready << std::endl;
+    std::cout << "CE to shell pkt count:    " << vals.ce_to_shell_pkt_count << std::endl;
+    std::cout << "CE to shell xfer count:   " << vals.ce_to_shell_xfer_count << std::endl;
 }
 
 void print_rx_statistics(
     const traffic_counter_values& vals,
     const double bus_clk_freq
 ) {
-    double bus_time_elapsed = vals.clock_cycles / bus_clk_freq;
-    uint64_t num_ce_packets_read = vals.ce_to_shell_last;
-    uint64_t num_ce_samples_read = (vals.ce_to_shell_valid - num_ce_packets_read)*2;
+    const double bus_time_elapsed = vals.clock_cycles / bus_clk_freq;
+    const uint64_t num_ce_packets_read = vals.ce_to_shell_pkt_count;
+    const uint64_t num_ce_samples_read = (vals.ce_to_shell_xfer_count - num_ce_packets_read)*2;
 
-    uint64_t num_non_data_packets_read = vals.shell_to_xbar_last - num_ce_packets_read;
-    double rx_data_packet_ratio = (double)num_ce_packets_read/num_non_data_packets_read;
+    const uint64_t num_non_data_packets_read = vals.shell_to_xbar_pkt_count - num_ce_packets_read;
+    const double rx_data_packet_ratio = (double)num_ce_packets_read/num_non_data_packets_read;
 
-    double calculated_throughput = num_ce_samples_read/bus_time_elapsed;
+    const double calculated_throughput = num_ce_samples_read/bus_time_elapsed;
 
     std::cout << "Time elapsed:          " << bus_time_elapsed << " s" << std::endl;
     std::cout << "Samples read:          " << num_ce_samples_read << std::endl;
@@ -141,14 +129,14 @@ void print_tx_statistics(
     const traffic_counter_values& vals,
     const double bus_clk_freq
 ) {
-    double bus_time_elapsed = vals.clock_cycles / bus_clk_freq;
-    uint64_t num_ce_packets_written = vals.shell_to_ce_last;
-    uint64_t num_ce_samples_written = (vals.shell_to_ce_valid - num_ce_packets_written)*2;
+    const double bus_time_elapsed = vals.clock_cycles / bus_clk_freq;
+    const uint64_t num_ce_packets_written = vals.shell_to_ce_pkt_count;
+    const uint64_t num_ce_samples_written = (vals.shell_to_ce_xfer_count - num_ce_packets_written)*2;
 
-    uint64_t num_non_data_packets_written = vals.xbar_to_shell_last - num_ce_packets_written;
-    double tx_data_packet_ratio = (double)num_ce_packets_written/num_non_data_packets_written;
+    const uint64_t num_non_data_packets_written = vals.xbar_to_shell_pkt_count - num_ce_packets_written;
+    const double tx_data_packet_ratio = (double)num_ce_packets_written/num_non_data_packets_written;
 
-    double calculated_throughput = num_ce_samples_written/bus_time_elapsed;
+    const double calculated_throughput = num_ce_samples_written/bus_time_elapsed;
 
     std::cout << "Time elapsed:          " << bus_time_elapsed << " s" << std::endl;
     std::cout << "Samples written:       " << num_ce_samples_written << std::endl;
@@ -160,15 +148,15 @@ void print_tx_statistics(
 void print_utilization_statistics(
     const traffic_counter_values& vals
 ) {
-    double rx_data_cycles = vals.ce_to_shell_valid - vals.ce_to_shell_last;
-    double rx_idle_cycles = vals.clock_cycles - vals.shell_to_xbar_valid;
-    double rx_data_header_cycles = vals.ce_to_shell_last;
-    double rx_other_cycles = vals.shell_to_xbar_valid - vals.ce_to_shell_valid;
+    const double rx_data_cycles = vals.ce_to_shell_xfer_count - vals.ce_to_shell_pkt_count;
+    const double rx_idle_cycles = vals.clock_cycles - vals.shell_to_xbar_xfer_count;
+    const double rx_data_header_cycles = vals.ce_to_shell_pkt_count;
+    const double rx_other_cycles = vals.shell_to_xbar_xfer_count - vals.ce_to_shell_xfer_count;
 
-    double rx_data_util = rx_data_cycles / vals.clock_cycles*100;
-    double rx_idle_util = rx_idle_cycles / vals.clock_cycles*100;
-    double rx_data_header_util = rx_data_header_cycles / vals.clock_cycles * 100;
-    double rx_other_util = rx_other_cycles / vals.clock_cycles * 100;
+    const double rx_data_util = rx_data_cycles / vals.clock_cycles*100;
+    const double rx_idle_util = rx_idle_cycles / vals.clock_cycles*100;
+    const double rx_data_header_util = rx_data_header_cycles / vals.clock_cycles * 100;
+    const double rx_other_util = rx_other_cycles / vals.clock_cycles * 100;
 
     std::cout << "RX utilization:" << std::endl;
     std::cout << "   data:        " << rx_data_util << " %" << std::endl;
@@ -177,15 +165,15 @@ void print_utilization_statistics(
     std::cout << "   other:       " << rx_other_util << " % (flow control, register I/O)" << std::endl;
     std::cout << std::endl;
 
-    double tx_data_cycles = vals.shell_to_ce_valid - vals.shell_to_ce_last;
-    double tx_idle_cycles = vals.clock_cycles - vals.xbar_to_shell_valid;
-    double tx_data_header_cycles = vals.shell_to_ce_last;
-    double tx_other_cycles = vals.xbar_to_shell_valid - vals.shell_to_ce_valid;
+    const double tx_data_cycles = vals.shell_to_ce_xfer_count - vals.shell_to_ce_pkt_count;
+    const double tx_idle_cycles = vals.clock_cycles - vals.xbar_to_shell_xfer_count;
+    const double tx_data_header_cycles = vals.shell_to_ce_pkt_count;
+    const double tx_other_cycles = vals.xbar_to_shell_xfer_count - vals.shell_to_ce_xfer_count;
 
-    double tx_data_util = tx_data_cycles / vals.clock_cycles*100;
-    double tx_idle_util = tx_idle_cycles / vals.clock_cycles*100;
-    double tx_data_header_util = tx_data_header_cycles / vals.clock_cycles * 100;
-    double tx_other_util = tx_other_cycles / vals.clock_cycles * 100;
+    const double tx_data_util = tx_data_cycles / vals.clock_cycles*100;
+    const double tx_idle_util = tx_idle_cycles / vals.clock_cycles*100;
+    const double tx_data_header_util = tx_data_header_cycles / vals.clock_cycles * 100;
+    const double tx_other_util = tx_other_cycles / vals.clock_cycles * 100;
 
     std::cout << "TX utilization:" << std::endl;
     std::cout << "   data:        " << tx_data_util << " %" << std::endl;
@@ -223,7 +211,7 @@ void print_rx_results(
 
 void print_tx_results(
     const test_results& results,
-    double bus_clk_freq
+    const double bus_clk_freq
 ) {
     std::cout << "------------------------------------------------------------------" << std::endl;
     std::cout << "------------------- Benchmarking tx stream -----------------------" << std::endl;
@@ -523,7 +511,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
     po::notify(vm);
 
     //print the help message
-    bool at_least_one_test_specified =
+    const bool at_least_one_test_specified =
         rx_duration != 0.0 or tx_duration != 0.0 or
         dual_rx_duration != 0.0 or dual_tx_duration != 0.0 or
         full_duplex_duration != 0.0 or dual_full_duplex_duration != 0.0;
diff --git a/host/include/uhd/rfnoc/traffic_counter.hpp b/host/include/uhd/rfnoc/traffic_counter.hpp
index 4077596cd..bff04e38e 100644
--- a/host/include/uhd/rfnoc/traffic_counter.hpp
+++ b/host/include/uhd/rfnoc/traffic_counter.hpp
@@ -50,18 +50,14 @@ public:
 
             const char* counters[] = {
                 "bus_clock_ticks",
-                "xbar_to_shell_last",
-                "xbar_to_shell_valid",
-                "xbar_to_shell_ready",
-                "shell_to_xbar_last",
-                "shell_to_xbar_valid",
-                "shell_to_xbar_ready",
-                "shell_to_ce_last",
-                "shell_to_ce_valid",
-                "shell_to_ce_ready",
-                "ce_to_shell_last",
-                "ce_to_shell_valid",
-                "ce_to_shell_ready"};
+                "xbar_to_shell_xfer_count",
+                "xbar_to_shell_pkt_count",
+                "shell_to_xbar_xfer_count",
+                "shell_to_xbar_pkt_count",
+                "shell_to_ce_xfer_count",
+                "shell_to_ce_pkt_count",
+                "ce_to_shell_xfer_count",
+                "ce_to_shell_pkt_count"};
 
             for (size_t i = 0; i < std::extent<decltype(counters)>::value; i++) {
                 tree->create<uint64_t>(root_path/"traffic_counter"/counters[i])