Line data    Source code

       1             : #include <chrono>
       2             : #include <string>
       3             : #include <thread>
       4             : 
       5             : #include "Module/Stateful/Sleeper/Sleeper.hpp"
       6             : 
       7             : using namespace spu;
       8             : using namespace spu::module;
       9             : 
      10           0 : Sleeper::Sleeper(const size_t ns)
      11             :   : Stateful()
      12           0 :   , ns(ns)
      13             : {
      14           0 :     const std::string name = "Sleeper";
      15           0 :     this->set_name(name);
      16           0 :     this->set_short_name(name);
      17             : 
      18           0 :     auto& p = this->create_task("sleep");
      19           0 :     this->create_codelet(p,
      20           0 :                          [](Module& m, runtime::Task& t, const size_t frame_id) -> int
      21             :                          {
      22           0 :                              auto& slp = static_cast<Sleeper&>(m);
      23           0 :                              slp._sleep(frame_id);
      24           0 :                              return runtime::status_t::SUCCESS;
      25             :                          });
      26           0 : }
      27             : 
      28             : Sleeper*
      29           0 : Sleeper::clone() const
      30             : {
      31           0 :     auto m = new Sleeper(*this);
      32           0 :     m->deep_copy(*this);
      33           0 :     return m;
      34             : }
      35             : 
      36             : size_t
      37           0 : Sleeper::get_ns() const
      38             : {
      39           0 :     return this->ns;
      40             : }
      41             : 
      42             : void
      43           0 : Sleeper::set_ns(const size_t ns)
      44             : {
      45           0 :     this->ns = ns;
      46           0 : }
      47             : 
      48             : void
      49           0 : Sleeper::sleep(const int frame_id, const bool managed_memory)
      50             : {
      51           0 :     (*this)[slp::tsk::sleep].exec(frame_id, managed_memory);
      52           0 : }
      53             : 
      54             : void
      55           0 : Sleeper::_sleep(const size_t frame_id)
      56             : {
      57           0 :     auto t_start = std::chrono::steady_clock::now();
      58             :     std::chrono::nanoseconds duration;
      59             :     do
      60           0 :         duration = std::chrono::steady_clock::now() - t_start;
      61           0 :     while ((size_t)duration.count() < this->ns);
      62           0 : }