|
| | noc_block_base (make_args_ptr make_args) |
| |
| void | set_num_input_ports (const size_t num_ports) |
| |
| void | set_num_output_ports (const size_t num_ports) |
| |
| void | set_tick_rate (const double tick_rate) |
| |
| void | set_mtu_forwarding_policy (const forwarding_policy_t policy) |
| |
| void | set_mtu (const res_source_info &edge, const size_t new_mtu) |
| |
| property_base_t * | get_mtu_prop_ref (const res_source_info &edge) |
| |
| virtual void | deinit () |
| |
| void | register_property (property_base_t *prop, resolve_callback_t &&clean_callback=nullptr) |
| |
| void | add_property_resolver (prop_ptrs_t &&inputs, prop_ptrs_t &&outputs, resolver_fn_t &&resolver_fn) |
| |
| void | set_prop_forwarding_policy (forwarding_policy_t policy, const std::string &prop_id="") |
| |
| void | set_prop_forwarding_map (const forwarding_map_t &map) |
| |
| template<typename prop_data_t > |
| void | set_property (const std::string &id, const prop_data_t &val, const res_source_info &src_info) |
| |
| template<typename prop_data_t > |
| const prop_data_t & | get_property (const std::string &id, const res_source_info &src_info) |
| |
| void | register_action_handler (const std::string &id, action_handler_t &&handler) |
| |
| void | set_action_forwarding_policy (forwarding_policy_t policy, const std::string &action_key="") |
| |
| void | set_action_forwarding_map (const forwarding_map_t &map) |
| |
| void | post_action (const res_source_info &edge_info, action_info::sptr action) |
| |
| virtual bool | check_topology (const std::vector< size_t > &connected_inputs, const std::vector< size_t > &connected_outputs) |
| |
| void | update_reg_iface (register_iface::sptr new_iface=nullptr) |
| |
The primary interface to a NoC block in the FPGA
The block supports three types of data access:
- Low-level register access
- High-level property access
- Action execution
The main difference between this class and its parent is the direct access to registers, and the NoC&block IDs.
| virtual void uhd::rfnoc::noc_block_base::deinit |
( |
| ) |
|
|
protectedvirtual |
Safely de-initialize the block
This function is called by the framework when the RFNoC session is about to finish to allow blocks to safely perform actions to shut down a block. For example, if your block is producing samples, like a radio or signal generator, this is a good place to issue a "stop" command.
After this function is called, register access is no more possible. So make sure not to interact with regs() after this was called. Future access to regs() won't throw, but will print error messages and do nothing.
The rationale for having this separate from the destructor is because rfnoc_graph allows exporting references to blocks, and this function ensures that blocks are safely shut down when the rest of the device control goes away.
| size_t uhd::rfnoc::noc_block_base::get_max_payload_size |
( |
const res_source_info & |
edge, |
|
|
const bool |
account_for_ts = true |
|
) |
| |
Return the maximum usable payload size on a given edge, in bytes.
This is very similar to get_mtu(), except it also accounts for the header.
Example: Say the MTU on a given edge is 8192 bytes. The CHDR width is 64 bits. If we wanted to add a timestamp, we would thus require 16 bytes for the total header, leaving only 8192-16=8176 bytes for a payload, which is what this function would return. The same MTU, with a CHDR width of 512 bits however, would require leaving 64 bytes for the header (regardless of whether or not a timestamp is included). In that case, this function would return 8192-64=8128 bytes max payload size.
- Parameters
-
| edge | The edge on which the max payload size is queried. edge.type must be INPUT_EDGE or OUTPUT_EDGE! See also get_mtu(). |
| account_for_ts | If true (default), the assumption is that we reserve space for a timestamp. It is possible to increase the payload if no timestamp is used (only for 64 bit CHDR widths!), however, this is advanced usage and should only be used in special circumstances, as downstream blocks might not be able to handle such packets. |
- Returns
- the max payload size as determined by the overall graph on this edge, as well as the CHDR width.
- Exceptions
-
| std::shared_ptr<mb_controller> uhd::rfnoc::noc_block_base::get_mb_controller |
( |
| ) |
|
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 motherboard. In order to gain access to the motherboard, the block needs to have requested access to the motherboard during the registration procedure. See also registry.hpp.
Even if this block requested access to the motherboard controller, there is no guarantee that UHD will honour that request. It is therefore important to verify that the returned pointer is valid.
Return the current MTU on a given edge
Note: The MTU is the maximum size of a CHDR packet, including header. In order to find out the maximum payload size, calling get_max_payload_size() is the recommended alternative.
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.
- Parameters
-
| 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
- Exceptions
-
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.
The reference is guaranteed to remain valid for the lifetime of this block.
| size_t uhd::rfnoc::noc_block_base::get_num_input_ports |
( |
| ) |
const |
|
inlineoverridevirtual |
Number of input ports. Note: This gets passed into this block from the information stored in the global register space.
Note: This may be overridden by the block (e.g., the X300 radio may not have all ports available if no TwinRX board is plugged in), but the subclassed version may never report more ports than this.
Implements uhd::rfnoc::node_t.
| size_t uhd::rfnoc::noc_block_base::get_num_output_ports |
( |
| ) |
const |
|
inlineoverridevirtual |
Number of output ports. Note: This gets passed into this block from the information stored in the global register space.
Note: This may be overridden by the block (e.g., the X300 radio may not have all ports available if no TwinRX board is plugged in), but the subclassed version may never report more ports than this.
Implements uhd::rfnoc::node_t.
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 ONE_TO_ONE.
Note: The MTU forwarding policy can only be set once, and only during construction of a noc_block_base. If an RFNoC block subclassing noc_block_base wants to modify the MTU forwarding policy, it must call this function in its constructor. Once set, however, the MTU forwarding policy cannot be changed. This represents a change in behaviour from UHD 4.0. Violations of this restriction will result in a uhd::runtime_error being thrown.
Public Types inherited from uhd::rfnoc::node_t
1.8.13