ThreadLocalTest.cpp File Reference

#include <folly/ThreadLocal.h>
#include <dlfcn.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <array>
#include <atomic>
#include <chrono>
#include <climits>
#include <condition_variable>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <thread>
#include <unordered_map>
#include <glog/logging.h>
#include <folly/Memory.h>
#include <folly/experimental/io/FsUtil.h>
#include <folly/portability/GTest.h>
#include <folly/portability/Unistd.h>
#include <folly/synchronization/Baton.h>
#include <folly/synchronization/detail/ThreadCachedInts.h>
#include <folly/system/ThreadId.h>

Go to the source code of this file.

Classes
class	Widget
struct	MultiWidget
class	SimpleThreadCachedInt
struct	HoldsOneTag2
struct	folly::threadlocal_detail::PthreadKeyUnregisterTester

Namespaces
	folly
	—— Concurrent Priority Queue Implementation ——
	folly::threadlocal_detail

Macros
#define	SHARED_LIBRARY_TEST_NAME   DISABLED_SharedLibrary

Functions
	TEST (ThreadLocalPtr, BasicDestructor)
	TEST (ThreadLocalPtr, CustomDeleter1)
	TEST (ThreadLocalPtr, CustomDeleterOwnershipTransfer)
	TEST (ThreadLocalPtr, DefaultDeleterOwnershipTransfer)
	TEST (ThreadLocalPtr, resetNull)
	TEST (ThreadLocalPtr, TestRelease)
	TEST (ThreadLocalPtr, CreateOnThreadExit)
	TEST (ThreadLocalPtr, CustomDeleter2)
	TEST (ThreadLocal, BasicDestructor)
	TEST (ThreadLocal, ReallocDestructor)
	TEST (ThreadLocal, SimpleRepeatDestructor)
	TEST (ThreadLocal, InterleavedDestructors)
	TEST (ThreadLocalPtr, AccessAllThreadsCounter)
	TEST (ThreadLocal, resetNull)
	TEST (ThreadLocal, Movable1)
	TEST (ThreadLocal, Movable2)
	TEST (ThreadLocal, TCICreateOnThreadExit)
	TEST (ThreadLocal, Stress)
	TEST (ThreadLocal, Fork2)
	TEST (ThreadLocal, DISABLED_SharedLibrary)
	TEST (ThreadLocal, UnregisterClassHasConstExprCtor)

Macro Definition Documentation

#define SHARED_LIBRARY_TEST_NAME   DISABLED_SharedLibrary

Definition at line 667 of file ThreadLocalTest.cpp.

Function Documentation

TEST	(	ThreadLocalPtr	,
		BasicDestructor
	)

Definition at line 81 of file ThreadLocalTest.cpp.

References EXPECT_EQ, folly::ThreadLocalPtr< T, Tag, AccessMode >::get(), folly::join(), folly::ThreadLocalPtr< T, Tag, AccessMode >::reset(), and Widget::totalVal_.

                                      {
  Widget::totalVal_ = 0;
  ThreadLocalPtr<Widget> w;
  std::thread([&w]() {
    w.reset(new Widget());
    w.get()->val_ += 10;
  })
      .join();
  EXPECT_EQ(10, Widget::totalVal_);
}

TEST	(	ThreadLocalPtr	,
		CustomDeleter1
	)

Definition at line 92 of file ThreadLocalTest.cpp.

References Widget::customDeleter(), EXPECT_EQ, folly::ThreadLocalPtr< T, Tag, AccessMode >::get(), folly::join(), folly::ThreadLocalPtr< T, Tag, AccessMode >::reset(), and Widget::totalVal_.

                                     {
  Widget::totalVal_ = 0;
  {
    ThreadLocalPtr<Widget> w;
    std::thread([&w]() {
      w.reset(new Widget(), Widget::customDeleter);
      w.get()->val_ += 10;
    })
        .join();
    EXPECT_EQ(11, Widget::totalVal_);
  }
  EXPECT_EQ(11, Widget::totalVal_);
}

TEST	(	ThreadLocalPtr	,
		CustomDeleterOwnershipTransfer
	)

