proxygen::AsyncTimeoutSet Class Reference

#include <AsyncTimeoutSet.h>

Inheritance diagram for proxygen::AsyncTimeoutSet:

Classes
class	Callback
class	TimeoutClock

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

Public Member Functions
	AsyncTimeoutSet (folly::TimeoutManager *timeoutManager, std::chrono::milliseconds intervalMS, std::chrono::milliseconds atMostEveryN=std::chrono::milliseconds(0), TimeoutClock *timeoutClock=nullptr)
	AsyncTimeoutSet (folly::TimeoutManager *timeoutManager, InternalEnum internal, std::chrono::milliseconds intervalMS, std::chrono::milliseconds atMostEveryN=std::chrono::milliseconds(0))
void	destroy () override
std::chrono::milliseconds	getInterval () const
void	scheduleTimeout (Callback *callback)
void	fireAtMostEvery (const std::chrono::milliseconds &ms)
Callback *	front ()
const Callback *	front () const
Public Member Functions inherited from folly::DelayedDestruction
bool	getDestroyPending () const
Public Member Functions inherited from folly::DelayedDestructionBase
virtual	~DelayedDestructionBase ()=default

Protected Member Functions
	~AsyncTimeoutSet () 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 Member Functions
	AsyncTimeoutSet (AsyncTimeoutSet const &)=delete
AsyncTimeoutSet &	operator= (AsyncTimeoutSet const &)=delete
void	headChanged ()
void	timeoutExpired () noexceptoverride
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
TimeoutClock &	timeoutClock_
Callback *	head_
Callback *	tail_
std::chrono::milliseconds	interval_
std::chrono::milliseconds	atMostEveryN_
bool	inTimeoutExpired_ {false}

Additional Inherited Members
Private Types inherited from folly::AsyncTimeout
typedef TimeoutManager::InternalEnum	InternalEnum
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

AsyncTimeoutSet exists for efficiently managing a group of timeouts events that always have the same timeout interval.

AsyncTimeoutSet takes advantage of the fact that the timeouts are always scheduled in sorted order. (Since each timeout has the same interval, when a new timeout is scheduled it will always be the last timeout in the set.) This avoids the need to perform any additional sorting of the timeouts within a single AsyncTimeoutSet.

AsyncTimeoutSet is useful whenever you have a large group of objects that each need their own timeout, but with the same interval for each object. For example, managing idle timeouts for thousands of connection, or scheduling health checks for a large group of servers.

Note, this class may not be needed given libevent's event_base_init_common_timeout(). We should look into using that.

Definition at line 40 of file AsyncTimeoutSet.h.

Member Typedef Documentation

using proxygen::AsyncTimeoutSet::UniquePtr = std::unique_ptr<AsyncTimeoutSet, Destructor>

Definition at line 43 of file AsyncTimeoutSet.h.

Constructor & Destructor Documentation

proxygen::AsyncTimeoutSet::AsyncTimeoutSet	(	folly::TimeoutManager *	timeoutManager,
		std::chrono::milliseconds	intervalMS,
		std::chrono::milliseconds	atMostEveryN = std::chrono::milliseconds(0),
		TimeoutClock *	timeoutClock = nullptr
	)

Create a new AsyncTimeoutSet with the specified interval.

If timeout clock is unspecified, it will use the default (system clock)

Referenced by proxygen::AsyncTimeoutSet::Callback::cancelTimeoutImpl().

proxygen::AsyncTimeoutSet::AsyncTimeoutSet	(	folly::TimeoutManager *	timeoutManager,
		InternalEnum	internal,
		std::chrono::milliseconds	intervalMS,
		std::chrono::milliseconds	atMostEveryN = std::chrono::milliseconds(0)
	)

Create a new AsyncTimeoutSet with the given 'internal' settting. For details on what the InternalEnum specifies, see the documentation in AsyncTimeout.h

proxygen::AsyncTimeoutSet::~AsyncTimeoutSet ( )

overrideprotected

Protected destructor.

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

Definition at line 100 of file AsyncTimeoutSet.cpp.

Referenced by front().

                                  {
  // DelayedDestruction should ensure that we are never destroyed while inside
  // a call to timeoutExpired().
  assert(!inTimeoutExpired_);

  // destroy() should have already cleared out the timeout list.
  // It's a bug if anyone tries to keep using the AsyncTimeoutSet after
  // calling destroy, so no new timeouts may have been scheduled since then.
  assert(head_ == nullptr);
  assert(tail_ == nullptr);
}

proxygen::AsyncTimeoutSet::AsyncTimeoutSet ( AsyncTimeoutSet const &  )

