artdaq  v3_00_01
FragmentReceiverManager.hh
1 #ifndef ARTDAQ_DAQRATE_DATATRANSFERMANAGER_HH
2 #define ARTDAQ_DAQRATE_DATATRANSFERMANAGER_HH
3 
4 #include <map>
5 #include <set>
6 #include <memory>
7 #include <condition_variable>
8 
9 #include "fhiclcpp/fwd.h"
10 
11 #include "artdaq-core/Data/Fragment.hh"
12 #include "artdaq/TransferPlugins/TransferInterface.hh"
13 #include "artdaq/DAQrate/detail/FragCounter.hh"
14 #include "artdaq-utilities/Plugins/MetricManager.hh"
15 
16 namespace artdaq
17 {
18  class FragmentReceiverManager;
19  class FragmentStoreElement;
20 }
21 
28 {
29 public:
30 
45  explicit FragmentReceiverManager(const fhicl::ParameterSet& ps);
46 
50  virtual ~FragmentReceiverManager();
51 
58  FragmentPtr recvFragment(int& rank, size_t timeout_usec = 0);
59 
64  size_t count() const;
65 
71  size_t slotCount(size_t rank) const;
72 
77  size_t byteCount() const;
78 
82  void start_threads();
83 
88  std::set<int> enabled_sources() const { return enabled_sources_; }
89 
90 private:
91  void runReceiver_(int);
92 
93  bool fragments_ready_() const;
94 
95  int get_next_source_() const;
96 
97  std::atomic<bool> stop_requested_;
98 
99  std::map<int, boost::thread> source_threads_;
100  std::map<int, std::unique_ptr<TransferInterface>> source_plugins_;
101  std::set<int> enabled_sources_;
102 
103  std::map<int, FragmentStoreElement> fragment_store_;
104 
105  std::mutex input_cv_mutex_;
106  std::condition_variable input_cv_;
107  std::mutex output_cv_mutex_;
108  std::condition_variable output_cv_;
109 
110  detail::FragCounter recv_frag_count_; // Number of frags received per source.
111  detail::FragCounter recv_frag_size_; // Number of bytes received per source.
112  detail::FragCounter recv_seq_count_; // For counting sequence IDs
113  bool suppress_noisy_senders_;
114  size_t suppression_threshold_;
115 
116  size_t receive_timeout_;
117 };
118 
127 {
128 public:
133  : frags_()
134  , empty_(true)
135  , eod_marker_(-1)
136  {
137  std::cout << "FragmentStoreElement CONSTRUCTOR" << std::endl;
138  }
139 
144  bool empty() const
145  {
146  return empty_;
147  }
148 
153  void emplace_front(FragmentPtr&& frag)
154  {
155  std::unique_lock<std::mutex> lk(mutex_);
156  frags_.emplace_front(std::move(frag));
157  empty_ = false;
158  }
159 
164  void emplace_back(FragmentPtr&& frag)
165  {
166  std::unique_lock<std::mutex> lk(mutex_);
167  frags_.emplace_back(std::move(frag));
168  empty_ = false;
169  }
170 
175  FragmentPtr front()
176  {
177  std::unique_lock<std::mutex> lk(mutex_);
178  auto current_fragment = std::move(frags_.front());
179  frags_.pop_front();
180  empty_ = frags_.size() == 0;
181  return std::move(current_fragment);
182  }
183 
188  void SetEndOfData(size_t eod) { eod_marker_ = eod; }
193  size_t GetEndOfData() const { return eod_marker_; }
194 
195 private:
196  mutable std::mutex mutex_;
197  FragmentPtrs frags_;
198  std::atomic<bool> empty_;
199  size_t eod_marker_;
200 };
201 
202 inline
203 size_t
205 count() const
206 {
207  return recv_frag_count_.count();
208 }
209 
210 inline
211 size_t
213 slotCount(size_t rank) const
214 {
215  return recv_frag_count_.slotCount(rank);
216 }
217 
218 inline
219 size_t
221 byteCount() const
222 {
223  return recv_frag_size_.count();
224 }
225 #endif //ARTDAQ_DAQRATE_DATATRANSFERMANAGER_HH
void start_threads()
Start receiver threads for all 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:20
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.
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.
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:128
std::set< int > enabled_sources() const
Get the list of enabled sources.