rfnoc: Add MTU tracking

MTUs are now tracked through the framework for all childs of
noc_block_base. Every edge gets an 'mtu' property. MTU can be set and
get either through the prop API, or through new API calls (get_mtu(),
set_mtu()). It is also possible to create custom properties that depend
on the MTU by asking for a reference to the MTU property, and then
adding that to the input list of a property resolver.

The radio_control_impl includes a change in this commit where it sets
the spp based on the MTU.

Blocks can also set an MTU forwarding policy. The DDC block includes a
change in this commit that sets a forwarding policy of ONE_TO_ONE,
meaning that the MTU on an input edge is forwarded to the corresponding
output edge (but not the other edges, as with the tick rate).

4 files changed, 74 insertions, 0 deletions

diff --git a/host/include/uhd/rfnoc/defaults.hpp b/host/include/uhd/rfnoc/defaults.hpp
index e1046ada2..99ac9791f 100644
--- a/host/include/uhd/rfnoc/defaults.hpp
+++ b/host/include/uhd/rfnoc/defaults.hpp
@@ -21,6 +21,7 @@ static const std::string PROP_KEY_TYPE("type");
 static const std::string PROP_KEY_FREQ("freq");
 static const std::string PROP_KEY_TICK_RATE("tick_rate");
 static const std::string PROP_KEY_SPP("spp");
+static const std::string PROP_KEY_MTU("mtu");
 
 static const std::string NODE_ID_SEP("SEP");
 
diff --git a/host/include/uhd/rfnoc/noc_block_base.hpp b/host/include/uhd/rfnoc/noc_block_base.hpp
index 485b2c8a3..4a8d2965f 100644
--- a/host/include/uhd/rfnoc/noc_block_base.hpp
+++ b/host/include/uhd/rfnoc/noc_block_base.hpp
@@ -98,6 +98,20 @@ public:
      */
     double get_tick_rate() const;
 
+    /*! Return the current MTU on a given edge
+     *
+     * The MTU is determined by the block itself (i.e., how big of a packet can
+     * this block handle on this edge), but also the neighboring block, and
+     * possibly the transport medium between the blocks. This value can thus be
+     * lower than what the block defines as MTU, but never higher.
+     *
+     * \param edge The edge on which the MTU is queried. edge.type must be
+     *             INPUT_EDGE or OUTPUT_EDGE!
+     * \returns the MTU as determined by the overall graph on this edge
+     * \throws uhd::value_error if edge is not referring to a valid edge
+     */
+    size_t get_mtu(const res_source_info& edge);
+
     /*! Return the arguments that were passed into this block from the framework
      */
     uhd::device_addr_t get_block_args() const { return _block_args; }
@@ -143,6 +157,43 @@ protected:
      */
     void set_tick_rate(const double tick_rate);
 
+    /*! Change the way MTUs are forwarded
+     *
+     * The policy will have the following effect:
+     * - DROP: This means that the MTU of one port has no bearing on the MTU
+     *   of another port. This is usually a valid choice if the FPGA is
+     *   repacking data, for example, a block could be consuming continous
+     *   streams of data, and producing small packets of a different type.
+     * - ONE_TO_ONE: This means the MTU is passed through from input to output
+     *   and vice versa. This is typically a good choice if packets are being
+     *   passed through without modifying their size. The DDC/DUC blocks will
+     *   choose this policy, because the want to relay MTU information to the
+     *   radio.
+     * - ONE_TO_ALL: This means the MTU is being set to the same value on all
+     *   ports.
+     * - ONE_TO_FAN: This means the MTU is forwarded from any input port to
+     *   all opposite side ports. This is an appropriate policy for the
+     *   split-stream block.
+     *
+     * The default policy is DROP.
+     */
+    void set_mtu_forwarding_policy(const forwarding_policy_t policy);
+
+    /*! Update the MTU
+     *
+     * This is another data point in the MTU discovery process. This means that
+     * the MTU cannot be increased using the method, only decreased.
+     */
+    void set_mtu(const res_source_info& edge, const size_t new_mtu);
+
+    /*! Return a reference to an MTU property
+     *
+     * This can be used to make the MTU an input to a property resolver. For
+     * example, blocks that have an spp property, such as the radio, can now
+     * trigger a property resolver based on the MTU.
+     */
+    property_base_t* get_mtu_prop_ref(const res_source_info& edge);
+
     /*! Get access to the motherboard controller for this block's motherboard
      *
      * This will return a nullptr if this block doesn't have access to the
@@ -211,6 +262,16 @@ private:
     // for all in- and output edges.
     std::vector<property_t<double>> _tick_rate_props;
 
+    //! Forwarding policy for the MTU properties
+    forwarding_policy_t _mtu_fwd_policy = forwarding_policy_t::DROP;
+
+    //! Container for the 'mtu' property. This will hold one edge property
+    // for all in- and output edges.
+    std::vector<property_t<size_t> > _mtu_props;
+
+    //! The actual MTU value
+    std::unordered_map<res_source_info, size_t> _mtu;
+
     //! Reference to the ctrlport clock_iface object shared with the register_iface
     std::shared_ptr<clock_iface> _ctrlport_clock_iface;
 
diff --git a/host/include/uhd/rfnoc/noc_block_make_args.hpp b/host/include/uhd/rfnoc/noc_block_make_args.hpp
index 7ed191079..8878cc1a8 100644
--- a/host/include/uhd/rfnoc/noc_block_make_args.hpp
+++ b/host/include/uhd/rfnoc/noc_block_make_args.hpp
@@ -37,6 +37,9 @@ struct noc_block_base::make_args_t
     //! Number of output ports (gets reported from the FPGA)
     size_t num_output_ports;
 
+    //! Value of the MTU register
+    size_t mtu;
+
     //! Register interface to this block's register space
     register_iface::sptr reg_iface;
 
diff --git a/host/include/uhd/rfnoc/node.hpp b/host/include/uhd/rfnoc/node.hpp
index eaeea20af..59836fbf6 100644
--- a/host/include/uhd/rfnoc/node.hpp
+++ b/host/include/uhd/rfnoc/node.hpp
@@ -217,6 +217,15 @@ protected:
      *   property access is not violated. All properties can be read during
      *   execution, but only properties in the \p outputs list can be written
      *   to.
+     * - Resolvers are stored and executed in the same order they are added.
+     *   That is to say, if two resolvers both share a condition that will
+     *   trigger them, the first resolver to be added will be the first resolver
+     *   to be executed. This allows to make some assumptions on the order of
+     *   execution, in case resolvers have dependencies.
+     * - This method has no built-in thread safety, since it is typically only
+     *   called in the constructor. If resolvers need to be added at runtime
+     *   (which is considered advanced usage), then the block needs to serialize
+     *   access to this function itself.
      *
      * \param inputs The properties that will cause this resolver to run
      * \param outputs The properties that this resolver will write to