SmallLocksTest.cpp File Reference

#include <folly/synchronization/SmallLocks.h>
#include <cassert>
#include <condition_variable>
#include <cstdio>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
#include <glog/logging.h>
#include <folly/Random.h>
#include <folly/portability/Asm.h>
#include <folly/portability/GTest.h>
#include <folly/portability/PThread.h>
#include <folly/portability/Unistd.h>

Go to the source code of this file.

Classes
struct	FOLLY_PACK_POP::SimpleBarrier

Namespaces
	FOLLY_PACK_POP

Functions
	TEST (SmallLocks, SpinLockCorrectness)
	TEST (SmallLocks, RegClobber)
	TEST (SmallLocks, MicroLock)
	TEST (SmallLocks, MicroLockTryLock)

Variables
	FOLLY_PACK_PUSH

Function Documentation

TEST	(	SmallLocks	,
		SpinLockCorrectness
	)

Definition at line 148 of file SmallLocksTest.cpp.

References EXPECT_EQ, folly::gen::guard(), i, nthrs, folly::pushmi::detail::t, threads, and val.

                                      {
  EXPECT_EQ(sizeof(MicroSpinLock), 1);

  int nthrs = sysconf(_SC_NPROCESSORS_ONLN) * 2;
  std::vector<std::thread> threads;
  for (int i = 0; i < nthrs; ++i) {
    threads.push_back(std::thread(splock_test));
  }
  for (auto& t : threads) {
    t.join();
  }
}

TEST	(	SmallLocks	,
		RegClobber
	)

Definition at line 187 of file SmallLocksTest.cpp.

References FOLLY_PACK_PUSH.

                             {
  TestClobber().go();
}

TEST	(	SmallLocks	,
		MicroLock
	)

Definition at line 228 of file SmallLocksTest.cpp.

References a, b, EXPECT_EQ, i, threads, uint64_t, uint8_t, and x.

                            {
  volatile uint64_t counters[4] = {0, 0, 0, 0};
  std::vector<std::thread> threads;
  static const unsigned nrThreads = 20;
  static const unsigned iterPerThread = 10000;
  SimpleBarrier startBarrier;

  assert(iterPerThread % 4 == 0);

  // Embed the lock in a larger structure to ensure that we do not
  // affect bits outside the ones MicroLock is defined to affect.
  struct {
    uint8_t a;
    std::atomic<uint8_t> b;
    MicroLock alock;
    std::atomic<uint8_t> d;
  } x;

  uint8_t origB = 'b';
  uint8_t origD = 'd';

  x.a = 'a';
  x.b = origB;
  x.alock.init();
  x.d = origD;

  // This thread touches other parts of the host word to show that
  // MicroLock does not interfere with memory outside of the byte
  // it owns.
  std::thread adjacentMemoryToucher = std::thread([&] {
    startBarrier.wait();
    for (unsigned iter = 0; iter < iterPerThread; ++iter) {
      if (iter % 2) {
        x.b++;
      } else {
        x.d++;
      }
    }
  });

  for (unsigned i = 0; i < nrThreads; ++i) {
    threads.emplace_back([&] {
      startBarrier.wait();
      for (unsigned iter = 0; iter < iterPerThread; ++iter) {
        unsigned slotNo = iter % 4;
        x.alock.lock(slotNo);
        counters[slotNo] += 1;
        // The occasional sleep makes it more likely that we'll
        // exercise the futex-wait path inside MicroLock.
        if (iter % 1000 == 0) {
          struct timespec ts = {0, 10000};
          (void)nanosleep(&ts, nullptr);
        }
        x.alock.unlock(slotNo);
      }
    });
  }

  startBarrier.run();

  for (auto it = threads.begin(); it != threads.end(); ++it) {
    it->join();
  }

  adjacentMemoryToucher.join();

  EXPECT_EQ(x.a, 'a');
  EXPECT_EQ(x.b, (uint8_t)(origB + iterPerThread / 2));
  EXPECT_EQ(x.d, (uint8_t)(origD + iterPerThread / 2));
  for (unsigned i = 0; i < 4; ++i) {
    EXPECT_EQ(counters[i], ((uint64_t)nrThreads * iterPerThread) / 4);
  }
}

TEST	(	SmallLocks	,
		MicroLockTryLock
	)

Definition at line 302 of file SmallLocksTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and folly::detail::lock().

                                   {
  MicroLock lock;
  lock.init();
  EXPECT_TRUE(lock.try_lock());
  EXPECT_FALSE(lock.try_lock());
  lock.unlock();
}

Variable Documentation

FOLLY_PACK_PUSH

Definition at line 196 of file SmallLocksTest.cpp.

Referenced by folly::exception_wrapper::ExceptionPtr::as_int_(), and TEST().