folly::logging::IntervalRateLimiter Class Reference

#include <RateLimiter.h>

Public Types
using	clock = chrono::coarse_steady_clock

Public Member Functions
constexpr	IntervalRateLimiter (uint64_t maxPerInterval, clock::duration interval)
bool	check ()

Private Member Functions
bool	checkSlow ()

Private Attributes
const uint64_t	maxPerInterval_
const clock::time_point::duration	interval_
std::atomic< uint64_t >	count_ {std::numeric_limits<uint64_t>::max()}
std::atomic< clock::rep >	timestamp_ {0}

Detailed Description

A rate limiter that can rate limit events to N events per M milliseconds.

It is intended to be fast to check when messages are not being rate limited. When messages are being rate limited it is slightly slower, as it has to check the clock each time check() is called in this case.

Definition at line 34 of file RateLimiter.h.

Member Typedef Documentation

using folly::logging::IntervalRateLimiter::clock = chrono::coarse_steady_clock

Definition at line 36 of file RateLimiter.h.

Constructor & Destructor Documentation

constexpr folly::logging::IntervalRateLimiter::IntervalRateLimiter ( uint64_t  maxPerInterval, clock::duration  interval  )

inline

Definition at line 38 of file RateLimiter.h.

References interval_.

      : maxPerInterval_{maxPerInterval}, interval_{interval} {}

Member Function Documentation

bool folly::logging::IntervalRateLimiter::check ( )

inline

Definition at line 43 of file RateLimiter.h.

References checkSlow(), count_, and maxPerInterval_.

               {
    auto origCount = count_.fetch_add(1, std::memory_order_acq_rel);
    if (origCount < maxPerInterval_) {
      return true;
    }
    return checkSlow();
  }

bool folly::logging::IntervalRateLimiter::checkSlow ( )

private

Definition at line 21 of file RateLimiter.cpp.

References count_, interval_, maxPerInterval_, now(), folly::chrono::coarse_steady_clock::now(), and timestamp_.

Referenced by check().

                                    {
  auto ts = timestamp_.load();
  auto now = clock::now().time_since_epoch().count();
  if (now < (ts + interval_.count())) {
    return false;
  }

  if (!timestamp_.compare_exchange_strong(ts, now)) {
    // We raced with another thread that reset the timestamp.
    // We treat this as if we fell into the previous interval, and so we
    // rate-limit ourself.
    return false;
  }

  if (ts == 0) {
    // If we initialized timestamp_ for the very first time increment count_ by
    // one instead of setting it to 0.  Our original increment made it roll over
    // to 0, so other threads may have already incremented it again and passed
    // the check.
    auto origCount = count_.fetch_add(1, std::memory_order_acq_rel);
    // Check to see if other threads already hit the rate limit cap before we
    // finished checkSlow().
    return (origCount < maxPerInterval_);
  }

  // In the future, if we wanted to return the number of dropped events we
  // could use (count_.exchange(0) - maxPerInterval_) here.
  count_.store(1, std::memory_order_release);
  return true;
}

Member Data Documentation

std::atomic<uint64_t> folly::logging::IntervalRateLimiter::count_ {std::numeric_limits<uint64_t>::max()}

private

Definition at line 60 of file RateLimiter.h.

Referenced by check(), and checkSlow().

const clock::time_point::duration folly::logging::IntervalRateLimiter::interval_

private

Definition at line 55 of file RateLimiter.h.

Referenced by checkSlow(), and IntervalRateLimiter().

const uint64_t folly::logging::IntervalRateLimiter::maxPerInterval_

private

Definition at line 54 of file RateLimiter.h.

Referenced by check(), and checkSlow().

std::atomic<clock::rep> folly::logging::IntervalRateLimiter::timestamp_ {0}

private

Definition at line 64 of file RateLimiter.h.

Referenced by checkSlow().

---

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

• proxygen/folly/folly/logging/RateLimiter.h
• proxygen/folly/folly/logging/RateLimiter.cpp