artdaq  v3_06_00
RTIDDS_transfer.cc
1 #include "artdaq/TransferPlugins/TransferInterface.hh"
2 
3 #include "artdaq/RTIDDS/RTIDDS.hh"
4 
5 #include "artdaq-core/Utilities/ExceptionHandler.hh"
6 #include <memory>
7 #include <iostream>
8 
9 
10 namespace fhicl
11 {
12  class ParameterSet;
13 }
14 
15 // ----------------------------------------------------------------------
16 
17 namespace artdaq
18 {
23  {
24  public:
28  virtual ~RTIDDSTransfer() = default;
29 
37  RTIDDSTransfer(fhicl::ParameterSet const& ps, Role role) :
38  TransferInterface(ps, role)
39  , rtidds_reader_(std::make_unique<artdaq::RTIDDS>("RTIDDSTransfer_reader", artdaq::RTIDDS::IOType::reader))
40  , rtidds_writer_(std::make_unique<artdaq::RTIDDS>("RTIDDSTransfer_writer", artdaq::RTIDDS::IOType::writer)) { }
41 
48  int receiveFragment(artdaq::Fragment& fragment,
49  size_t receiveTimeout) override;
50 
57  CopyStatus transfer_fragment_min_blocking_mode(artdaq::Fragment const& fragment,
58  size_t send_timeout_usec = std::numeric_limits<size_t>::max()) override;
59 
65  CopyStatus transfer_fragment_reliable_mode(artdaq::Fragment&& fragment) override;
66 
71  bool isRunning() override
72  {
73  switch (role())
74  {
76  return rtidds_writer_ != nullptr;
78  return rtidds_reader_ != nullptr;
79  }
80  }
81 
86  void flush_buffers() override {}
87  private:
88  std::unique_ptr<artdaq::RTIDDS> rtidds_reader_;
89  std::unique_ptr<artdaq::RTIDDS> rtidds_writer_;
90  };
91 }
92 
93 int artdaq::RTIDDSTransfer::receiveFragment(artdaq::Fragment& fragment,
94  size_t receiveTimeout)
95 {
96  bool receivedFragment = false;
97  // static std::size_t consecutive_timeouts = 0;
98  // std::size_t message_after_N_timeouts = 10;
99 
100  // while (!receivedFragment) {
101 
102  try
103  {
104  receivedFragment = rtidds_reader_->octets_listener_.receiveFragmentFromDDS(fragment, receiveTimeout);
105  }
106  catch (...)
107  {
108  ExceptionHandler(ExceptionHandlerRethrow::yes,
109  "Error in RTIDDS transfer plugin: caught exception in call to OctetsListener::receiveFragmentFromDDS, rethrowing");
110  }
111 
112  // if (!receivedFragment) {
113 
114  // consecutive_timeouts++;
115 
116  // if (consecutive_timeouts % message_after_N_timeouts == 0) {
117  // TLOG_INFO("RTIDDSTransfer") << consecutive_timeouts << " consecutive " <<
118  // static_cast<float>(receiveTimeout)/1e6 << "-second timeouts calling OctetsListener::receiveFragmentFromDDS, will continue trying..." ;
119  // }
120  // } else {
121  // consecutive_timeouts = 0;
122  // }
123  // }
124 
125  // return 0;
126 
127  return receivedFragment ? source_rank() : TransferInterface::RECV_TIMEOUT;
128 }
129 
132 {
133  rtidds_writer_->transfer_fragment_reliable_mode_via_DDS_(std::move(fragment));
134  return CopyStatus::kSuccess;
135 }
136 
139  size_t send_timeout_usec)
140 {
141  (void) &send_timeout_usec; // No-op to get the compiler not to complain about unused parameter
142 
143  rtidds_writer_->transfer_fragment_min_blocking_mode_via_DDS_(fragment);
144  return CopyStatus::kSuccess;
145 }
146 
147 DEFINE_ARTDAQ_TRANSFER(artdaq::RTIDDSTransfer)
148 
149 // Local Variables:
150 // mode: c++
151 // 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:21
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.