ThreadLocalDestroyBenchmark.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
template<typename Tag1 , typename Tag2 >
void	runTestTag (int iters, int numThreads)
void	runTestSameTag (int iters, int numThreads)
void	runTestDiffTag (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 119 of file ThreadLocalDestroyBenchmark.cpp.

References folly::runBenchmarks().

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

  return 0;
}

void runTestDiffTag	(	int	iters,
		int	numThreads
	)

Definition at line 99 of file ThreadLocalDestroyBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), BENCHMARK_PARAM, and runTestSameTag().

                                               {
  runTestTag<void, int>(iters, numThreads);
}

void runTestSameTag	(	int	iters,
		int	numThreads
	)

Definition at line 95 of file ThreadLocalDestroyBenchmark.cpp.

Referenced by runTestDiffTag().

                                               {
  runTestTag<void, void>(iters, numThreads);
}

template<typename Tag1 , typename Tag2 >

void runTestTag	(	int	iters,
		int	numThreads
	)

Definition at line 26 of file ThreadLocalDestroyBenchmark.cpp.

References folly::BenchmarkSuspender::dismiss(), i, m, mutex, folly::BenchmarkSuspender::rehire(), folly::ThreadLocalPtr< T, Tag, AccessMode >::reset(), folly::pushmi::detail::t, and threads.

                                           {
  BenchmarkSuspender susp;

  ThreadLocalPtr<int, Tag1> t1;

  t1.reset(new int(1));

  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([&]() mutable {
      t1.reset(new int(1));

      // notify if all the threads have created the t1
      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 t1
  {
    std::unique_lock<std::mutex> lk(m);
    cv.wait(lk, [&]() { return numRunning == numThreads; });
  }

  ThreadLocalPtr<int, Tag2> t3;
  t3.reset(new int(2));

  susp.dismiss();

  // run the test loop
  for (int i = 0; i < iters; i++) {
    ThreadLocalPtr<int, Tag2> t2;
    t2.reset(new int(2));
  }

  susp.rehire();

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

  cvw.notify_all();

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