rfnoc: add rx and tx transports, and amend rfnoc_graph

transports:

Transports build on I/O service and implements flow control and
sequence number checking.

The rx streamer subclass extends the streamer implementation to connect
it to the rfnoc graph. It receives configuration values from property
propagation and configures the streamer accordingly. It also implements
the issue_stream_cmd rx_streamer API method.

Add implementation of rx streamer creation and method to connect it to
an rfnoc block.

rfnoc_graph: Cache more connection info, clarify contract

Summary of changes:
- rfnoc_graph stores more information about static connections at the
  beginning. Some search algorithms are replaced by simpler lookups.
- The contract for connect() was clarified. It is required to call
  connect, even for static connections.

1 files changed, 99 insertions, 0 deletions

diff --git a/host/lib/include/uhdlib/rfnoc/tx_flow_ctrl_state.hpp b/host/lib/include/uhdlib/rfnoc/tx_flow_ctrl_state.hpp
new file mode 100644
index 000000000..65fc1b093
--- /dev/null
+++ b/host/lib/include/uhdlib/rfnoc/tx_flow_ctrl_state.hpp
@@ -0,0 +1,99 @@
+//
+// Copyright 2019 Ettus Research, a National Instruments Brand
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_LIBUHD_RFNOC_TX_FLOW_CTRL_STATE_HPP
+#define INCLUDED_LIBUHD_RFNOC_TX_FLOW_CTRL_STATE_HPP
+
+#include <uhdlib/rfnoc/rfnoc_common.hpp>
+
+namespace uhd { namespace rfnoc {
+
+//! Class to manage tx flow control state
+class tx_flow_ctrl_state
+{
+public:
+    //! Updates destination capacity
+    void set_dest_capacity(const stream_buff_params_t& capacity)
+    {
+        _dest_capacity = capacity;
+    }
+
+    //! Updates destination received count
+    void update_dest_recv_count(const stream_buff_params_t& recv_count)
+    {
+        _recv_counts = recv_count;
+    }
+
+    /*! Returns whether the destination has buffer space for the requested
+     *  packet size
+     */
+    bool dest_has_space(const size_t packet_size)
+    {
+        // The stream endpoint only cares about bytes, the packet count is not
+        // important to determine the space available.
+        const auto buffer_fullness = _xfer_counts.bytes - _recv_counts.bytes;
+        const auto space_available = _dest_capacity.bytes - buffer_fullness;
+        return space_available >= packet_size;
+    }
+
+    //! Increments transfer count with amount of data sent
+    void data_sent(const size_t packet_size)
+    {
+        _xfer_counts.bytes += packet_size;
+        _xfer_counts.packets++;
+
+        // Request an fc resync after we have transferred a number of bytes >=
+        // to the destination capacity. There is no strict requirement on how
+        // often we need to send this, as it is only needed to correct for
+        // dropped packets. One buffer's worth of bytes is probably a good
+        // cadence.
+        if (_xfer_counts.bytes - _last_fc_resync_bytes >= _dest_capacity.bytes) {
+            _fc_resync_req = true;
+        }
+    }
+
+    /*! Returns whether an fc resync request is pending. The policy we use
+     * here is to send an fc resync every time we send a number of bytes
+     * equal to the destination buffer capacity.
+     */
+    bool get_fc_resync_req_pending() const
+    {
+        return _fc_resync_req;
+    }
+
+    //! Clears fc resync request pending status
+    void clear_fc_resync_req_pending()
+    {
+        _fc_resync_req = false;
+        _last_fc_resync_bytes = _xfer_counts.bytes;
+    }
+
+    //! Returns counts for packets sent
+    stream_buff_params_t get_xfer_counts() const
+    {
+        return _xfer_counts;
+    }
+
+private:
+    // Counts for data sent
+    stream_buff_params_t _xfer_counts{0, 0};
+
+    // Counts for data received by the destination
+    stream_buff_params_t _recv_counts{0, 0};
+
+    // Buffer size at the destination
+    stream_buff_params_t _dest_capacity{0, 0};
+
+    // Counts sent in last flow control resync
+    size_t _last_fc_resync_bytes = 0;
+
+    // Track when to send ack packets
+    bool _fc_resync_req = false;
+};
+
+}} // namespace uhd::rfnoc
+
+#endif /* INCLUDED_LIBUHD_RFNOC_TX_FLOW_CTRL_STATE_HPP */