X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=glib%2Fgthread-posix.c;h=f4703f5e1a695d348172c847b6f9d2f9665542a2;hb=49a5d0f6f2aed99cd78f25655f137f4448e47d92;hp=4b4d334370c10dc2681986efeadb07d089f357bf;hpb=900c467fd0f5f375acabad78246ed320d1f208a1;p=platform%2Fupstream%2Fglib.git diff --git a/glib/gthread-posix.c b/glib/gthread-posix.c index 4b4d334..f4703f5 100644 --- a/glib/gthread-posix.c +++ b/glib/gthread-posix.c @@ -15,9 +15,7 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library; if not, see . */ /* @@ -47,6 +45,7 @@ #include "gslice.h" #include "gmessages.h" #include "gstrfuncs.h" +#include "gmain.h" #include #include @@ -54,28 +53,91 @@ #include #include -#ifdef HAVE_SYS_TIME_H -# include -#endif -#ifdef HAVE_UNISTD_H -# include -#endif +#include +#include + #ifdef HAVE_SCHED_H #include #endif +#ifdef HAVE_SYS_PRCTL_H +#include +#endif +#ifdef G_OS_WIN32 +#include +#endif +/* clang defines __ATOMIC_SEQ_CST but doesn't support the GCC extension */ +#if defined(HAVE_FUTEX) && defined(__ATOMIC_SEQ_CST) && !defined(__clang__) +#define USE_NATIVE_MUTEX +#endif static void g_thread_abort (gint status, const gchar *function) { fprintf (stderr, "GLib (gthread-posix.c): Unexpected error from C library during '%s': %s. Aborting.\n", - strerror (status), function); + function, strerror (status)); abort (); } /* {{{1 GMutex */ +#if !defined(USE_NATIVE_MUTEX) + +static pthread_mutex_t * +g_mutex_impl_new (void) +{ + pthread_mutexattr_t *pattr = NULL; + pthread_mutex_t *mutex; + gint status; +#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP + pthread_mutexattr_t attr; +#endif + + mutex = malloc (sizeof (pthread_mutex_t)); + if G_UNLIKELY (mutex == NULL) + g_thread_abort (errno, "malloc"); + +#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP + pthread_mutexattr_init (&attr); + pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ADAPTIVE_NP); + pattr = &attr; +#endif + + if G_UNLIKELY ((status = pthread_mutex_init (mutex, pattr)) != 0) + g_thread_abort (status, "pthread_mutex_init"); + +#ifdef PTHREAD_ADAPTIVE_MUTEX_NP + pthread_mutexattr_destroy (&attr); +#endif + + return mutex; +} + +static void +g_mutex_impl_free (pthread_mutex_t *mutex) +{ + pthread_mutex_destroy (mutex); + free (mutex); +} + +static inline pthread_mutex_t * +g_mutex_get_impl (GMutex *mutex) +{ + pthread_mutex_t *impl = g_atomic_pointer_get (&mutex->p); + + if G_UNLIKELY (impl == NULL) + { + impl = g_mutex_impl_new (); + if (!g_atomic_pointer_compare_and_exchange (&mutex->p, NULL, impl)) + g_mutex_impl_free (impl); + impl = mutex->p; + } + + return impl; +} + + /** * g_mutex_init: * @mutex: an uninitialized #GMutex @@ -85,10 +147,9 @@ g_thread_abort (gint status, * This function is useful to initialize a mutex that has been * allocated on the stack, or as part of a larger structure. * It is not necessary to initialize a mutex that has been - * created with g_mutex_new(). Also see #G_MUTEX_INIT for an - * alternative way to initialize statically allocated mutexes. + * statically allocated. * - * |[ + * |[ * typedef struct { * GMutex m; * ... @@ -111,21 +172,7 @@ g_thread_abort (gint status, void g_mutex_init (GMutex *mutex) { - gint status; - pthread_mutexattr_t *pattr = NULL; -#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP - pthread_mutexattr_t attr; - pthread_mutexattr_init (&attr); - pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ADAPTIVE_NP); - pattr = &attr; -#endif - - if G_UNLIKELY ((status = pthread_mutex_init (&mutex->impl, pattr)) != 0) - g_thread_abort (status, "pthread_mutex_init"); - -#ifdef PTHREAD_ADAPTIVE_MUTEX_NP - pthread_mutexattr_destroy (&attr); -#endif + mutex->p = g_mutex_impl_new (); } /** @@ -134,8 +181,8 @@ g_mutex_init (GMutex *mutex) * * Frees the resources allocated to a mutex with g_mutex_init(). * - * #GMutexes that have have been created with g_mutex_new() should - * be freed with g_mutex_free() instead. + * This function should not be used with a #GMutex that has been + * statically allocated. * * Calling g_mutex_clear() on a locked mutex leads to undefined * behaviour. @@ -145,10 +192,7 @@ g_mutex_init (GMutex *mutex) void g_mutex_clear (GMutex *mutex) { - gint status; - - if G_UNLIKELY ((status = pthread_mutex_destroy (&mutex->impl)) != 0) - g_thread_abort (status, "pthread_mutex_destroy"); + g_mutex_impl_free (mutex->p); } /** @@ -159,20 +203,17 @@ g_mutex_clear (GMutex *mutex) * current thread will block until @mutex is unlocked by the other * thread. * - * This function can be used even if g_thread_init() has not yet been - * called, and, in that case, will do nothing. - * - * #GMutex is neither guaranteed to be recursive nor to be - * non-recursive, i.e. a thread could deadlock while calling - * g_mutex_lock(), if it already has locked @mutex. Use - * #GRecMutex if you need recursive mutexes. + * #GMutex is neither guaranteed to be recursive nor to be + * non-recursive. As such, calling g_mutex_lock() on a #GMutex that has + * already been locked by the same thread results in undefined behaviour + * (including but not limited to deadlocks). */ void g_mutex_lock (GMutex *mutex) { gint status; - if G_UNLIKELY ((status = pthread_mutex_lock (&mutex->impl)) != 0) + if G_UNLIKELY ((status = pthread_mutex_lock (g_mutex_get_impl (mutex))) != 0) g_thread_abort (status, "pthread_mutex_lock"); } @@ -185,17 +226,14 @@ g_mutex_lock (GMutex *mutex) * * Calling g_mutex_unlock() on a mutex that is not locked by the * current thread leads to undefined behaviour. - * - * This function can be used even if g_thread_init() has not yet been - * called, and, in that case, will do nothing. */ void g_mutex_unlock (GMutex *mutex) { gint status; - if G_UNLIKELY ((status = pthread_mutex_unlock (&mutex->impl)) != 0) - g_thread_abort (status, "pthread_mutex_lock"); + if G_UNLIKELY ((status = pthread_mutex_unlock (g_mutex_get_impl (mutex))) != 0) + g_thread_abort (status, "pthread_mutex_unlock"); } /** @@ -206,13 +244,10 @@ g_mutex_unlock (GMutex *mutex) * it immediately returns %FALSE. Otherwise it locks @mutex and returns * %TRUE. * - * This function can be used even if g_thread_init() has not yet been - * called, and, in that case, will immediately return %TRUE. - * - * #GMutex is neither guaranteed to be recursive nor to be - * non-recursive, i.e. the return value of g_mutex_trylock() could be - * both %FALSE or %TRUE, if the current thread already has locked - * @mutex. Use #GRecMutex if you need recursive mutexes. + * #GMutex is neither guaranteed to be recursive nor to be + * non-recursive. As such, calling g_mutex_lock() on a #GMutex that has + * already been locked by the same thread results in undefined behaviour + * (including but not limited to deadlocks or arbitrary return values). * Returns: %TRUE if @mutex could be locked */ @@ -221,7 +256,7 @@ g_mutex_trylock (GMutex *mutex) { gint status; - if G_LIKELY ((status = pthread_mutex_trylock (&mutex->impl)) == 0) + if G_LIKELY ((status = pthread_mutex_trylock (g_mutex_get_impl (mutex))) == 0) return TRUE; if G_UNLIKELY (status != EBUSY) @@ -230,6 +265,8 @@ g_mutex_trylock (GMutex *mutex) return FALSE; } +#endif /* !defined(USE_NATIVE_MUTEX) */ + /* {{{1 GRecMutex */ static pthread_mutex_t * @@ -238,7 +275,10 @@ g_rec_mutex_impl_new (void) pthread_mutexattr_t attr; pthread_mutex_t *mutex; - mutex = g_slice_new (pthread_mutex_t); + mutex = malloc (sizeof (pthread_mutex_t)); + if G_UNLIKELY (mutex == NULL) + g_thread_abort (errno, "malloc"); + pthread_mutexattr_init (&attr); pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init (mutex, &attr); @@ -251,20 +291,20 @@ static void g_rec_mutex_impl_free (pthread_mutex_t *mutex) { pthread_mutex_destroy (mutex); - g_slice_free (pthread_mutex_t, mutex); + free (mutex); } -static pthread_mutex_t * -g_rec_mutex_get_impl (GRecMutex *mutex) +static inline pthread_mutex_t * +g_rec_mutex_get_impl (GRecMutex *rec_mutex) { - pthread_mutex_t *impl = mutex->impl; + pthread_mutex_t *impl = g_atomic_pointer_get (&rec_mutex->p); - if G_UNLIKELY (mutex->impl == NULL) + if G_UNLIKELY (impl == NULL) { impl = g_rec_mutex_impl_new (); - if (!g_atomic_pointer_compare_and_exchange (&mutex->impl, NULL, impl)) + if (!g_atomic_pointer_compare_and_exchange (&rec_mutex->p, NULL, impl)) g_rec_mutex_impl_free (impl); - impl = mutex->impl; + impl = rec_mutex->p; } return impl; @@ -279,12 +319,11 @@ g_rec_mutex_get_impl (GRecMutex *mutex) * This function is useful to initialize a recursive mutex * that has been allocated on the stack, or as part of a larger * structure. - * It is not necessary to initialize a recursive mutex that has - * been created with g_rec_mutex_new(). Also see #G_REC_MUTEX_INIT - * for an alternative way to initialize statically allocated - * recursive mutexes. * - * |[ + * It is not necessary to initialise a recursive mutex that has been + * statically allocated. + * + * |[ * typedef struct { * GRecMutex m; * ... @@ -307,7 +346,7 @@ g_rec_mutex_get_impl (GRecMutex *mutex) void g_rec_mutex_init (GRecMutex *rec_mutex) { - rec_mutex->impl = g_rec_mutex_impl_new (); + rec_mutex->p = g_rec_mutex_impl_new (); } /** @@ -317,8 +356,8 @@ g_rec_mutex_init (GRecMutex *rec_mutex) * Frees the resources allocated to a recursive mutex with * g_rec_mutex_init(). * - * #GRecMutexes that have have been created with g_rec_mutex_new() - * should be freed with g_rec_mutex_free() instead. + * This function should not be used with a #GRecMutex that has been + * statically allocated. * * Calling g_rec_mutex_clear() on a locked recursive mutex leads * to undefined behaviour. @@ -328,8 +367,7 @@ g_rec_mutex_init (GRecMutex *rec_mutex) void g_rec_mutex_clear (GRecMutex *rec_mutex) { - if (rec_mutex->impl) - g_rec_mutex_impl_free (rec_mutex->impl); + g_rec_mutex_impl_free (rec_mutex->p); } /** @@ -353,7 +391,7 @@ g_rec_mutex_lock (GRecMutex *mutex) /** * g_rec_mutex_unlock: - * @rec_mutex: a #RecGMutex + * @rec_mutex: a #GRecMutex * * Unlocks @rec_mutex. If another thread is blocked in a * g_rec_mutex_lock() call for @rec_mutex, it will become unblocked @@ -367,7 +405,7 @@ g_rec_mutex_lock (GRecMutex *mutex) void g_rec_mutex_unlock (GRecMutex *rec_mutex) { - pthread_mutex_unlock (rec_mutex->impl); + pthread_mutex_unlock (rec_mutex->p); } /** @@ -393,18 +431,57 @@ g_rec_mutex_trylock (GRecMutex *rec_mutex) /* {{{1 GRWLock */ +static pthread_rwlock_t * +g_rw_lock_impl_new (void) +{ + pthread_rwlock_t *rwlock; + gint status; + + rwlock = malloc (sizeof (pthread_rwlock_t)); + if G_UNLIKELY (rwlock == NULL) + g_thread_abort (errno, "malloc"); + + if G_UNLIKELY ((status = pthread_rwlock_init (rwlock, NULL)) != 0) + g_thread_abort (status, "pthread_rwlock_init"); + + return rwlock; +} + +static void +g_rw_lock_impl_free (pthread_rwlock_t *rwlock) +{ + pthread_rwlock_destroy (rwlock); + free (rwlock); +} + +static inline pthread_rwlock_t * +g_rw_lock_get_impl (GRWLock *lock) +{ + pthread_rwlock_t *impl = g_atomic_pointer_get (&lock->p); + + if G_UNLIKELY (impl == NULL) + { + impl = g_rw_lock_impl_new (); + if (!g_atomic_pointer_compare_and_exchange (&lock->p, NULL, impl)) + g_rw_lock_impl_free (impl); + impl = lock->p; + } + + return impl; +} + /** * g_rw_lock_init: - * @lock: an uninitialized #GRWLock + * @rw_lock: an uninitialized #GRWLock * * Initializes a #GRWLock so that it can be used. * * This function is useful to initialize a lock that has been - * allocated on the stack, or as part of a larger structure. - * Also see #G_RW_LOCK_INIT for an alternative way to initialize - * statically allocated locks. + * allocated on the stack, or as part of a larger structure. It is not + * necessary to initialise a reader-writer lock that has been statically + * allocated. * - * |[ + * |[ * typedef struct { * GRWLock l; * ... @@ -425,60 +502,63 @@ g_rec_mutex_trylock (GRecMutex *rec_mutex) * Since: 2.32 */ void -g_rw_lock_init (GRWLock *lock) +g_rw_lock_init (GRWLock *rw_lock) { - pthread_rwlock_init (&lock->impl, NULL); + rw_lock->p = g_rw_lock_impl_new (); } /** * g_rw_lock_clear: - * @lock: an initialized #GRWLock + * @rw_lock: an initialized #GRWLock * * Frees the resources allocated to a lock with g_rw_lock_init(). * + * This function should not be used with a #GRWLock that has been + * statically allocated. + * * Calling g_rw_lock_clear() when any thread holds the lock * leads to undefined behaviour. * * Sine: 2.32 */ void -g_rw_lock_clear (GRWLock *lock) +g_rw_lock_clear (GRWLock *rw_lock) { - pthread_rwlock_destroy (&lock->impl); + g_rw_lock_impl_free (rw_lock->p); } /** * g_rw_lock_writer_lock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Obtain a write lock on @lock. If any thread already holds - * a read or write lock on @lock, the current thread will block - * until all other threads have dropped their locks on @lock. + * Obtain a write lock on @rw_lock. If any thread already holds + * a read or write lock on @rw_lock, the current thread will block + * until all other threads have dropped their locks on @rw_lock. * * Since: 2.32 */ void -g_rw_lock_writer_lock (GRWLock *lock) +g_rw_lock_writer_lock (GRWLock *rw_lock) { - pthread_rwlock_wrlock (&lock->impl); + pthread_rwlock_wrlock (g_rw_lock_get_impl (rw_lock)); } /** * g_rw_lock_writer_trylock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Tries to obtain a write lock on @lock. If any other thread holds - * a read or write lock on @lock, it immediately returns %FALSE. - * Otherwise it locks @lock and returns %TRUE. + * Tries to obtain a write lock on @rw_lock. If any other thread holds + * a read or write lock on @rw_lock, it immediately returns %FALSE. + * Otherwise it locks @rw_lock and returns %TRUE. * - * Returns: %TRUE if @lock could be locked + * Returns: %TRUE if @rw_lock could be locked * * Since: 2.32 */ gboolean -g_rw_lock_writer_trylock (GRWLock *lock) +g_rw_lock_writer_trylock (GRWLock *rw_lock) { - if (pthread_rwlock_trywrlock (&lock->impl) != 0) + if (pthread_rwlock_trywrlock (g_rw_lock_get_impl (rw_lock)) != 0) return FALSE; return TRUE; @@ -486,9 +566,9 @@ g_rw_lock_writer_trylock (GRWLock *lock) /** * g_rw_lock_writer_unlock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Release a write lock on @lock. + * Release a write lock on @rw_lock. * * Calling g_rw_lock_writer_unlock() on a lock that is not held * by the current thread leads to undefined behaviour. @@ -496,17 +576,17 @@ g_rw_lock_writer_trylock (GRWLock *lock) * Since: 2.32 */ void -g_rw_lock_writer_unlock (GRWLock *lock) +g_rw_lock_writer_unlock (GRWLock *rw_lock) { - pthread_rwlock_unlock (&lock->impl); + pthread_rwlock_unlock (g_rw_lock_get_impl (rw_lock)); } /** * g_rw_lock_reader_lock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Obtain a read lock on @lock. If another thread currently holds - * the write lock on @lock or blocks waiting for it, the current + * Obtain a read lock on @rw_lock. If another thread currently holds + * the write lock on @rw_lock or blocks waiting for it, the current * thread will block. Read locks can be taken recursively. * * It is implementation-defined how many threads are allowed to @@ -515,27 +595,27 @@ g_rw_lock_writer_unlock (GRWLock *lock) * Since: 2.32 */ void -g_rw_lock_reader_lock (GRWLock *lock) +g_rw_lock_reader_lock (GRWLock *rw_lock) { - pthread_rwlock_rdlock (&lock->impl); + pthread_rwlock_rdlock (g_rw_lock_get_impl (rw_lock)); } /** * g_rw_lock_reader_trylock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Tries to obtain a read lock on @lock and returns %TRUE if + * Tries to obtain a read lock on @rw_lock and returns %TRUE if * the read lock was successfully obtained. Otherwise it * returns %FALSE. * - * Returns: %TRUE if @lock could be locked + * Returns: %TRUE if @rw_lock could be locked * * Since: 2.32 */ gboolean -g_rw_lock_reader_trylock (GRWLock *lock) +g_rw_lock_reader_trylock (GRWLock *rw_lock) { - if (pthread_rwlock_tryrdlock (&lock->impl) != 0) + if (pthread_rwlock_tryrdlock (g_rw_lock_get_impl (rw_lock)) != 0) return FALSE; return TRUE; @@ -543,9 +623,9 @@ g_rw_lock_reader_trylock (GRWLock *lock) /** * g_rw_lock_reader_unlock: - * @lock: a #GRWLock + * @rw_lock: a #GRWLock * - * Release a read lock on @lock. + * Release a read lock on @rw_lock. * * Calling g_rw_lock_reader_unlock() on a lock that is not held * by the current thread leads to undefined behaviour. @@ -553,29 +633,81 @@ g_rw_lock_reader_trylock (GRWLock *lock) * Since: 2.32 */ void -g_rw_lock_reader_unlock (GRWLock *lock) +g_rw_lock_reader_unlock (GRWLock *rw_lock) { - pthread_rwlock_unlock (&lock->impl); + pthread_rwlock_unlock (g_rw_lock_get_impl (rw_lock)); } /* {{{1 GCond */ +#if !defined(USE_NATIVE_MUTEX) + +static pthread_cond_t * +g_cond_impl_new (void) +{ + pthread_condattr_t attr; + pthread_cond_t *cond; + gint status; + + pthread_condattr_init (&attr); + +#ifdef HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP +#elif defined (HAVE_PTHREAD_CONDATTR_SETCLOCK) && defined (CLOCK_MONOTONIC) + if G_UNLIKELY ((status = pthread_condattr_setclock (&attr, CLOCK_MONOTONIC)) != 0) + g_thread_abort (status, "pthread_condattr_setclock"); +#else +#error Cannot support GCond on your platform. +#endif + + cond = malloc (sizeof (pthread_cond_t)); + if G_UNLIKELY (cond == NULL) + g_thread_abort (errno, "malloc"); + + if G_UNLIKELY ((status = pthread_cond_init (cond, &attr)) != 0) + g_thread_abort (status, "pthread_cond_init"); + + pthread_condattr_destroy (&attr); + + return cond; +} + +static void +g_cond_impl_free (pthread_cond_t *cond) +{ + pthread_cond_destroy (cond); + free (cond); +} + +static inline pthread_cond_t * +g_cond_get_impl (GCond *cond) +{ + pthread_cond_t *impl = g_atomic_pointer_get (&cond->p); + + if G_UNLIKELY (impl == NULL) + { + impl = g_cond_impl_new (); + if (!g_atomic_pointer_compare_and_exchange (&cond->p, NULL, impl)) + g_cond_impl_free (impl); + impl = cond->p; + } + + return impl; +} + /** * g_cond_init: * @cond: an uninitialized #GCond * - * Initialized a #GCond so that it can be used. + * Initialises a #GCond so that it can be used. * - * This function is useful to initialize a #GCond that has been - * allocated on the stack, or as part of a larger structure. - * It is not necessary to initialize a #GCond that has been - * created with g_cond_new(). Also see #G_COND_INIT for an - * alternative way to initialize statically allocated #GConds. + * This function is useful to initialise a #GCond that has been + * allocated as part of a larger structure. It is not necessary to + * initialise a #GCond that has been statically allocated. * * To undo the effect of g_cond_init() when a #GCond is no longer * needed, use g_cond_clear(). * - * Calling g_cond_init() on an already initialized #GCond leads + * Calling g_cond_init() on an already-initialised #GCond leads * to undefined behaviour. * * Since: 2.32 @@ -583,20 +715,17 @@ g_rw_lock_reader_unlock (GRWLock *lock) void g_cond_init (GCond *cond) { - gint status; - - if G_UNLIKELY ((status = pthread_cond_init (&cond->impl, NULL)) != 0) - g_thread_abort (status, "pthread_cond_init"); + cond->p = g_cond_impl_new (); } /** * g_cond_clear: - * @cond: an initialized #GCond + * @cond: an initialised #GCond * * Frees the resources allocated to a #GCond with g_cond_init(). * - * #GConds that have been created with g_cond_new() should - * be freed with g_cond_free() instead. + * This function should not be used with a #GCond that has been + * statically allocated. * * Calling g_cond_clear() for a #GCond on which threads are * blocking leads to undefined behaviour. @@ -606,10 +735,7 @@ g_cond_init (GCond *cond) void g_cond_clear (GCond *cond) { - gint status; - - if G_UNLIKELY ((status = pthread_cond_destroy (&cond->impl)) != 0) - g_thread_abort (status, "pthread_cond_destroy"); + g_cond_impl_free (cond->p); } /** @@ -617,19 +743,28 @@ g_cond_clear (GCond *cond) * @cond: a #GCond * @mutex: a #GMutex that is currently locked * - * Waits until this thread is woken up on @cond. The @mutex is unlocked - * before falling asleep and locked again before resuming. - * - * This function can be used even if g_thread_init() has not yet been - * called, and, in that case, will immediately return. - */ + * Atomically releases @mutex and waits until @cond is signalled. + * When this function returns, @mutex is locked again and owned by the + * calling thread. + * + * When using condition variables, it is possible that a spurious wakeup + * may occur (ie: g_cond_wait() returns even though g_cond_signal() was + * not called). It's also possible that a stolen wakeup may occur. + * This is when g_cond_signal() is called, but another thread acquires + * @mutex before this thread and modifies the state of the program in + * such a way that when g_cond_wait() is able to return, the expected + * condition is no longer met. + * + * For this reason, g_cond_wait() must always be used in a loop. See + * the documentation for #GCond for a complete example. + **/ void g_cond_wait (GCond *cond, GMutex *mutex) { gint status; - if G_UNLIKELY ((status = pthread_cond_wait (&cond->impl, &mutex->impl)) != 0) + if G_UNLIKELY ((status = pthread_cond_wait (g_cond_get_impl (cond), g_mutex_get_impl (mutex))) != 0) g_thread_abort (status, "pthread_cond_wait"); } @@ -641,16 +776,13 @@ g_cond_wait (GCond *cond, * If no threads are waiting for @cond, this function has no effect. * It is good practice to hold the same lock as the waiting thread * while calling this function, though not required. - * - * This function can be used even if g_thread_init() has not yet been - * called, and, in that case, will do nothing. */ void g_cond_signal (GCond *cond) { gint status; - if G_UNLIKELY ((status = pthread_cond_signal (&cond->impl)) != 0) + if G_UNLIKELY ((status = pthread_cond_signal (g_cond_get_impl (cond))) != 0) g_thread_abort (status, "pthread_cond_signal"); } @@ -662,58 +794,118 @@ g_cond_signal (GCond *cond) * If no threads are waiting for @cond, this function has no effect. * It is good practice to lock the same mutex as the waiting threads * while calling this function, though not required. - * - * This function can be used even if g_thread_init() has not yet been - * called, and, in that case, will do nothing. */ void g_cond_broadcast (GCond *cond) { gint status; - if G_UNLIKELY ((status = pthread_cond_broadcast (&cond->impl)) != 0) + if G_UNLIKELY ((status = pthread_cond_broadcast (g_cond_get_impl (cond))) != 0) g_thread_abort (status, "pthread_cond_broadcast"); } /** - * g_cond_timed_wait: + * g_cond_wait_until: * @cond: a #GCond * @mutex: a #GMutex that is currently locked - * @abs_time: a #GTimeVal, determining the final time + * @end_time: the monotonic time to wait until * - * Waits until this thread is woken up on @cond, but not longer than - * until the time specified by @abs_time. The @mutex is unlocked before - * falling asleep and locked again before resuming. + * Waits until either @cond is signalled or @end_time has passed. * - * If @abs_time is %NULL, g_cond_timed_wait() acts like g_cond_wait(). + * As with g_cond_wait() it is possible that a spurious or stolen wakeup + * could occur. For that reason, waiting on a condition variable should + * always be in a loop, based on an explicitly-checked predicate. * - * This function can be used even if g_thread_init() has not yet been - * called, and, in that case, will immediately return %TRUE. + * %TRUE is returned if the condition variable was signalled (or in the + * case of a spurious wakeup). %FALSE is returned if @end_time has + * passed. * - * To easily calculate @abs_time a combination of g_get_current_time() - * and g_time_val_add() can be used. + * The following code shows how to correctly perform a timed wait on a + * condition variable (extending the example presented in the + * documentation for #GCond): * - * Returns: %TRUE if @cond was signalled, or %FALSE on timeout - */ + * |[ + * gpointer + * pop_data_timed (void) + * { + * gint64 end_time; + * gpointer data; + * + * g_mutex_lock (&data_mutex); + * + * end_time = g_get_monotonic_time () + 5 * G_TIME_SPAN_SECOND; + * while (!current_data) + * if (!g_cond_wait_until (&data_cond, &data_mutex, end_time)) + * { + * // timeout has passed. + * g_mutex_unlock (&data_mutex); + * return NULL; + * } + * + * // there is data for us + * data = current_data; + * current_data = NULL; + * + * g_mutex_unlock (&data_mutex); + * + * return data; + * } + * ]| + * + * Notice that the end time is calculated once, before entering the + * loop and reused. This is the motivation behind the use of absolute + * time on this API -- if a relative time of 5 seconds were passed + * directly to the call and a spurious wakeup occurred, the program would + * have to start over waiting again (which would lead to a total wait + * time of more than 5 seconds). + * + * Returns: %TRUE on a signal, %FALSE on a timeout + * Since: 2.32 + **/ gboolean -g_cond_timed_wait (GCond *cond, - GMutex *mutex, - GTimeVal *abs_time) +g_cond_wait_until (GCond *cond, + GMutex *mutex, + gint64 end_time) { - struct timespec end_time; + struct timespec ts; gint status; - if (abs_time == NULL) - { - g_cond_wait (cond, mutex); - return TRUE; - } +#ifdef HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP + /* end_time is given relative to the monotonic clock as returned by + * g_get_monotonic_time(). + * + * Since this pthreads wants the relative time, convert it back again. + */ + { + gint64 now = g_get_monotonic_time (); + gint64 relative; - end_time.tv_sec = abs_time->tv_sec; - end_time.tv_nsec = abs_time->tv_usec * 1000; + if (end_time <= now) + return FALSE; - if ((status = pthread_cond_timedwait (&cond->impl, &mutex->impl, &end_time)) == 0) - return TRUE; + relative = end_time - now; + + ts.tv_sec = relative / 1000000; + ts.tv_nsec = (relative % 1000000) * 1000; + + if ((status = pthread_cond_timedwait_relative_np (g_cond_get_impl (cond), g_mutex_get_impl (mutex), &ts)) == 0) + return TRUE; + } +#elif defined (HAVE_PTHREAD_CONDATTR_SETCLOCK) && defined (CLOCK_MONOTONIC) + /* This is the exact check we used during init to set the clock to + * monotonic, so if we're in this branch, timedwait() will already be + * expecting a monotonic clock. + */ + { + ts.tv_sec = end_time / 1000000; + ts.tv_nsec = (end_time % 1000000) * 1000; + + if ((status = pthread_cond_timedwait (g_cond_get_impl (cond), g_mutex_get_impl (mutex), &ts)) == 0) + return TRUE; + } +#else +#error Cannot support GCond on your platform. +#endif if G_UNLIKELY (status != ETIMEDOUT) g_thread_abort (status, "pthread_cond_timedwait"); @@ -721,89 +913,160 @@ g_cond_timed_wait (GCond *cond, return FALSE; } +#endif /* defined(USE_NATIVE_MUTEX) */ + +/* {{{1 GPrivate */ + /** - * g_cond_timedwait: - * @cond: a #GCond - * @mutex: a #GMutex that is currently locked - * @abs_time: the final time, in microseconds + * GPrivate: * - * A variant of g_cond_timed_wait() that takes @abs_time - * as a #gint64 instead of a #GTimeVal. - * See g_cond_timed_wait() for details. + * The #GPrivate struct is an opaque data structure to represent a + * thread-local data key. It is approximately equivalent to the + * pthread_setspecific()/pthread_getspecific() APIs on POSIX and to + * TlsSetValue()/TlsGetValue() on Windows. * - * Returns: %TRUE if @cond was signalled, or %FALSE on timeout + * If you don't already know why you might want this functionality, + * then you probably don't need it. * - * Since: 2.32 + * #GPrivate is a very limited resource (as far as 128 per program, + * shared between all libraries). It is also not possible to destroy a + * #GPrivate after it has been used. As such, it is only ever acceptable + * to use #GPrivate in static scope, and even then sparingly so. + * + * See G_PRIVATE_INIT() for a couple of examples. + * + * The #GPrivate structure should be considered opaque. It should only + * be accessed via the g_private_ functions. */ -gboolean -g_cond_timedwait (GCond *cond, - GMutex *mutex, - gint64 abs_time) + +/** + * G_PRIVATE_INIT: + * @notify: a #GDestroyNotify + * + * A macro to assist with the static initialisation of a #GPrivate. + * + * This macro is useful for the case that a #GDestroyNotify function + * should be associated the key. This is needed when the key will be + * used to point at memory that should be deallocated when the thread + * exits. + * + * Additionally, the #GDestroyNotify will also be called on the previous + * value stored in the key when g_private_replace() is used. + * + * If no #GDestroyNotify is needed, then use of this macro is not + * required -- if the #GPrivate is declared in static scope then it will + * be properly initialised by default (ie: to all zeros). See the + * examples below. + * + * |[ + * static GPrivate name_key = G_PRIVATE_INIT (g_free); + * + * // return value should not be freed + * const gchar * + * get_local_name (void) + * { + * return g_private_get (&name_key); + * } + * + * void + * set_local_name (const gchar *name) + * { + * g_private_replace (&name_key, g_strdup (name)); + * } + * + * + * static GPrivate count_key; // no free function + * + * gint + * get_local_count (void) + * { + * return GPOINTER_TO_INT (g_private_get (&count_key)); + * } + * + * void + * set_local_count (gint count) + * { + * g_private_set (&count_key, GINT_TO_POINTER (count)); + * } + * ]| + * + * Since: 2.32 + **/ + +static pthread_key_t * +g_private_impl_new (GDestroyNotify notify) { - struct timespec end_time; + pthread_key_t *key; gint status; - end_time.tv_sec = abs_time / 1000000; - end_time.tv_nsec = (abs_time % 1000000) * 1000; + key = malloc (sizeof (pthread_key_t)); + if G_UNLIKELY (key == NULL) + g_thread_abort (errno, "malloc"); + status = pthread_key_create (key, notify); + if G_UNLIKELY (status != 0) + g_thread_abort (status, "pthread_key_create"); - if ((status = pthread_cond_timedwait (&cond->impl, &mutex->impl, &end_time)) == 0) - return TRUE; + return key; +} - if G_UNLIKELY (status != ETIMEDOUT) - g_thread_abort (status, "pthread_cond_timedwait"); +static void +g_private_impl_free (pthread_key_t *key) +{ + gint status; - return FALSE; + status = pthread_key_delete (*key); + if G_UNLIKELY (status != 0) + g_thread_abort (status, "pthread_key_delete"); + free (key); } -/* {{{1 GPrivate */ - -void -g_private_init (GPrivate *key, - GDestroyNotify notify) +static inline pthread_key_t * +g_private_get_impl (GPrivate *key) { - pthread_key_create (&key->key, notify); - key->ready = TRUE; + pthread_key_t *impl = g_atomic_pointer_get (&key->p); + + if G_UNLIKELY (impl == NULL) + { + impl = g_private_impl_new (key->notify); + if (!g_atomic_pointer_compare_and_exchange (&key->p, NULL, impl)) + { + g_private_impl_free (impl); + impl = key->p; + } + } + + return impl; } /** * g_private_get: - * @private_key: a #GPrivate + * @key: a #GPrivate * - * Returns the pointer keyed to @private_key for the current thread. If - * g_private_set() hasn't been called for the current @private_key and - * thread yet, this pointer will be %NULL. + * Returns the current value of the thread local variable @key. * - * This function can be used even if g_thread_init() has not yet been - * called, and, in that case, will return the value of @private_key - * casted to #gpointer. Note however, that private data set - * before g_thread_init() will - * not be retained after the - * call. Instead, %NULL will be returned in all threads directly after - * g_thread_init(), regardless of any g_private_set() calls issued - * before threading system initialization. + * If the value has not yet been set in this thread, %NULL is returned. + * Values are never copied between threads (when a new thread is + * created, for example). * - * Returns: the corresponding pointer + * Returns: the thread-local value */ gpointer g_private_get (GPrivate *key) { - if (!key->ready) - return key->single_value; - /* quote POSIX: No errors are returned from pthread_getspecific(). */ - return pthread_getspecific (key->key); + return pthread_getspecific (*g_private_get_impl (key)); } /** * g_private_set: - * @private_key: a #GPrivate - * @data: the new pointer + * @key: a #GPrivate + * @value: the new value * - * Sets the pointer keyed to @private_key for the current thread. + * Sets the thread local variable @key to have the value @value in the + * current thread. * - * This function can be used even if g_thread_init() has not yet been - * called, and, in that case, will set @private_key to @data casted to - * #GPrivate*. See g_private_get() for resulting caveats. + * This function differs from g_private_replace() in the following way: + * the #GDestroyNotify for @key is not called on the old value. */ void g_private_set (GPrivate *key, @@ -811,13 +1074,37 @@ g_private_set (GPrivate *key, { gint status; - if (!key->ready) - { - key->single_value = value; - return; - } + if G_UNLIKELY ((status = pthread_setspecific (*g_private_get_impl (key), value)) != 0) + g_thread_abort (status, "pthread_setspecific"); +} - if G_UNLIKELY ((status = pthread_setspecific (key->key, value)) != 0) +/** + * g_private_replace: + * @key: a #GPrivate + * @value: the new value + * + * Sets the thread local variable @key to have the value @value in the + * current thread. + * + * This function differs from g_private_set() in the following way: if + * the previous value was non-%NULL then the #GDestroyNotify handler for + * @key is run on it. + * + * Since: 2.32 + **/ +void +g_private_replace (GPrivate *key, + gpointer value) +{ + pthread_key_t *impl = g_private_get_impl (key); + gpointer old; + gint status; + + old = pthread_getspecific (*impl); + if (old && key->notify) + key->notify (old); + + if G_UNLIKELY ((status = pthread_setspecific (*impl, value)) != 0) g_thread_abort (status, "pthread_setspecific"); } @@ -833,18 +1120,38 @@ g_private_set (GPrivate *key, #define posix_check_cmd(cmd) posix_check_err (cmd, #cmd) +typedef struct +{ + GRealThread thread; + + pthread_t system_thread; + gboolean joined; + GMutex lock; +} GThreadPosix; + void -g_system_thread_create (GThreadFunc thread_func, - gpointer arg, - gulong stack_size, - gboolean joinable, - gpointer thread, - GError **error) +g_system_thread_free (GRealThread *thread) { + GThreadPosix *pt = (GThreadPosix *) thread; + + if (!pt->joined) + pthread_detach (pt->system_thread); + + g_mutex_clear (&pt->lock); + + g_slice_free (GThreadPosix, pt); +} + +GRealThread * +g_system_thread_new (GThreadFunc thread_func, + gulong stack_size, + GError **error) +{ + GThreadPosix *thread; pthread_attr_t attr; gint ret; - g_return_if_fail (thread_func); + thread = g_slice_new0 (GThreadPosix); posix_check_cmd (pthread_attr_init (&attr)); @@ -860,31 +1167,32 @@ g_system_thread_create (GThreadFunc thread_func, } #endif /* HAVE_PTHREAD_ATTR_SETSTACKSIZE */ - posix_check_cmd (pthread_attr_setdetachstate (&attr, - joinable ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED)); - - ret = pthread_create (thread, &attr, (void* (*)(void*))thread_func, arg); + ret = pthread_create (&thread->system_thread, &attr, (void* (*)(void*))thread_func, thread); posix_check_cmd (pthread_attr_destroy (&attr)); if (ret == EAGAIN) { g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN, - "Error creating thread: %s", g_strerror (ret)); - return; + "Error creating thread: %s", g_strerror (ret)); + g_slice_free (GThreadPosix, thread); + return NULL; } posix_check_err (ret, "pthread_create"); + + g_mutex_init (&thread->lock); + + return (GRealThread *) thread; } /** * g_thread_yield: * - * Gives way to other threads waiting to be scheduled. + * Causes the calling thread to voluntarily relinquish the CPU, so + * that other threads can run. * * This function is often used as a method to make busy wait less evil. - * But in most cases you will encounter, there are better methods to do - * that. So in general you shouldn't use this function. */ void g_thread_yield (void) @@ -893,10 +1201,19 @@ g_thread_yield (void) } void -g_system_thread_join (gpointer thread) +g_system_thread_wait (GRealThread *thread) { - gpointer ignore; - posix_check_cmd (pthread_join (*(pthread_t*)thread, &ignore)); + GThreadPosix *pt = (GThreadPosix *) thread; + + g_mutex_lock (&pt->lock); + + if (!pt->joined) + { + posix_check_cmd (pthread_join (pt->system_thread, NULL)); + pt->joined = TRUE; + } + + g_mutex_unlock (&pt->lock); } void @@ -906,17 +1223,224 @@ g_system_thread_exit (void) } void -g_system_thread_self (gpointer thread) +g_system_thread_set_name (const gchar *name) +{ +#ifdef HAVE_SYS_PRCTL_H +#ifdef PR_SET_NAME + prctl (PR_SET_NAME, name, 0, 0, 0, 0); +#endif +#endif +} + +/* {{{1 GMutex and GCond futex implementation */ + +#if defined(USE_NATIVE_MUTEX) + +#include +#include + +/* We should expand the set of operations available in gatomic once we + * have better C11 support in GCC in common distributions (ie: 4.9). + * + * Before then, let's define a couple of useful things for our own + * purposes... + */ + +#define exchange_acquire(ptr, new) \ + __atomic_exchange_4((ptr), (new), __ATOMIC_ACQUIRE) +#define compare_exchange_acquire(ptr, old, new) \ + __atomic_compare_exchange_4((ptr), (old), (new), 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED) + +#define exchange_release(ptr, new) \ + __atomic_exchange_4((ptr), (new), __ATOMIC_RELEASE) +#define store_release(ptr, new) \ + __atomic_store_4((ptr), (new), __ATOMIC_RELEASE) + +/* Our strategy for the mutex is pretty simple: + * + * 0: not in use + * + * 1: acquired by one thread only, no contention + * + * > 1: contended + * + * + * As such, attempting to acquire the lock should involve an increment. + * If we find that the previous value was 0 then we can return + * immediately. + * + * On unlock, we always store 0 to indicate that the lock is available. + * If the value there was 1 before then we didn't have contention and + * can return immediately. If the value was something other than 1 then + * we have the contended case and need to wake a waiter. + * + * If it was not 0 then there is another thread holding it and we must + * wait. We must always ensure that we mark a value >1 while we are + * waiting in order to instruct the holder to do a wake operation on + * unlock. + */ + +void +g_mutex_init (GMutex *mutex) +{ + mutex->i[0] = 0; +} + +void +g_mutex_clear (GMutex *mutex) +{ + if G_UNLIKELY (mutex->i[0] != 0) + { + fprintf (stderr, "g_mutex_clear() called on uninitialised or locked mutex\n"); + abort (); + } +} + +static void __attribute__((noinline)) +g_mutex_lock_slowpath (GMutex *mutex) +{ + /* Set to 2 to indicate contention. If it was zero before then we + * just acquired the lock. + * + * Otherwise, sleep for as long as the 2 remains... + */ + while (exchange_acquire (&mutex->i[0], 2) != 0) + syscall (__NR_futex, &mutex->i[0], (gsize) FUTEX_WAIT, (gsize) 2, NULL); +} + +static void __attribute__((noinline)) +g_mutex_unlock_slowpath (GMutex *mutex, + guint prev) +{ + /* We seem to get better code for the uncontended case by splitting + * this out... + */ + if G_UNLIKELY (prev == 0) + { + fprintf (stderr, "Attempt to unlock mutex that was not locked\n"); + abort (); + } + + syscall (__NR_futex, &mutex->i[0], (gsize) FUTEX_WAKE, (gsize) 1, NULL); +} + +void +g_mutex_lock (GMutex *mutex) +{ + /* 0 -> 1 and we're done. Anything else, and we need to wait... */ + if G_UNLIKELY (g_atomic_int_add (&mutex->i[0], 1) != 0) + g_mutex_lock_slowpath (mutex); +} + +void +g_mutex_unlock (GMutex *mutex) +{ + guint prev; + + prev = exchange_release (&mutex->i[0], 0); + + /* 1-> 0 and we're done. Anything else and we need to signal... */ + if G_UNLIKELY (prev != 1) + g_mutex_unlock_slowpath (mutex, prev); +} + +gboolean +g_mutex_trylock (GMutex *mutex) +{ + guint zero = 0; + + /* We don't want to touch the value at all unless we can move it from + * exactly 0 to 1. + */ + return compare_exchange_acquire (&mutex->i[0], &zero, 1); +} + +/* Condition variables are implemented in a rather simple way as well. + * In many ways, futex() as an abstraction is even more ideally suited + * to condition variables than it is to mutexes. + * + * We store a generation counter. We sample it with the lock held and + * unlock before sleeping on the futex. + * + * Signalling simply involves increasing the counter and making the + * appropriate futex call. + * + * The only thing that is the slightest bit complicated is timed waits + * because we must convert our absolute time to relative. + */ + +void +g_cond_init (GCond *cond) +{ + cond->i[0] = 0; +} + +void +g_cond_clear (GCond *cond) +{ +} + +void +g_cond_wait (GCond *cond, + GMutex *mutex) { - *(pthread_t*)thread = pthread_self(); + guint sampled = g_atomic_int_get (&cond->i[0]); + + g_mutex_unlock (mutex); + syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAIT, (gsize) sampled, NULL); + g_mutex_lock (mutex); +} + +void +g_cond_signal (GCond *cond) +{ + g_atomic_int_inc (&cond->i[0]); + + syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAKE, (gsize) 1, NULL); +} + +void +g_cond_broadcast (GCond *cond) +{ + g_atomic_int_inc (&cond->i[0]); + + syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAKE, (gsize) INT_MAX, NULL); } gboolean -g_system_thread_equal (gpointer thread1, - gpointer thread2) +g_cond_wait_until (GCond *cond, + GMutex *mutex, + gint64 end_time) { - return (pthread_equal (*(pthread_t*)thread1, *(pthread_t*)thread2) != 0); + struct timespec now; + struct timespec span; + guint sampled; + int res; + + if (end_time < 0) + return FALSE; + + clock_gettime (CLOCK_MONOTONIC, &now); + span.tv_sec = (end_time / 1000000) - now.tv_sec; + span.tv_nsec = ((end_time % 1000000) * 1000) - now.tv_nsec; + if (span.tv_nsec < 0) + { + span.tv_nsec += 1000000000; + span.tv_sec--; + } + + if (span.tv_sec < 0) + return FALSE; + + sampled = cond->i[0]; + g_mutex_unlock (mutex); + res = syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAIT, (gsize) sampled, &span); + g_mutex_lock (mutex); + + return (res < 0 && errno == ETIMEDOUT) ? FALSE : TRUE; } -/* {{{1 Epilogue */ +#endif + + /* {{{1 Epilogue */ /* vim:set foldmethod=marker: */