proxygen: folly::HHWheelTimer Class Reference

#include <HHWheelTimer.h>

Inheritance diagram for folly::HHWheelTimer:

Classes
class	Callback

Public Types
using	UniquePtr = std::unique_ptr< HHWheelTimer, Destructor >

using	SharedPtr = std::shared_ptr< HHWheelTimer >

Public Member Functions
	HHWheelTimer (folly::TimeoutManager *timeoutManager, std::chrono::milliseconds intervalMS=std::chrono::milliseconds(DEFAULT_TICK_INTERVAL), AsyncTimeout::InternalEnum internal=AsyncTimeout::InternalEnum::NORMAL, std::chrono::milliseconds defaultTimeoutMS=std::chrono::milliseconds(-1))

size_t	cancelAll ()

std::chrono::milliseconds	getTickInterval () const

std::chrono::milliseconds	getDefaultTimeout () const

void	setDefaultTimeout (std::chrono::milliseconds timeout)

void	scheduleTimeout (Callback *callback, std::chrono::milliseconds timeout)

void	scheduleTimeoutImpl (Callback *callback, std::chrono::milliseconds timeout)

void	scheduleTimeout (Callback *callback)

template<class F >
void	scheduleTimeoutFn (F fn, std::chrono::milliseconds timeout)

std::size_t	count () const

bool	isDetachable () const

Public Member Functions inherited from folly::DelayedDestruction
virtual void	destroy ()

bool	getDestroyPending () const

Public Member Functions inherited from folly::DelayedDestructionBase
virtual	~DelayedDestructionBase ()=default

Static Public Member Functions
template<typename... Args>
static UniquePtr	newTimer (Args &&...args)

Static Public Attributes
static int	DEFAULT_TICK_INTERVAL = 10

Protected Member Functions
	~HHWheelTimer () override

Protected Member Functions inherited from folly::DelayedDestruction
	~DelayedDestruction () override=default

	DelayedDestruction ()

Protected Member Functions inherited from folly::DelayedDestructionBase
	DelayedDestructionBase ()

uint32_t	getDestructorGuardCount () const

Private Types
typedef Callback::List	CallbackList

Private Types inherited from folly::AsyncTimeout
typedef TimeoutManager::InternalEnum	InternalEnum

Private Member Functions
	HHWheelTimer (HHWheelTimer const &)=delete

HHWheelTimer &	operator= (HHWheelTimer const &)=delete

void	timeoutExpired () noexceptoverride

int64_t	timeToWheelTicks (std::chrono::milliseconds t)

bool	cascadeTimers (int bucket, int tick)

int64_t	calcNextTick ()

void	scheduleNextTimeout ()

std::chrono::steady_clock::time_point	getCurTime ()

Private Member Functions inherited from folly::AsyncTimeout
	AsyncTimeout (TimeoutManager *timeoutManager)

	AsyncTimeout (EventBase *eventBase)

	AsyncTimeout (TimeoutManager *timeoutManager, InternalEnum internal)

	AsyncTimeout (EventBase *eventBase, InternalEnum internal)

	AsyncTimeout ()

virtual	~AsyncTimeout ()

bool	scheduleTimeout (uint32_t milliseconds)

bool	scheduleTimeout (TimeoutManager::timeout_type timeout)

void	cancelTimeout ()

bool	isScheduled () const

void	attachTimeoutManager (TimeoutManager *timeoutManager, InternalEnum internal=InternalEnum::NORMAL)

void	attachEventBase (EventBase *eventBase, InternalEnum internal=InternalEnum::NORMAL)

void	detachTimeoutManager ()

void	detachEventBase ()

const TimeoutManager *	getTimeoutManager ()

struct event *	getEvent ()

Private Attributes
std::chrono::milliseconds	interval_

std::chrono::milliseconds	defaultTimeout_

CallbackList	buckets_ [WHEEL_BUCKETS][WHEEL_SIZE]

std::vector< std::size_t >	bitmap_

int64_t	lastTick_

int64_t	expireTick_

std::size_t	count_

std::chrono::steady_clock::time_point	startTime_

bool *	processingCallbacksGuard_

CallbackList	timeouts

Static Private Attributes
static constexpr int	WHEEL_BUCKETS = 4

static constexpr int	WHEEL_BITS = 8

