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:
ThreadLocalStorageRunner(int * tls_value_ptr)35 explicit ThreadLocalStorageRunner(int* tls_value_ptr)
36 : tls_value_ptr_(tls_value_ptr) {}
37
~ThreadLocalStorageRunner()38 ~ThreadLocalStorageRunner() override {}
39
Run()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
ThreadLocalStorageCleanup(void * value)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
TEST(ThreadLocalStorageTest,Basics)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
TEST(ThreadLocalStorageTest,MAYBE_TLSDestructors)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