Method timer_thread

src/common/ceph_timer.h:101–155

  std::thread thread;

  void timer_thread() {
    ceph_pthread_setname("ceph_timer");
    std::unique_lock l(lock);
    while (!suspended) {
      auto now = TC::now();

      while (!schedule.empty()) {
	auto p = schedule.begin();
	// Should we wait for the future?
        #if defined(_WIN32)
        if (p->t - now > std::chrono::milliseconds(1)) {
          // std::condition_variable::wait_for uses SleepConditionVariableSRW
          // on Windows, which has millisecond precision. Deltas <1ms will
          // lead to busy loops, which should be avoided. This situation is
          // quite common since "wait_for" often returns ~1ms earlier than
          // requested.
          break;
        }
        #else // !_WIN32
        if (p->t > now) {
          break;
        }
        #endif

	auto& e = *p;
	schedule.erase(e);
	events.erase(e.id);

	// Since we have only one thread it is impossible to have more
	// than one running event
	running = &e;

	l.unlock();
	p->f();
	l.lock();

	if (running) {
	  running = nullptr;
	  delete &e;
	} // Otherwise the event requeued itself
      }

      if (suspended)
	break;
      if (schedule.empty()) {
	cond.wait(l);
      } else {
	// Since wait_until takes its parameter by reference, passing
	// the time /in the event/ is unsafe, as it might be canceled
	// while we wait.
	const auto t = schedule.begin()->t;
	cond.wait_until(l, t);
      }
    }
  }

public:
  timer() : suspended(false) {