Page MenuHomePhabricator
Differential D115204 Diff 392377 compiler-rt/lib/sanitizer_common/tests/sanitizer_stoptheworld_test.cpp

Changeset View

Standalone View

View Options

compiler-rt/lib/sanitizer_common/tests/sanitizer_stoptheworld_test.cpp

//===-- sanitizer_stoptheworld_test.cpp -----------------------------------===// //===-- sanitizer_stoptheworld_test.cpp -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Tests for sanitizer_stoptheworld.h // Tests for sanitizer_stoptheworld.h
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "sanitizer_common/sanitizer_platform.h" #include "sanitizer_common/sanitizer_platform.h"
#if SANITIZER_LINUX && defined(__x86_64__) #if (SANITIZER_LINUX || SANITIZER_WINDOWS) && defined(__x86_64__)
#include "sanitizer_common/sanitizer_stoptheworld.h" # include <mutex>
#include "gtest/gtest.h" # include <thread>
#include "sanitizer_common/sanitizer_libc.h" # include "gtest/gtest.h"
#include "sanitizer_common/sanitizer_common.h" # include "sanitizer_common/sanitizer_common.h"
# include "sanitizer_common/sanitizer_libc.h"
#include <pthread.h> # include "sanitizer_common/sanitizer_stoptheworld.h"
#include <sched.h>
namespace __sanitizer { namespace __sanitizer {
static pthread_mutex_t incrementer_thread_exit_mutex; static std::mutex incrementer_thread_exit_mutex;
struct CallbackArgument { struct CallbackArgument {
volatile int counter; volatile int counter;
volatile bool threads_stopped; volatile bool threads_stopped;
volatile bool callback_executed; volatile bool callback_executed;
CallbackArgument() CallbackArgument()
: counter(0), : counter(0), threads_stopped(false), callback_executed(false) {}
threads_stopped(false),
callback_executed(false) {}
}; };
void *IncrementerThread(void *argument) { void IncrementerThread(CallbackArgument &callback_argument) {
CallbackArgument *callback_argument = (CallbackArgument *)argument;
while (true) { while (true) {
__sync_fetch_and_add(&callback_argument->counter, 1); __sync_fetch_and_add(&callback_argument.counter, 1);
if (pthread_mutex_trylock(&incrementer_thread_exit_mutex) == 0) {
pthread_mutex_unlock(&incrementer_thread_exit_mutex); if (incrementer_thread_exit_mutex.try_lock()) {
return NULL; incrementer_thread_exit_mutex.unlock();
} else { return;
sched_yield();
} }
std::this_thread::yield();
} }
} }
// This callback checks that IncrementerThread is suspended at the time of its // This callback checks that IncrementerThread is suspended at the time of its
// execution. // execution.
void Callback(const SuspendedThreadsList &suspended_threads_list, void Callback(const SuspendedThreadsList &suspended_threads_list,
void *argument) { void *argument) {
CallbackArgument *callback_argument = (CallbackArgument *)argument; CallbackArgument *callback_argument = (CallbackArgument *)argument;
callback_argument->callback_executed = true; callback_argument->callback_executed = true;
int counter_at_init = __sync_fetch_and_add(&callback_argument->counter, 0); int counter_at_init = __sync_fetch_and_add(&callback_argument->counter, 0);
for (uptr i = 0; i < 1000; i++) { for (uptr i = 0; i < 1000; i++) {
sched_yield(); std::this_thread::yield();
if (__sync_fetch_and_add(&callback_argument->counter, 0) != if (__sync_fetch_and_add(&callback_argument->counter, 0) !=
counter_at_init) { counter_at_init) {
callback_argument->threads_stopped = false; callback_argument->threads_stopped = false;
return; return;
} }
} }
callback_argument->threads_stopped = true; callback_argument->threads_stopped = true;
} }
TEST(StopTheWorld, SuspendThreadsSimple) { TEST(StopTheWorld, SuspendThreadsSimple) {
pthread_mutex_init(&incrementer_thread_exit_mutex, NULL);
CallbackArgument argument; CallbackArgument argument;
pthread_t thread_id; std::thread thread;
int pthread_create_result; incrementer_thread_exit_mutex.lock();
pthread_mutex_lock(&incrementer_thread_exit_mutex); ASSERT_NO_THROW(thread = std::thread(IncrementerThread, std::ref(argument)));
pthread_create_result = pthread_create(&thread_id, NULL, IncrementerThread,
&argument);
ASSERT_EQ(0, pthread_create_result);
StopTheWorld(&Callback, &argument); StopTheWorld(&Callback, &argument);
pthread_mutex_unlock(&incrementer_thread_exit_mutex); incrementer_thread_exit_mutex.unlock();
EXPECT_TRUE(argument.callback_executed); EXPECT_TRUE(argument.callback_executed);
EXPECT_TRUE(argument.threads_stopped); EXPECT_TRUE(argument.threads_stopped);
// argument is on stack, so we have to wait for the incrementer thread to // argument is on stack, so we have to wait for the incrementer thread to
// terminate before we can return from this function. // terminate before we can return from this function.
ASSERT_EQ(0, pthread_join(thread_id, NULL)); ASSERT_NO_THROW(thread.join());
pthread_mutex_destroy(&incrementer_thread_exit_mutex);
} }
// A more comprehensive test where we spawn a bunch of threads while executing // A more comprehensive test where we spawn a bunch of threads while executing
// StopTheWorld in parallel. // StopTheWorld in parallel.
static const uptr kThreadCount = 50; static const uptr kThreadCount = 50;
static const uptr kStopWorldAfter = 10; // let this many threads spawn first static const uptr kStopWorldAfter = 10; // let this many threads spawn first
static pthread_mutex_t advanced_incrementer_thread_exit_mutex; static std::mutex advanced_incrementer_thread_exit_mutex;
struct AdvancedCallbackArgument { struct AdvancedCallbackArgument {
volatile uptr thread_index; volatile uptr thread_index;
volatile int counters[kThreadCount]; volatile int counters[kThreadCount];
pthread_t thread_ids[kThreadCount]; std::thread threads[kThreadCount];
volatile bool threads_stopped; volatile bool threads_stopped;
volatile bool callback_executed; volatile bool callback_executed;
volatile bool fatal_error; volatile bool fatal_error;
AdvancedCallbackArgument() AdvancedCallbackArgument()
: thread_index(0), : thread_index(0),
threads_stopped(false), threads_stopped(false),
callback_executed(false), callback_executed(false),
fatal_error(false) {} fatal_error(false) {}
}; };
void *AdvancedIncrementerThread(void *argument) { void AdvancedIncrementerThread(AdvancedCallbackArgument &callback_argument) {
AdvancedCallbackArgument *callback_argument = uptr this_thread_index =
(AdvancedCallbackArgument *)argument; __sync_fetch_and_add(&callback_argument.thread_index, 1);
uptr this_thread_index = __sync_fetch_and_add(
&callback_argument->thread_index, 1);
// Spawn the next thread. // Spawn the next thread.
int pthread_create_result; int pthread_create_result;
if (this_thread_index + 1 < kThreadCount) { if (this_thread_index + 1 < kThreadCount) {
pthread_create_result = try {
pthread_create(&callback_argument->thread_ids[this_thread_index + 1], callback_argument.threads[this_thread_index + 1] =
NULL, AdvancedIncrementerThread, argument); std::thread(AdvancedIncrementerThread, std::ref(callback_argument));
} catch (...) {
// Cannot use ASSERT_EQ in non-void-returning functions. If there's a // Cannot use ASSERT_EQ in non-void-returning functions. If there's a
// problem, defer failing to the main thread. // problem, defer failing to the main thread.
if (pthread_create_result != 0) { callback_argument.fatal_error = true;
callback_argument->fatal_error = true; __sync_fetch_and_add(&callback_argument.thread_index,
__sync_fetch_and_add(&callback_argument->thread_index, kThreadCount - callback_argument.thread_index);
kThreadCount - callback_argument->thread_index);
} }
} }
// Do the actual work. // Do the actual work.
while (true) { while (true) {
__sync_fetch_and_add(&callback_argument->counters[this_thread_index], 1); __sync_fetch_and_add(&callback_argument.counters[this_thread_index], 1);
if (pthread_mutex_trylock(&advanced_incrementer_thread_exit_mutex) == 0) { if (advanced_incrementer_thread_exit_mutex.try_lock()) {
pthread_mutex_unlock(&advanced_incrementer_thread_exit_mutex); advanced_incrementer_thread_exit_mutex.unlock();
return NULL; return;
} else {
sched_yield();
} }
std::this_thread::yield();
} }
} }
void AdvancedCallback(const SuspendedThreadsList &suspended_threads_list, void AdvancedCallback(const SuspendedThreadsList &suspended_threads_list,
void *argument) { void *argument) {
AdvancedCallbackArgument *callback_argument = AdvancedCallbackArgument *callback_argument =
(AdvancedCallbackArgument *)argument; (AdvancedCallbackArgument *)argument;
callback_argument->callback_executed = true; callback_argument->callback_executed = true;
int counters_at_init[kThreadCount]; int counters_at_init[kThreadCount];
for (uptr j = 0; j < kThreadCount; j++) for (uptr j = 0; j < kThreadCount; j++)
counters_at_init[j] = __sync_fetch_and_add(&callback_argument->counters[j], counters_at_init[j] =
0); __sync_fetch_and_add(&callback_argument->counters[j], 0);
for (uptr i = 0; i < 10; i++) { for (uptr i = 0; i < 10; i++) {
sched_yield(); std::this_thread::yield();
for (uptr j = 0; j < kThreadCount; j++) for (uptr j = 0; j < kThreadCount; j++)
if (__sync_fetch_and_add(&callback_argument->counters[j], 0) != if (__sync_fetch_and_add(&callback_argument->counters[j], 0) !=
counters_at_init[j]) { counters_at_init[j]) {
callback_argument->threads_stopped = false; callback_argument->threads_stopped = false;
return; return;
} }
} }
callback_argument->threads_stopped = true; callback_argument->threads_stopped = true;
} }
TEST(StopTheWorld, SuspendThreadsAdvanced) { TEST(StopTheWorld, SuspendThreadsAdvanced) {
pthread_mutex_init(&advanced_incrementer_thread_exit_mutex, NULL);
AdvancedCallbackArgument argument; AdvancedCallbackArgument argument;
pthread_mutex_lock(&advanced_incrementer_thread_exit_mutex); advanced_incrementer_thread_exit_mutex.lock();
int pthread_create_result; argument.threads[0] =
pthread_create_result = pthread_create(&argument.thread_ids[0], NULL, std::thread(AdvancedIncrementerThread, std::ref(argument));
vitalybukaUnsubmitted
Done
ReplyInline Actions

why do we need NO_THROW? Isn't the test fails if it throws anyway?

And I see the following on linux:

[ RUN      ] StopTheWorld.SuspendThreadsAdvanced
llvm-project/compiler-rt/lib/sanitizer_common/tests/sanitizer_stoptheworld_test.cpp:174: Failure
Expected: argument.threads[i].join() doesn't throw an exception.
  Actual: it throws.
terminate called without an active exception
vitalybuka: why do we need NO_THROW? Isn't the test fails if it throws anyway? And I see the following on…
AdvancedIncrementerThread,
&argument);
ASSERT_EQ(0, pthread_create_result);
// Wait for several threads to spawn before proceeding. // Wait for several threads to spawn before proceeding.
while (__sync_fetch_and_add(&argument.thread_index, 0) < kStopWorldAfter) while (__sync_fetch_and_add(&argument.thread_index, 0) < kStopWorldAfter)
sched_yield(); std::this_thread::yield();
StopTheWorld(&AdvancedCallback, &argument); StopTheWorld(&AdvancedCallback, &argument);
EXPECT_TRUE(argument.callback_executed); EXPECT_TRUE(argument.callback_executed);
EXPECT_TRUE(argument.threads_stopped); EXPECT_TRUE(argument.threads_stopped);
// Wait for all threads to spawn before we start terminating them. // Wait for all threads to spawn before we start terminating them.
while (__sync_fetch_and_add(&argument.thread_index, 0) < kThreadCount) while (__sync_fetch_and_add(&argument.thread_index, 0) < kThreadCount)
sched_yield(); std::this_thread::yield();
ASSERT_FALSE(argument.fatal_error); // a pthread_create has failed ASSERT_FALSE(argument.fatal_error); // a thread could not be started
// Signal the threads to terminate. // Signal the threads to terminate.
pthread_mutex_unlock(&advanced_incrementer_thread_exit_mutex); advanced_incrementer_thread_exit_mutex.unlock();
for (uptr i = 0; i < kThreadCount; i++) for (uptr i = 0; i < kThreadCount; i++) argument.threads[i].join();
ASSERT_EQ(0, pthread_join(argument.thread_ids[i], NULL));
pthread_mutex_destroy(&advanced_incrementer_thread_exit_mutex);
} }
static void SegvCallback(const SuspendedThreadsList &suspended_threads_list, static void SegvCallback(const SuspendedThreadsList &suspended_threads_list,
void *argument) { void *argument) {
*(volatile int*)0x1234 = 0; *(volatile int *)0x1234 = 0;
} }
TEST(StopTheWorld, SegvInCallback) { TEST(StopTheWorld, SegvInCallback) {
// Test that tracer thread catches SIGSEGV. // Test that tracer thread catches SIGSEGV.
StopTheWorld(&SegvCallback, NULL); StopTheWorld(&SegvCallback, NULL);
} }
} // namespace __sanitizer } // namespace __sanitizer
#endif // SANITIZER_LINUX && defined(__x86_64__) #endif // SANITIZER_LINUX && defined(__x86_64__)