Line data    Source code

       1              : #include "artdaq/TransferPlugins/TransferInterface.hh"
       2              : 
       3              : namespace artdaq {
       4              : /**
       5              :  * \brief NullTransfer does not send or receive data, but acts as if it did
       6              :  */
       7              : class NullTransfer : public TransferInterface
       8              : {
       9              : public:
      10              :         /**
      11              :          * \brief NullTransfer constructor
      12              :          * \param pset ParameterSet used to configure TransferInterface
      13              :          * \param role Role of this NullTransfer instance (kSend or kReceive)
      14              :          *
      15              :          * NullTransfer only requires the Parameters for configuring a TransferInterface
      16              :          */
      17              :         NullTransfer(const fhicl::ParameterSet& pset, Role role);
      18              : 
      19              :         /**
      20              :          * \brief NullTransfer default Destructor
      21              :          */
      22            0 :         ~NullTransfer() override = default;
      23              : 
      24              :         /**
      25              :          * \brief Pretend to receive a Fragment
      26              :          * \return Source Rank (Success code)
      27              :          *
      28              :          * WARNING: This function may create unintended side-effets. NullTransfer should
      29              :          * only really be used in Role::kSend!
      30              :          */
      31            0 :         int receiveFragment(artdaq::Fragment& /*fragment*/, size_t /*receiveTimeout*/) override
      32              :         {
      33            0 :                 std::this_thread::sleep_for(sleep_time_);
      34            0 :                 return source_rank();
      35              :         }
      36              : 
      37              :         /**
      38              :          * \brief Pretend to receive a Fragment Header
      39              :          * \return Source Rank (Success code)
      40              :          *
      41              :          * WARNING: This function may create unintended side-effets. NullTransfer should
      42              :          * only really be used in Role::kSend!
      43              :          */
      44            0 :         int receiveFragmentHeader(detail::RawFragmentHeader& /*header*/, size_t /*receiveTimeout*/) override
      45              :         {
      46            0 :                 std::this_thread::sleep_for(sleep_time_);
      47            0 :                 return source_rank();
      48              :         }
      49              : 
      50              :         /**
      51              :          * \brief Pretend to receive Fragment Data
      52              :          * \return Source Rank (Success code)
      53              :          *
      54              :          * WARNING: This function may create unintended side-effets. NullTransfer should
      55              :          * only really be used in Role::kSend!
      56              :          */
      57            0 :         int receiveFragmentData(RawDataType* /*destination*/ /*destination*/ /*destination*/ /*destination*/, size_t /*wordCount*/) override
      58              :         {
      59            0 :                 std::this_thread::sleep_for(sleep_time_);
      60            0 :                 return source_rank();
      61              :         }
      62              : 
      63              :         /**
      64              :          * \brief Pretend to send a Fragment to a destination
      65              :          * \return CopyStatus::kSuccess (No-Op)
      66              :          */
      67            0 :         CopyStatus transfer_fragment_min_blocking_mode(artdaq::Fragment const& /*fragment*/, size_t /*send_timeout_usec*/) override
      68              :         {
      69            0 :                 return CopyStatus::kSuccess;
      70              :         }
      71              : 
      72              :         /**
      73              :          * \brief Pretend to send a Fragment to a destination
      74              :          * \return CopyStatus::kSuccess (No-Op)
      75              :          */
      76            0 :         CopyStatus transfer_fragment_reliable_mode(artdaq::Fragment&& /*fragment*/) override { return CopyStatus::kSuccess; }
      77              : 
      78              :         /**
      79              :          * \brief Determine whether the TransferInterface plugin is able to send/receive data
      80              :          * \return True if the TransferInterface plugin is currently able to send/receive data
      81              :          */
      82            0 :         bool isRunning() override { return true; }
      83              : 
      84              :         /**
      85              :          * \brief Flush any in-flight data. This should be used by the receiver after the receive loop has
      86              :          * ended.
      87              :          */
      88            0 :         void flush_buffers() override {}
      89              : 
      90              : private:
      91              :         NullTransfer(NullTransfer const&) = delete;
      92              :         NullTransfer(NullTransfer&&) = delete;
      93              :         NullTransfer& operator=(NullTransfer const&) = delete;
      94              :         NullTransfer& operator=(NullTransfer&&) = delete;
      95              : 
      96              :         std::chrono::microseconds sleep_time_;
      97              : };
      98              : }  // namespace artdaq
      99              : 
     100            0 : artdaq::NullTransfer::NullTransfer(const fhicl::ParameterSet& pset, Role role)
     101              :     : TransferInterface(pset, role)
     102            0 :     , sleep_time_(pset.get<size_t>("sleep_time_us", 1000))
     103            0 : {}
     104              : 
     105            0 : DEFINE_ARTDAQ_TRANSFER(artdaq::NullTransfer)