static constexpr unsigned int	WHEEL_SIZE = (1 << WHEEL_BITS)

static constexpr unsigned int	WHEEL_MASK = (WHEEL_SIZE - 1)

static constexpr uint32_t	LARGEST_SLOT = 0xffffffffUL

Additional Inherited Members
Static Private Member Functions inherited from folly::AsyncTimeout
template<typename TCallback >
static std::unique_ptr< AsyncTimeout >	make (TimeoutManager &manager, TCallback &&callback)

template<typename TCallback >
static std::unique_ptr< AsyncTimeout >	schedule (TimeoutManager::timeout_type timeout, TimeoutManager &manager, TCallback &&callback)

Detailed Description

Hashed Hierarchical Wheel Timer

We model timers as the number of ticks until the next due event. We allow 32-bits of space to track this due interval, and break that into 4 regions of 8 bits. Each region indexes into a bucket of 256 lists.

Bucket 0 represents those events that are due the soonest. Each tick causes us to look at the next list in a bucket. The 0th list in a bucket is special; it means that it is time to flush the timers from the next higher bucket and schedule them into a different bucket.

This technique results in a very cheap mechanism for maintaining time and timers.

Unlike the original timer wheel paper, this implementation does not tick constantly, and instead calculates the exact next wakeup time.

Definition at line 54 of file HHWheelTimer.h.

Member Typedef Documentation

typedef Callback::List folly::HHWheelTimer::CallbackList

private

Definition at line 290 of file HHWheelTimer.h.

using folly::HHWheelTimer::SharedPtr = std::shared_ptr<HHWheelTimer>

Definition at line 58 of file HHWheelTimer.h.

using folly::HHWheelTimer::UniquePtr = std::unique_ptr<HHWheelTimer, Destructor>

Definition at line 57 of file HHWheelTimer.h.

Constructor & Destructor Documentation

folly::HHWheelTimer::HHWheelTimer	(	folly::TimeoutManager *	timeoutManager,
		std::chrono::milliseconds	intervalMS = `std::chrono::milliseconds(DEFAULT_TICK_INTERVAL)`,
		AsyncTimeout::InternalEnum	internal = `AsyncTimeout::InternalEnum::NORMAL`,
		std::chrono::milliseconds	defaultTimeoutMS = `std::chrono::milliseconds(-1)`
	)

explicit

Definition at line 78 of file HHWheelTimer.cpp.

References bitmap_, and WHEEL_SIZE.

Referenced by newTimer().

     : AsyncTimeout(timeoutMananger, internal),
       interval_(intervalMS),
       defaultTimeout_(defaultTimeoutMS),
       lastTick_(1),
       expireTick_(1),
       count_(0),
       startTime_(getCurTime()),
       processingCallbacksGuard_(nullptr) {
   bitmap_.resize((WHEEL_SIZE / sizeof(std::size_t)) / 8, 0);
 }

folly::HHWheelTimer::~HHWheelTimer ( )

overrideprotected

Protected destructor.

Use destroy() instead. See the comments in DelayedDestruction for more details.

Definition at line 94 of file HHWheelTimer.cpp.

References cancelAll(), folly::makeGuard(), processingCallbacksGuard_, and timeouts.

Referenced by isDetachable().

                             {
   // Ensure this gets done, but right before destruction finishes.
   auto destructionPublisherGuard = folly::makeGuard([&] {
     // Inform the subscriber that this instance is doomed.
     if (processingCallbacksGuard_) {
       *processingCallbacksGuard_ = true;
     }
   });
   while (!timeouts.empty()) {
     auto* cb = &timeouts.front();
     timeouts.pop_front();
     cb->cancelTimeout();
     cb->callbackCanceled();
   }
   cancelAll();
 }

folly::HHWheelTimer::HHWheelTimer ( HHWheelTimer const & )

privatedelete

Member Function Documentation

int64_t folly::HHWheelTimer::calcNextTick ( )

private

Definition at line 307 of file HHWheelTimer.cpp.

References getCurTime(), interval_, lastTick_, processingCallbacksGuard_, and startTime_.

Referenced by scheduleNextTimeout(), scheduleTimeoutImpl(), and timeoutExpired().

                                    {
   auto intervals = (getCurTime() - startTime_) / interval_;
   // Slow eventbases will have skew between the actual time and the
   // callback time.  To avoid racing the next scheduleNextTimeout()
   // call, always schedule new timeouts against the actual
   // timeoutExpired() time.
   if (!processingCallbacksGuard_) {
     return intervals;
   } else {
     return lastTick_;
   }
 }

