rfnoc_graph.hpp

Go to the documentation of this file.

//
// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
 
#pragma once
 
#include <uhd/config.hpp>
#include <uhd/rfnoc/block_id.hpp>
#include <uhd/rfnoc/graph_edge.hpp>
#include <uhd/rfnoc/noc_block_base.hpp>
#include <uhd/rfnoc/rfnoc_types.hpp>
#include <uhd/stream.hpp>
#include <uhd/transport/adapter_id.hpp>
#include <uhd/types/device_addr.hpp>
#include <uhd/types/time_spec.hpp>
#include <uhd/utils/noncopyable.hpp>
#include <boost/units/detail/utility.hpp> // for demangle
#include <memory>
#include <vector>
 
namespace uhd { namespace rfnoc {
 
class mb_controller;
 
class UHD_API rfnoc_graph : public uhd::noncopyable,
                            public std::enable_shared_from_this<rfnoc_graph>
{
public:
    using sptr = std::shared_ptr<rfnoc_graph>;
 
    virtual ~rfnoc_graph() {}
 
    /******************************************
     * Factory
     ******************************************/
    static sptr make(const device_addr_t& dev_addr);
 
    /******************************************
     * Block Discovery/Retrieval
     ******************************************/
    virtual std::vector<block_id_t> find_blocks(
        const std::string& block_id_hint) const = 0;
 
    template <typename T>
    std::vector<block_id_t> find_blocks(const std::string& block_id_hint) const
    {
        std::vector<block_id_t> all_block_ids = find_blocks(block_id_hint);
        std::vector<block_id_t> filt_block_ids;
        for (size_t i = 0; i < all_block_ids.size(); i++) {
            if (has_block<T>(all_block_ids[i])) {
                filt_block_ids.push_back(all_block_ids[i]);
            }
        }
        return filt_block_ids;
    }
 
    virtual bool has_block(const block_id_t& block_id) const = 0;
 
    template <typename T>
    bool has_block(const block_id_t& block_id) const
    {
        return has_block(block_id)
               && bool(std::dynamic_pointer_cast<T>(get_block(block_id)));
    }
 
    virtual noc_block_base::sptr get_block(const block_id_t& block_id) const = 0;
 
    template <typename T>
    std::shared_ptr<T> get_block(const block_id_t& block_id) const
    {
        std::shared_ptr<T> blk = std::dynamic_pointer_cast<T>(get_block(block_id));
        if (blk) {
            return blk;
        } else {
            throw uhd::lookup_error(
                std::string("This device does not have a block of type ")
                + boost::units::detail::demangle(typeid(T).name())
                + " with ID: " + block_id.to_string());
        }
    }
 
    /**************************************************************************
     * Connection APIs
     *************************************************************************/
    virtual bool is_connectable(const block_id_t& src_blk,
        size_t src_port,
        const block_id_t& dst_blk,
        size_t dst_port) = 0;
 
    virtual void connect(const block_id_t& src_blk,
        size_t src_port,
        const block_id_t& dst_blk,
        size_t dst_port,
        bool is_back_edge = false) = 0;
 
    virtual void connect(uhd::tx_streamer::sptr streamer,
        size_t strm_port,
        const block_id_t& dst_blk,
        size_t dst_port,
        uhd::transport::adapter_id_t adapter_id = uhd::transport::NULL_ADAPTER_ID) = 0;
 
    virtual void connect(const block_id_t& src_blk,
        size_t src_port,
        uhd::rx_streamer::sptr streamer,
        size_t strm_port,
        uhd::transport::adapter_id_t adapter_id = uhd::transport::NULL_ADAPTER_ID) = 0;
 
    virtual void disconnect(const block_id_t& src_blk,
        size_t src_port,
        const block_id_t& dst_blk,
        size_t dst_port) = 0;
 
    virtual void disconnect(const std::string& streamer_id) = 0;
 
    virtual void disconnect(const std::string& streamer_id, size_t port) = 0;
 
    virtual std::vector<uhd::transport::adapter_id_t> enumerate_adapters_from_src(
        const block_id_t& src_blk, size_t src_port) = 0;
 
    virtual std::vector<uhd::transport::adapter_id_t> enumerate_adapters_to_dst(
        const block_id_t& dst_blk, size_t dst_port) = 0;
 
    virtual std::vector<graph_edge_t> enumerate_static_connections() const = 0;
 
    virtual std::vector<graph_edge_t> enumerate_active_connections() = 0;
 
    virtual void commit() = 0;
 
    virtual void release() = 0;
 
    virtual std::string to_dot() = 0;
 
    /******************************************
     * Streaming
     ******************************************/
 
    virtual rx_streamer::sptr create_rx_streamer(
        const size_t num_ports, const stream_args_t& args) = 0;
 
    virtual tx_streamer::sptr create_tx_streamer(
        const size_t num_ports, const stream_args_t& args) = 0;
 
    /**************************************************************************
     * Hardware Control
     *************************************************************************/
    virtual size_t get_num_mboards() const = 0;
 
    virtual std::shared_ptr<mb_controller> get_mb_controller(
        const size_t mb_index = 0) = 0;
 
    virtual bool synchronize_devices(
        const uhd::time_spec_t& time_spec, const bool quiet) = 0;
 
    virtual uhd::property_tree::sptr get_tree(void) const = 0;
 
    virtual chdr_w_t get_chdr_width(const size_t mb_index = 0) const = 0;
}; // class rfnoc_graph
 
}}; // namespace uhd::rfnoc