Line data    Source code

       1             : #include <chrono>
       2             : #include <sstream>
       3             : 
       4             : #include "Module/Stateful/Relayer/Relayer.hpp"
       5             : 
       6             : using namespace spu;
       7             : using namespace spu::module;
       8             : 
       9             : template<typename T>
      10         370 : Relayer<T>::Relayer(const size_t n_elmts, const size_t ns)
      11             :   : Stateful()
      12         370 :   , n_elmts(n_elmts)
      13         370 :   , ns(ns)
      14             : {
      15         370 :     const std::string name = "Relayer";
      16         370 :     this->set_name(name);
      17         370 :     this->set_short_name(name);
      18             : 
      19         370 :     if (n_elmts == 0)
      20             :     {
      21           0 :         std::stringstream message;
      22           0 :         message << "'n_elmts' has to be greater than 0 ('n_elmts' = " << n_elmts << ").";
      23           0 :         throw tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
      24           0 :     }
      25             : 
      26         370 :     auto& p1 = this->create_task("relay");
      27         370 :     auto p1s_in = this->template create_socket_in<T>(p1, "in", this->n_elmts);
      28         370 :     auto p1s_out = this->template create_socket_out<T>(p1, "out", this->n_elmts);
      29         370 :     this->create_codelet(
      30             :       p1,
      31      327225 :       [p1s_in, p1s_out](Module& m, runtime::Task& t, const size_t frame_id) -> int
      32             :       {
      33      163718 :           auto& rly = static_cast<Relayer&>(m);
      34      163718 :           rly._relay(t[p1s_in].template get_dataptr<const T>(), t[p1s_out].template get_dataptr<T>(), frame_id);
      35      164023 :           return runtime::status_t::SUCCESS;
      36             :       });
      37             : 
      38         370 :     auto& p2 = this->create_task("relayf");
      39         370 :     auto p2s_fwd = this->template create_socket_fwd<T>(p2, "fwd", this->n_elmts);
      40         370 :     this->create_codelet(
      41             :       p2,
      42      560146 :       [p2s_fwd](Module& m, runtime::Task& t, const size_t frame_id) -> int
      43             :       {
      44      280082 :           auto& rly_fwd = static_cast<Relayer&>(m);
      45      280082 :           rly_fwd._relay(t[p2s_fwd].template get_dataptr<const T>(), t[p2s_fwd].template get_dataptr<T>(), frame_id);
      46      280897 :           return runtime::status_t::SUCCESS;
      47             :       });
      48         370 : }
      49             : 
      50             : template<typename T>
      51             : Relayer<T>*
      52        6260 : Relayer<T>::clone() const
      53             : {
      54        6260 :     auto m = new Relayer(*this);
      55        6260 :     m->deep_copy(*this);
      56        6260 :     return m;
      57             : }
      58             : 
      59             : template<typename T>
      60             : size_t
      61           0 : Relayer<T>::get_ns() const
      62             : {
      63           0 :     return this->ns;
      64             : }
      65             : 
      66             : template<typename T>
      67             : size_t
      68           0 : Relayer<T>::get_n_elmts() const
      69             : {
      70           0 :     return this->n_elmts;
      71             : }
      72             : 
      73             : template<typename T>
      74             : void
      75         358 : Relayer<T>::set_ns(const size_t ns)
      76             : {
      77         358 :     this->ns = ns;
      78         358 : }
      79             : 
      80             : template<typename T>
      81             : void
      82           0 : Relayer<T>::relay(const T* in, T* out, const int frame_id, const bool managed_memory)
      83             : {
      84           0 :     (*this)[rly::sck::relay::in].bind(in);
      85           0 :     (*this)[rly::sck::relay::out].bind(out);
      86           0 :     (*this)[rly::tsk::relay].exec(frame_id, managed_memory);
      87           0 : }
      88             : 
      89             : template<typename T>
      90             : void
      91      441868 : Relayer<T>::_relay(const T* in, T* out, const size_t frame_id)
      92             : {
      93      441868 :     std::chrono::time_point<std::chrono::steady_clock> t_start;
      94      441868 :     if (this->ns) t_start = std::chrono::steady_clock::now();
      95             : 
      96      444777 :     if (in != out) std::copy(in, in + this->n_elmts, out);
      97             : 
      98      445763 :     if (this->ns)
      99             :     {
     100      431803 :         std::chrono::nanoseconds duration = std::chrono::steady_clock::now() - t_start;
     101    28963191 :         while ((size_t)duration.count() < this->ns) // active waiting
     102    28488770 :             duration = std::chrono::steady_clock::now() - t_start;
     103             :     }
     104      441235 : }
     105             : 
     106             : // ==================================================================================== explicit template instantiation
     107             : template class spu::module::Relayer<int8_t>;
     108             : template class spu::module::Relayer<uint8_t>;
     109             : template class spu::module::Relayer<int16_t>;
     110             : template class spu::module::Relayer<uint16_t>;
     111             : template class spu::module::Relayer<int32_t>;
     112             : template class spu::module::Relayer<uint32_t>;
     113             : template class spu::module::Relayer<int64_t>;
     114             : template class spu::module::Relayer<uint64_t>;
     115             : template class spu::module::Relayer<float>;
     116             : template class spu::module::Relayer<double>;
     117             : // ==================================================================================== explicit template instantiation