size_t folly::HHWheelTimer::cancelAll ( )

Cancel all outstanding timeouts

Returns: the number of timeouts that were cancelled.

Definition at line 247 of file HHWheelTimer.cpp.

References buckets_, count(), count_, i, min, folly::f14::swap(), WHEEL_BUCKETS, and WHEEL_SIZE.

Referenced by TEST_F(), and ~HHWheelTimer().

                                {
   size_t count = 0;
 
   if (count_ != 0) {
     const std::size_t numElements = WHEEL_BUCKETS * WHEEL_SIZE;
     auto maxBuckets = std::min(numElements, count_);
     auto buckets = std::make_unique<CallbackList[]>(maxBuckets);
     size_t countBuckets = 0;
     for (auto& tick : buckets_) {
       for (auto& bucket : tick) {
         if (bucket.empty()) {
           continue;
         }
         count += bucket.size();
         std::swap(bucket, buckets[countBuckets++]);
         if (count >= count_) {
           break;
         }
       }
     }
 
     for (size_t i = 0; i < countBuckets; ++i) {
       auto& bucket = buckets[i];
       while (!bucket.empty()) {
         auto& cb = bucket.front();
         cb.cancelTimeout();
         cb.callbackCanceled();
       }
     }
   }
 
   return count;
 }

bool folly::HHWheelTimer::cascadeTimers	(	int	bucket,
		int	tick
	)

private

Definition at line 171 of file HHWheelTimer.cpp.

References buckets_, getCurTime(), and scheduleTimeoutImpl().

Referenced by timeoutExpired(), and timeToWheelTicks().

                                                      {
   CallbackList cbs;
   cbs.swap(buckets_[bucket][tick]);
   while (!cbs.empty()) {
     auto* cb = &cbs.front();
     cbs.pop_front();
     scheduleTimeoutImpl(cb, cb->getTimeRemaining(getCurTime()));
   }
 
   // If tick is zero, timeoutExpired will cascade the next bucket.
   return tick == 0;
 }

std::size_t folly::HHWheelTimer::count ( ) const

inline

Return the number of currently pending timeouts

Definition at line 252 of file HHWheelTimer.h.

References count_.

Referenced by cancelAll(), and TEST_F().

                           {
     return count_;
   }

std::chrono::steady_clock::time_point folly::HHWheelTimer::getCurTime ( )

inlineprivate

Definition at line 311 of file HHWheelTimer.h.

References now().

Referenced by calcNextTick(), and cascadeTimers().

                                                {
     return std::chrono::steady_clock::now();
   }

std::chrono::milliseconds folly::HHWheelTimer::getDefaultTimeout ( ) const

inline

Get the default timeout interval for this HHWheelTimer.

Returns the timeout interval in milliseconds.

Definition at line 193 of file HHWheelTimer.h.

References defaultTimeout_.

Referenced by TEST_F(), and proxygen::WheelTimerInstance::WheelTimerInstance().

                                                   {
     return defaultTimeout_;
   }

std::chrono::milliseconds folly::HHWheelTimer::getTickInterval ( ) const

inline

Get the tick interval for this HHWheelTimer.

Returns the tick interval in milliseconds.

Definition at line 184 of file HHWheelTimer.h.

References interval_.

                                                 {
     return interval_;
   }

bool folly::HHWheelTimer::isDetachable ( ) const

inline

Definition at line 256 of file HHWheelTimer.h.

References folly::AsyncTimeout::attachEventBase(), folly::AsyncTimeout::detachEventBase(), folly::AsyncTimeout::getTimeoutManager(), folly::HHWheelTimer::Callback::HHWheelTimer, folly::AsyncTimeout::isScheduled(), folly::pushmi::__adl::noexcept(), operator=(), folly::HHWheelTimer::Callback::timeoutExpired(), and ~HHWheelTimer().

                             {
     return !folly::AsyncTimeout::isScheduled();
   }

template<typename... Args>

static UniquePtr folly::HHWheelTimer::newTimer ( Args &&... args )

inlinestatic

Definition at line 61 of file HHWheelTimer.h.

References HHWheelTimer().

