artdaq  v3_09_00
RTIDDS_transfer.cc
1 #include "artdaq/TransferPlugins/TransferInterface.hh"
2 
3 #include "artdaq/RTIDDS/RTIDDS.hh"
4 
5 #include <iostream>
6 #include <memory>
7 #include "artdaq-core/Utilities/ExceptionHandler.hh"
8 
9 namespace fhicl {
10 class ParameterSet;
11 }
12 
13 // ----------------------------------------------------------------------
14 
15 namespace artdaq {
20 {
21 public:
25  virtual ~RTIDDSTransfer() = default;
26 
34  RTIDDSTransfer(fhicl::ParameterSet const& ps, Role role)
35  : TransferInterface(ps, role)
36  , rtidds_reader_(std::make_unique<artdaq::RTIDDS>("RTIDDSTransfer_reader", artdaq::RTIDDS::IOType::reader))
37  , rtidds_writer_(std::make_unique<artdaq::RTIDDS>("RTIDDSTransfer_writer", artdaq::RTIDDS::IOType::writer)) {}
38 
45  int receiveFragment(artdaq::Fragment& fragment,
46  size_t receiveTimeout) override;
47 
54  CopyStatus transfer_fragment_min_blocking_mode(artdaq::Fragment const& fragment,
55  size_t send_timeout_usec = std::numeric_limits<size_t>::max()) override;
56 
62  CopyStatus transfer_fragment_reliable_mode(artdaq::Fragment&& fragment) override;
63 
68  bool isRunning() override
69  {
70  switch (role())
71  {
73  return rtidds_writer_ != nullptr;
75  return rtidds_reader_ != nullptr;
76  }
77  }
78 
83  void flush_buffers() override {}
84 
85 private:
86  std::unique_ptr<artdaq::RTIDDS> rtidds_reader_;
87  std::unique_ptr<artdaq::RTIDDS> rtidds_writer_;
88 };
89 } // namespace artdaq
90 
91 int artdaq::RTIDDSTransfer::receiveFragment(artdaq::Fragment& fragment,
92  size_t receiveTimeout)
93 {
94  bool receivedFragment = false;
95  // static std::size_t consecutive_timeouts = 0;
96  // std::size_t message_after_N_timeouts = 10;
97 
98  // while (!receivedFragment) {
99 
100  try
101  {
102  receivedFragment = rtidds_reader_->octets_listener_.receiveFragmentFromDDS(fragment, receiveTimeout);
103  }
104  catch (...)
105  {
106  ExceptionHandler(ExceptionHandlerRethrow::yes,
107  "Error in RTIDDS transfer plugin: caught exception in call to OctetsListener::receiveFragmentFromDDS, rethrowing");
108  }
109 
110  // if (!receivedFragment) {
111 
112  // consecutive_timeouts++;
113 
114  // if (consecutive_timeouts % message_after_N_timeouts == 0) {
115  // TLOG_INFO("RTIDDSTransfer") << consecutive_timeouts << " consecutive " <<
116  // static_cast<float>(receiveTimeout)/1e6 << "-second timeouts calling OctetsListener::receiveFragmentFromDDS, will continue trying..." ;
117  // }
118  // } else {
119  // consecutive_timeouts = 0;
120  // }
121  // }
122 
123  // return 0;
124 
125  return receivedFragment ? source_rank() : TransferInterface::RECV_TIMEOUT;
126 }
127 
130 {
131  rtidds_writer_->transfer_fragment_reliable_mode_via_DDS_(std::move(fragment));
132  return CopyStatus::kSuccess;
133 }
134 
137  size_t send_timeout_usec)
138 {
139  (void)&send_timeout_usec; // No-op to get the compiler not to complain about unused parameter
140 
141  rtidds_writer_->transfer_fragment_min_blocking_mode_via_DDS_(fragment);
142  return CopyStatus::kSuccess;
143 }
144 
145 DEFINE_ARTDAQ_TRANSFER(artdaq::RTIDDSTransfer)
146 
147 // Local Variables:
148 // mode: c++
149 // End:
CopyStatus transfer_fragment_reliable_mode(artdaq::Fragment &&fragment) override
Transfer a Fragment to the destination. This should be reliable, if the underlying transport mechanis...
DDS Transport Implementation.
Definition: RTIDDS.hh:19
virtual int source_rank() const
Get the source rank for this TransferInterface instance.
Role role() const
Get the TransferInterface::Role of this TransferInterface.
CopyStatus transfer_fragment_min_blocking_mode(artdaq::Fragment const &fragment, size_t send_timeout_usec=std::numeric_limits< size_t >::max()) override
Transfer a Fragment to the destination. May not necessarily be reliable, but will not block longer th...
This TransferInterface is a Receiver.
bool isRunning() override
Determine whether the TransferInterface plugin is able to send/receive data.
void flush_buffers() override
Flush any in-flight data. This should be used by the receiver after the receive loop has ended...
This TransferInterface is a Sender.
Role
Used to determine if a TransferInterface is a Sender or Receiver.
int receiveFragment(artdaq::Fragment &fragment, size_t receiveTimeout) override
Receive a Fragment using DDS.
RTIDDSTransfer is a TransferInterface implementation plugin that transfers data using RTI DDS...
This interface defines the functions used to transfer data between artdaq applications.
RTIDDSTransfer(fhicl::ParameterSet const &ps, Role role)
RTIDDSTransfer Constructor.
Value to be returned upon receive timeout.
virtual ~RTIDDSTransfer()=default
RTIDDSTransfer default Destructor.
CopyStatus
Returned from the send functions, this enumeration describes the possible return codes. If an exception occurs, it will be thrown and should be handled normally.