RateLimiterTest.cpp File Reference

#include <chrono>
#include <condition_variable>
#include <mutex>
#include <string>
#include <thread>
#include <folly/Conv.h>
#include <folly/logging/RateLimiter.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Typedefs
using	irl_clock = IntervalRateLimiter::clock

Functions
void	intervalTest (uint64_t eventsPerInterval, irl_clock::duration interval)
	TEST (RateLimiter, interval3per100ms)
	TEST (RateLimiter, interval1per100ms)
	TEST (RateLimiter, interval15per150ms)
	TEST (RateLimiter, concurrentThreads)

Typedef Documentation

using irl_clock = IntervalRateLimiter::clock

Definition at line 31 of file RateLimiterTest.cpp.

Function Documentation

void intervalTest	(	uint64_t	eventsPerInterval,
		irl_clock::duration	interval
	)

Definition at line 33 of file RateLimiterTest.cpp.

References count, EXPECT_FALSE, EXPECT_TRUE, now(), SCOPED_TRACE, and uint64_t.

Referenced by TEST().

                                                                          {
  SCOPED_TRACE(folly::to<std::string>(
      eventsPerInterval,
      " events every ",
      duration_cast<std::chrono::milliseconds>(interval).count(),
      "ms"));
  IntervalRateLimiter limiter{eventsPerInterval, interval};
  for (int iter = 0; iter < 4; ++iter) {
    if (iter != 0) {
      auto now = irl_clock::now();
      auto const deadline = now + interval;
      while (now < deadline) {
        /* sleep override */
        std::this_thread::sleep_for(now - deadline);
        now = irl_clock::now();
      }
    }
    for (uint64_t n = 0; n < eventsPerInterval * 2; ++n) {
      if (n < eventsPerInterval) {
        EXPECT_TRUE(limiter.check())
            << "expected check success on loop " << iter << " event " << n;
      } else {
        EXPECT_FALSE(limiter.check())
            << "expected check failure on loop " << iter << " event " << n;
      }
    }
  }
}

TEST	(	RateLimiter	,
		interval3per100ms
	)

Definition at line 62 of file RateLimiterTest.cpp.

References intervalTest().

                                     {
  intervalTest(3, 100ms);
}

TEST	(	RateLimiter	,
		interval1per100ms
	)

Definition at line 66 of file RateLimiterTest.cpp.

References intervalTest().

                                     {
  intervalTest(1, 100ms);
}

TEST	(	RateLimiter	,
		interval15per150ms
	)

Definition at line 70 of file RateLimiterTest.cpp.

References intervalTest().

                                      {
  intervalTest(15, 150ms);
}

TEST	(	RateLimiter	,
		concurrentThreads
	)

Definition at line 74 of file RateLimiterTest.cpp.

References count, EXPECT_EQ, folly::detail::lock(), m, mutex, s, threads, and uint64_t.

                                     {
  constexpr uint64_t maxEvents = 20;
  constexpr uint64_t numThreads = 32;

  IntervalRateLimiter limiter{20, 10s};
  std::atomic<uint32_t> count{0};
  std::mutex m;
  std::condition_variable cv;
  bool go = false;

  auto threadMain = [&]() {
    // Have each thread wait for go to become true before starting.
    // This hopefully gives us the best chance of having all threads start
    // at close to the same time.
    {
      std::unique_lock<std::mutex> lock{m};
      cv.wait(lock, [&go] { return go; });
    }

    for (uint64_t iteration = 0; iteration < maxEvents * 2; ++iteration) {
      if (limiter.check()) {
        count.fetch_add(1, std::memory_order_relaxed);
      }
    }
  };

  // Start the threads
  std::vector<std::thread> threads;
  threads.reserve(numThreads);
  for (uint64_t n = 0; n < numThreads; ++n) {
    threads.emplace_back(threadMain);
  }

  // Set go to true and notify all the threads
  {
    std::lock_guard<std::mutex> lg(m);
    go = true;
  }
  cv.notify_all();

  // Wait for all of the threads
  for (auto& thread : threads) {
    thread.join();
  }

  // We should have passed the check exactly maxEvents times
  EXPECT_EQ(maxEvents, count.load(std::memory_order_relaxed));
}