Referenced by HTTPUpstreamTest< SPDY3CodecPair >::HTTPUpstreamTest(), proxygen::makeInternalTimeoutSet(), proxygen::makeTimeoutSet(), TEST_F(), folly::ThreadWheelTimekeeper::ThreadWheelTimekeeper(), TimeoutableHTTPUpstreamTest< C >::TimeoutableHTTPUpstreamTest(), and folly::EventBase::timer().

                                             {
     return UniquePtr(new HHWheelTimer(std::forward<Args>(args)...));
   }

HHWheelTimer& folly::HHWheelTimer::operator= ( HHWheelTimer const & )

privatedelete

Referenced by isDetachable().

void folly::HHWheelTimer::scheduleNextTimeout ( )

private

Definition at line 281 of file HHWheelTimer.cpp.

References bitmap_, calcNextTick(), folly::AsyncTimeout::cancelTimeout(), count_, expireTick_, folly::findFirstSet(), int64_t, interval_, folly::AsyncTimeout::isScheduled(), folly::makeBitIterator(), folly::AsyncTimeout::scheduleTimeout(), WHEEL_MASK, and WHEEL_SIZE.

Referenced by scheduleTimeout(), and timeoutExpired().

                                        {
   auto nextTick = calcNextTick();
   int64_t tick = 1;
 
   if (nextTick & WHEEL_MASK) {
     auto bi = makeBitIterator(bitmap_.begin());
     auto bi_end = makeBitIterator(bitmap_.end());
     auto it = folly::findFirstSet(bi + (nextTick & WHEEL_MASK), bi_end);
     if (it == bi_end) {
       tick = WHEEL_SIZE - ((nextTick - 1) & WHEEL_MASK);
     } else {
       tick = std::distance(bi + (nextTick & WHEEL_MASK), it) + 1;
     }
   }
 
   if (count_ > 0) {
     if (!this->AsyncTimeout::isScheduled() ||
         (expireTick_ > tick + nextTick - 1)) {
       this->AsyncTimeout::scheduleTimeout(interval_ * tick);
       expireTick_ = tick + nextTick - 1;
     }
   } else {
     this->AsyncTimeout::cancelTimeout();
   }
 }

void folly::HHWheelTimer::scheduleTimeout	(	Callback *	callback,
		std::chrono::milliseconds	timeout
	)

Schedule the specified Callback to be invoked after the specified timeout interval.

If the callback is already scheduled, this cancels the existing timeout before scheduling the new timeout.

Definition at line 144 of file HHWheelTimer.cpp.

References folly::HHWheelTimer::Callback::cancelTimeout(), count_, processingCallbacksGuard_, folly::HHWheelTimer::Callback::requestContext_, folly::RequestContext::saveContext(), scheduleNextTimeout(), scheduleTimeoutImpl(), and folly::HHWheelTimer::Callback::setScheduled().

Referenced by proxygen::HTTPTransaction::maybeDelayForRateLimit(), proxygen::WheelTimerInstance::scheduleTimeout(), scheduleTimeout(), scheduleTimeoutFn(), setDefaultTimeout(), TEST_F(), and TestTimeout::TestTimeout().

                                    {
   // Cancel the callback if it happens to be scheduled already.
   callback->cancelTimeout();
 
   callback->requestContext_ = RequestContext::saveContext();
 
   count_++;
 
   callback->setScheduled(this, timeout);
   scheduleTimeoutImpl(callback, timeout);
 
   /* If we're calling callbacks, timer will be reset after all
    * callbacks are called.
    */
   if (!processingCallbacksGuard_) {
     scheduleNextTimeout();
   }
 }

void folly::HHWheelTimer::scheduleTimeout ( Callback * callback )

Schedule the specified Callback to be invoked after the default timeout interval.

If the callback is already scheduled, this cancels the existing timeout before scheduling the new timeout.

This method uses CHECK() to make sure that the default timeout was specified on the object initialization.

Definition at line 165 of file HHWheelTimer.cpp.

References defaultTimeout_, and scheduleTimeout().

                                                      {
   CHECK(std::chrono::milliseconds(-1) != defaultTimeout_)
       << "Default timeout was not initialized";
   scheduleTimeout(callback, defaultTimeout_);
 }

template<class F >

