diff options
Diffstat (limited to 'libstdc++-v3/libsupc++/guard.cc')
| -rw-r--r-- | libstdc++-v3/libsupc++/guard.cc | 303 |
1 files changed, 259 insertions, 44 deletions
diff --git a/libstdc++-v3/libsupc++/guard.cc b/libstdc++-v3/libsupc++/guard.cc index eb6421689b3..e4665773ca2 100644 --- a/libstdc++-v3/libsupc++/guard.cc +++ b/libstdc++-v3/libsupc++/guard.cc @@ -35,12 +35,21 @@ #include <new> #include <ext/atomicity.h> #include <ext/concurrence.h> +#if defined(__GTHREADS) && defined(__GTHREAD_HAS_COND) \ + && defined(_GLIBCXX_ATOMIC_BUILTINS) && defined(_GLIBCXX_HAVE_LINUX_FUTEX) +# include <climits> +# include <syscall.h> +# define _GLIBCXX_USE_FUTEX +# define _GLIBCXX_FUTEX_WAIT 0 +# define _GLIBCXX_FUTEX_WAKE 1 +#endif // The IA64/generic ABI uses the first byte of the guard variable. // The ARM EABI uses the least significant bit. // Thread-safe static local initialization support. #ifdef __GTHREADS +# ifndef _GLIBCXX_USE_FUTEX namespace { // A single mutex controlling all static initializations. @@ -60,9 +69,48 @@ namespace __gthread_once(&once, init); return *static_mutex; } + + // Simple wrapper for exception safety. + struct mutex_wrapper + { + bool unlock; + mutex_wrapper() : unlock(true) + { get_static_mutex().lock(); } + + ~mutex_wrapper() + { + if (unlock) + static_mutex->unlock(); + } + }; } +# endif + +# if defined(__GTHREAD_HAS_COND) && !defined(_GLIBCXX_USE_FUTEX) +namespace +{ + // A single conditional variable controlling all static initializations. + static __gnu_cxx::__cond* static_cond; + + // using a fake type to avoid initializing a static class. + typedef char fake_cond_t[sizeof(__gnu_cxx::__cond)] + __attribute__ ((aligned(__alignof__(__gnu_cxx::__cond)))); + fake_cond_t fake_cond; + + static void init_static_cond() + { static_cond = new (&fake_cond) __gnu_cxx::__cond(); } -#ifndef _GLIBCXX_GUARD_TEST_AND_ACQUIRE + __gnu_cxx::__cond& + get_static_cond() + { + static __gthread_once_t once = __GTHREAD_ONCE_INIT; + __gthread_once(&once, init_static_cond); + return *static_cond; + } +} +# endif + +# ifndef _GLIBCXX_GUARD_TEST_AND_ACQUIRE inline bool __test_and_acquire (__cxxabiv1::__guard *g) { @@ -70,24 +118,24 @@ __test_and_acquire (__cxxabiv1::__guard *g) _GLIBCXX_READ_MEM_BARRIER; return b; } -#define _GLIBCXX_GUARD_TEST_AND_ACQUIRE(G) __test_and_acquire (G) -#endif +# define _GLIBCXX_GUARD_TEST_AND_ACQUIRE(G) __test_and_acquire (G) +# endif -#ifndef _GLIBCXX_GUARD_SET_AND_RELEASE +# ifndef _GLIBCXX_GUARD_SET_AND_RELEASE inline void __set_and_release (__cxxabiv1::__guard *g) { _GLIBCXX_WRITE_MEM_BARRIER; _GLIBCXX_GUARD_SET (g); } -#define _GLIBCXX_GUARD_SET_AND_RELEASE(G) __set_and_release (G) -#endif +# define _GLIBCXX_GUARD_SET_AND_RELEASE(G) __set_and_release (G) +# endif #else /* !__GTHREADS */ -#undef _GLIBCXX_GUARD_TEST_AND_ACQUIRE -#undef _GLIBCXX_GUARD_SET_AND_RELEASE -#define _GLIBCXX_GUARD_SET_AND_RELEASE(G) _GLIBCXX_GUARD_SET (G) +# undef _GLIBCXX_GUARD_TEST_AND_ACQUIRE +# undef _GLIBCXX_GUARD_SET_AND_RELEASE +# define _GLIBCXX_GUARD_SET_AND_RELEASE(G) _GLIBCXX_GUARD_SET (G) #endif /* __GTHREADS */ @@ -110,31 +158,95 @@ namespace __gnu_cxx recursive_init_error::~recursive_init_error() throw() { } } +// +// Here are C++ run-time routines for guarded initiailization of static +// variables. There are 4 scenarios under which these routines are called: +// +// 1. Threads not supported (__GTHREADS not defined) +// 2. Threads are supported but not enabled at run-time. +// 3. Threads enabled at run-time but __gthreads_* are not fully POSIX. +// 4. Threads enabled at run-time and __gthreads_* support all POSIX threads +// primitives we need here. +// +// The old code supported scenarios 1-3 but was broken since it used a global +// mutex for all threads and had the mutex locked during the whole duration of +// initlization of a guarded static variable. The following created a dead-lock +// with the old code. +// +// Thread 1 acquires the global mutex. +// Thread 1 starts initializing static variable. +// Thread 1 creates thread 2 during initialization. +// Thread 2 attempts to acuqire mutex to initialize another variable. +// Thread 2 blocks since thread 1 is locking the mutex. +// Thread 1 waits for result from thread 2 and also blocks. A deadlock. +// +// The new code here can handle this situation and thus is more robust. Howere, +// we need to use the POSIX thread conditional variable, which is not supported +// in all platforms, notably older versions of Microsoft Windows. The gthr*.h +// headers define a symbol __GTHREAD_HAS_COND for platforms that support POSIX +// like conditional variables. For platforms that do not support conditional +// variables, we need to fall back to the old code. + +// If _GLIBCXX_USE_FUTEX, no global mutex or conditional variable is used, +// only atomic operations are used together with futex syscall. +// Valid values of the first integer in guard are: +// 0 No thread encountered the guarded init +// yet or it has been aborted. +// _GLIBCXX_GUARD_BIT The guarded static var has been successfully +// initialized. +// _GLIBCXX_GUARD_PENDING_BIT The guarded static var is being initialized +// and no other thread is waiting for its +// initialization. +// (_GLIBCXX_GUARD_PENDING_BIT The guarded static var is being initialized +// | _GLIBCXX_GUARD_WAITING_BIT) and some other threads are waiting until +// it is initialized. + namespace __cxxabiv1 { +#ifdef _GLIBCXX_USE_FUTEX + namespace + { + static inline int __guard_test_bit (const int __byte, const int __val) + { + union { int __i; char __c[sizeof (int)]; } __u = { 0 }; + __u.__c[__byte] = __val; + return __u.__i; + } + } +#endif + static inline int - recursion_push (__guard* g) - { return ((char *)g)[1]++; } + init_in_progress_flag(__guard* g) + { return ((char *)g)[1]; } static inline void - recursion_pop (__guard* g) - { --((char *)g)[1]; } + set_init_in_progress_flag(__guard* g, int v) + { ((char *)g)[1] = v; } - static int - acquire (__guard *g) + static inline void + throw_recursive_init_exception() { - if (_GLIBCXX_GUARD_TEST (g)) - return 0; - - if (recursion_push (g)) - { #ifdef __EXCEPTIONS throw __gnu_cxx::recursive_init_error(); #else // Use __builtin_trap so we don't require abort(). - __builtin_trap (); + __builtin_trap(); #endif - } + } + + // acuire() is a helper function used to acquire guard if thread support is + // not compiled in or is compiled in but not enabled at run-time. + static int + acquire(__guard *g) + { + // Quit if the object is already initialized. + if (_GLIBCXX_GUARD_TEST(g)) + return 0; + + if (init_in_progress_flag(g)) + throw_recursive_init_exception(); + + set_init_in_progress_flag(g, 1); return 1; } @@ -148,31 +260,75 @@ namespace __cxxabiv1 if (_GLIBCXX_GUARD_TEST_AND_ACQUIRE (g)) return 0; +# ifdef _GLIBCXX_USE_FUTEX + // If __sync_* and futex syscall are supported, don't use any global + // mutex. if (__gthread_active_p ()) { - // Simple wrapper for exception safety. - struct mutex_wrapper - { - bool unlock; - mutex_wrapper() : unlock(true) - { get_static_mutex().lock(); } - - ~mutex_wrapper() + int *gi = (int *) (void *) g; + const int guard_bit = _GLIBCXX_GUARD_BIT; + const int pending_bit = _GLIBCXX_GUARD_PENDING_BIT; + const int waiting_bit = _GLIBCXX_GUARD_WAITING_BIT; + + while (1) { - if (unlock) - static_mutex->unlock(); - } - }; + int old = __sync_val_compare_and_swap (gi, 0, pending_bit); + if (old == 0) + return 1; // This thread should do the initialization. + if (old == guard_bit) + return 0; // Already initialized. + + if (old == pending_bit) + { + int newv = old | waiting_bit; + if (__sync_val_compare_and_swap (gi, old, newv) != old) + continue; + + old = newv; + } + + syscall (SYS_futex, gi, _GLIBCXX_FUTEX_WAIT, old, 0); + } + } +# else + if (__gthread_active_p ()) + { mutex_wrapper mw; - if (acquire (g)) + + while (1) // When this loop is executing, mutex is locked. { - mw.unlock = false; - return 1; - } +# ifdef __GTHREAD_HAS_COND + // The static is already initialized. + if (_GLIBCXX_GUARD_TEST(g)) + return 0; // The mutex will be unlocked via wrapper - return 0; + if (init_in_progress_flag(g)) + { + // The guarded static is currently being initialized by + // another thread, so we release mutex and wait for the + // conditional variable. We will lock the mutex again after + // this. + get_static_cond().wait_recursive(&get_static_mutex()); + } + else + { + set_init_in_progress_flag(g, 1); + return 1; // The mutex will be unlocked via wrapper. + } +# else + // This provides compatibility with older systems not supporting + // POSIX like conditional variables. + if (acquire(g)) + { + mw.unlock = false; + return 1; // The mutex still locked. + } + return 0; // The mutex will be unlocked via wrapper. +# endif + } } +# endif #endif return acquire (g); @@ -181,8 +337,37 @@ namespace __cxxabiv1 extern "C" void __cxa_guard_abort (__guard *g) { - recursion_pop (g); -#ifdef __GTHREADS +#ifdef _GLIBCXX_USE_FUTEX + // If __sync_* and futex syscall are supported, don't use any global + // mutex. + if (__gthread_active_p ()) + { + int *gi = (int *) (void *) g; + const int waiting_bit = _GLIBCXX_GUARD_WAITING_BIT; + int old = __sync_lock_test_and_set (gi, 0); + + if ((old & waiting_bit) != 0) + syscall (SYS_futex, gi, _GLIBCXX_FUTEX_WAKE, INT_MAX); + return; + } +#elif defined(__GTHREAD_HAS_COND) + if (__gthread_active_p()) + { + mutex_wrapper mw; + + set_init_in_progress_flag(g, 0); + + // If we abort, we still need to wake up all other threads waiting for + // the conditional variable. + get_static_cond().broadcast(); + return; + } +#endif + + set_init_in_progress_flag(g, 0); +#if defined(__GTHREADS) && !defined(__GTHREAD_HAS_COND) + // This provides compatibility with older systems not supporting POSIX like + // conditional variables. if (__gthread_active_p ()) static_mutex->unlock(); #endif @@ -191,10 +376,40 @@ namespace __cxxabiv1 extern "C" void __cxa_guard_release (__guard *g) { - recursion_pop (g); - _GLIBCXX_GUARD_SET_AND_RELEASE (g); -#ifdef __GTHREADS +#ifdef _GLIBCXX_USE_FUTEX + // If __sync_* and futex syscall are supported, don't use any global + // mutex. if (__gthread_active_p ()) + { + int *gi = (int *) (void *) g; + const int guard_bit = _GLIBCXX_GUARD_BIT; + const int waiting_bit = _GLIBCXX_GUARD_WAITING_BIT; + int old = __sync_lock_test_and_set (gi, guard_bit); + + if ((old & waiting_bit) != 0) + syscall (SYS_futex, gi, _GLIBCXX_FUTEX_WAKE, INT_MAX); + return; + } +#elif defined(__GTHREAD_HAS_COND) + if (__gthread_active_p()) + { + mutex_wrapper mw; + + set_init_in_progress_flag(g, 0); + _GLIBCXX_GUARD_SET_AND_RELEASE(g); + + get_static_cond().broadcast(); + return; + } +#endif + + set_init_in_progress_flag(g, 0); + _GLIBCXX_GUARD_SET_AND_RELEASE (g); + +#if defined(__GTHREADS) && !defined(__GTHREAD_HAS_COND) + // This provides compatibility with older systems not supporting POSIX like + // conditional variables. + if (__gthread_active_p()) static_mutex->unlock(); #endif } |