Line data    Source code

       1             : #include <chrono>
       2             : #include <sstream>
       3             : #include <string>
       4             : #include <thread>
       5             : 
       6             : #include "Module/Iterator/Iterator.hpp"
       7             : 
       8             : using namespace spu;
       9             : using namespace spu::module;
      10             : 
      11          48 : Iterator::Iterator(const size_t limit)
      12             :   : Module()
      13          48 :   , limit(limit)
      14          48 :   , counter(0)
      15             : {
      16          48 :     const std::string name = "Iterator";
      17          48 :     this->set_name(name);
      18          48 :     this->set_short_name(name);
      19          48 :     this->set_single_wave(true);
      20             : 
      21          48 :     auto& p1 = this->create_task("iterate");
      22          48 :     const auto p1s_out = this->create_socket_out(p1, "out", 1, typeid(int8_t));
      23          48 :     this->create_codelet(p1,
      24       49328 :                          [p1s_out](Module& m, runtime::Task& t, const size_t frame_id) -> int
      25             :                          {
      26       49328 :                              auto& ite = static_cast<Iterator&>(m);
      27       49328 :                              ite._iterate(t[p1s_out].get_dataptr<int8_t>(), frame_id);
      28       49287 :                              return runtime::status_t::SUCCESS;
      29             :                          });
      30             : 
      31          48 :     auto& p2 = this->create_task("reset");
      32          48 :     this->create_codelet(p2,
      33           0 :                          [](Module& m, runtime::Task& t, const size_t frame_id) -> int
      34             :                          {
      35           0 :                              auto& ite = static_cast<Iterator&>(m);
      36           0 :                              ite.reset();
      37           0 :                              return runtime::status_t::SUCCESS;
      38             :                          });
      39          48 : }
      40             : 
      41             : Iterator*
      42        1636 : Iterator::clone() const
      43             : {
      44        1636 :     auto m = new Iterator(*this);
      45        1636 :     m->deep_copy(*this);
      46        1636 :     return m;
      47             : }
      48             : 
      49             : size_t
      50    32419876 : Iterator::get_limit() const
      51             : {
      52    32419876 :     return this->limit;
      53             : }
      54             : 
      55             : void
      56           0 : Iterator::set_limit(const size_t limit)
      57             : {
      58           0 :     this->limit = limit;
      59           0 :     this->counter = this->counter % (this->limit + 1);
      60           0 : }
      61             : 
      62             : void
      63        1566 : Iterator::reset()
      64             : {
      65        1566 :     this->counter = 0;
      66        1566 : }
      67             : 
      68             : void
      69           0 : Iterator::iterate(int8_t* out, const int frame_id, const bool managed_memory)
      70             : {
      71           0 :     (*this)[ite::sck::iterate::out].bind(out);
      72           0 :     (*this)[ite::tsk::iterate].exec(frame_id, managed_memory);
      73           0 : }
      74             : 
      75             : void
      76       49287 : Iterator::_iterate(int8_t* out, const size_t frame_id)
      77             : {
      78       49287 :     size_t is_over_path = this->counter < this->limit ? 0 : 1;
      79       49287 :     this->counter++;
      80       49287 :     this->counter = this->counter % (this->limit + 1);
      81       49287 :     out[0] = is_over_path;
      82       49287 : }