proxygen: proxygen/folly/folly/synchronization/test/SmallLocksBenchmark.cpp File Reference

#include <algorithm>
#include <cmath>
#include <condition_variable>
#include <numeric>
#include <thread>
#include <vector>
#include <google/base/spinlock.h>
#include <folly/Benchmark.h>
#include <folly/SharedMutex.h>
#include <folly/synchronization/DistributedMutex.h>
#include <folly/synchronization/SmallLocks.h>

Go to the source code of this file.

Classes
class	InitLock< Lock >

class	GoogleSpinLockAdapter

struct	VirtualBase

struct	VirtualImpl

Macros
#define	BENCH_BASE(...) FB_VA_GLUE(BENCHMARK_NAMED_PARAM, (__VA_ARGS__))

#define	BENCH_REL(...) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM, (__VA_ARGS__))

#define	FairnessTest(type)

Functions
	DEFINE_int32 (work, 100,"Number of work cycles")

	DEFINE_int32 (unlocked_work, 1000,"Number of unlocked work cycles")

	DEFINE_int32 (threads, std::thread::hardware_concurrency(),"Number of threads for fairness test")

static void	burn (size_t n)

template<typename Lock >
static void	runContended (size_t numOps, size_t numThreads)

template<typename Lock >
static void	runFairness ()

template<typename Mutex >
void	runUncontended (std::size_t iters)

	BENCHMARK (StdMutexUncontendedBenchmark, iters)

	BENCHMARK (GoogleSpinUncontendedBenchmark, iters)

	BENCHMARK (MicroSpinLockUncontendedBenchmark, iters)

	BENCHMARK (PicoSpinLockUncontendedBenchmark, iters)

	BENCHMARK (MicroLockUncontendedBenchmark, iters)

	BENCHMARK (SharedMutexUncontendedBenchmark, iters)

	BENCHMARK (DistributedMutexUncontendedBenchmark, iters)

	BENCHMARK (AtomicFetchAddUncontendedBenchmark, iters)

	__attribute__ ((noinline, noclone)) VirtualBase *makeVirtual()

	BENCHMARK (VirtualFunctionCall, iters)

	BENCHMARK_DRAW_LINE ()

static void	std_mutex (size_t numOps, size_t numThreads)

static void	google_spin (size_t numOps, size_t numThreads)

static void	folly_microspin (size_t numOps, size_t numThreads)

static void	folly_picospin (size_t numOps, size_t numThreads)

static void	folly_microlock (size_t numOps, size_t numThreads)

static void	folly_sharedmutex (size_t numOps, size_t numThreads)