privatedelete

Member Function Documentation

void proxygen::AsyncTimeoutSet::destroy ( )

overridevirtual

Destroy the AsyncTimeoutSet.

Normally a AsyncTimeoutSet should only be destroyed when there are no more callbacks pending in the set. If there are timeout callbacks pending for this set, destroying the AsyncTimeoutSet will automatically cancel them. If you destroy a AsyncTimeoutSet with callbacks pending, your callback code needs to be aware that the callbacks will never be invoked.

Reimplemented from folly::DelayedDestruction.

Definition at line 112 of file AsyncTimeoutSet.cpp.

References destroy().

Referenced by proxygen::AsyncTimeoutSet::TimeoutClock::~TimeoutClock().

                              {
  // If there are any timeout callbacks pending, get rid of them without ever
  // invoking them.  This is somewhat undesirable from the callback's
  // perspective (how is it supposed to know that it will never get invoked?).
  // Most users probably only want to destroy a AsyncTimeoutSet when it has no
  // callbacks remaining.  Otherwise they need to implement their own code to
  // take care of cleaning up the callbacks that will never be invoked.

  // cancel from tail to head, to avoid extra calls to headChanged
  while (tail_ != nullptr) {
    tail_->cancelTimeout();
  }

  DelayedDestruction::destroy();
}

void proxygen::AsyncTimeoutSet::fireAtMostEvery ( const std::chrono::milliseconds &  ms )

inline

Limit how frequently this AsyncTimeoutSet will fire.

Definition at line 179 of file AsyncTimeoutSet.h.

References atMostEveryN_.

                                                        {
    atMostEveryN_ = ms;
  }

Callback* proxygen::AsyncTimeoutSet::front ( )

inline

Get a pointer to the next Callback scheduled to be invoked (may be null).

Definition at line 186 of file AsyncTimeoutSet.h.

References head_.

Referenced by TestTimeout::_scheduleNext().

{ return head_; }

const Callback* proxygen::AsyncTimeoutSet::front ( ) const

inline

Definition at line 187 of file AsyncTimeoutSet.h.

References proxygen::AsyncTimeoutSet::Callback::AsyncTimeoutSet, head_, headChanged(), folly::pushmi::__adl::noexcept(), operator=(), proxygen::AsyncTimeoutSet::Callback::timeoutExpired(), and ~AsyncTimeoutSet().

{ return head_; }

std::chrono::milliseconds proxygen::AsyncTimeoutSet::getInterval ( ) const

inline

Get the interval for this AsyncTimeoutSet.

Returns the timeout interval in milliseconds. All callbacks scheduled with scheduleTimeout() will be invoked after this amount of time has passed since the call to scheduleTimeout().

Definition at line 163 of file AsyncTimeoutSet.h.

References interval_, and scheduleTimeout().

                                            {
    return interval_;
  }

void proxygen::AsyncTimeoutSet::headChanged ( )

private

Definition at line 158 of file AsyncTimeoutSet.cpp.

References folly::AsyncTimeout::cancelTimeout(), and folly::AsyncTimeout::scheduleTimeout().

Referenced by front().

                                  {
  if (inTimeoutExpired_) {
    // timeoutExpired() will always update the scheduling correctly before it
    // returns.  No need to change the state now, since we are just going to
    // change it again later.
    return;
  }

  if (!head_) {
    this->folly::AsyncTimeout::cancelTimeout();
  } else {
    milliseconds delta =
      head_->getTimeRemaining(timeoutClock_.millisecondsSinceEpoch());
    this->folly::AsyncTimeout::scheduleTimeout(delta.count());
  }
}

AsyncTimeoutSet& proxygen::AsyncTimeoutSet::operator= ( AsyncTimeoutSet const &  )

privatedelete

Referenced by front().

void proxygen::AsyncTimeoutSet::scheduleTimeout

(

Callback *

callback

)

Schedule the specified Callback to be invoked after the AsyncTimeoutSet's specified timeout interval.

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

Definition at line 128 of file AsyncTimeoutSet.cpp.

References proxygen::AsyncTimeoutSet::Callback::cancelTimeout(), proxygen::AsyncTimeoutSet::Callback::context_, proxygen::AsyncTimeoutSet::Callback::next_, proxygen::AsyncTimeoutSet::Callback::prev_, folly::RequestContext::saveContext(), folly::AsyncTimeout::scheduleTimeout(), and proxygen::AsyncTimeoutSet::Callback::setScheduled().

