folly::fibers::TimeoutController Class Reference

#include <TimeoutController.h>

Inheritance diagram for folly::fibers::TimeoutController:

Classes
struct	TimeoutHandle

Public Types
typedef std::chrono::steady_clock	Clock
typedef std::chrono::time_point< Clock >	TimePoint
typedef Clock::duration	Duration

Public Member Functions
	TimeoutController (LoopController &loopController)
intptr_t	registerTimeout (std::function< void()> f, Duration duration)
void	cancel (intptr_t id)
void	runTimeouts (TimePoint time)

Private Types
typedef std::queue< TimeoutHandle >	TimeoutHandleList
typedef std::unique_ptr< TimeoutHandleList >	TimeoutHandleListPtr

Private Member Functions
void	scheduleRun ()

Private Attributes
std::vector< std::pair< Duration, TimeoutHandleListPtr > >	timeoutHandleBuckets_
TimePoint	nextTimeout_
LoopController &	loopController_

Detailed Description

Definition at line 32 of file TimeoutController.h.

Member Typedef Documentation

typedef std::chrono::steady_clock folly::fibers::TimeoutController::Clock

Definition at line 35 of file TimeoutController.h.

typedef Clock::duration folly::fibers::TimeoutController::Duration

Definition at line 37 of file TimeoutController.h.

typedef std::queue<TimeoutHandle> folly::fibers::TimeoutController::TimeoutHandleList

private

Definition at line 49 of file TimeoutController.h.

typedef std::unique_ptr<TimeoutHandleList> folly::fibers::TimeoutController::TimeoutHandleListPtr

private

Definition at line 51 of file TimeoutController.h.

typedef std::chrono::time_point<Clock> folly::fibers::TimeoutController::TimePoint

Definition at line 36 of file TimeoutController.h.

Constructor & Destructor Documentation

folly::fibers::TimeoutController::TimeoutController ( LoopController &  loopController )

explicit

Definition at line 22 of file TimeoutController.cpp.

    : nextTimeout_(TimePoint::max()), loopController_(loopController) {}

Member Function Documentation

void folly::fibers::TimeoutController::cancel

(

intptr_t

id

)

Definition at line 97 of file TimeoutController.cpp.

References folly::fibers::TimeoutController::TimeoutHandle::canceled, and bm::list.

                                         {
  auto handle = reinterpret_cast<TimeoutHandle*>(p);
  handle->canceled = true;

  auto& list = handle->list;

  while (!list.empty() && list.front().canceled) {
    list.pop();
  }
}

intptr_t folly::fibers::TimeoutController::registerTimeout	(	std::function< void()>	f,
		Duration	duration
	)

Definition at line 25 of file TimeoutController.cpp.

References f, bm::list, folly::gen::move, nextTimeout_, now(), scheduleRun(), folly::detail::timeout, and timeoutHandleBuckets_.

                       {
  auto& list = [&]() -> TimeoutHandleList& {
    for (auto& bucket : timeoutHandleBuckets_) {
      if (bucket.first == duration) {
        return *bucket.second;
      }
    }

    timeoutHandleBuckets_.emplace_back(
        duration, std::make_unique<TimeoutHandleList>());
    return *timeoutHandleBuckets_.back().second;
  }();

  auto timeout = Clock::now() + duration;
  list.emplace(std::move(f), timeout, list);

  if (timeout < nextTimeout_) {
    nextTimeout_ = timeout;
    scheduleRun();
  }

  return reinterpret_cast<intptr_t>(&list.back());
}

void folly::fibers::TimeoutController::runTimeouts

(

TimePoint

time

)

Definition at line 51 of file TimeoutController.cpp.

References bm::list, max, min, nextTimeout_, now(), scheduleRun(), folly::detail::distributed_mutex::time(), and timeoutHandleBuckets_.

                                                  {
  auto now = Clock::now();
  // Make sure we don't skip some events if function was run before actual time.
  if (time < now) {
    time = now;
  }
  if (nextTimeout_ > time) {
    return;
  }

  nextTimeout_ = TimePoint::max();

  for (auto& bucket : timeoutHandleBuckets_) {
    auto& list = *bucket.second;

    while (!list.empty()) {
      if (!list.front().canceled) {
        if (list.front().timeout > time) {
          nextTimeout_ = std::min(nextTimeout_, list.front().timeout);
          break;
        }

        list.front().func();
      }
      list.pop();
    }
  }

  if (nextTimeout_ != TimePoint::max()) {
    scheduleRun();
  }
}

void folly::fibers::TimeoutController::scheduleRun ( )

private

Definition at line 84 of file TimeoutController.cpp.

References loopController_, nextTimeout_, folly::detail::distributed_mutex::time(), and folly::fibers::LoopController::timedSchedule().

Referenced by registerTimeout(), and runTimeouts().

                                    {
  auto time = nextTimeout_;
  std::weak_ptr<TimeoutController> timeoutControllerWeak = shared_from_this();

  loopController_.timedSchedule(
      [timeoutControllerWeak, time]() {
        if (auto timeoutController = timeoutControllerWeak.lock()) {
          timeoutController->runTimeouts(time);
        }
      },
      time);
}

Member Data Documentation

LoopController& folly::fibers::TimeoutController::loopController_

private

Definition at line 68 of file TimeoutController.h.

Referenced by scheduleRun().

TimePoint folly::fibers::TimeoutController::nextTimeout_

private

Definition at line 67 of file TimeoutController.h.

Referenced by registerTimeout(), runTimeouts(), and scheduleRun().

std::vector<std::pair<Duration, TimeoutHandleListPtr> > folly::fibers::TimeoutController::timeoutHandleBuckets_

private

Definition at line 66 of file TimeoutController.h.

Referenced by registerTimeout(), and runTimeouts().

---

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

• proxygen/folly/folly/fibers/TimeoutController.h
• proxygen/folly/folly/fibers/TimeoutController.cpp