static void	folly_distributedmutex (size_t numOps, size_t numThreads)

	FB_VA_GLUE (BENCHMARK_NAMED_PARAM,(std_mutex, 1thread, 1)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microspin, 1thread, 1)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microlock, 1thread, 1)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_distributedmutex, 1thread, 1)) BENCHMARK_DRAW_LINE()

	FB_VA_GLUE (BENCHMARK_NAMED_PARAM,(std_mutex, 2thread, 2)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microspin, 2thread, 2)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microlock, 2thread, 2)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_distributedmutex, 2thread, 2)) BENCHMARK_DRAW_LINE()

	FB_VA_GLUE (BENCHMARK_NAMED_PARAM,(std_mutex, 4thread, 4)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microspin, 4thread, 4)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microlock, 4thread, 4)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_distributedmutex, 4thread, 4)) BENCHMARK_DRAW_LINE()

	FB_VA_GLUE (BENCHMARK_NAMED_PARAM,(std_mutex, 8thread, 8)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microspin, 8thread, 8)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microlock, 8thread, 8)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_distributedmutex, 8thread, 8)) BENCHMARK_DRAW_LINE()

	FB_VA_GLUE (BENCHMARK_NAMED_PARAM,(std_mutex, 16thread, 16)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microspin, 16thread, 16)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microlock, 16thread, 16)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_distributedmutex, 16thread, 16)) BENCHMARK_DRAW_LINE()

	FB_VA_GLUE (BENCHMARK_NAMED_PARAM,(std_mutex, 32thread, 32)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microspin, 32thread, 32)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microlock, 32thread, 32)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_distributedmutex, 32thread, 32)) BENCHMARK_DRAW_LINE()

	FB_VA_GLUE (BENCHMARK_NAMED_PARAM,(std_mutex, 64thread, 64)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microspin, 64thread, 64)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microlock, 64thread, 64)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_distributedmutex, 64thread, 64)) BENCHMARK_DRAW_LINE()

	FB_VA_GLUE (BENCHMARK_NAMED_PARAM,(std_mutex, 128thread, 128)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microspin, 128thread, 128)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_microlock, 128thread, 128)) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM

	FB_VA_GLUE (BENCHMARK_RELATIVE_NAMED_PARAM,(folly_distributedmutex, 128thread, 128)) int main(int argc

	runFairness< std::mutex > ()

	runFairness< GoogleSpinLockAdapter > ()

	runFairness< InitLock< folly::MicroSpinLock > > ()

	runFairness< InitLock< folly::PicoSpinLock< uint16_t > > > ()

	runFairness< InitLock< folly::MicroLock > > ()

	runFairness< folly::SharedMutex > ()

	runFairness< folly::DistributedMutex > ()

Variables
	google_spin

	folly_picospin

	folly_sharedmutex

char **	argv

	return

Macro Definition Documentation

#define BENCH_BASE ( ... ) FB_VA_GLUE(BENCHMARK_NAMED_PARAM, (__VA_ARGS__))

Definition at line 334 of file SmallLocksBenchmark.cpp.

Referenced by folly_distributedmutex().

#define BENCH_REL ( ... ) FB_VA_GLUE(BENCHMARK_RELATIVE_NAMED_PARAM, (__VA_ARGS__))

Definition at line 335 of file SmallLocksBenchmark.cpp.

#define FairnessTest ( type )

Value:

{                        \
    printf(#type ": \n");  \
    runFairness<type>();   \
  }

Function Documentation

__attribute__ ( (noinline, noclone) )

Definition at line 319 of file SmallLocksBenchmark.cpp.

Referenced by folly::SingletonVault::scheduleDestroyInstances().

                                                               {
   return new VirtualImpl();
 }

BENCHMARK	(	StdMutexUncontendedBenchmark	,
		iters
	)

Definition at line 272 of file SmallLocksBenchmark.cpp.

                                                {
   runUncontended<std::mutex>(iters);
 }

BENCHMARK	(	GoogleSpinUncontendedBenchmark	,
		iters
	)

Definition at line 276 of file SmallLocksBenchmark.cpp.

                                                  {
   runUncontended<GoogleSpinLockAdapter>(iters);
 }

BENCHMARK	(	MicroSpinLockUncontendedBenchmark	,
		iters
	)

Definition at line 280 of file SmallLocksBenchmark.cpp.

                                                     {
   runUncontended<InitLock<folly::MicroSpinLock>>(iters);
 }

BENCHMARK	(	PicoSpinLockUncontendedBenchmark	,
		iters
	)

Definition at line 284 of file SmallLocksBenchmark.cpp.

                                                    {
   runUncontended<InitLock<folly::PicoSpinLock<std::uint16_t>>>(iters);
 }

BENCHMARK	(	MicroLockUncontendedBenchmark	,
		iters
	)

Definition at line 288 of file SmallLocksBenchmark.cpp.

                                                 {
   runUncontended<InitLock<folly::MicroLock>>(iters);
 }

BENCHMARK	(	SharedMutexUncontendedBenchmark	,
		iters
	)

Definition at line 292 of file SmallLocksBenchmark.cpp.

                                                   {
   runUncontended<folly::SharedMutex>(iters);
 }

BENCHMARK	(	DistributedMutexUncontendedBenchmark	,
		iters
	)

Definition at line 296 of file SmallLocksBenchmark.cpp.

                                                        {
   runUncontended<folly::DistributedMutex>(iters);
 }

BENCHMARK	(	AtomicFetchAddUncontendedBenchmark	,
		iters
	)

Definition at line 300 of file SmallLocksBenchmark.cpp.

References folly::doNotOptimizeAway().

                                                      {
   auto&& atomic = std::atomic<uint64_t>{0};
   while (iters--) {
     folly::doNotOptimizeAway(atomic.fetch_add(1));
   }
 }

BENCHMARK	(	VirtualFunctionCall	,
		iters
	)

Definition at line 323 of file SmallLocksBenchmark.cpp.

References BENCHMARK_DRAW_LINE(), and VirtualBase::foo().

                                       {
   VirtualBase* vb = makeVirtual();
   while (iters--) {
     vb->foo();
   }
   delete vb;
 }

BENCHMARK_DRAW_LINE ( )

Referenced by BENCHMARK(), and folly_distributedmutex().

static void burn ( size_t n )

static

Definition at line 44 of file SmallLocksBenchmark.cpp.

References count, folly::doNotOptimizeAway(), i, folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::lock(), folly::detail::lock(), folly::gen::move, mutex, Mutex, folly::detail::distributed_mutex::DistributedMutex< Atomic, TimePublishing >::unlock(), and folly::detail::distributed_mutex::wait().

Referenced by runContended(), and runFairness().

                            {
   for (size_t i = 0; i < n; ++i) {
     folly::doNotOptimizeAway(i);
   }
 }

DEFINE_int32	(	work	,
		100	,
		"Number of work cycles"
	)

DEFINE_int32	(	unlocked_work	,
		1000	,
		"Number of unlocked work cycles"
	)

DEFINE_int32	(	threads	,
		std::thread::hardware_concurrency()	,
		"Number of threads for fairness test"
	)

FB_VA_GLUE	(	BENCHMARK_NAMED_PARAM	,
		(std_mutex, 1thread, 1)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microspin, 1thread, 1)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microlock, 1thread, 1)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_distributedmutex, 1thread, 1)
	)

FB_VA_GLUE	(	BENCHMARK_NAMED_PARAM	,
		(std_mutex, 2thread, 2)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microspin, 2thread, 2)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microlock, 2thread, 2)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_distributedmutex, 2thread, 2)
	)

FB_VA_GLUE	(	BENCHMARK_NAMED_PARAM	,
		(std_mutex, 4thread, 4)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microspin, 4thread, 4)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microlock, 4thread, 4)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_distributedmutex, 4thread, 4)
	)

FB_VA_GLUE	(	BENCHMARK_NAMED_PARAM	,
		(std_mutex, 8thread, 8)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microspin, 8thread, 8)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microlock, 8thread, 8)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_distributedmutex, 8thread, 8)
	)

FB_VA_GLUE	(	BENCHMARK_NAMED_PARAM	,
		(std_mutex, 16thread, 16)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microspin, 16thread, 16)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microlock, 16thread, 16)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_distributedmutex, 16thread, 16)
	)

FB_VA_GLUE	(	BENCHMARK_NAMED_PARAM	,
		(std_mutex, 32thread, 32)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microspin, 32thread, 32)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microlock, 32thread, 32)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_distributedmutex, 32thread, 32)
	)

FB_VA_GLUE	(	BENCHMARK_NAMED_PARAM	,
		(std_mutex, 64thread, 64)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microspin, 64thread, 64)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microlock, 64thread, 64)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_distributedmutex, 64thread, 64)
	)

FB_VA_GLUE	(	BENCHMARK_NAMED_PARAM	,
		(std_mutex, 128thread, 128)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microspin, 128thread, 128)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_microlock, 128thread, 128)
	)

FB_VA_GLUE	(	BENCHMARK_RELATIVE_NAMED_PARAM	,
		(folly_distributedmutex, 128thread, 128)
	)

static void folly_distributedmutex	(	size_t	numOps,
		size_t	numThreads
	)

static

Definition at line 355 of file SmallLocksBenchmark.cpp.

References BENCH_BASE, BENCHMARK_DRAW_LINE(), and std_mutex().

                                                                      {
   runContended<folly::DistributedMutex>(numOps, numThreads);
 }

static void folly_microlock	(	size_t	numOps,
		size_t	numThreads
	)

static

Definition at line 349 of file SmallLocksBenchmark.cpp.

                                                               {
   runContended<folly::MicroLock>(numOps, numThreads);
 }

static void folly_microspin	(	size_t	numOps,
		size_t	numThreads
	)

static

Definition at line 343 of file SmallLocksBenchmark.cpp.

                                                               {
   runContended<InitLock<folly::MicroSpinLock>>(numOps, numThreads);
 }

static void folly_picospin	(	size_t	numOps,
		size_t	numThreads
	)

static

Definition at line 346 of file SmallLocksBenchmark.cpp.

                                                              {
   runContended<InitLock<folly::PicoSpinLock<uint16_t>>>(numOps, numThreads);
 }

static void folly_sharedmutex	(	size_t	numOps,
		size_t	numThreads
	)

static

Definition at line 352 of file SmallLocksBenchmark.cpp.

                                                                 {
   runContended<folly::SharedMutex>(numOps, numThreads);
 }

static void google_spin	(	size_t	numOps,
		size_t	numThreads
	)

static

Definition at line 340 of file SmallLocksBenchmark.cpp.

                                                           {
   runContended<GoogleSpinLockAdapter>(numOps, numThreads);
 }

template<typename Lock >

static void runContended	(	size_t	numOps,
		size_t	numThreads
	)

static

Definition at line 115 of file SmallLocksBenchmark.cpp.

References burn(), folly::BenchmarkSuspender::dismissing(), folly::detail::lock(), folly::ssl::detail::locks(), folly::gen::move, mutex, folly::pushmi::detail::t, threads, and value.

                                                            {
   folly::BenchmarkSuspender braces;
   size_t totalthreads = std::thread::hardware_concurrency();
   if (totalthreads < numThreads) {
     totalthreads = numThreads;
   }
   size_t threadgroups = totalthreads / numThreads;
   struct lockstruct {
     char padding1[128];
     Lock mutex;
     char padding2[128];
     long value = 1;
   };
 
   auto locks =
       (struct lockstruct*)calloc(threadgroups, sizeof(struct lockstruct));
 
   char padding3[128];
   (void)padding3;
   std::vector<std::thread> threads(totalthreads);
 
   SimpleBarrier runbarrier(totalthreads + 1);
 
   for (size_t t = 0; t < totalthreads; ++t) {
     threads[t] = std::thread([&, t] {
       lockstruct* mutex = &locks[t % threadgroups];
       runbarrier.wait();
       for (size_t op = 0; op < numOps; op += 1) {
         auto state = lock(mutex->mutex);
         burn(FLAGS_work);
         mutex->value++;
         unlock(mutex->mutex, std::move(state));
         burn(FLAGS_unlocked_work);
       }
     });
   }
 
   runbarrier.wait();
   braces.dismissing([&] {
     for (auto& thr : threads) {
       thr.join();
     }
   });
 }

template<typename Lock >

static void runFairness ( )

static

Definition at line 161 of file SmallLocksBenchmark.cpp.

