//===-- sanitizer_stoptheworld_test.cc ------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Tests for sanitizer_stoptheworld.h // //===----------------------------------------------------------------------===// #include "sanitizer_common/sanitizer_platform.h" #if SANITIZER_LINUX && defined(__x86_64__) #include "sanitizer_common/sanitizer_stoptheworld.h" #include "gtest/gtest.h" #include "sanitizer_common/sanitizer_libc.h" #include "sanitizer_common/sanitizer_common.h" #include <pthread.h> #include <sched.h> namespace __sanitizer { static pthread_mutex_t incrementer_thread_exit_mutex; struct CallbackArgument { volatile int counter; volatile bool threads_stopped; volatile bool callback_executed; CallbackArgument() : counter(0), threads_stopped(false), callback_executed(false) {} }; void *IncrementerThread(void *argument) { CallbackArgument *callback_argument = (CallbackArgument *)argument; while (true) { __sync_fetch_and_add(&callback_argument->counter, 1); if (pthread_mutex_trylock(&incrementer_thread_exit_mutex) == 0) { pthread_mutex_unlock(&incrementer_thread_exit_mutex); return NULL; } else { sched_yield(); } } } // This callback checks that IncrementerThread is suspended at the time of its // execution. void Callback(const SuspendedThreadsList &suspended_threads_list, void *argument) { CallbackArgument *callback_argument = (CallbackArgument *)argument; callback_argument->callback_executed = true; int counter_at_init = __sync_fetch_and_add(&callback_argument->counter, 0); for (uptr i = 0; i < 1000; i++) { sched_yield(); if (__sync_fetch_and_add(&callback_argument->counter, 0) != counter_at_init) { callback_argument->threads_stopped = false; return; } } callback_argument->threads_stopped = true; } TEST(StopTheWorld, SuspendThreadsSimple) { pthread_mutex_init(&incrementer_thread_exit_mutex, NULL); CallbackArgument argument; pthread_t thread_id; int pthread_create_result; pthread_mutex_lock(&incrementer_thread_exit_mutex); pthread_create_result = pthread_create(&thread_id, NULL, IncrementerThread, &argument); ASSERT_EQ(0, pthread_create_result); StopTheWorld(&Callback, &argument); pthread_mutex_unlock(&incrementer_thread_exit_mutex); EXPECT_TRUE(argument.callback_executed); EXPECT_TRUE(argument.threads_stopped); // argument is on stack, so we have to wait for the incrementer thread to // terminate before we can return from this function. ASSERT_EQ(0, pthread_join(thread_id, NULL)); pthread_mutex_destroy(&incrementer_thread_exit_mutex); } // A more comprehensive test where we spawn a bunch of threads while executing // StopTheWorld in parallel. static const uptr kThreadCount = 50; static const uptr kStopWorldAfter = 10; // let this many threads spawn first static pthread_mutex_t advanced_incrementer_thread_exit_mutex; struct AdvancedCallbackArgument { volatile uptr thread_index; volatile int counters[kThreadCount]; pthread_t thread_ids[kThreadCount]; volatile bool threads_stopped; volatile bool callback_executed; volatile bool fatal_error; AdvancedCallbackArgument() : thread_index(0), threads_stopped(false), callback_executed(false), fatal_error(false) {} }; void *AdvancedIncrementerThread(void *argument) { AdvancedCallbackArgument *callback_argument = (AdvancedCallbackArgument *)argument; uptr this_thread_index = __sync_fetch_and_add( &callback_argument->thread_index, 1); // Spawn the next thread. int pthread_create_result; if (this_thread_index + 1 < kThreadCount) { pthread_create_result = pthread_create(&callback_argument->thread_ids[this_thread_index + 1], NULL, AdvancedIncrementerThread, argument); // Cannot use ASSERT_EQ in non-void-returning functions. If there's a // problem, defer failing to the main thread. if (pthread_create_result != 0) { callback_argument->fatal_error = true; __sync_fetch_and_add(&callback_argument->thread_index, kThreadCount - callback_argument->thread_index); } } // Do the actual work. while (true) { __sync_fetch_and_add(&callback_argument->counters[this_thread_index], 1); if (pthread_mutex_trylock(&advanced_incrementer_thread_exit_mutex) == 0) { pthread_mutex_unlock(&advanced_incrementer_thread_exit_mutex); return NULL; } else { sched_yield(); } } } void AdvancedCallback(const SuspendedThreadsList &suspended_threads_list, void *argument) { AdvancedCallbackArgument *callback_argument = (AdvancedCallbackArgument *)argument; callback_argument->callback_executed = true; int counters_at_init[kThreadCount]; for (uptr j = 0; j < kThreadCount; j++) counters_at_init[j] = __sync_fetch_and_add(&callback_argument->counters[j], 0); for (uptr i = 0; i < 10; i++) { sched_yield(); for (uptr j = 0; j < kThreadCount; j++) if (__sync_fetch_and_add(&callback_argument->counters[j], 0) != counters_at_init[j]) { callback_argument->threads_stopped = false; return; } } callback_argument->threads_stopped = true; } TEST(StopTheWorld, SuspendThreadsAdvanced) { pthread_mutex_init(&advanced_incrementer_thread_exit_mutex, NULL); AdvancedCallbackArgument argument; pthread_mutex_lock(&advanced_incrementer_thread_exit_mutex); int pthread_create_result; pthread_create_result = pthread_create(&argument.thread_ids[0], NULL, AdvancedIncrementerThread, &argument); ASSERT_EQ(0, pthread_create_result); // Wait for several threads to spawn before proceeding. while (__sync_fetch_and_add(&argument.thread_index, 0) < kStopWorldAfter) sched_yield(); StopTheWorld(&AdvancedCallback, &argument); EXPECT_TRUE(argument.callback_executed); EXPECT_TRUE(argument.threads_stopped); // Wait for all threads to spawn before we start terminating them. while (__sync_fetch_and_add(&argument.thread_index, 0) < kThreadCount) sched_yield(); ASSERT_FALSE(argument.fatal_error); // a pthread_create has failed // Signal the threads to terminate. pthread_mutex_unlock(&advanced_incrementer_thread_exit_mutex); for (uptr i = 0; i < kThreadCount; i++) ASSERT_EQ(0, pthread_join(argument.thread_ids[i], NULL)); pthread_mutex_destroy(&advanced_incrementer_thread_exit_mutex); } } // namespace __sanitizer #endif // SANITIZER_LINUX && defined(__x86_64__)