mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-05-28 08:12:28 +00:00
third_party/libcxxabi: Add test suite (#1076)
Added the `libcxxabi` test suite as found in LLVM 17.0.6. Some tests that do not apply to the current configuration of comsopolitan are not added. These include: - `backtrace_test`, `forced_unwind*`: Use unwind function unsupported in SjLj mode. - `noexception*`: Designed to test `libcxxabi` in no exceptions mode. Some tests are added but not enabled due to bugs specific to GCC or cosmopolitan. These are clearly indicated in the `BUILD.mk` file.
This commit is contained in:
Trung Nguyen
GitHub
parent
8fb24a8f88
commit
b0566348b2
65 changed files with 43262 additions and 2 deletions
386
third_party/libcxxabi/test/guard_threaded_test.pass.cc
vendored
Normal file
386
third_party/libcxxabi/test/guard_threaded_test.pass.cc
vendored
Normal file
|
|
@ -0,0 +1,386 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++03
|
||||
// UNSUPPORTED: no-threads
|
||||
// UNSUPPORTED: no-exceptions
|
||||
|
||||
#define TESTING_CXA_GUARD
|
||||
#include "third_party/libcxxabi/cxa_guard_impl.h"
|
||||
#include "third_party/libcxx/unordered_map"
|
||||
#include "third_party/libcxx/thread"
|
||||
#include "third_party/libcxx/atomic"
|
||||
#include "third_party/libcxx/array"
|
||||
#include "third_party/libcxx/cassert"
|
||||
#include "third_party/libcxx/memory"
|
||||
#include "third_party/libcxx/vector"
|
||||
|
||||
#include "third_party/libcxxabi/libcxx/test/support/make_test_thread.hh"
|
||||
#include "third_party/libcxxabi/libcxx/test/support/test_macros.hh"
|
||||
|
||||
|
||||
using namespace __cxxabiv1;
|
||||
|
||||
// Misc test configuration. It's used to tune the flakyness of the test.
|
||||
// ThreadsPerTest - The number of threads used
|
||||
constexpr int ThreadsPerTest = 10;
|
||||
// The number of instances of a test to run concurrently.
|
||||
constexpr int ConcurrentRunsPerTest = 10;
|
||||
// The number of times to rerun each test.
|
||||
constexpr int TestSamples = 50;
|
||||
|
||||
|
||||
|
||||
void BusyWait() {
|
||||
std::this_thread::yield();
|
||||
}
|
||||
|
||||
void YieldAfterBarrier() {
|
||||
std::this_thread::sleep_for(std::chrono::nanoseconds(10));
|
||||
std::this_thread::yield();
|
||||
}
|
||||
|
||||
struct Barrier {
|
||||
explicit Barrier(int n) : m_threads(n), m_remaining(n) { }
|
||||
Barrier(Barrier const&) = delete;
|
||||
Barrier& operator=(Barrier const&) = delete;
|
||||
|
||||
void arrive_and_wait() const {
|
||||
--m_remaining;
|
||||
while (m_remaining.load()) {
|
||||
BusyWait();
|
||||
}
|
||||
}
|
||||
|
||||
void arrive_and_drop() const {
|
||||
--m_remaining;
|
||||
}
|
||||
|
||||
void wait_for_threads(int n) const {
|
||||
while ((m_threads - m_remaining.load()) < n) {
|
||||
std::this_thread::yield();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
const int m_threads;
|
||||
mutable std::atomic<int> m_remaining;
|
||||
};
|
||||
|
||||
|
||||
enum class InitResult {
|
||||
COMPLETE,
|
||||
PERFORMED,
|
||||
WAITED,
|
||||
ABORTED
|
||||
};
|
||||
constexpr InitResult COMPLETE = InitResult::COMPLETE;
|
||||
constexpr InitResult PERFORMED = InitResult::PERFORMED;
|
||||
constexpr InitResult WAITED = InitResult::WAITED;
|
||||
constexpr InitResult ABORTED = InitResult::ABORTED;
|
||||
|
||||
|
||||
template <class Impl, class GuardType, class Init>
|
||||
InitResult check_guard(GuardType *g, Init init) {
|
||||
uint8_t *first_byte = reinterpret_cast<uint8_t*>(g);
|
||||
if (std::__libcpp_atomic_load(first_byte, std::_AO_Acquire) == 0) {
|
||||
Impl impl(g);
|
||||
if (impl.cxa_guard_acquire() == INIT_IS_PENDING) {
|
||||
#ifndef TEST_HAS_NO_EXCEPTIONS
|
||||
try {
|
||||
#endif
|
||||
init();
|
||||
impl.cxa_guard_release();
|
||||
return PERFORMED;
|
||||
#ifndef TEST_HAS_NO_EXCEPTIONS
|
||||
} catch (...) {
|
||||
impl.cxa_guard_abort();
|
||||
return ABORTED;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
return WAITED;
|
||||
}
|
||||
return COMPLETE;
|
||||
}
|
||||
|
||||
|
||||
template <class GuardType, class Impl>
|
||||
struct FunctionLocalStatic {
|
||||
FunctionLocalStatic() {}
|
||||
FunctionLocalStatic(FunctionLocalStatic const&) = delete;
|
||||
|
||||
template <class InitFunc>
|
||||
InitResult access(InitFunc&& init) {
|
||||
auto res = check_guard<Impl>(&guard_object, init);
|
||||
++result_counts[static_cast<int>(res)];
|
||||
return res;
|
||||
}
|
||||
|
||||
template <class InitFn>
|
||||
struct AccessCallback {
|
||||
void operator()() const { this_obj->access(init); }
|
||||
|
||||
FunctionLocalStatic *this_obj;
|
||||
InitFn init;
|
||||
};
|
||||
|
||||
template <class InitFn, class Callback = AccessCallback< InitFn > >
|
||||
Callback access_callback(InitFn init) {
|
||||
return Callback{this, init};
|
||||
}
|
||||
|
||||
int get_count(InitResult I) const {
|
||||
return result_counts[static_cast<int>(I)].load();
|
||||
}
|
||||
|
||||
int num_completed() const {
|
||||
return get_count(COMPLETE) + get_count(PERFORMED) + get_count(WAITED);
|
||||
}
|
||||
|
||||
int num_waiting() const {
|
||||
return waiting_threads.load();
|
||||
}
|
||||
|
||||
private:
|
||||
GuardType guard_object = {};
|
||||
std::atomic<int> waiting_threads{0};
|
||||
std::array<std::atomic<int>, 4> result_counts{};
|
||||
static_assert(static_cast<int>(ABORTED) == 3, "only 4 result kinds expected");
|
||||
};
|
||||
|
||||
struct ThreadGroup {
|
||||
ThreadGroup() = default;
|
||||
ThreadGroup(ThreadGroup const&) = delete;
|
||||
|
||||
template <class ...Args>
|
||||
void Create(Args&& ...args) {
|
||||
threads.emplace_back(std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
template <class Callback>
|
||||
void CreateThreadsWithBarrier(int N, Callback cb) {
|
||||
auto start = std::make_shared<Barrier>(N + 1);
|
||||
for (int I=0; I < N; ++I) {
|
||||
Create([start, cb]() {
|
||||
start->arrive_and_wait();
|
||||
cb();
|
||||
});
|
||||
}
|
||||
start->arrive_and_wait();
|
||||
}
|
||||
|
||||
void JoinAll() {
|
||||
for (auto& t : threads) {
|
||||
t.join();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
std::vector<std::thread> threads;
|
||||
};
|
||||
|
||||
|
||||
template <class GuardType, class Impl>
|
||||
void test_free_for_all(int num_waiters) {
|
||||
FunctionLocalStatic<GuardType, Impl> test_obj;
|
||||
|
||||
ThreadGroup threads;
|
||||
|
||||
bool already_init = false;
|
||||
threads.CreateThreadsWithBarrier(num_waiters,
|
||||
test_obj.access_callback([&]() {
|
||||
assert(!already_init);
|
||||
already_init = true;
|
||||
})
|
||||
);
|
||||
|
||||
// wait for the other threads to finish initialization.
|
||||
threads.JoinAll();
|
||||
|
||||
assert(test_obj.get_count(PERFORMED) == 1);
|
||||
assert(test_obj.get_count(COMPLETE) + test_obj.get_count(WAITED) == num_waiters - 1);
|
||||
}
|
||||
|
||||
template <class GuardType, class Impl>
|
||||
void test_waiting_for_init(int num_waiters) {
|
||||
FunctionLocalStatic<GuardType, Impl> test_obj;
|
||||
|
||||
ThreadGroup threads;
|
||||
|
||||
Barrier start_init(2);
|
||||
threads.Create(test_obj.access_callback(
|
||||
[&]() {
|
||||
start_init.arrive_and_wait();
|
||||
// Take our sweet time completing the initialization...
|
||||
//
|
||||
// There's a race condition between the other threads reaching the
|
||||
// start_init barrier, and them actually hitting the cxa guard.
|
||||
// But we're trying to test the waiting logic, we want as many
|
||||
// threads to enter the waiting loop as possible.
|
||||
YieldAfterBarrier();
|
||||
}
|
||||
));
|
||||
start_init.wait_for_threads(1);
|
||||
|
||||
threads.CreateThreadsWithBarrier(num_waiters,
|
||||
test_obj.access_callback([]() { assert(false); })
|
||||
);
|
||||
// unblock the initializing thread
|
||||
start_init.arrive_and_drop();
|
||||
|
||||
// wait for the other threads to finish initialization.
|
||||
threads.JoinAll();
|
||||
|
||||
assert(test_obj.get_count(PERFORMED) == 1);
|
||||
assert(test_obj.get_count(ABORTED) == 0);
|
||||
assert(test_obj.get_count(COMPLETE) + test_obj.get_count(WAITED) == num_waiters);
|
||||
}
|
||||
|
||||
|
||||
template <class GuardType, class Impl>
|
||||
void test_aborted_init(int num_waiters) {
|
||||
FunctionLocalStatic<GuardType, Impl> test_obj;
|
||||
|
||||
Barrier start_init(2);
|
||||
ThreadGroup threads;
|
||||
threads.Create(test_obj.access_callback(
|
||||
[&]() {
|
||||
start_init.arrive_and_wait();
|
||||
YieldAfterBarrier();
|
||||
throw 42;
|
||||
})
|
||||
);
|
||||
start_init.wait_for_threads(1);
|
||||
|
||||
bool already_init = false;
|
||||
threads.CreateThreadsWithBarrier(num_waiters,
|
||||
test_obj.access_callback([&]() {
|
||||
assert(!already_init);
|
||||
already_init = true;
|
||||
})
|
||||
);
|
||||
// unblock the initializing thread
|
||||
start_init.arrive_and_drop();
|
||||
|
||||
// wait for the other threads to finish initialization.
|
||||
threads.JoinAll();
|
||||
|
||||
assert(test_obj.get_count(ABORTED) == 1);
|
||||
assert(test_obj.get_count(PERFORMED) == 1);
|
||||
assert(test_obj.get_count(WAITED) + test_obj.get_count(COMPLETE) == num_waiters - 1);
|
||||
}
|
||||
|
||||
|
||||
template <class GuardType, class Impl>
|
||||
void test_completed_init(int num_waiters) {
|
||||
|
||||
FunctionLocalStatic<GuardType, Impl> test_obj;
|
||||
|
||||
test_obj.access([]() {}); // initialize the object
|
||||
assert(test_obj.num_waiting() == 0);
|
||||
assert(test_obj.num_completed() == 1);
|
||||
assert(test_obj.get_count(PERFORMED) == 1);
|
||||
|
||||
ThreadGroup threads;
|
||||
threads.CreateThreadsWithBarrier(num_waiters,
|
||||
test_obj.access_callback([]() { assert(false); })
|
||||
);
|
||||
// wait for the other threads to finish initialization.
|
||||
threads.JoinAll();
|
||||
|
||||
assert(test_obj.get_count(ABORTED) == 0);
|
||||
assert(test_obj.get_count(PERFORMED) == 1);
|
||||
assert(test_obj.get_count(WAITED) == 0);
|
||||
assert(test_obj.get_count(COMPLETE) == num_waiters);
|
||||
}
|
||||
|
||||
template <class Impl>
|
||||
void test_impl() {
|
||||
using TestFn = void(*)(int);
|
||||
TestFn TestList[] = {
|
||||
test_free_for_all<uint32_t, Impl>,
|
||||
test_free_for_all<uint32_t, Impl>,
|
||||
test_waiting_for_init<uint32_t, Impl>,
|
||||
test_waiting_for_init<uint64_t, Impl>,
|
||||
test_aborted_init<uint32_t, Impl>,
|
||||
test_aborted_init<uint64_t, Impl>,
|
||||
test_completed_init<uint32_t, Impl>,
|
||||
test_completed_init<uint64_t, Impl>
|
||||
};
|
||||
|
||||
for (auto test_func : TestList) {
|
||||
ThreadGroup test_threads;
|
||||
test_threads.CreateThreadsWithBarrier(ConcurrentRunsPerTest, [=]() {
|
||||
for (int I = 0; I < TestSamples; ++I) {
|
||||
test_func(ThreadsPerTest);
|
||||
}
|
||||
});
|
||||
test_threads.JoinAll();
|
||||
}
|
||||
}
|
||||
|
||||
void test_all_impls() {
|
||||
using MutexImpl = SelectImplementation<Implementation::GlobalMutex>::type;
|
||||
|
||||
// Attempt to test the Futex based implementation if it's supported on the
|
||||
// target platform.
|
||||
using RealFutexImpl = SelectImplementation<Implementation::Futex>::type;
|
||||
using FutexImpl = typename std::conditional<
|
||||
PlatformSupportsFutex(),
|
||||
RealFutexImpl,
|
||||
MutexImpl
|
||||
>::type;
|
||||
|
||||
test_impl<MutexImpl>();
|
||||
if (PlatformSupportsFutex())
|
||||
test_impl<FutexImpl>();
|
||||
}
|
||||
|
||||
// A dummy
|
||||
template <bool Dummy = true>
|
||||
void test_futex_syscall() {
|
||||
if (!PlatformSupportsFutex())
|
||||
return;
|
||||
int lock1 = 0;
|
||||
int lock2 = 0;
|
||||
int lock3 = 0;
|
||||
std::thread waiter1 = support::make_test_thread([&]() {
|
||||
int expect = 0;
|
||||
PlatformFutexWait(&lock1, expect);
|
||||
assert(lock1 == 1);
|
||||
});
|
||||
std::thread waiter2 = support::make_test_thread([&]() {
|
||||
int expect = 0;
|
||||
PlatformFutexWait(&lock2, expect);
|
||||
assert(lock2 == 2);
|
||||
});
|
||||
std::thread waiter3 = support::make_test_thread([&]() {
|
||||
int expect = 42; // not the value
|
||||
PlatformFutexWait(&lock3, expect); // doesn't block
|
||||
});
|
||||
std::thread waker = support::make_test_thread([&]() {
|
||||
lock1 = 1;
|
||||
PlatformFutexWake(&lock1);
|
||||
lock2 = 2;
|
||||
PlatformFutexWake(&lock2);
|
||||
});
|
||||
waiter1.join();
|
||||
waiter2.join();
|
||||
waiter3.join();
|
||||
waker.join();
|
||||
}
|
||||
|
||||
int main(int, char**) {
|
||||
// Test each multi-threaded implementation with real threads.
|
||||
test_all_impls();
|
||||
// Test the basic sanity of the futex syscall wrappers.
|
||||
test_futex_syscall();
|
||||
|
||||
return 0;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue