ReadMostlySharedPtrBenchmark.cpp File Reference

#include <folly/experimental/ReadMostlySharedPtr.h>
#include <iostream>
#include <thread>
#include <folly/Benchmark.h>
#include <folly/Memory.h>
#include <folly/portability/GFlags.h>

Go to the source code of this file.

Typedefs
template<typename T >
using	TLMainPtr = folly::ReadMostlyMainPtr< T, folly::TLRefCount >
template<typename T >
using	TLWeakPtr = folly::ReadMostlyWeakPtr< T, folly::TLRefCount >

Functions
template<template< typename > class MainPtr, template< typename > class WeakPtr, size_t threadCount>
void	benchmark (size_t n)
	BENCHMARK (WeakPtrOneThread, n)
	BENCHMARK (WeakPtrFourThreads, n)
	BENCHMARK (TLReadMostlyWeakPtrOneThread, n)
	BENCHMARK (TLReadMostlyWeakPtrFourThreads, n)
int	main (int argc, char **argv)

Typedef Documentation

template<typename T >

using TLMainPtr = folly::ReadMostlyMainPtr<T, folly::TLRefCount>

Definition at line 54 of file ReadMostlySharedPtrBenchmark.cpp.

template<typename T >

using TLWeakPtr = folly::ReadMostlyWeakPtr<T, folly::TLRefCount>

Definition at line 56 of file ReadMostlySharedPtrBenchmark.cpp.

Function Documentation

template<template< typename > class MainPtr, template< typename > class WeakPtr, size_t threadCount>

void benchmark

(

size_t

n

)

Definition at line 31 of file ReadMostlySharedPtrBenchmark.cpp.

References FOLLY_NOINLINE, i, and folly::pushmi::detail::t.

                         {
  MainPtr<int> mainPtr(std::make_unique<int>(42));

  std::vector<std::thread> ts;

  for (size_t t = 0; t < threadCount; ++t) {
    ts.emplace_back([&]() {
      WeakPtr<int> weakPtr(mainPtr);
      // Prevent the compiler from hoisting code out of the loop.
      auto op = [&]() FOLLY_NOINLINE { weakPtr.lock(); };

      for (size_t i = 0; i < n; ++i) {
        op();
      }
    });
  }

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

BENCHMARK	(	WeakPtrOneThread	,
		n
	)

Definition at line 58 of file ReadMostlySharedPtrBenchmark.cpp.

                               {
  benchmark<std::shared_ptr, std::weak_ptr, 1>(n);
}

BENCHMARK	(	WeakPtrFourThreads	,
		n
	)

Definition at line 62 of file ReadMostlySharedPtrBenchmark.cpp.

                                 {
  benchmark<std::shared_ptr, std::weak_ptr, 4>(n);
}

BENCHMARK	(	TLReadMostlyWeakPtrOneThread	,
		n
	)

Definition at line 66 of file ReadMostlySharedPtrBenchmark.cpp.

                                           {
  benchmark<TLMainPtr, TLWeakPtr, 1>(n);
}

BENCHMARK	(	TLReadMostlyWeakPtrFourThreads	,
		n
	)

Definition at line 70 of file ReadMostlySharedPtrBenchmark.cpp.

                                             {
  benchmark<TLMainPtr, TLWeakPtr, 4>(n);
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 74 of file ReadMostlySharedPtrBenchmark.cpp.

References folly::runBenchmarks().

                                {
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  gflags::SetCommandLineOptionWithMode(
      "bm_min_usec", "100000", gflags::SET_FLAG_IF_DEFAULT);

  folly::runBenchmarks();

  return 0;
}