Definition at line 106 of file ThreadLocalTest.cpp.

References Widget::customDeleter(), EXPECT_EQ, folly::ThreadLocalPtr< T, Tag, AccessMode >::get(), folly::join(), folly::gen::move, ptr, folly::ThreadLocalPtr< T, Tag, AccessMode >::reset(), folly::THIS_THREAD, and Widget::totalVal_.

                                                     {
  Widget::totalVal_ = 0;
  {
    ThreadLocalPtr<Widget> w;
    auto deleter = [](Widget* ptr) {
      Widget::customDeleter(ptr, TLPDestructionMode::THIS_THREAD);
    };
    std::unique_ptr<Widget, decltype(deleter)> source(new Widget(), deleter);
    std::thread([&w, &source]() {
      w.reset(std::move(source));
      w.get()->val_ += 10;
    })
        .join();
    EXPECT_EQ(11, Widget::totalVal_);
  }
  EXPECT_EQ(11, Widget::totalVal_);
}

TEST	(	ThreadLocalPtr	,
		DefaultDeleterOwnershipTransfer
	)

Definition at line 124 of file ThreadLocalTest.cpp.

References EXPECT_EQ, folly::ThreadLocalPtr< T, Tag, AccessMode >::get(), folly::join(), folly::gen::move, folly::ThreadLocalPtr< T, Tag, AccessMode >::reset(), and Widget::totalVal_.

                                                      {
  Widget::totalVal_ = 0;
  {
    ThreadLocalPtr<Widget> w;
    auto source = std::make_unique<Widget>();
    std::thread([&w, &source]() {
      w.reset(std::move(source));
      w.get()->val_ += 10;
    })
        .join();
    EXPECT_EQ(10, Widget::totalVal_);
  }
  EXPECT_EQ(10, Widget::totalVal_);
}

TEST	(	ThreadLocalPtr	,
		resetNull
	)

Definition at line 139 of file ThreadLocalTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::ThreadLocalPtr< T, Tag, AccessMode >::get(), and folly::ThreadLocalPtr< T, Tag, AccessMode >::reset().

                                {
  ThreadLocalPtr<int> tl;
  EXPECT_FALSE(tl);
  tl.reset(new int(4));
  EXPECT_TRUE(static_cast<bool>(tl));
  EXPECT_EQ(*tl.get(), 4);
  tl.reset();
  EXPECT_FALSE(tl);
}

TEST	(	ThreadLocalPtr	,
		TestRelease
	)

Definition at line 149 of file ThreadLocalTest.cpp.

References EXPECT_EQ, folly::ThreadLocalPtr< T, Tag, AccessMode >::get(), folly::join(), folly::ThreadLocalPtr< T, Tag, AccessMode >::release(), folly::ThreadLocalPtr< T, Tag, AccessMode >::reset(), and Widget::totalVal_.

                                  {
  Widget::totalVal_ = 0;
  ThreadLocalPtr<Widget> w;
  std::unique_ptr<Widget> wPtr;
  std::thread([&w, &wPtr]() {
    w.reset(new Widget());
    w.get()->val_ += 10;

    wPtr.reset(w.release());
  })
      .join();
  EXPECT_EQ(0, Widget::totalVal_);
  wPtr.reset();
  EXPECT_EQ(10, Widget::totalVal_);
}

TEST	(	ThreadLocalPtr	,
		CreateOnThreadExit
	)

Definition at line 165 of file ThreadLocalTest.cpp.

References EXPECT_EQ, folly::ThreadLocal< T, Tag, AccessMode >::get(), folly::join(), ptr, folly::ThreadLocalPtr< T, Tag, AccessMode >::reset(), and Widget::totalVal_.

                                         {
  Widget::totalVal_ = 0;
  ThreadLocal<Widget> w;
  ThreadLocalPtr<int> tl;

  std::thread([&] {
    tl.reset(new int(1), [&](int* ptr, TLPDestructionMode /* mode */) {
      delete ptr;
      // This test ensures Widgets allocated here are not leaked.
      ++w.get()->val_;
      ThreadLocal<Widget> wl;
      ++wl.get()->val_;
    });
  })
      .join();
  EXPECT_EQ(2, Widget::totalVal_);
}

