USRP Hardware Driver and USRP Manual  Version: 4.2.0.1+ds1-1
UHD and USRP Manual
node.hpp
Go to the documentation of this file.
1 //
2 // Copyright 2019 Ettus Research, a National Instruments Brand
3 //
4 // SPDX-License-Identifier: GPL-3.0-or-later
5 //
6 
7 #pragma once
8 
9 #include <uhd/rfnoc/actions.hpp>
10 #include <uhd/rfnoc/dirtifier.hpp>
11 #include <uhd/rfnoc/property.hpp>
13 #include <uhd/types/time_spec.hpp>
14 #include <uhd/utils/log.hpp>
15 #include <uhd/utils/scope_exit.hpp>
16 #include <unordered_map>
17 #include <unordered_set>
18 #include <boost/graph/adjacency_list.hpp>
19 #include <functional>
20 #include <memory>
21 #include <mutex>
22 #include <string>
23 #include <tuple>
24 #include <vector>
25 
26 namespace uhd { namespace rfnoc {
27 
35 {
36 public:
37  using resolver_fn_t = std::function<void(void)>;
38  using resolve_callback_t = std::function<void(void)>;
40  std::function<void(const res_source_info&, action_info::sptr)>;
42  std::unordered_map<res_source_info, std::vector<res_source_info>>;
43 
45  enum class forwarding_policy_t {
47  //(e.g., if it comes from input port 0, forward it to output port 0).
48  ONE_TO_ONE,
50  ONE_TO_FAN,
52  ONE_TO_ALL_IN,
54  ONE_TO_ALL_OUT,
56  ONE_TO_ALL,
58  DROP,
60  USE_MAP
61  };
62 
63  static const size_t ANY_PORT = size_t(~0);
64 
65  /**************************************************************************
66  * Structors
67  *************************************************************************/
68  node_t();
69 
70  virtual ~node_t() {}
71 
72  /******************************************
73  * Basic Operations
74  ******************************************/
76  // no two nodes cannot have the same ID.
77  //
78  // \returns The unique ID as a string
79  virtual std::string get_unique_id() const;
80 
87  virtual size_t get_num_input_ports() const = 0;
88 
95  virtual size_t get_num_output_ports() const = 0;
96 
97  /******************************************
98  * Property Specific
99  ******************************************/
100 
109  std::vector<std::string> get_property_ids() const;
110 
126  template <typename prop_data_t>
127  void set_property(
128  const std::string& id, const prop_data_t& val, const size_t instance = 0);
129 
162  void set_properties(const uhd::device_addr_t& props, const size_t instance = 0);
163 
181  template <typename prop_data_t>
182  const prop_data_t& get_property(
183  const std::string& id, const size_t instance = 0) /* mutable */;
184 
200  virtual void set_command_time(uhd::time_spec_t time, const size_t instance);
201 
206  virtual uhd::time_spec_t get_command_time(const size_t instance) const;
207 
213  virtual void clear_command_time(const size_t instance);
214 
215 protected:
216  /******************************************
217  * Internal Registration Functions
218  ******************************************/
219  using prop_ptrs_t = std::unordered_set<property_base_t*>;
220 
242  property_base_t* prop, resolve_callback_t&& clean_callback = nullptr);
243 
279  prop_ptrs_t&& inputs, prop_ptrs_t&& outputs, resolver_fn_t&& resolver_fn);
280 
281  /**************************************************************************
282  * Property forwarding
283  *************************************************************************/
305  forwarding_policy_t policy, const std::string& prop_id = "");
306 
329 
341  template <typename prop_data_t>
342  void set_property(
343  const std::string& id, const prop_data_t& val, const res_source_info& src_info);
344 
356  template <typename prop_data_t>
357  const prop_data_t& get_property(
358  const std::string& id, const res_source_info& src_info) /* mutable */;
359 
360  /******************************************
361  * Internal action forwarding
362  ******************************************/
376  void register_action_handler(const std::string& id, action_handler_t&& handler);
377 
397  forwarding_policy_t policy, const std::string& action_key = "");
398 
422 
434  void post_action(const res_source_info& edge_info, action_info::sptr action);
435 
436  /**************************************************************************
437  * Graph Interaction
438  *************************************************************************/
459  virtual bool check_topology(const std::vector<size_t>& connected_inputs,
460  const std::vector<size_t>& connected_outputs);
461 
467  virtual void shutdown();
468 
469  /**************************************************************************
470  * Attributes
471  *************************************************************************/
474 
475 private:
476  friend class node_accessor_t;
477 
482  property_base_t* _find_property(
483  res_source_info src_info, const std::string& id) const;
484 
490  uhd::utils::scope_exit::uptr _request_property_access(
491  property_base_t* prop, property_base_t::access_t access) const;
492 
497  template <typename PredicateType>
498  prop_ptrs_t filter_props(PredicateType&& predicate)
499  {
500  prop_ptrs_t filtered_props{};
501  for (const auto& type_prop_pair : _props) {
502  for (const auto& prop : type_prop_pair.second) {
503  if (predicate(prop)) {
504  filtered_props.insert(prop);
505  }
506  }
507  }
508 
509  return filtered_props;
510  }
511 
519  property_base_t* inject_edge_property(
520  property_base_t* blueprint, res_source_info new_src_info);
521 
535  void init_props();
536 
560  void resolve_props();
561 
564  void resolve_all();
565 
571  void clean_props();
572 
576  void set_resolve_all_callback(resolve_callback_t&& resolver)
577  {
578  _resolve_all_cb = resolver;
579  }
580 
583  void clear_resolve_all_callback()
584  {
585  _resolve_all_cb = _default_resolve_all_cb;
586  }
587 
622  void forward_edge_property(
623  property_base_t* incoming_prop, const size_t incoming_port);
624 
625  /**************************************************************************
626  * Action-Related Methods
627  *************************************************************************/
631  void set_post_action_callback(action_handler_t&& post_handler)
632  {
633  _post_action_cb = std::move(post_handler);
634  }
635 
644  void receive_action(const res_source_info& src_info, action_info::sptr action);
645 
646  /**************************************************************************
647  * Private helpers
648  *************************************************************************/
650  bool _has_port(const res_source_info& port_info) const;
651 
652  /****** Attributes *******************************************************/
654  // global property mutex, this only write-protects access to the property-
655  // related containers in this class.
656  mutable std::mutex _prop_mutex;
657 
659  std::unordered_map<res_source_info::source_t,
660  std::vector<property_base_t*>,
661  std::hash<size_t>>
662  _props;
663 
665  std::unordered_map<property_base_t*, resolve_callback_t> _clean_cb_registry;
666 
667  using property_resolver_t = std::tuple<prop_ptrs_t, prop_ptrs_t, resolver_fn_t>;
669  std::vector<property_resolver_t> _prop_resolvers;
670 
672  // has changed, and that a property resolution needs to be performed.
673  resolve_callback_t _resolve_all_cb;
674 
676  // method.
677  const resolve_callback_t _default_resolve_all_cb = [this]() {
678  resolve_props();
679  clean_props();
680  };
681 
683  // explicitly.
684  //
685  // Dynamic properties include properties defined in the block descriptor
686  // file, as well as new properties that get passed in during property
687  // propagation.
688  std::unordered_set<std::unique_ptr<property_base_t>> _dynamic_props;
689 
691  //
692  // The entry with the empty-string-key is the default policy.
693  std::unordered_map<std::string, forwarding_policy_t> _prop_fwd_policies{
694  {"", forwarding_policy_t::ONE_TO_ONE}};
695 
697  forwarding_map_t _prop_fwd_map;
698 
699  /**************************************************************************
700  * Action-related attributes
701  *************************************************************************/
702  mutable std::mutex _action_mutex;
703 
705  std::unordered_map<std::string, action_handler_t> _action_handlers;
706 
708  std::unordered_map<std::string, forwarding_policy_t> _action_fwd_policies{
709  {"", forwarding_policy_t::ONE_TO_ONE}};
710 
712  //
713  // The default callback will simply drop actions
714  action_handler_t _post_action_cb = [](const res_source_info&,
715  action_info::sptr) { /* nop */ };
716 
718  forwarding_map_t _action_fwd_map;
719 
720  /**************************************************************************
721  * Other attributes
722  *************************************************************************/
723  std::vector<uhd::time_spec_t> _cmd_timespecs;
724 }; // class node_t
725 
726 }} /* namespace uhd::rfnoc */
727 
728 #include <uhd/rfnoc/node.ipp>
Definition: device_addr.hpp:38
Definition: dirtifier.hpp:19
Definition: node.hpp:35
virtual std::string get_unique_id() const
Return a unique identifier string for this node. In every RFNoC graph,.
void register_property(property_base_t *prop, resolve_callback_t &&clean_callback=nullptr)
std::unordered_map< res_source_info, std::vector< res_source_info > > forwarding_map_t
Definition: node.hpp:42
void set_action_forwarding_policy(forwarding_policy_t policy, const std::string &action_key="")
void set_prop_forwarding_map(const forwarding_map_t &map)
std::function< void(void)> resolver_fn_t
Definition: node.hpp:37
std::function< void(void)> resolve_callback_t
Definition: node.hpp:38
void register_action_handler(const std::string &id, action_handler_t &&handler)
virtual void set_command_time(uhd::time_spec_t time, const size_t instance)
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)
virtual ~node_t()
Definition: node.hpp:70
void set_action_forwarding_map(const forwarding_map_t &map)
virtual size_t get_num_output_ports() const =0
virtual void shutdown()
std::unordered_set< property_base_t * > prop_ptrs_t
Definition: node.hpp:219
void set_properties(const uhd::device_addr_t &props, const size_t instance=0)
forwarding_policy_t
Types of property/action forwarding for those not defined by the block itself.
Definition: node.hpp:45
virtual size_t get_num_input_ports() const =0
void add_property_resolver(prop_ptrs_t &&inputs, prop_ptrs_t &&outputs, resolver_fn_t &&resolver_fn)
std::function< void(const res_source_info &, action_info::sptr)> action_handler_t
Definition: node.hpp:40
virtual void clear_command_time(const size_t instance)
static dirtifier_t ALWAYS_DIRTY
A dirtifyer object, useful for properties that always need updating.
Definition: node.hpp:473
virtual uhd::time_spec_t get_command_time(const size_t instance) const
std::vector< std::string > get_property_ids() const
void set_prop_forwarding_policy(forwarding_policy_t policy, const std::string &prop_id="")
Definition: property.hpp:26
access_t
Definition: property.hpp:28
Definition: time_spec.hpp:31
std::unique_ptr< scope_exit > uptr
Definition: scope_exit.hpp:25
#define UHD_API
Definition: config.h:87
Definition: build_info.hpp:12
std::shared_ptr< action_info > sptr
Definition: actions.hpp:32
Definition: res_source_info.hpp:18
source_t
Definition: res_source_info.hpp:21