base/threading/thread_local_storage_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #if defined(OS_WIN)
   6 #include <windows.h>
   7 #include <process.h>
   8 #endif
   9
  10 #include "base/threading/simple_thread.h"
  11 #include "base/threading/thread_local_storage.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 #if defined(OS_WIN)
  15 // Ignore warnings about ptr->int conversions that we use when
  16 // storing ints into ThreadLocalStorage.
  17 #pragma warning(disable : 4311 4312)
  18 #endif
  19
  20 namespace base {
  21
  22 namespace {
  23
  24 const int kInitialTlsValue = 0x5555;
  25 const int kFinalTlsValue = 0x7777;
  26 // How many times must a destructor be called before we really are done.
  27 const int kNumberDestructorCallRepetitions = 3;
  28
  29 static ThreadLocalStorage::StaticSlot tls_slot = TLS_INITIALIZER;
  30
  31 class ThreadLocalStorageRunner : public DelegateSimpleThread::Delegate {
  32  public:
  33   explicit ThreadLocalStorageRunner(int* tls_value_ptr)
  34       : tls_value_ptr_(tls_value_ptr) {}
  35
  36   virtual ~ThreadLocalStorageRunner() {}
  37
  38   virtual void Run() OVERRIDE {
  39     *tls_value_ptr_ = kInitialTlsValue;
  40     tls_slot.Set(tls_value_ptr_);
  41
  42     int *ptr = static_cast<int*>(tls_slot.Get());
  43     EXPECT_EQ(ptr, tls_value_ptr_);
  44     EXPECT_EQ(*ptr, kInitialTlsValue);
  45     *tls_value_ptr_ = 0;
  46
  47     ptr = static_cast<int*>(tls_slot.Get());
  48     EXPECT_EQ(ptr, tls_value_ptr_);
  49     EXPECT_EQ(*ptr, 0);
  50
  51     *ptr = kFinalTlsValue + kNumberDestructorCallRepetitions;
  52   }
  53
  54  private:
  55   int* tls_value_ptr_;
  56   DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorageRunner);
  57 };
  58
  59
  60 void ThreadLocalStorageCleanup(void *value) {
  61   int *ptr = reinterpret_cast<int*>(value);
  62   // Destructors should never be called with a NULL.
  63   ASSERT_NE(reinterpret_cast<int*>(NULL), ptr);
  64   if (*ptr == kFinalTlsValue)
  65     return;  // We've been called enough times.
  66   ASSERT_LT(kFinalTlsValue, *ptr);
  67   ASSERT_GE(kFinalTlsValue + kNumberDestructorCallRepetitions, *ptr);
  68   --*ptr;  // Move closer to our target.
  69   // Tell tls that we're not done with this thread, and still need destruction.
  70   tls_slot.Set(value);
  71 }
  72
  73 }  // namespace
  74
  75 TEST(ThreadLocalStorageTest, Basics) {
  76   ThreadLocalStorage::Slot slot;
  77   slot.Set(reinterpret_cast<void*>(123));
  78   int value = reinterpret_cast<intptr_t>(slot.Get());
  79   EXPECT_EQ(value, 123);
  80 }
  81
  82 #if defined(THREAD_SANITIZER) ||                    \
  83     (defined(OS_WIN) && defined(ARCH_CPU_X86_64) && \
  84      defined(INCREMENTAL_LINKING))
  85 // Do not run the test under ThreadSanitizer. Because this test iterates its
  86 // own TSD destructor for the maximum possible number of times, TSan can't jump
  87 // in after the last destructor invocation, therefore the destructor remains
  88 // unsynchronized with the following users of the same TSD slot. This results
  89 // in race reports between the destructor and functions in other tests.
  90 //
  91 // It is disabled on Win x64 with incremental linking pending resolution of
  92 // http://crbug.com/251251.
  93 #define MAYBE_TLSDestructors DISABLED_TLSDestructors
  94 #else
  95 #define MAYBE_TLSDestructors TLSDestructors
  96 #endif
  97 TEST(ThreadLocalStorageTest, MAYBE_TLSDestructors) {
  98   // Create a TLS index with a destructor.  Create a set of
  99   // threads that set the TLS, while the destructor cleans it up.
 100   // After the threads finish, verify that the value is cleaned up.
 101   const int kNumThreads = 5;
 102   int values[kNumThreads];
 103   ThreadLocalStorageRunner* thread_delegates[kNumThreads];
 104   DelegateSimpleThread* threads[kNumThreads];
 105
 106   tls_slot.Initialize(ThreadLocalStorageCleanup);
 107
 108   // Spawn the threads.
 109   for (int index = 0; index < kNumThreads; index++) {
 110     values[index] = kInitialTlsValue;
 111     thread_delegates[index] = new ThreadLocalStorageRunner(&values[index]);
 112     threads[index] = new DelegateSimpleThread(thread_delegates[index],
 113                                               "tls thread");
 114     threads[index]->Start();
 115   }
 116
 117   // Wait for the threads to finish.
 118   for (int index = 0; index < kNumThreads; index++) {
 119     threads[index]->Join();
 120     delete threads[index];
 121     delete thread_delegates[index];
 122
 123     // Verify that the destructor was called and that we reset.
 124     EXPECT_EQ(values[index], kFinalTlsValue);
 125   }
 126   tls_slot.Free();  // Stop doing callbacks to cleanup threads.
 127 }
 128
 129 }  // namespace base