artdaq  v3_09_00
FragmentReceiverManager.hh
1 #ifndef ARTDAQ_DAQRATE_DATATRANSFERMANAGER_HH
2 #define ARTDAQ_DAQRATE_DATATRANSFERMANAGER_HH
3 
4 #include <condition_variable>
5 #include <map>
6 #include <memory>
7 #include <set>
8 
9 #include "fhiclcpp/fwd.h"
10 
11 #include "artdaq-core/Data/Fragment.hh"
12 #include "artdaq-utilities/Plugins/MetricManager.hh"
13 #include "artdaq/DAQrate/detail/FragCounter.hh"
14 #include "artdaq/TransferPlugins/TransferInterface.hh"
15 
16 namespace artdaq {
17 class FragmentReceiverManager;
18 class FragmentStoreElement;
19 } // namespace artdaq
20 
27 {
28 public:
43  explicit FragmentReceiverManager(const fhicl::ParameterSet& ps);
44 
48  virtual ~FragmentReceiverManager();
49 
56  FragmentPtr recvFragment(int& rank, size_t timeout_usec = 0);
57 
62  size_t count() const;
63 
69  size_t slotCount(size_t rank) const;
70 
75  size_t byteCount() const;
76 
80  void start_threads();
81 
86  std::set<int> enabled_sources() const;
87 
92  std::set<int> running_sources() const;
93 
94 private:
97  FragmentReceiverManager& operator=(FragmentReceiverManager const&) = delete;
98  FragmentReceiverManager& operator=(FragmentReceiverManager&&) = delete;
99 
100  void runReceiver_(int);
101 
102  bool fragments_ready_() const;
103 
104  int get_next_source_() const;
105 
106  std::atomic<bool> stop_requested_;
107 
108  std::map<int, boost::thread> source_threads_;
109  std::map<int, std::unique_ptr<TransferInterface>> source_plugins_;
110  std::unordered_map<int, std::pair<size_t, double>> source_metric_data_;
111  std::unordered_map<int, std::chrono::steady_clock::time_point> source_metric_send_time_;
112  std::unordered_map<int, std::atomic<bool>> enabled_sources_;
113  std::unordered_map<int, std::atomic<bool>> running_sources_;
114 
115  std::map<int, FragmentStoreElement> fragment_store_;
116 
117  std::mutex input_cv_mutex_;
118  std::condition_variable input_cv_;
119  std::mutex output_cv_mutex_;
120  std::condition_variable output_cv_;
121 
122  detail::FragCounter recv_frag_count_; // Number of frags received per source.
123  detail::FragCounter recv_frag_size_; // Number of bytes received per source.
124  detail::FragCounter recv_seq_count_; // For counting sequence IDs
125  bool suppress_noisy_senders_;
126  size_t suppression_threshold_;
127 
128  size_t receive_timeout_;
129  mutable int last_source_;
130 };
131 
140 {
141 public:
146  : frags_()
147  , empty_(true)
148  {
149  std::cout << "FragmentStoreElement CONSTRUCTOR" << std::endl;
150  }
151 
156  bool empty() const
157  {
158  return empty_;
159  }
160 
165  void emplace_front(FragmentPtr&& frag)
166  {
167  std::unique_lock<std::mutex> lk(mutex_);
168  frags_.emplace_front(std::move(frag));
169  empty_ = false;
170  }
171 
176  void emplace_back(FragmentPtr&& frag)
177  {
178  std::unique_lock<std::mutex> lk(mutex_);
179  frags_.emplace_back(std::move(frag));
180  empty_ = false;
181  }
182 
187  FragmentPtr front()
188  {
189  std::unique_lock<std::mutex> lk(mutex_);
190  auto current_fragment = std::move(frags_.front());
191  frags_.pop_front();
192  empty_ = frags_.empty();
193  return current_fragment;
194  }
195 
200  void SetEndOfData(size_t eod) { eod_marker_ = eod; }
205  size_t GetEndOfData() const { return eod_marker_; }
206 
211  size_t size() const { return frags_.size(); }
212 
213 private:
214  mutable std::mutex mutex_;
215  FragmentPtrs frags_;
216  std::atomic<bool> empty_;
217  size_t eod_marker_{0xFFFFFFFFFFFFFFFF};
218 };
219 
220 inline size_t
222  count() const
223 {
224  return recv_frag_count_.count();
225 }
226 
227 inline size_t
229  slotCount(size_t rank) const
230 {
231  return recv_frag_count_.slotCount(rank);
232 }
233 
234 inline size_t
236  byteCount() const
237 {
238  return recv_frag_size_.count();
239 }
240 #endif //ARTDAQ_DAQRATE_DATATRANSFERMANAGER_HH
void start_threads()
Start receiver threads for all enabled sources.
std::set< int > enabled_sources() const
Get the list of enabled sources.
void emplace_front(FragmentPtr &&frag)
Add a Fragment to the front of the FragmentStoreElement.
size_t byteCount() const
Get the total size of all data recieved by this FragmentReceiverManager.
void emplace_back(FragmentPtr &&frag)
Add a Fragment to the end of the FragmentStoreElement.
This class contains tracking information for all Fragment objects which have been received from a spe...
size_t count() const
Return the count of Fragment objects received by this FragmentReceiverManager.
virtual ~FragmentReceiverManager()
FragmentReceiverManager Destructor.
Receives Fragment objects from one or more DataSenderManager instances using TransferInterface plugin...
Keep track of the count of Fragments received from a set of sources.
Definition: FragCounter.hh:18
bool empty() const
Are any Fragment objects contained in this FragmentStoreElement?
FragmentReceiverManager(const fhicl::ParameterSet &ps)
FragmentReceiverManager Constructor.
void SetEndOfData(size_t eod)
Set the End-Of-Data marker value for this Receiver.
size_t size() const
Get the number of Fragments stored in this FragmentStoreElement.
FragmentPtr recvFragment(int &rank, size_t timeout_usec=0)
Receive a Fragment.
size_t slotCount(size_t rank) const
Get the count of Fragment objects received by this FragmentReceiverManager from a given source...
size_t GetEndOfData() const
Get the value of the End-Of-Data marker for this Receiver.
FragmentStoreElement()
FragmentStoreElement Constructor.
std::set< int > running_sources() const
Get the list of sources which are still receiving data.
FragmentPtr front()
Remove the first Fragment from the FragmentStoreElement and return it.
size_t count() const
Get the total number of Fragments received.
Definition: FragCounter.hh:120