void folly::HHWheelTimer::scheduleTimeoutFn	(	F	fn,
		std::chrono::milliseconds	timeout
	)

inline

Definition at line 229 of file HHWheelTimer.h.

References f, folly::gen::move, folly::pushmi::__adl::noexcept(), scheduleTimeout(), and folly::HHWheelTimer::Callback::timeoutExpired().

Referenced by folly::EventBase::scheduleAt(), and TEST_F().

                                                               {
     struct Wrapper : Callback {
       Wrapper(F f) : fn_(std::move(f)) {}
       void timeoutExpired() noexcept override {
         try {
           fn_();
         } catch (std::exception const& e) {
           LOG(ERROR) << "HHWheelTimer timeout callback threw an exception: "
                      << e.what();
         } catch (...) {
           LOG(ERROR) << "HHWheelTimer timeout callback threw a non-exception.";
         }
         delete this;
       }
       F fn_;
     };
     Wrapper* w = new Wrapper(std::move(fn));
     scheduleTimeout(w, timeout);
   }

void folly::HHWheelTimer::scheduleTimeoutImpl	(	Callback *	callback,
		std::chrono::milliseconds	timeout
	)

Definition at line 111 of file HHWheelTimer.cpp.

References bitmap_, folly::HHWheelTimer::Callback::bucket_, buckets_, calcNextTick(), diff(), int64_t, LARGEST_SLOT, bm::list, folly::makeBitIterator(), timeToWheelTicks(), WHEEL_BITS, WHEEL_MASK, and WHEEL_SIZE.

Referenced by cascadeTimers(), scheduleTimeout(), and setDefaultTimeout().

                                    {
   auto nextTick = calcNextTick();
   int64_t due = timeToWheelTicks(timeout) + nextTick;
   int64_t diff = due - nextTick;
   CallbackList* list;
 
   auto bi = makeBitIterator(bitmap_.begin());
 
   if (diff < 0) {
     list = &buckets_[0][nextTick & WHEEL_MASK];
     *(bi + (nextTick & WHEEL_MASK)) = true;
     callback->bucket_ = nextTick & WHEEL_MASK;
   } else if (diff < WHEEL_SIZE) {
     list = &buckets_[0][due & WHEEL_MASK];
     *(bi + (due & WHEEL_MASK)) = true;
     callback->bucket_ = due & WHEEL_MASK;
   } else if (diff < 1 << (2 * WHEEL_BITS)) {
     list = &buckets_[1][(due >> WHEEL_BITS) & WHEEL_MASK];
   } else if (diff < 1 << (3 * WHEEL_BITS)) {
     list = &buckets_[2][(due >> 2 * WHEEL_BITS) & WHEEL_MASK];
   } else {
     /* in largest slot */
     if (diff > LARGEST_SLOT) {
       diff = LARGEST_SLOT;
       due = diff + nextTick;
     }
     list = &buckets_[3][(due >> 3 * WHEEL_BITS) & WHEEL_MASK];
   }
   list->push_back(*callback);
 }

void folly::HHWheelTimer::setDefaultTimeout ( std::chrono::milliseconds timeout )

inline

Set the default timeout interval for this HHWheelTimer.

Definition at line 200 of file HHWheelTimer.h.

References defaultTimeout_, scheduleTimeout(), scheduleTimeoutImpl(), and folly::detail::timeout.

Referenced by TEST_F().

                                                         {
     defaultTimeout_ = timeout;
   }

void folly::HHWheelTimer::timeoutExpired ( )

overrideprivatevirtualnoexcept

timeoutExpired() is invoked when the timeout period has expired.

Implements folly::AsyncTimeout.

Definition at line 184 of file HHWheelTimer.cpp.

