ThreadLocalAccessBenchmark.cpp File Reference

#include <folly/Benchmark.h>
#include <folly/ThreadLocal.h>
#include <condition_variable>
#include <mutex>
#include <thread>

Go to the source code of this file.

Functions
void	runTest (int iters, int numThreads)
	BENCHMARK_DRAW_LINE ()
int	main (int argc, char *argv[])

Function Documentation

BENCHMARK_DRAW_LINE

(

)

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 123 of file ThreadLocalAccessBenchmark.cpp.

References folly::runBenchmarks().

                                 {
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  folly::runBenchmarks();

  return 0;
}

void runTest	(	int	iters,
		int	numThreads
	)

Definition at line 42 of file ThreadLocalAccessBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), BENCHMARK_PARAM, folly::BenchmarkSuspender::dismiss(), i, m, mutex, folly::BenchmarkSuspender::rehire(), folly::pushmi::detail::t, and threads.

                                        {
  BenchmarkSuspender susp;

  std::vector<SimpleThreadCachedInt> stci(numThreads);

  std::mutex m, mw;
  std::condition_variable cv, cvw;
  bool running = true;
  int numRunning = 0;

  std::vector<std::thread> threads;
  for (int i = 0; i < numThreads; i++) {
    threads.push_back(std::thread([i,
                                   numThreads,
                                   &stci,
                                   &m,
                                   &mw,
                                   &cv,
                                   &cvw,
                                   &running,
                                   &numRunning]() mutable {
      stci[i].set();

      // notify if all the threads have created the
      // thread local var
      bool notify = false;
      {
        std::lock_guard<std::mutex> lk(m);
        if (++numRunning == numThreads) {
          notify = true;
        }
      }

      if (notify) {
        cv.notify_one();
      }

      // now wait
      {
        std::unique_lock<std::mutex> lk(mw);
        cvw.wait(lk, [&]() { return !running; });
      }
    }));
  }

  // wait for the threads to create the thread locals
  {
    std::unique_lock<std::mutex> lk(m);
    cv.wait(lk, [&]() { return numRunning == numThreads; });
  }

  susp.dismiss();

  // run the test loop
  for (int i = 0; i < iters; i++) {
    stci[i % numThreads].access();
  }

  susp.rehire();

  {
    std::lock_guard<std::mutex> lk(mw);
    running = false;
  }

  cvw.notify_all();

  for (auto& t : threads) {
    t.join();
  }
}