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