References bitmap_, buckets_, calcNextTick(), cascadeTimers(), count_, expireTick_, lastTick_, folly::makeBitIterator(), folly::makeGuard(), processingCallbacksGuard_, scheduleNextTimeout(), timeouts, WHEEL_BITS, and WHEEL_MASK.

                                            {
   auto nextTick = calcNextTick();
 
   // If the last smart pointer for "this" is reset inside the callback's
   // timeoutExpired(), then the guard will detect that it is time to bail from
   // this method.
   auto isDestroyed = false;
   // If scheduleTimeout is called from a callback in this function, it may
   // cause inconsistencies in the state of this object. As such, we need
   // to treat these calls slightly differently.
   CHECK(!processingCallbacksGuard_);
   processingCallbacksGuard_ = &isDestroyed;
   auto reEntryGuard = folly::makeGuard([&] {
     if (!isDestroyed) {
       processingCallbacksGuard_ = nullptr;
     }
   });
 
   // timeoutExpired() can only be invoked directly from the event base loop.
   // It should never be invoked recursively.
   //
   lastTick_ = expireTick_;
   while (lastTick_ < nextTick) {
     int idx = lastTick_ & WHEEL_MASK;
 
     auto bi = makeBitIterator(bitmap_.begin());
     *(bi + idx) = false;
 
     lastTick_++;
     CallbackList* cbs = &buckets_[0][idx];
     while (!cbs->empty()) {
       auto* cb = &cbs->front();
       cbs->pop_front();
       timeouts.push_back(*cb);
     }
 
     if (idx == 0) {
       // Cascade timers
       if (cascadeTimers(1, (lastTick_ >> WHEEL_BITS) & WHEEL_MASK) &&
           cascadeTimers(2, (lastTick_ >> (2 * WHEEL_BITS)) & WHEEL_MASK)) {
         cascadeTimers(3, (lastTick_ >> (3 * WHEEL_BITS)) & WHEEL_MASK);
       }
     }
   }
 
   while (!timeouts.empty()) {
     auto* cb = &timeouts.front();
     timeouts.pop_front();
     count_--;
     cb->wheel_ = nullptr;
     cb->expiration_ = {};
     RequestContextScopeGuard rctx(cb->requestContext_);
     cb->timeoutExpired();
     if (isDestroyed) {
       // The HHWheelTimer itself has been destroyed. The other callbacks
       // will have been cancelled from the destructor. Bail before causing
       // damage.
       return;
     }
   }
   scheduleNextTimeout();
 }

int64_t folly::HHWheelTimer::timeToWheelTicks ( std::chrono::milliseconds t )

inlineprivate

Definition at line 294 of file HHWheelTimer.h.

References cascadeTimers().

Referenced by scheduleTimeoutImpl().

                                                     {
     return t.count() / interval_.count();
   }

Member Data Documentation

std::vector<std::size_t> folly::HHWheelTimer::bitmap_

private

Definition at line 292 of file HHWheelTimer.h.

Referenced by folly::HHWheelTimer::Callback::cancelTimeoutImpl(), HHWheelTimer(), scheduleNextTimeout(), scheduleTimeoutImpl(), and timeoutExpired().

CallbackList folly::HHWheelTimer::buckets_[WHEEL_BUCKETS][WHEEL_SIZE]

private

Definition at line 291 of file HHWheelTimer.h.

Referenced by cancelAll(), folly::HHWheelTimer::Callback::cancelTimeoutImpl(), cascadeTimers(), scheduleTimeoutImpl(), and timeoutExpired().

std::size_t folly::HHWheelTimer::count_

private

Definition at line 301 of file HHWheelTimer.h.

Referenced by cancelAll(), folly::HHWheelTimer::Callback::cancelTimeoutImpl(), count(), scheduleNextTimeout(), scheduleTimeout(), and timeoutExpired().

int folly::HHWheelTimer::DEFAULT_TICK_INTERVAL = 10

static

Create a new HHWheelTimer with the specified interval and the default timeout value set.

Objects created using this version of constructor can be used to schedule both variable interval timeouts using scheduleTimeout(callback, timeout) method, and default interval timeouts using scheduleTimeout(callback) method.

We want to select the default interval carefully. An interval of 10ms will give us 10ms * WHEEL_SIZE^WHEEL_BUCKETS for the largest timeout possible, or about 497 days.

For a lower bound, we want a reasonable limit on local IO, 10ms seems short enough

A shorter interval also has CPU implications, less than 1ms might start showing up in cpu perf. Also, it might not be possible to set tick interval less than 10ms on older kernels.

Definition at line 163 of file HHWheelTimer.h.

Referenced by HTTPUpstreamTest< SPDY3CodecPair >::HTTPUpstreamTest(), proxygen::makeInternalTimeoutSet(), proxygen::makeTimeoutSet(), ScopedServerTest::SetUp(), TEST(), TEST_F(), and TimeoutableHTTPUpstreamTest< C >::TimeoutableHTTPUpstreamTest().