lib/sanitizer_common/tests/sanitizer_stoptheworld_test.cc

   1 //===-- sanitizer_stoptheworld_test.cc ------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Tests for sanitizer_stoptheworld.h
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "sanitizer_common/sanitizer_platform.h"
  15 #if SANITIZER_LINUX && defined(__x86_64__)
  16
  17 #include "sanitizer_common/sanitizer_stoptheworld.h"
  18 #include "gtest/gtest.h"
  19
  20 #include "sanitizer_common/sanitizer_libc.h"
  21 #include "sanitizer_common/sanitizer_common.h"
  22
  23 #include <pthread.h>
  24 #include <sched.h>
  25
  26 namespace __sanitizer {
  27
  28 static pthread_mutex_t incrementer_thread_exit_mutex;
  29
  30 struct CallbackArgument {
  31   volatile int counter;
  32   volatile bool threads_stopped;
  33   volatile bool callback_executed;
  34   CallbackArgument()
  35     : counter(0),
  36       threads_stopped(false),
  37       callback_executed(false) {}
  38 };
  39
  40 void *IncrementerThread(void *argument) {
  41   CallbackArgument *callback_argument = (CallbackArgument *)argument;
  42   while (true) {
  43     __sync_fetch_and_add(&callback_argument->counter, 1);
  44     if (pthread_mutex_trylock(&incrementer_thread_exit_mutex) == 0) {
  45       pthread_mutex_unlock(&incrementer_thread_exit_mutex);
  46       return NULL;
  47     } else {
  48       sched_yield();
  49     }
  50   }
  51 }
  52
  53 // This callback checks that IncrementerThread is suspended at the time of its
  54 // execution.
  55 void Callback(const SuspendedThreadsList &suspended_threads_list,
  56               void *argument) {
  57   CallbackArgument *callback_argument = (CallbackArgument *)argument;
  58   callback_argument->callback_executed = true;
  59   int counter_at_init = __sync_fetch_and_add(&callback_argument->counter, 0);
  60   for (uptr i = 0; i < 1000; i++) {
  61     sched_yield();
  62     if (__sync_fetch_and_add(&callback_argument->counter, 0) !=
  63           counter_at_init) {
  64       callback_argument->threads_stopped = false;
  65       return;
  66     }
  67   }
  68   callback_argument->threads_stopped = true;
  69 }
  70
  71 TEST(StopTheWorld, SuspendThreadsSimple) {
  72   pthread_mutex_init(&incrementer_thread_exit_mutex, NULL);
  73   CallbackArgument argument;
  74   pthread_t thread_id;
  75   int pthread_create_result;
  76   pthread_mutex_lock(&incrementer_thread_exit_mutex);
  77   pthread_create_result = pthread_create(&thread_id, NULL, IncrementerThread,
  78                                          &argument);
  79   ASSERT_EQ(0, pthread_create_result);
  80   StopTheWorld(&Callback, &argument);
  81   pthread_mutex_unlock(&incrementer_thread_exit_mutex);
  82   EXPECT_TRUE(argument.callback_executed);
  83   EXPECT_TRUE(argument.threads_stopped);
  84   // argument is on stack, so we have to wait for the incrementer thread to
  85   // terminate before we can return from this function.
  86   ASSERT_EQ(0, pthread_join(thread_id, NULL));
  87   pthread_mutex_destroy(&incrementer_thread_exit_mutex);
  88 }
  89
  90 // A more comprehensive test where we spawn a bunch of threads while executing
  91 // StopTheWorld in parallel.
  92 static const uptr kThreadCount = 50;
  93 static const uptr kStopWorldAfter = 10; // let this many threads spawn first
  94
  95 static pthread_mutex_t advanced_incrementer_thread_exit_mutex;
  96
  97 struct AdvancedCallbackArgument {
  98   volatile uptr thread_index;
  99   volatile int counters[kThreadCount];
 100   pthread_t thread_ids[kThreadCount];
 101   volatile bool threads_stopped;
 102   volatile bool callback_executed;
 103   volatile bool fatal_error;
 104   AdvancedCallbackArgument()
 105     : thread_index(0),
 106       threads_stopped(false),
 107       callback_executed(false),
 108       fatal_error(false) {}
 109 };
 110
 111 void *AdvancedIncrementerThread(void *argument) {
 112   AdvancedCallbackArgument *callback_argument =
 113       (AdvancedCallbackArgument *)argument;
 114   uptr this_thread_index = __sync_fetch_and_add(
 115       &callback_argument->thread_index, 1);
 116   // Spawn the next thread.
 117   int pthread_create_result;
 118   if (this_thread_index + 1 < kThreadCount) {
 119     pthread_create_result =
 120         pthread_create(&callback_argument->thread_ids[this_thread_index + 1],
 121                        NULL, AdvancedIncrementerThread, argument);
 122     // Cannot use ASSERT_EQ in non-void-returning functions. If there's a
 123     // problem, defer failing to the main thread.
 124     if (pthread_create_result != 0) {
 125       callback_argument->fatal_error = true;
 126       __sync_fetch_and_add(&callback_argument->thread_index,
 127                            kThreadCount - callback_argument->thread_index);
 128     }
 129   }
 130   // Do the actual work.
 131   while (true) {
 132     __sync_fetch_and_add(&callback_argument->counters[this_thread_index], 1);
 133     if (pthread_mutex_trylock(&advanced_incrementer_thread_exit_mutex) == 0) {
 134       pthread_mutex_unlock(&advanced_incrementer_thread_exit_mutex);
 135       return NULL;
 136     } else {
 137       sched_yield();
 138     }
 139   }
 140 }
 141
 142 void AdvancedCallback(const SuspendedThreadsList &suspended_threads_list,
 143                              void *argument) {
 144   AdvancedCallbackArgument *callback_argument =
 145       (AdvancedCallbackArgument *)argument;
 146   callback_argument->callback_executed = true;
 147
 148   int counters_at_init[kThreadCount];
 149   for (uptr j = 0; j < kThreadCount; j++)
 150     counters_at_init[j] = __sync_fetch_and_add(&callback_argument->counters[j],
 151                                                0);
 152   for (uptr i = 0; i < 10; i++) {
 153     sched_yield();
 154     for (uptr j = 0; j < kThreadCount; j++)
 155       if (__sync_fetch_and_add(&callback_argument->counters[j], 0) !=
 156             counters_at_init[j]) {
 157         callback_argument->threads_stopped = false;
 158         return;
 159       }
 160   }
 161   callback_argument->threads_stopped = true;
 162 }
 163
 164 TEST(StopTheWorld, SuspendThreadsAdvanced) {
 165   pthread_mutex_init(&advanced_incrementer_thread_exit_mutex, NULL);
 166   AdvancedCallbackArgument argument;
 167
 168   pthread_mutex_lock(&advanced_incrementer_thread_exit_mutex);
 169   int pthread_create_result;
 170   pthread_create_result = pthread_create(&argument.thread_ids[0], NULL,
 171                                          AdvancedIncrementerThread,
 172                                          &argument);
 173   ASSERT_EQ(0, pthread_create_result);
 174   // Wait for several threads to spawn before proceeding.
 175   while (__sync_fetch_and_add(&argument.thread_index, 0) < kStopWorldAfter)
 176     sched_yield();
 177   StopTheWorld(&AdvancedCallback, &argument);
 178   EXPECT_TRUE(argument.callback_executed);
 179   EXPECT_TRUE(argument.threads_stopped);
 180
 181   // Wait for all threads to spawn before we start terminating them.
 182   while (__sync_fetch_and_add(&argument.thread_index, 0) < kThreadCount)
 183     sched_yield();
 184   ASSERT_FALSE(argument.fatal_error); // a pthread_create has failed
 185   // Signal the threads to terminate.
 186   pthread_mutex_unlock(&advanced_incrementer_thread_exit_mutex);
 187   for (uptr i = 0; i < kThreadCount; i++)
 188     ASSERT_EQ(0, pthread_join(argument.thread_ids[i], NULL));
 189   pthread_mutex_destroy(&advanced_incrementer_thread_exit_mutex);
 190 }
 191
 192 }  // namespace __sanitizer
 193
 194 #endif  // SANITIZER_LINUX && defined(__x86_64__)