SingletonThreadLocalTest.cpp File Reference

#include <thread>
#include <unordered_set>
#include <vector>
#include <folly/SingletonThreadLocal.h>
#include <folly/Synchronized.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
	TEST (SingletonThreadLocalTest, OneSingletonPerThread)
	TEST (SingletonThreadLocalTest, MoveConstructibleMake)
	TEST (SingletonThreadLocalTest, NotMoveConstructibleMake)
	TEST (SingletonThreadLocalTest, AccessAfterFastPathDestruction)
	TEST (ThreadLocal, DependencyTest)
	TEST (SingletonThreadLocalTest, Reused)

Function Documentation

TEST	(	SingletonThreadLocalTest	,
		OneSingletonPerThread
	)

Definition at line 41 of file SingletonThreadLocalTest.cpp.

References EXPECT_EQ, folly::pushmi::operators::get, threads, and folly::fibers::yield().

                                                      {
  static constexpr std::size_t targetThreadCount{64};
  std::atomic<std::size_t> completedThreadCount{0};
  Synchronized<std::unordered_set<Foo*>> fooAddresses{};
  std::vector<std::thread> threads{};
  auto threadFunction = [&fooAddresses, &completedThreadCount] {
    fooAddresses.wlock()->emplace(&FooSingletonTL::get());
    ++completedThreadCount;
    while (completedThreadCount < targetThreadCount) {
      std::this_thread::yield();
    }
  };
  {
    for (std::size_t threadCount{0}; threadCount < targetThreadCount;
         ++threadCount) {
      threads.emplace_back(threadFunction);
    }
  }
  for (auto& thread : threads) {
    thread.join();
  }
  EXPECT_EQ(threads.size(), fooAddresses.rlock()->size());
  EXPECT_EQ(threads.size(), fooCreatedCount);
  EXPECT_EQ(threads.size(), fooDeletedCount);
}

TEST	(	SingletonThreadLocalTest	,
		MoveConstructibleMake
	)

Definition at line 67 of file SingletonThreadLocalTest.cpp.

References a, b, EXPECT_EQ, folly::SingletonThreadLocal< T, Tag, Make, TLTag >::get(), and single.

                                                      {
  struct Foo {
    int a, b;
    Foo(int a_, int b_) : a(a_), b(b_) {}
    Foo(Foo&&) = default;
    Foo& operator=(Foo&&) = default;
  };
  struct Tag {};
  struct Make {
    Foo operator()() const {
      return Foo(3, 4);
    }
  };
  auto& single = SingletonThreadLocal<Foo, Tag, Make>::get();
  EXPECT_EQ(4, single.b);
}

TEST	(	SingletonThreadLocalTest	,
		NotMoveConstructibleMake
	)

Definition at line 84 of file SingletonThreadLocalTest.cpp.

References a, b, EXPECT_EQ, folly::SingletonThreadLocal< T, Tag, Make, TLTag >::get(), and single.

                                                         {
  struct Foo {
    int a, b;
    Foo(int a_, int b_) : a(a_), b(b_) {}
    Foo(Foo&&) = delete;
    Foo& operator=(Foo&&) = delete;
  };
  struct Tag {};
  struct Make {
    Foo* operator()(unsigned char (&buf)[sizeof(Foo)]) const {
      return new (buf) Foo(3, 4);
    }
  };
  auto& single = SingletonThreadLocal<Foo, Tag, Make>::get();
  EXPECT_EQ(4, single.b);
}

TEST	(	SingletonThreadLocalTest	,
		AccessAfterFastPathDestruction
	)

Definition at line 101 of file SingletonThreadLocalTest.cpp.

References counter, EXPECT_EQ, folly::SingletonThreadLocal< T, Tag, Make, TLTag >::get(), and i.

                                                               {
  static std::atomic<int> counter{};
  struct Foo {
    int i = 3;
  };
  struct Bar {
    ~Bar() {
      counter += SingletonThreadLocal<Foo>::get().i;
    }
  };
  auto th = std::thread([] {
    SingletonThreadLocal<Bar>::get();
    counter += SingletonThreadLocal<Foo>::get().i;
  });
  th.join();
  EXPECT_EQ(6, counter);
}

TEST	(	ThreadLocal	,
		DependencyTest
	)

Definition at line 119 of file SingletonThreadLocalTest.cpp.

References folly::data(), folly::pushmi::operators::get, and folly::join().

                                  {
  typedef folly::ThreadLocalPtr<int> Data;

  struct mytag {};

  typedef SingletonThreadLocal<int> SingletonInt;
  struct barstruct {
    ~barstruct() {
      SingletonInt::get()++;
      Data data;
      data.reset(new int(0));
    }
  };
  typedef SingletonThreadLocal<barstruct, mytag> BarSingleton;

  std::thread([&]() {
    Data data;
    data.reset(new int(0));
    SingletonInt::get();
    BarSingleton::get();
  })
      .join();
}

TEST	(	SingletonThreadLocalTest	,
		Reused
	)

Definition at line 143 of file SingletonThreadLocalTest.cpp.

References folly::data(), EXPECT_EQ, FOLLY_DECLARE_REUSED, i, and string.

                                       {
  for (auto i = 0u; i < 2u; ++i) {
    FOLLY_DECLARE_REUSED(data, std::string);
    if (i == 0u) {
      data = "hello";
    }
    EXPECT_EQ(i == 0u ? "hello" : "", data);
  }
}