Line data    Source code

       1             : #include <sstream>
       2             : #include <string>
       3             : 
       4             : #include "Module/Stateful/Source/Source.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             : Source<B>::operator[](const src::tsk t)
      15             : {
      16             :     return Module::operator[]((size_t)t);
      17             : }
      18             : 
      19             : template<typename B>
      20             : runtime::Socket&
      21             : Source<B>::operator[](const src::sck::generate s)
      22             : {
      23             :     return Module::operator[]((size_t)src::tsk::generate)[(size_t)s];
      24             : }
      25             : 
      26             : template<typename B>
      27             : runtime::Socket&
      28             : Source<B>::operator[](const std::string& tsk_sck)
      29             : {
      30             :     return Module::operator[](tsk_sck);
      31             : }
      32             : 
      33             : template<typename B>
      34          51 : Source<B>::Source(const int max_data_size)
      35             :   : Stateful()
      36          51 :   , max_data_size(max_data_size)
      37             : {
      38          51 :     const std::string name = "Source";
      39          51 :     this->set_name(name);
      40          51 :     this->set_short_name(name);
      41             : 
      42          51 :     if (max_data_size <= 0)
      43             :     {
      44           0 :         std::stringstream message;
      45           0 :         message << "'max_data_size' has to be greater than 0 ('max_data_size' = " << max_data_size << ").";
      46           0 :         throw tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
      47           0 :     }
      48             : 
      49          51 :     auto& p = this->create_task("generate");
      50          51 :     auto ps_out_data = this->template create_socket_out<B>(p, "out_data", this->max_data_size);
      51          51 :     auto ps_out_count = this->template create_socket_out<uint32_t>(p, "out_count", 1);
      52          51 :     this->create_codelet(p,
      53       23536 :                          [ps_out_data, ps_out_count](Module& m, runtime::Task& t, const size_t frame_id) -> int
      54             :                          {
      55       11768 :                              auto& src = static_cast<Source<B>&>(m);
      56             : 
      57       11768 :                              src._generate(t[ps_out_data].template get_dataptr<B>(),
      58       11768 :                                            t[ps_out_count].template get_dataptr<uint32_t>(),
      59             :                                            frame_id);
      60             : 
      61       11763 :                              return runtime::status_t::SUCCESS;
      62             :                          });
      63          51 : }
      64             : 
      65             : template<typename B>
      66             : Source<B>*
      67          18 : Source<B>::clone() const
      68             : {
      69          18 :     throw tools::unimplemented_error(__FILE__, __LINE__, __func__);
      70             : }
      71             : 
      72             : template<typename B>
      73             : int
      74           0 : Source<B>::get_max_data_size() const
      75             : {
      76           0 :     return max_data_size;
      77             : }
      78             : 
      79             : template<typename B>
      80             : template<class A>
      81             : void
      82             : Source<B>::generate(std::vector<B, A>& out_data, const int frame_id, const bool managed_memory)
      83             : {
      84             :     (*this)[src::sck::generate::out_data].bind(out_data);
      85             :     (*this)[src::tsk::generate].exec(frame_id, managed_memory);
      86             : }
      87             : 
      88             : template<typename B>
      89             : void
      90             : Source<B>::generate(B* out_data, const int frame_id, const bool managed_memory)
      91             : {
      92             :     (*this)[src::sck::generate::out_data].bind(out_data);
      93             :     (*this)[src::tsk::generate].exec(frame_id, managed_memory);
      94             : }
      95             : 
      96             : template<typename B>
      97             : template<class A>
      98             : void
      99             : Source<B>::generate(std::vector<B, A>& out_data,
     100             :                     std::vector<uint32_t>& out_count,
     101             :                     const int frame_id,
     102             :                     const bool managed_memory)
     103             : {
     104             :     (*this)[src::sck::generate::out_data].bind(out_data);
     105             :     (*this)[src::sck::generate::out_count].bind(out_count);
     106             :     (*this)[src::tsk::generate].exec(frame_id, managed_memory);
     107             : }
     108             : 
     109             : template<typename B>
     110             : void
     111             : Source<B>::generate(B* out_data, uint32_t* out_count, const int frame_id, const bool managed_memory)
     112             : {
     113             :     (*this)[src::sck::generate::out_data].bind(out_data);
     114             :     (*this)[src::sck::generate::out_count].bind(out_count);
     115             :     (*this)[src::tsk::generate].exec(frame_id, managed_memory);
     116             : }
     117             : 
     118             : template<typename B>
     119             : void
     120           0 : Source<B>::_generate(B* out_data, const size_t frame_id)
     121             : {
     122           0 :     throw tools::unimplemented_error(__FILE__, __LINE__, __func__);
     123             : }
     124             : 
     125             : template<typename B>
     126             : void
     127           0 : Source<B>::_generate(B* out_data, uint32_t* out_count, const size_t frame_id)
     128             : {
     129           0 :     this->_generate(out_data, frame_id);
     130           0 :     *out_count = this->max_data_size;
     131           0 : }
     132             : 
     133             : template<typename B>
     134             : void
     135           0 : Source<B>::set_seed(const int seed)
     136             : {
     137             :     // do nothing in the general case, this method has to be overrided
     138           0 : }
     139             : 
     140             : template<typename B>
     141             : bool
     142           0 : Source<B>::is_done() const
     143             : {
     144           0 :     return false;
     145             : }
     146             : 
     147             : template<typename B>
     148             : void
     149           0 : Source<B>::reset()
     150             : {
     151             :     // do nothing in the general case, this method has to be overrided
     152           0 : }
     153             : 
     154             : }
     155             : }