tests/thread_local_test.cpp

   1 /*
   2  * Copyright (C) 2015 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gtest/gtest.h>
  18 #include <stdint.h>
  19 #include <string.h>
  20
  21 #if defined(__GNUC__) && !defined(__clang__) && \
  22     (defined(__arm__) || defined(__aarch64__))
  23 // Gcc has a bug with -O -fdata-section for the arm target: http://b/22772147.
  24 // Until that bug is fixed, disable optimization since
  25 // it is not essential for this test.
  26 #pragma GCC optimize("-O0")
  27 #endif
  28
  29 __thread int local_var = 100;
  30 int shared_var = 200;
  31
  32 static void reset_vars() {
  33   local_var = 1000;
  34   shared_var = 2000;
  35   // local_var should be reset by threads
  36 }
  37
  38 typedef void* (*MyThread)(void*);
  39
  40 static void* inc_shared_var(void* p) {
  41   int *data = reinterpret_cast<int*>(p);
  42   shared_var++;
  43   *data = shared_var;
  44   return nullptr;
  45 }
  46
  47 static void* inc_local_var(void* p) {
  48   int *data = reinterpret_cast<int*>(p);
  49   local_var++;
  50   *data = local_var;
  51   return nullptr;
  52 }
  53
  54 static int run_one_thread(MyThread foo) {
  55   pthread_t t;
  56   int data;
  57   int error = pthread_create(&t, nullptr, foo, &data);
  58   if (!error)
  59       error = pthread_join(t, nullptr);
  60   return error ? error : data;
  61 }
  62
  63 TEST(thread_local_storage, shared) {
  64   reset_vars();
  65   ASSERT_EQ(local_var, 1000);
  66   ASSERT_EQ(shared_var, 2000);
  67
  68   // Update shared_var, local_var remains 1000.
  69   ASSERT_EQ(run_one_thread(inc_shared_var), 2001);
  70   ASSERT_EQ(local_var, 1000);
  71   ASSERT_EQ(shared_var, 2001);
  72
  73   ASSERT_EQ(run_one_thread(inc_shared_var), 2002);
  74   ASSERT_EQ(local_var, 1000);
  75   ASSERT_EQ(shared_var, 2002);
  76
  77   ASSERT_EQ(run_one_thread(inc_shared_var), 2003);
  78   ASSERT_EQ(local_var, 1000);
  79   ASSERT_EQ(shared_var, 2003);
  80 }
  81
  82 TEST(thread_local_storage, local) {
  83   reset_vars();
  84   ASSERT_EQ(local_var, 1000);
  85   ASSERT_EQ(shared_var, 2000);
  86
  87   // When a child thread updates its own TLS variable,
  88   // this thread's local_var and shared_var are not changed.
  89   // TLS local_var is initialized to 100 in a thread.
  90   ASSERT_EQ(run_one_thread(inc_local_var), 101);
  91   ASSERT_EQ(local_var, 1000);
  92   ASSERT_EQ(shared_var, 2000);
  93
  94   ASSERT_EQ(run_one_thread(inc_local_var), 101);
  95   ASSERT_EQ(local_var, 1000);
  96   ASSERT_EQ(shared_var, 2000);
  97
  98   ASSERT_EQ(run_one_thread(inc_local_var), 101);
  99   ASSERT_EQ(local_var, 1000);
 100   ASSERT_EQ(shared_var, 2000);
 101 }
 102
 103 // Test TLS initialization of more complicated type, array of struct.
 104 struct Point {
 105   int x, y;
 106 };
 107
 108 typedef Point Triangle[3];
 109
 110 __thread Triangle local_triangle = {{10,10}, {20,20}, {30,30}};
 111 Triangle shared_triangle = {{1,1}, {2,2}, {3,3}};
 112
 113 static void reset_triangle() {
 114   static const Triangle t1 = {{3,3}, {4,4}, {5,5}};
 115   static const Triangle t2 = {{2,2}, {3,3}, {4,4}};
 116   memcpy(local_triangle, t1, sizeof(local_triangle));
 117   memcpy(shared_triangle, t2, sizeof(shared_triangle));
 118 }
 119
 120 static void* move_shared_triangle(void* p) {
 121   int *data = reinterpret_cast<int*>(p);
 122   shared_triangle[1].y++;
 123   *data = shared_triangle[1].y;
 124   return nullptr;
 125 }
 126
 127 static void* move_local_triangle(void* p) {
 128   int *data = reinterpret_cast<int*>(p);
 129   local_triangle[1].y++;
 130   *data = local_triangle[1].y;
 131   return nullptr;
 132 }
 133
 134 TEST(thread_local_storage, shared_triangle) {
 135   reset_triangle();
 136   ASSERT_EQ(local_triangle[1].y, 4);
 137   ASSERT_EQ(shared_triangle[1].y, 3);
 138
 139   // Update shared_triangle, local_triangle remains 1000.
 140   ASSERT_EQ(run_one_thread(move_shared_triangle), 4);
 141   ASSERT_EQ(local_triangle[1].y, 4);
 142   ASSERT_EQ(shared_triangle[1].y, 4);
 143
 144   ASSERT_EQ(run_one_thread(move_shared_triangle), 5);
 145   ASSERT_EQ(local_triangle[1].y, 4);
 146   ASSERT_EQ(shared_triangle[1].y, 5);
 147
 148   ASSERT_EQ(run_one_thread(move_shared_triangle), 6);
 149   ASSERT_EQ(local_triangle[1].y, 4);
 150   ASSERT_EQ(shared_triangle[1].y, 6);
 151 }
 152
 153 TEST(thread_local_storage, local_triangle) {
 154   reset_triangle();
 155   ASSERT_EQ(local_triangle[1].y, 4);
 156   ASSERT_EQ(shared_triangle[1].y, 3);
 157
 158   // Update local_triangle, parent thread's
 159   // shared_triangle and local_triangle are unchanged.
 160   ASSERT_EQ(run_one_thread(move_local_triangle), 21);
 161   ASSERT_EQ(local_triangle[1].y, 4);
 162   ASSERT_EQ(shared_triangle[1].y, 3);
 163
 164   ASSERT_EQ(run_one_thread(move_local_triangle), 21);
 165   ASSERT_EQ(local_triangle[1].y, 4);
 166   ASSERT_EQ(shared_triangle[1].y, 3);
 167
 168   ASSERT_EQ(run_one_thread(move_local_triangle), 21);
 169   ASSERT_EQ(local_triangle[1].y, 4);
 170   ASSERT_EQ(shared_triangle[1].y, 3);
 171 }
 172
 173 // Test emutls runtime data structures and __emutls_get_address function.
 174 typedef unsigned int gcc_word __attribute__((mode(word)));
 175 typedef unsigned int gcc_pointer __attribute__((mode(pointer)));
 176 struct gcc_emutls_object {  // for libgcc
 177   gcc_word size;
 178   gcc_word align;
 179   union {
 180     gcc_pointer offset;
 181     void* ptr;
 182   } loc;
 183   void* templ;
 184 };
 185
 186 typedef struct __emutls_control {  // for clang/llvm
 187   size_t size;
 188   size_t align;
 189   union {
 190     uintptr_t index;
 191     void* address;
 192   } object;
 193   void* value;
 194 } __emutls_control;
 195
 196 TEST(thread_local_storage, type_size) {
 197   static_assert(sizeof(size_t) == sizeof(gcc_word),
 198                 "size_t != gcc_word");
 199   static_assert(sizeof(uintptr_t) == sizeof(gcc_pointer),
 200                 "uintptr_t != gcc_pointer");
 201   static_assert(sizeof(uintptr_t) == sizeof(void*),
 202                 "sizoeof(uintptr_t) != sizeof(void*)");
 203   static_assert(sizeof(__emutls_control) == sizeof(struct gcc_emutls_object),
 204                 "sizeof(__emutls_control) != sizeof(struct gcc_emutls_object)");
 205 }
 206
 207 extern "C" void* __emutls_get_address(__emutls_control*);
 208
 209 TEST(thread_local_storage, init_value) {
 210   char tls_value1[] = "123456789";
 211   char tls_value2[] = "abcdefghi";
 212   constexpr size_t num_saved_values = 10;
 213   __emutls_control tls_var[num_saved_values];
 214   size_t prev_index = 0;
 215   void* saved_gap[num_saved_values];
 216   void* saved_p[num_saved_values];
 217   ASSERT_TRUE(strlen(tls_value2) <= strlen(tls_value1));
 218   __emutls_control c =
 219       {strlen(tls_value1) + 1, 1, {0}, tls_value1};
 220   for (size_t n = 0; n < num_saved_values; n++) {
 221     memcpy(&tls_var[n], &c, sizeof(c));
 222     tls_var[n].align = (1 << n);
 223   }
 224   for (size_t n = 0; n < num_saved_values; n++) {
 225     // Try to mess up malloc space so that the next malloc will not have the
 226     // required alignment, but __emutls_get_address should still return an
 227     // aligned address.
 228     saved_gap[n] = malloc(1);
 229     void* p = __emutls_get_address(&tls_var[n]);
 230     saved_p[n] = p;
 231     ASSERT_TRUE(p != nullptr);
 232     ASSERT_TRUE(tls_var[n].object.index != 0);
 233     // check if p is a new object.
 234     if (n > 0) {
 235       // In single-thread environment, object.address == p.
 236       // In multi-threads environment, object.index is increased.
 237       ASSERT_TRUE(prev_index + 1 == tls_var[n].object.index ||
 238                   p == tls_var[n].object.address);
 239       ASSERT_TRUE(p != saved_p[n - 1]);
 240     }
 241     prev_index = tls_var[n].object.index;
 242     // check if p is aligned
 243     uintptr_t align = (1 << n);
 244     uintptr_t address= reinterpret_cast<uintptr_t>(p);
 245     ASSERT_EQ((address & ~(align - 1)), address);
 246     // check if *p is initialized
 247     ASSERT_STREQ(tls_value1, static_cast<char*>(p));
 248     // change value in *p
 249     memcpy(p, tls_value2, strlen(tls_value2) + 1);
 250   }
 251   for (size_t n = 0; n < num_saved_values; n++) {
 252     free(saved_gap[n]);
 253   }
 254   for (size_t n = 0; n < num_saved_values; n++) {
 255     void* p = __emutls_get_address(&tls_var[n]);
 256     ASSERT_EQ(p, saved_p[n]);
 257     // check if *p has the new value
 258     ASSERT_STREQ(tls_value2, static_cast<char*>(p));
 259   }
 260 }