TEST	(	ThreadLocalPtr	,
		CustomDeleter2
	)

Definition at line 184 of file ThreadLocalTest.cpp.

References Widget::customDeleter(), EXPECT_EQ, folly::ThreadLocalPtr< T, Tag, AccessMode >::get(), folly::lock(), mutex, folly::ThreadLocalPtr< T, Tag, AccessMode >::reset(), folly::pushmi::detail::t, and Widget::totalVal_.

                                     {
  Widget::totalVal_ = 0;
  std::thread t;
  std::mutex mutex;
  std::condition_variable cv;
  enum class State {
    START,
    DONE,
    EXIT,
  };
  State state = State::START;
  {
    ThreadLocalPtr<Widget> w;
    t = std::thread([&]() {
      w.reset(new Widget(), Widget::customDeleter);
      w.get()->val_ += 10;

      // Notify main thread that we're done
      {
        std::unique_lock<std::mutex> lock(mutex);
        state = State::DONE;
        cv.notify_all();
      }

      // Wait for main thread to allow us to exit
      {
        std::unique_lock<std::mutex> lock(mutex);
        while (state != State::EXIT) {
          cv.wait(lock);
        }
      }
    });

    // Wait for main thread to start (and set w.get()->val_)
    {
      std::unique_lock<std::mutex> lock(mutex);
      while (state != State::DONE) {
        cv.wait(lock);
      }
    }

    // Thread started but hasn't exited yet
    EXPECT_EQ(0, Widget::totalVal_);

    // Destroy ThreadLocalPtr<Widget> (by letting it go out of scope)
  }

  EXPECT_EQ(1010, Widget::totalVal_);

  // Allow thread to exit
  {
    std::unique_lock<std::mutex> lock(mutex);
    state = State::EXIT;
    cv.notify_all();
  }
  t.join();

  EXPECT_EQ(1010, Widget::totalVal_);
}

TEST	(	ThreadLocal	,
		BasicDestructor
	)

Definition at line 244 of file ThreadLocalTest.cpp.

References EXPECT_EQ, folly::join(), and Widget::totalVal_.

                                   {
  Widget::totalVal_ = 0;
  ThreadLocal<Widget> w;
  std::thread([&w]() { w->val_ += 10; }).join();
  EXPECT_EQ(10, Widget::totalVal_);
}

TEST	(	ThreadLocal	,
		ReallocDestructor
	)

Definition at line 252 of file ThreadLocalTest.cpp.

References folly::join(), and MultiWidget::val_.

                                     {
  ThreadLocal<MultiWidget> w;
  std::thread([&w]() { w->val_ += 10; }).join();
}

TEST	(	ThreadLocal	,
		SimpleRepeatDestructor
	)

Definition at line 257 of file ThreadLocalTest.cpp.

References EXPECT_EQ, and Widget::totalVal_.

                                          {
  Widget::totalVal_ = 0;
  {
    ThreadLocal<Widget> w;
    w->val_ += 10;
  }
  {
    ThreadLocal<Widget> w;
    w->val_ += 10;
  }
  EXPECT_EQ(20, Widget::totalVal_);
}

TEST	(	ThreadLocal	,
		InterleavedDestructors
	)

Definition at line 270 of file ThreadLocalTest.cpp.

References EXPECT_EQ, FOR_EACH_RANGE, g(), i, folly::lock(), mutex, and Widget::totalVal_.

                                          {
  Widget::totalVal_ = 0;
  std::unique_ptr<ThreadLocal<Widget>> w;
  int wVersion = 0;
  const int wVersionMax = 2;
  int thIter = 0;
  std::mutex lock;
  auto th = std::thread([&]() {
    int wVersionPrev = 0;
    while (true) {
      while (true) {
        std::lock_guard<std::mutex> g(lock);
        if (wVersion > wVersionMax) {
          return;
        }
        if (wVersion > wVersionPrev) {
          // We have a new version of w, so it should be initialized to zero
          EXPECT_EQ((*w)->val_, 0);
          break;
        }
      }
      std::lock_guard<std::mutex> g(lock);
      wVersionPrev = wVersion;
      (*w)->val_ += 10;
      ++thIter;
    }
  });
  FOR_EACH_RANGE (i, 0, wVersionMax) {
    int thIterPrev = 0;
    {
      std::lock_guard<std::mutex> g(lock);
      thIterPrev = thIter;
      w = std::make_unique<ThreadLocal<Widget>>();
      ++wVersion;
    }
    while (true) {
      std::lock_guard<std::mutex> g(lock);
      if (thIter > thIterPrev) {
        break;
      }
    }
  }
  {
    std::lock_guard<std::mutex> g(lock);
    wVersion = wVersionMax + 1;
  }
  th.join();
  EXPECT_EQ(wVersionMax * 10, Widget::totalVal_);
}

TEST	(	ThreadLocalPtr	,
		AccessAllThreadsCounter
	)

Definition at line 338 of file ThreadLocalTest.cpp.

References SimpleThreadCachedInt::add(), EXPECT_EQ, i, kNumThreads, fizz::detail::read(), folly::run(), folly::pushmi::detail::t, and threads.

                                              {
  const int kNumThreads = 256;
  SimpleThreadCachedInt stci[kNumThreads + 1];
  std::atomic<bool> run(true);
  std::atomic<int> totalAtomic{0};
  std::vector<std::thread> threads;
  // thread i will increment all the thread locals
  // in the range 0..i
  for (int i = 0; i < kNumThreads; ++i) {
    threads.push_back(std::thread([i, // i needs to be captured by value
                                   &stci,
                                   &run,
                                   &totalAtomic]() {
      for (int j = 0; j <= i; j++) {
        stci[j].add(1);
      }

      totalAtomic.fetch_add(1);
      while (run.load()) {
        usleep(100);
      }
    }));
  }
  while (totalAtomic.load() != kNumThreads) {
    usleep(100);
  }
  for (int i = 0; i <= kNumThreads; i++) {
    EXPECT_EQ(kNumThreads - i, stci[i].read());
  }
  run.store(false);
  for (auto& t : threads) {
    t.join();
  }
}

TEST	(	ThreadLocal	,
		resetNull
	)

Definition at line 373 of file ThreadLocalTest.cpp.

References EXPECT_EQ, folly::ThreadLocal< T, Tag, AccessMode >::get(), and folly::ThreadLocal< T, Tag, AccessMode >::reset().

                             {
  ThreadLocal<int> tl;
  tl.reset(new int(4));
  EXPECT_EQ(*tl.get(), 4);
  tl.reset();
  EXPECT_EQ(*tl.get(), 0);
  tl.reset(new int(5));
  EXPECT_EQ(*tl.get(), 5);
}

TEST	(	ThreadLocal	,
		Movable1
	)

Definition at line 391 of file ThreadLocalTest.cpp.

References a, b, and EXPECT_TRUE.

                            {
  Foo a;
  Foo b;
  EXPECT_TRUE(a.tl.get() != b.tl.get());

  a = Foo();
  b = Foo();
  EXPECT_TRUE(a.tl.get() != b.tl.get());
}

TEST	(	ThreadLocal	,
		Movable2
	)

Definition at line 401 of file ThreadLocalTest.cpp.

References EXPECT_EQ, m, and map().

                            {
  std::map<int, Foo> map;

  map[42];
  map[10];
  map[23];
  map[100];

  std::set<void*> tls;
  for (auto& m : map) {
    tls.insert(m.second.tl.get());
  }

  // Make sure that we have 4 different instances of *tl
  EXPECT_EQ(4, tls.size());
}

TEST	(	ThreadLocal	,
		TCICreateOnThreadExit
	)

Definition at line 438 of file ThreadLocalTest.cpp.

References check(), data_, folly::getCurrentThreadID(), i, folly::join(), uint64_t, v, and val.

                                         {
  detail::ThreadCachedInts<void> ints;
  ThreadLocal<ThreadCachedIntWidget> w;

  std::thread([&] {
    // make sure the ints object is created
    ints.increment(1);
    // now the widget
    w->set(&ints);
  })
      .join();
}

TEST	(	ThreadLocal	,
		Stress
	)

Definition at line 494 of file ThreadLocalTest.cpp.

References folly::ThreadLocal< T, Tag, AccessMode >::accessAllThreads(), ADD_FAILURE, EXPECT_EQ, EXPECT_TRUE, i, k, folly::lock(), mutex, ptr, folly::pushmi::detail::t, folly::TEST(), threads, and folly::value().

                          {
  static constexpr size_t numFillObjects = 250;
  std::array<ThreadLocalPtr<FillObject>, numFillObjects> objects;

  static constexpr size_t numThreads = 32;
  static constexpr size_t numReps = 20;

  std::vector<std::thread> threads;
  threads.reserve(numThreads);

  for (size_t k = 0; k < numThreads; ++k) {
    threads.emplace_back([&objects] {
      for (size_t rep = 0; rep < numReps; ++rep) {
        for (size_t i = 0; i < objects.size(); ++i) {
          objects[i].reset(new FillObject(rep * objects.size() + i));
          std::this_thread::sleep_for(std::chrono::microseconds(100));
        }
        for (size_t i = 0; i < objects.size(); ++i) {
          objects[i]->check();
        }
      }
    });
  }

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

  EXPECT_EQ(numFillObjects * numThreads * numReps, gDestroyed);
}

TEST	(	ThreadLocal	,
		Fork2
	)

Definition at line 632 of file ThreadLocalTest.cpp.

References ADD_FAILURE, EXPECT_EQ, EXPECT_TRUE, folly::ThreadLocal< T, Tag, AccessMode >::get(), and folly::pushmi::detail::t.

                         {
  // A thread-local tag that was used in the parent from a *different* thread
  // (but not the forking thread) would cause the child to hang in a
  // ThreadLocalPtr's object destructor. Yeah.
  ThreadLocal<HoldsOne, HoldsOneTag2> p;
  {
    // use tag in different thread
    std::thread t([&p] { p.get(); });
    t.join();
  }
  pid_t pid = fork();
  if (pid == 0) {
    {
      ThreadLocal<HoldsOne, HoldsOneTag2> q;
      q.get();
    }
    _exit(0);
  } else if (pid > 0) {
    int status;
    EXPECT_EQ(pid, waitpid(pid, &status, 0));
    EXPECT_TRUE(WIFEXITED(status));
    EXPECT_EQ(0, WEXITSTATUS(status));
  } else {
    ADD_FAILURE() << "fork failed";
  }
}

TEST	(	ThreadLocal	,
		DISABLED_SharedLibrary
	)

Definition at line 672 of file ThreadLocalTest.cpp.

References ASSERT_NE, exe, folly::fs::executable_path(), EXPECT_EQ, lib, folly::Baton< MayBlock, Atom >::post(), useA(), and folly::Baton< MayBlock, Atom >::wait().

                                            {
  auto exe = fs::executable_path();
  auto lib = exe.parent_path() / "thread_local_test_lib.so";
  auto handle = dlopen(lib.string().c_str(), RTLD_LAZY);
  ASSERT_NE(nullptr, handle)
      << "unable to load " << lib.string() << ": " << dlerror();

  typedef void (*useA_t)();
  dlerror();
  useA_t useA = (useA_t)dlsym(handle, "useA");

  const char* dlsym_error = dlerror();
  EXPECT_EQ(nullptr, dlsym_error);
  ASSERT_NE(nullptr, useA);

  useA();

  folly::Baton<> b11, b12, b21, b22;

  std::thread t1([&]() {
    useA();
    b11.post();
    b12.wait();
  });

  std::thread t2([&]() {
    useA();
    b21.post();
    b22.wait();
  });

  b11.wait();
  b21.wait();

  dlclose(handle);

  b12.post();
  b22.post();

  t1.join();
  t2.join();
}

TEST	(	ThreadLocal	,
		UnregisterClassHasConstExprCtor
	)

Definition at line 726 of file ThreadLocalTest.cpp.

References SUCCEED, and x.

                                                   {
  folly::threadlocal_detail::PthreadKeyUnregisterTester x;
  // yep!
  SUCCEED();
}