Line data    Source code

       1             : #include <algorithm>
       2             : #include <chrono>
       3             : #include <sstream>
       4             : #include <string>
       5             : #include <thread>
       6             : 
       7             : #include "Module/Stateful/Initializer/Initializer.hpp"
       8             : 
       9             : using namespace spu;
      10             : using namespace spu::module;
      11             : 
      12             : template<typename T>
      13         117 : Initializer<T>::Initializer(const size_t n_elmts)
      14             :   : Stateful()
      15         117 :   , init_data(this->get_n_frames(), std::vector<T>(n_elmts, 0))
      16             : {
      17         117 :     const std::string name = "Initializer";
      18         117 :     this->set_name(name);
      19         117 :     this->set_short_name(name);
      20             : 
      21         117 :     if (n_elmts == 0)
      22             :     {
      23           0 :         std::stringstream message;
      24           0 :         message << "'n_elmts' has to be greater than 0.";
      25           0 :         throw tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
      26           0 :     }
      27             : 
      28         117 :     auto& p = this->create_task("initialize");
      29         117 :     auto ps_out = this->template create_socket_out<T>(p, "out", n_elmts);
      30         117 :     this->create_codelet(p,
      31      298175 :                          [ps_out](Module& m, runtime::Task& t, const size_t frame_id) -> int
      32             :                          {
      33      298175 :                              auto& ini = static_cast<Initializer&>(m);
      34      298175 :                              ini._initialize(t[ps_out].template get_dataptr<T>(), frame_id);
      35      302548 :                              return runtime::status_t::SUCCESS;
      36             :                          });
      37         117 : }
      38             : 
      39             : template<typename T>
      40             : Initializer<T>*
      41        2551 : Initializer<T>::clone() const
      42             : {
      43        2551 :     auto m = new Initializer(*this);
      44        2551 :     m->deep_copy(*this);
      45        2551 :     return m;
      46             : }
      47             : 
      48             : template<typename T>
      49             : const std::vector<std::vector<T>>&
      50           0 : Initializer<T>::get_init_data() const
      51             : {
      52           0 :     return this->init_data;
      53             : }
      54             : 
      55             : template<typename T>
      56             : void
      57           0 : Initializer<T>::set_init_data(const std::vector<T>& init_data)
      58             : {
      59           0 :     if (init_data.size() != this->init_data[0].size())
      60             :     {
      61           0 :         std::stringstream message;
      62           0 :         message << "'init_data.size()' has to be equal to 'this->init_data[0].size()' ('init_data.size()' = "
      63           0 :                 << init_data.size() << ", 'this->init_data[0].size()' = " << this->init_data[0].size() << ").";
      64           0 :         throw tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
      65           0 :     }
      66             : 
      67           0 :     for (auto& ini : this->init_data)
      68           0 :         ini = init_data;
      69           0 : }
      70             : 
      71             : template<typename T>
      72             : void
      73        2551 : Initializer<T>::set_init_data(const std::vector<std::vector<T>>& init_data)
      74             : {
      75        2551 :     if (init_data.size() != this->get_n_frames())
      76             :     {
      77           0 :         std::stringstream message;
      78           0 :         message << "'init_data.size()' has to be equal to 'this->get_n_frames()' ('init_data.size()' = "
      79           0 :                 << init_data.size() << ", 'this->get_n_frames()' = " << this->get_n_frames() << ").";
      80           0 :         throw tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
      81           0 :     }
      82             : 
      83       26716 :     for (size_t f = 0; f < init_data.size(); f++)
      84             :     {
      85       24165 :         if (init_data[f].size() != this->init_data[f].size())
      86             :         {
      87           0 :             std::stringstream message;
      88           0 :             message << "'init_data[f].size()' has to be equal to 'this->init_data[f].size()' ('init_data[f].size()' = "
      89           0 :                     << init_data[f].size() << ", 'this->init_data[f].size()' = " << this->init_data[f].size()
      90           0 :                     << ", 'f' = " << f << ").";
      91           0 :             throw tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
      92           0 :         }
      93       24165 :         this->init_data[f] = init_data[f];
      94             :     }
      95        2551 : }
      96             : 
      97             : template<typename T>
      98             : void
      99           0 : Initializer<T>::set_init_data(const T val)
     100             : {
     101           0 :     for (auto& ini : this->init_data)
     102           0 :         std::fill(ini.begin(), ini.end(), val);
     103           0 : }
     104             : 
     105             : template<typename T>
     106             : void
     107        3706 : Initializer<T>::set_n_frames(const size_t n_frames)
     108             : {
     109        3706 :     const auto old_n_frames = this->get_n_frames();
     110        3706 :     if (old_n_frames != n_frames)
     111             :     {
     112        3706 :         Module::set_n_frames(n_frames);
     113             : 
     114        3706 :         this->init_data.resize(n_frames);
     115       25320 :         for (size_t f = old_n_frames; f < n_frames; f++)
     116       21614 :             this->init_data[f] = this->init_data[0];
     117             :     }
     118        3706 : }
     119             : 
     120             : template<typename T>
     121             : void
     122           0 : Initializer<T>::initialize(T* out, const int frame_id, const bool managed_memory)
     123             : {
     124           0 :     (*this)[ini::sck::initialize::out].bind(out);
     125           0 :     (*this)[ini::tsk::initialize].exec(frame_id, managed_memory);
     126           0 : }
     127             : 
     128             : template<typename T>
     129             : void
     130      297933 : Initializer<T>::_initialize(T* out, const size_t frame_id)
     131             : {
     132      297933 :     std::copy(this->init_data[frame_id].begin(), this->init_data[frame_id].end(), out);
     133      302712 : }
     134             : 
     135             : // ==================================================================================== explicit template instantiation
     136             : template class spu::module::Initializer<int8_t>;
     137             : template class spu::module::Initializer<uint8_t>;
     138             : template class spu::module::Initializer<int16_t>;
     139             : template class spu::module::Initializer<uint16_t>;
     140             : template class spu::module::Initializer<int32_t>;
     141             : template class spu::module::Initializer<uint32_t>;
     142             : template class spu::module::Initializer<int64_t>;
     143             : template class spu::module::Initializer<uint64_t>;
     144             : template class spu::module::Initializer<float>;
     145             : template class spu::module::Initializer<double>;
     146             : // ==================================================================================== explicit template instantiation