Line data    Source code

       1             : #include <mutex>
       2             : 
       3             : #include "base/task.h"
       4             : #include "base/timer.h"
       5             : #include <boost/bind/bind.hpp>
       6             : #include "io/event_manager.h"
       7             : 
       8             : using namespace boost::placeholders;
       9             : 
      10             : class TaskTbbKeepAwake {
      11             : public:
      12           0 :     TaskTbbKeepAwake() : tbb_awake_count_(0), tbb_awake_val_(0),
      13           0 :                          timeout_changed_(false), tbb_awake_timer_(NULL) { }
      14             : 
      15           0 :     bool StartTbbKeepAwakeTask(TaskScheduler *ts, EventManager *event_mgr,
      16             :                                const std::string task_name,
      17             :                                uint32_t tbbKeepawakeTimeout = 1000) {
      18           0 :         uint32_t task_id = ts->GetTaskId(task_name);
      19           0 :         tbb_awake_timer_ = TimerManager::CreateTimer(*event_mgr->io_service(),
      20             :                                                      "TBB Keep Awake",
      21             :                                                      task_id, 0);
      22           0 :         tbb_awake_val_ = tbbKeepawakeTimeout;
      23           0 :         bool ret = tbb_awake_timer_->Start(tbbKeepawakeTimeout,
      24             :                        boost::bind(&TaskTbbKeepAwake::TbbKeepAwake, this));
      25           0 :         return ret;
      26             :     }
      27             : 
      28           0 :     void ModifyTbbKeepAwakeTimeout(uint32_t timeout) {
      29           0 :         std::scoped_lock lock(mutex_);
      30           0 :         if (tbb_awake_val_ != timeout) {
      31           0 :             timeout_changed_ = true;
      32           0 :             tbb_awake_val_ = timeout;
      33             :         }
      34           0 :     }
      35             : 
      36           0 :     bool TbbKeepAwake() {
      37           0 :         tbb_awake_count_++;
      38           0 :         if (timeout_changed_) {
      39           0 :             tbb_awake_timer_->Reschedule(tbb_awake_val_);
      40           0 :             timeout_changed_ = false;
      41             :         }
      42           0 :         return true;
      43             :     }
      44             : 
      45           0 :     void ShutTbbKeepAwakeTask() {
      46           0 :         if (tbb_awake_timer_) {
      47           0 :             tbb_awake_timer_->Cancel();
      48           0 :             TimerManager::DeleteTimer(tbb_awake_timer_);
      49             :         }
      50           0 :     }
      51             : 
      52             :     uint32_t tbb_awake_val() const { return tbb_awake_val_; }
      53             : private:
      54             :     uint64_t tbb_awake_count_;
      55             :     uint32_t tbb_awake_val_;
      56             :     bool timeout_changed_;
      57             :     Timer *tbb_awake_timer_;
      58             :     std::mutex mutex_;
      59             : };