folly::ThreadWheelTimekeeper Class Reference

#include <ThreadWheelTimekeeper.h>

Inheritance diagram for folly::ThreadWheelTimekeeper:

Public Member Functions
	ThreadWheelTimekeeper ()
	But it doesn't have to be a singleton. More...
	~ThreadWheelTimekeeper () override
Future< Unit >	after (Duration) override
Public Member Functions inherited from folly::Timekeeper
virtual	~Timekeeper ()=default
template<class Clock >
Future< Unit >	at (std::chrono::time_point< Clock > when)

Protected Attributes
folly::EventBase	eventBase_
std::thread	thread_
HHWheelTimer::UniquePtr	wheelTimer_

Detailed Description

The default Timekeeper implementation which uses a HHWheelTimer on an EventBase in a dedicated thread. Users needn't deal with this directly, it is used by default by Future methods that work with timeouts.

Definition at line 29 of file ThreadWheelTimekeeper.h.

Constructor & Destructor Documentation

folly::ThreadWheelTimekeeper::ThreadWheelTimekeeper

(

)

But it doesn't have to be a singleton.

Definition at line 104 of file ThreadWheelTimekeeper.cpp.

References eventBase_, folly::EventBase::loopForever(), folly::HHWheelTimer::newTimer(), folly::EventBase::runInEventBaseThread(), folly::EventBase::setName(), folly::EventBase::waitUntilRunning(), and wheelTimer_.

    : thread_([this] { eventBase_.loopForever(); }),
      wheelTimer_(
          HHWheelTimer::newTimer(&eventBase_, std::chrono::milliseconds(1))) {
  eventBase_.waitUntilRunning();
  eventBase_.runInEventBaseThread([this] {
    // 15 characters max
    eventBase_.setName("FutureTimekeepr");
  });
}

folly::ThreadWheelTimekeeper::~ThreadWheelTimekeeper ( )

override

Definition at line 115 of file ThreadWheelTimekeeper.cpp.

References eventBase_, folly::EventBase::runInEventBaseThreadAndWait(), folly::EventBase::terminateLoopSoon(), thread_, and wheelTimer_.

                                              {
  eventBase_.runInEventBaseThreadAndWait([this] {
    wheelTimer_->cancelAll();
    eventBase_.terminateLoopSoon();
  });
  thread_.join();
}

Member Function Documentation

Future< Unit > folly::ThreadWheelTimekeeper::after ( Duration  dur )

overridevirtual

Implement the Timekeeper interface This future does complete on the timer thread. You should almost certainly follow it with a via() call or the accuracy of other timers will suffer.

Implements folly::Timekeeper.

Definition at line 123 of file ThreadWheelTimekeeper.cpp.

References eventBase_, f, and folly::EventBase::runInEventBaseThread().

Referenced by TEST_F().

                                                      {
  auto cob = WTCallback::create(&eventBase_);
  auto f = cob->getFuture();
  //
  // Even shared_ptr of cob is captured in lambda this is still somewhat *racy*
  // because it will be released once timeout is scheduled. So technically there
  // is no gurantee that EventBase thread can safely call timeout callback.
  // However due to fact that we are having circular reference here:
  // WTCallback->Promise->Core->WTCallbak, so three of them won't go away until
  // we break the circular reference. The break happens either in
  // WTCallback::timeoutExpired or WTCallback::interruptHandler. Former means
  // timeout callback is being safely executed. Latter captures shared_ptr of
  // WTCallback again in another lambda for canceling timeout. The moment
  // canceling timeout is executed in EventBase thread, the actual timeout
  // callback has either been executed, or will never be executed. So we are
  // fine here.
  //
  if (!eventBase_.runInEventBaseThread(
          [this, cob, dur] { wheelTimer_->scheduleTimeout(cob.get(), dur); })) {
    // Release promise to break the circular reference. Because if
    // scheduleTimeout fails, there is nothing to *promise*. Internally
    // Core would automatically set an exception result when Promise is
    // destructed before fulfilling.
    // This is either called from EventBase thread, or here.
    // They are somewhat racy but given the rare chance this could fail,
    // I don't see it is introducing any problem yet.
    auto promise = cob->stealPromise();
    if (!promise.isFulfilled()) {
      promise.setException(FutureNoTimekeeper{});
    }
  }
  return f;
}

Member Data Documentation

folly::EventBase folly::ThreadWheelTimekeeper::eventBase_

protected

Definition at line 42 of file ThreadWheelTimekeeper.h.

Referenced by after(), ThreadWheelTimekeeper(), and ~ThreadWheelTimekeeper().

std::thread folly::ThreadWheelTimekeeper::thread_

protected

Definition at line 43 of file ThreadWheelTimekeeper.h.

Referenced by ~ThreadWheelTimekeeper().

HHWheelTimer::UniquePtr folly::ThreadWheelTimekeeper::wheelTimer_

protected

Definition at line 44 of file ThreadWheelTimekeeper.h.

Referenced by ThreadWheelTimekeeper(), and ~ThreadWheelTimekeeper().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/futures/ThreadWheelTimekeeper.h
• proxygen/folly/folly/futures/ThreadWheelTimekeeper.cpp