References folly::f14::accumulate(), burn(), diff(), for_each(), g(), folly::detail::lock(), folly::ssl::detail::locks(), m, max, folly::gen::move, mutex, now(), folly::detail::rlock(), stop(), sum(), folly::pushmi::detail::t, threads, folly::detail::distributed_mutex::time(), and value.

                           {
   size_t numThreads = FLAGS_threads;
   size_t totalthreads = std::thread::hardware_concurrency();
   if (totalthreads < numThreads) {
     totalthreads = numThreads;
   }
   long threadgroups = totalthreads / numThreads;
   struct lockstruct {
     char padding1[128];
     Lock lock;
   };
 
   auto locks =
       (struct lockstruct*)calloc(threadgroups, sizeof(struct lockstruct));
 
   char padding3[64];
   (void)padding3;
   std::vector<std::thread> threads(totalthreads);
 
   std::atomic<bool> stop{false};
 
   std::mutex rlock;
   std::vector<long> results;
   std::vector<std::chrono::microseconds> maxes;
 
   std::vector<std::chrono::microseconds> aqTime;
   std::vector<unsigned long> aqTimeSq;
 
   SimpleBarrier runbarrier(totalthreads + 1);
 
   for (size_t t = 0; t < totalthreads; ++t) {
     threads[t] = std::thread([&, t] {
       lockstruct* mutex = &locks[t % threadgroups];
       long value = 0;
       std::chrono::microseconds max(0);
       std::chrono::microseconds time(0);
       unsigned long timeSq(0);
       runbarrier.wait();
       while (!stop) {
         std::chrono::steady_clock::time_point prelock =
             std::chrono::steady_clock::now();
         auto state = lock(mutex->lock);
         std::chrono::steady_clock::time_point postlock =
             std::chrono::steady_clock::now();
         auto diff = std::chrono::duration_cast<std::chrono::microseconds>(
             postlock - prelock);
         time += diff;
         timeSq += diff.count() * diff.count();
         if (diff > max) {
           max = diff;
         }
         burn(FLAGS_work);
         value++;
         unlock(mutex->lock, std::move(state));
         burn(FLAGS_unlocked_work);
       }
       {
         std::lock_guard<std::mutex> g(rlock);
         results.push_back(value);
         maxes.push_back(max);
         aqTime.push_back(time);
         aqTimeSq.push_back(timeSq);
       }
     });
   }
 
   runbarrier.wait();
   /* sleep override */
   std::this_thread::sleep_for(std::chrono::seconds(2));
   stop = true;
 
   for (auto& thr : threads) {
     thr.join();
   }
 
   // Calulate some stats
   unsigned long sum = std::accumulate(results.begin(), results.end(), 0.0);
   double m = sum / results.size();
 
   double accum = 0.0;
   std::for_each(results.begin(), results.end(), [&](const double d) {
     accum += (d - m) * (d - m);
   });
   double stdev = std::sqrt(accum / (results.size() - 1));
   std::chrono::microseconds mx = *std::max_element(maxes.begin(), maxes.end());
   std::chrono::microseconds agAqTime = std::accumulate(
       aqTime.begin(), aqTime.end(), std::chrono::microseconds(0));
   unsigned long agAqTimeSq =
       std::accumulate(aqTimeSq.begin(), aqTimeSq.end(), 0);
   std::chrono::microseconds mean = agAqTime / sum;
   double variance = (sum * agAqTimeSq - (agAqTime.count() * agAqTime.count())) /
       sum / (sum - 1);
   double stddev2 = std::sqrt(variance);
 
   printf("Sum: %li Mean: %.0f stddev: %.0f\n", sum, m, stdev);
   printf(
       "Lock time stats in us: mean %li stddev %.0f max %li\n",
       mean.count(),
       stddev2,
       mx.count());
 }

runFairness< folly::DistributedMutex > ( )

runFairness< folly::SharedMutex > ( )

runFairness< GoogleSpinLockAdapter > ( )

runFairness< InitLock< folly::MicroLock > > ( )

runFairness< InitLock< folly::MicroSpinLock > > ( )

runFairness< InitLock< folly::PicoSpinLock< uint16_t > > > ( )

runFairness< std::mutex > ( )

template<typename Mutex >

void runUncontended ( std::size_t iters )

Definition at line 264 of file SmallLocksBenchmark.cpp.

References i, folly::detail::lock(), folly::gen::move, mutex, and Mutex.

                                      {
   auto&& mutex = Mutex{};
   for (auto i = std::size_t{0}; i < iters; ++i) {
     auto state = lock(mutex);
     unlock(mutex, std::move(state));
   }
 }

static void std_mutex	(	size_t	numOps,
		size_t	numThreads
	)

static

Definition at line 337 of file SmallLocksBenchmark.cpp.

Referenced by folly_distributedmutex().

                                                         {
   runContended<std::mutex>(numOps, numThreads);
 }

Variable Documentation

char** argv

Initial value:

{

gflags::ParseCommandLineFlags(&argc, &argv, true)

argv

char ** argv

Definition: SmallLocksBenchmark.cpp:430

Definition at line 430 of file SmallLocksBenchmark.cpp.

Referenced by testing::AddGlobalTestEnvironment(), testing::internal::GetUnitTestImpl(), folly::NestedCommandLineApp::globalOptions(), testing::UnitTest::impl(), main(), testing::internal::ParseGoogleMockStringFlag(), testing::internal::UnitTestImpl::set_catch_exceptions(), folly::Subprocess::spawn(), folly::Subprocess::Subprocess(), TEST(), testing::TEST_F(), and TestInitGoogleMock().

folly_picospin

Definition at line 363 of file SmallLocksBenchmark.cpp.

folly_sharedmutex

Definition at line 365 of file SmallLocksBenchmark.cpp.

google_spin

Definition at line 361 of file SmallLocksBenchmark.cpp.

return

Definition at line 443 of file SmallLocksBenchmark.cpp.

Classes

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation