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