Line data    Source code

       1             : #include <sstream>
       2             : #include <string>
       3             : 
       4             : #include "Module/Stateful/Sink/Sink.hpp"
       5             : #include "Tools/Exception/exception.hpp"
       6             : 
       7             : namespace spu
       8             : {
       9             : namespace module
      10             : {
      11             : 
      12             : template<typename B>
      13             : runtime::Task&
      14             : Sink<B>::operator[](const snk::tsk t)
      15             : {
      16             :     return Module::operator[]((size_t)t);
      17             : }
      18             : 
      19             : template<typename B>
      20             : runtime::Socket&
      21             : Sink<B>::operator[](const snk::sck::send s)
      22             : {
      23             :     return Module::operator[]((size_t)snk::tsk::send)[(size_t)s];
      24             : }
      25             : 
      26             : template<typename B>
      27             : runtime::Socket&
      28             : Sink<B>::operator[](const snk::sck::send_count s)
      29             : {
      30             :     return Module::operator[]((size_t)snk::tsk::send_count)[(size_t)s];
      31             : }
      32             : 
      33             : template<typename B>
      34             : runtime::Socket&
      35             : Sink<B>::operator[](const std::string& tsk_sck)
      36             : {
      37             :     return Module::operator[](tsk_sck);
      38             : }
      39             : 
      40             : template<typename B>
      41          60 : Sink<B>::Sink(const int max_data_size)
      42             :   : Stateful()
      43          60 :   , max_data_size(max_data_size)
      44             : {
      45          60 :     const std::string name = "Sink";
      46          60 :     this->set_name(name);
      47          60 :     this->set_short_name(name);
      48             : 
      49          60 :     if (max_data_size <= 0)
      50             :     {
      51           0 :         std::stringstream message;
      52           0 :         message << "'max_data_size' has to be greater than 0 ('max_data_size' = " << max_data_size << ").";
      53           0 :         throw tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
      54           0 :     }
      55             : 
      56          60 :     auto& p1 = this->create_task("send");
      57          60 :     auto p1s_in_data = this->template create_socket_in<B>(p1, "in_data", max_data_size);
      58          60 :     this->create_codelet(p1,
      59           0 :                          [p1s_in_data](Module& m, runtime::Task& t, const size_t frame_id) -> int
      60             :                          {
      61           0 :                              auto& snk = static_cast<Sink<B>&>(m);
      62           0 :                              snk._send(t[p1s_in_data].template get_dataptr<const B>(), frame_id);
      63           0 :                              return runtime::status_t::SUCCESS;
      64             :                          });
      65             : 
      66          60 :     auto& p2 = this->create_task("send_count");
      67          60 :     auto p2s_in_data = this->template create_socket_in<B>(p2, "in_data", max_data_size);
      68          60 :     auto p2s_in_count = this->template create_socket_in<uint32_t>(p2, "in_count", 1);
      69          60 :     this->create_codelet(p2,
      70       23692 :                          [p2s_in_data, p2s_in_count](Module& m, runtime::Task& t, const size_t frame_id) -> int
      71             :                          {
      72       11846 :                              auto& snk = static_cast<Sink<B>&>(m);
      73       11846 :                              snk._send_count(t[p2s_in_data].template get_dataptr<const B>(),
      74       11846 :                                              t[p2s_in_count].template get_dataptr<const uint32_t>(),
      75             :                                              frame_id);
      76       11846 :                              return runtime::status_t::SUCCESS;
      77             :                          });
      78          60 : }
      79             : 
      80             : template<typename B>
      81             : Sink<B>*
      82          38 : Sink<B>::clone() const
      83             : {
      84          38 :     throw tools::unimplemented_error(__FILE__, __LINE__, __func__);
      85             : }
      86             : 
      87             : template<typename B>
      88             : template<class A>
      89             : void
      90             : Sink<B>::send(const std::vector<B, A>& in_data, const int frame_id, const bool managed_memory)
      91             : {
      92             :     (*this)[snk::sck::send::in_data].bind(in_data);
      93             :     (*this)[snk::tsk::send].exec(frame_id, managed_memory);
      94             : }
      95             : 
      96             : template<typename B>
      97             : void
      98             : Sink<B>::send(const B* in_data, const int frame_id, const bool managed_memory)
      99             : {
     100             :     (*this)[snk::sck::send::in_data].bind(in_data);
     101             :     (*this)[snk::tsk::send].exec(frame_id, managed_memory);
     102             : }
     103             : 
     104             : template<typename B>
     105             : template<class A>
     106             : void
     107             : Sink<B>::send_count(const std::vector<B, A>& in_data,
     108             :                     const std::vector<uint32_t>& in_count,
     109             :                     const int frame_id,
     110             :                     const bool managed_memory)
     111             : {
     112             :     (*this)[snk::sck::send_count::in_data].bind(in_data);
     113             :     (*this)[snk::sck::send_count::in_count].bind(in_count);
     114             :     (*this)[snk::tsk::send_count].exec(frame_id, managed_memory);
     115             : }
     116             : 
     117             : template<typename B>
     118             : void
     119             : Sink<B>::send_count(const B* in_data, uint32_t* in_count, const int frame_id, const bool managed_memory)
     120             : {
     121             :     (*this)[snk::sck::send_count::in_data].bind(in_data);
     122             :     (*this)[snk::sck::send_count::in_count].bind(in_count);
     123             :     (*this)[snk::tsk::send_count].exec(frame_id, managed_memory);
     124             : }
     125             : 
     126             : template<typename B>
     127             : void
     128           0 : Sink<B>::_send(const B* in_data, const size_t frame_id)
     129             : {
     130           0 :     const uint32_t in_count = (uint32_t)this->max_data_size;
     131           0 :     this->_send_count(in_data, &in_count, frame_id);
     132           0 : }
     133             : 
     134             : template<typename B>
     135             : void
     136           0 : Sink<B>::_send_count(const B* /*in_data*/, const uint32_t* /*in_count*/, const size_t /*frame_id*/)
     137             : {
     138           0 :     throw tools::unimplemented_error(__FILE__, __LINE__, __func__);
     139             : }
     140             : 
     141             : template<typename B>
     142             : void
     143           0 : Sink<B>::reset()
     144             : {
     145             :     // do nothing in the general case, this method has to be overrided
     146           0 : }
     147             : 
     148             : }
     149             : }