Method TimerLoop

src/runtime/core/executor/time_wheel_executor.cc:217–327

}

void TimeWheelExecutor::TimerLoop() {
  tid_ = std::this_thread::get_id();

  std::string threadname = name_;

  try {
    aimrt::runtime::core::util::SetNameForCurrentThread(threadname);
    aimrt::runtime::core::util::BindCpuForCurrentThread(options_.thread_bind_cpu);
    aimrt::runtime::core::util::SetCpuSchedForCurrentThread(options_.thread_sched_policy);
  } catch (const std::exception& e) {
    AIMRT_WARN("Set thread policy for time manipulator executor '{}' get exception, {}",
               Name(), e.what());
  }

  auto last_loop_sys_tp = std::chrono::system_clock::now();
  auto last_loop_std_tp = std::chrono::steady_clock::now();

  // Record the initial time
  start_time_point_ =
      std::chrono::duration_cast<std::chrono::nanoseconds>(
          (options_.use_system_clock ? last_loop_sys_tp.time_since_epoch() : last_loop_std_tp.time_since_epoch()))
          .count();

  start_flag_.store(true);
  start_flag_.notify_all();

  while (state_.load() != State::kShutdown) {
    try {
      // sleep a dt
      auto real_dt = options_.dt;
      do {
        // Maximum sleep time
        static constexpr auto kMaxSleepDt = std::chrono::seconds(1);

        auto sleep_time = (real_dt > kMaxSleepDt) ? kMaxSleepDt : real_dt;
        real_dt -= sleep_time;

        // A small optimization to prevent real_dt from being too small
        if (real_dt.count() && options_.dt < kMaxSleepDt && real_dt <= options_.dt) {
          sleep_time += real_dt;
          real_dt = std::chrono::nanoseconds(0);
        }

        if (!options_.use_system_clock) {
          std::this_thread::sleep_until(
              last_loop_std_tp +=
              std::chrono::duration_cast<std::chrono::steady_clock::time_point::duration>(sleep_time));
        } else {
          std::this_thread::sleep_until(
              last_loop_sys_tp +=
              std::chrono::duration_cast<std::chrono::system_clock::time_point::duration>(sleep_time));
        }

      } while (state_.load() != State::kShutdown && real_dt.count());

      // Perform an immediate task
      if (!bind_executor_ref_) {
        std::queue<aimrt::executor::Task> tmp_queue;