Referenced by TestTimeout::_scheduleNext(), and getInterval().

                                                        {
  // Cancel the callback if it happens to be scheduled already.
  callback->cancelTimeout();
  assert(callback->prev_ == nullptr);
  assert(callback->next_ == nullptr);

  callback->context_ = folly::RequestContext::saveContext();

  Callback* old_tail = tail_;
  if (head_ == nullptr) {
    // We don't have any timeouts scheduled already.  We have to schedule
    // ourself.
    assert(tail_ == nullptr);
    assert(!isScheduled());
    if (!inTimeoutExpired_) {
      this->folly::AsyncTimeout::scheduleTimeout(interval_.count());
    }
    head_ = callback;
    tail_ = callback;
  } else {
    assert(inTimeoutExpired_ || isScheduled());
    assert(tail_->next_ == nullptr);
    tail_->next_ = callback;
    tail_ = callback;
  }

  // callback->prev_ = tail_;
  callback->setScheduled(this, old_tail);
}

void proxygen::AsyncTimeoutSet::timeoutExpired ( )

overrideprivatevirtualnoexcept

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

Implements folly::AsyncTimeout.

Definition at line 175 of file AsyncTimeoutSet.cpp.

References proxygen::AsyncTimeoutSet::Callback::cancelTimeout(), proxygen::AsyncTimeoutSet::Callback::context_, now(), folly::AsyncTimeout::scheduleTimeout(), SCOPE_EXIT, folly::RequestContext::setContext(), and proxygen::AsyncTimeoutSet::Callback::timeoutExpired().

                                              {
  // If destroy() is called inside timeoutExpired(), delay actual destruction
  // until timeoutExpired() returns
  DestructorGuard dg(this);

  // timeoutExpired() can only be invoked directly from the event base loop.
  // It should never be invoked recursively.
  //
  // Set inTimeoutExpired_ to true, so that we won't bother rescheduling the
  // main AsyncTimeout inside timeoutExpired().  We'll always make sure this
  // is up-to-date before we return.  This simply prevents us from
  // unnecessarily modifying the main timeout heap multiple times before we
  // return.
  assert(!inTimeoutExpired_);
  inTimeoutExpired_ = true;
  SCOPE_EXIT { inTimeoutExpired_ = false; };

  // Get the current time.
  // For now we only compute the current time at the start of the loop.
  // If a callback takes a very long time to execute its timeoutExpired()
  // method, this value could potentially get stale.
  //
  // However, this should be rare, and it doesn't seem worth the overhead of
  // recomputing the current time each time around the loop.  If the value does
  // go stale, we won't invoke as many callbacks as we could.  They will have
  // to wait until the next call to timeoutExpired().  However, we could also
  // end up rescheduling the next timeoutExpired() call a bit late if now gets
  // stale.  If we find that this becomes a problem in practice we could be
  // more smart about when we recompute the current time.
  auto now = timeoutClock_.millisecondsSinceEpoch();

  while (head_ != nullptr) {
    milliseconds delta = head_->getTimeRemaining(now);
    if (delta > milliseconds(0)) {
      if (delta < atMostEveryN_) {
        delta = atMostEveryN_;
      }
      this->folly::AsyncTimeout::scheduleTimeout(delta.count());
      break;
    }

    // Remember the callback to invoke, since calling cancelTimeout()
    // on it will modify head_.
    Callback* cb = head_;
    head_->cancelTimeout();
    auto old_ctx =
      folly::RequestContext::setContext(cb->context_);
    cb->timeoutExpired();
    folly::RequestContext::setContext(old_ctx);
  }
}

Member Data Documentation

std::chrono::milliseconds proxygen::AsyncTimeoutSet::atMostEveryN_

private

Definition at line 213 of file AsyncTimeoutSet.h.

Referenced by fireAtMostEvery().

Callback* proxygen::AsyncTimeoutSet::head_

private

Definition at line 210 of file AsyncTimeoutSet.h.

Referenced by front().

std::chrono::milliseconds proxygen::AsyncTimeoutSet::interval_

private

Definition at line 212 of file AsyncTimeoutSet.h.

Referenced by getInterval().

bool proxygen::AsyncTimeoutSet::inTimeoutExpired_ {false}

private

Definition at line 214 of file AsyncTimeoutSet.h.

Callback* proxygen::AsyncTimeoutSet::tail_

private

Definition at line 211 of file AsyncTimeoutSet.h.

TimeoutClock& proxygen::AsyncTimeoutSet::timeoutClock_

private

Definition at line 209 of file AsyncTimeoutSet.h.

Referenced by proxygen::AsyncTimeoutSet::Callback::setScheduled().

---

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

• proxygen/lib/utils/AsyncTimeoutSet.h
• proxygen/lib/utils/AsyncTimeoutSet.cpp