X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=glib%2Fgthread-posix.c;h=f4703f5e1a695d348172c847b6f9d2f9665542a2;hb=d0083f7e2dd621c6b78496bdb6ecf5d580c5e110;hp=7e86e3890aa33fbbc4e1ec8860e4f50b7aa2f150;hpb=4bb968e3358db98a4ad41ce7e72cf62f4458053d;p=platform%2Fupstream%2Fglib.git diff --git a/glib/gthread-posix.c b/glib/gthread-posix.c index 7e86e38..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,43 +53,52 @@ #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_t attr; pthread_mutexattr_init (&attr); pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ADAPTIVE_NP); pattr = &attr; @@ -113,10 +121,10 @@ g_mutex_impl_free (pthread_mutex_t *mutex) free (mutex); } -static pthread_mutex_t * +static inline pthread_mutex_t * g_mutex_get_impl (GMutex *mutex) { - pthread_mutex_t *impl = mutex->p; + pthread_mutex_t *impl = g_atomic_pointer_get (&mutex->p); if G_UNLIKELY (impl == NULL) { @@ -139,9 +147,9 @@ g_mutex_get_impl (GMutex *mutex) * 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 that has been statically allocated. + * statically allocated. * - * |[ + * |[ * typedef struct { * GMutex m; * ... @@ -195,13 +203,10 @@ 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 + * #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). + * (including but not limited to deadlocks). */ void g_mutex_lock (GMutex *mutex) @@ -221,9 +226,6 @@ 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) @@ -231,7 +233,7 @@ g_mutex_unlock (GMutex *mutex) gint status; if G_UNLIKELY ((status = pthread_mutex_unlock (g_mutex_get_impl (mutex))) != 0) - g_thread_abort (status, "pthread_mutex_lock"); + g_thread_abort (status, "pthread_mutex_unlock"); } /** @@ -242,14 +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 + * #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 */ @@ -267,6 +265,8 @@ g_mutex_trylock (GMutex *mutex) return FALSE; } +#endif /* !defined(USE_NATIVE_MUTEX) */ + /* {{{1 GRecMutex */ static pthread_mutex_t * @@ -275,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); @@ -288,13 +291,13 @@ 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 * +static inline pthread_mutex_t * g_rec_mutex_get_impl (GRecMutex *rec_mutex) { - pthread_mutex_t *impl = rec_mutex->p; + pthread_mutex_t *impl = g_atomic_pointer_get (&rec_mutex->p); if G_UNLIKELY (impl == NULL) { @@ -320,7 +323,7 @@ g_rec_mutex_get_impl (GRecMutex *rec_mutex) * It is not necessary to initialise a recursive mutex that has been * statically allocated. * - * |[ + * |[ * typedef struct { * GRecMutex m; * ... @@ -388,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 @@ -451,10 +454,10 @@ g_rw_lock_impl_free (pthread_rwlock_t *rwlock) free (rwlock); } -static pthread_rwlock_t * +static inline pthread_rwlock_t * g_rw_lock_get_impl (GRWLock *lock) { - pthread_rwlock_t *impl = lock->p; + pthread_rwlock_t *impl = g_atomic_pointer_get (&lock->p); if G_UNLIKELY (impl == NULL) { @@ -478,7 +481,7 @@ g_rw_lock_get_impl (GRWLock *lock) * necessary to initialise a reader-writer lock that has been statically * allocated. * - * |[ + * |[ * typedef struct { * GRWLock l; * ... @@ -637,19 +640,34 @@ g_rw_lock_reader_unlock (GRWLock *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, NULL)) != 0) + if G_UNLIKELY ((status = pthread_cond_init (cond, &attr)) != 0) g_thread_abort (status, "pthread_cond_init"); + pthread_condattr_destroy (&attr); + return cond; } @@ -660,10 +678,10 @@ g_cond_impl_free (pthread_cond_t *cond) free (cond); } -static pthread_cond_t * +static inline pthread_cond_t * g_cond_get_impl (GCond *cond) { - pthread_cond_t *impl = cond->p; + pthread_cond_t *impl = g_atomic_pointer_get (&cond->p); if G_UNLIKELY (impl == NULL) { @@ -680,17 +698,16 @@ g_cond_get_impl (GCond *cond) * 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 - * statically allocated. + * 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 @@ -703,7 +720,7 @@ g_cond_init (GCond *cond) /** * g_cond_clear: - * @cond: an initialized #GCond + * @cond: an initialised #GCond * * Frees the resources allocated to a #GCond with g_cond_init(). * @@ -726,12 +743,21 @@ 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. + * Atomically releases @mutex and waits until @cond is signalled. + * When this function returns, @mutex is locked again and owned by the + * calling thread. * - * This function can be used even if g_thread_init() has not yet been - * called, and, in that case, will immediately return. - */ + * 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) @@ -750,9 +776,6 @@ 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) @@ -771,9 +794,6 @@ 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) @@ -785,78 +805,107 @@ g_cond_broadcast (GCond *cond) } /** - * 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 - */ -gboolean -g_cond_timed_wait (GCond *cond, - GMutex *mutex, - GTimeVal *abs_time) -{ - struct timespec end_time; - gint status; - - if (abs_time == NULL) - { - g_cond_wait (cond, mutex); - return TRUE; - } - - end_time.tv_sec = abs_time->tv_sec; - end_time.tv_nsec = abs_time->tv_usec * 1000; - - if ((status = pthread_cond_timedwait (g_cond_get_impl (cond), g_mutex_get_impl (mutex), &end_time)) == 0) - return TRUE; - - if G_UNLIKELY (status != ETIMEDOUT) - g_thread_abort (status, "pthread_cond_timedwait"); - - return FALSE; -} - -/** - * g_cond_timedwait: - * @cond: a #GCond - * @mutex: a #GMutex that is currently locked - * @abs_time: the final time, in microseconds + * |[ + * 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; + * } * - * 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. + * // there is data for us + * data = current_data; + * current_data = NULL; * - * Returns: %TRUE if @cond was signalled, or %FALSE on timeout + * 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_timedwait (GCond *cond, - GMutex *mutex, - gint64 abs_time) +g_cond_wait_until (GCond *cond, + GMutex *mutex, + gint64 end_time) { - struct timespec end_time; + struct timespec ts; gint status; - end_time.tv_sec = abs_time / 1000000; - end_time.tv_nsec = (abs_time % 1000000) * 1000; +#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; - if ((status = pthread_cond_timedwait (g_cond_get_impl (cond), g_mutex_get_impl (mutex), &end_time)) == 0) - return TRUE; + if (end_time <= now) + return FALSE; + + 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"); @@ -864,6 +913,8 @@ g_cond_timedwait (GCond *cond, return FALSE; } +#endif /* defined(USE_NATIVE_MUTEX) */ + /* {{{1 GPrivate */ /** @@ -885,7 +936,7 @@ g_cond_timedwait (GCond *cond, * 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. + * be accessed via the g_private_ functions. */ /** @@ -907,7 +958,7 @@ g_cond_timedwait (GCond *cond, * 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 @@ -969,10 +1020,10 @@ g_private_impl_free (pthread_key_t *key) free (key); } -static pthread_key_t * +static inline pthread_key_t * g_private_get_impl (GPrivate *key) { - pthread_key_t *impl = key->p; + pthread_key_t *impl = g_atomic_pointer_get (&key->p); if G_UNLIKELY (impl == NULL) { @@ -1069,30 +1120,38 @@ g_private_replace (GPrivate *key, #define posix_check_cmd(cmd) posix_check_err (cmd, #cmd) -GRealThread * -g_system_thread_new (void) +typedef struct { - return g_slice_new0 (GRealThread); -} + GRealThread thread; + + pthread_t system_thread; + gboolean joined; + GMutex lock; +} GThreadPosix; void g_system_thread_free (GRealThread *thread) { - g_slice_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); } -void -g_system_thread_create (GThreadFunc thread_func, - gpointer arg, - gulong stack_size, - gboolean joinable, - gpointer thread, - GError **error) +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)); @@ -1108,21 +1167,23 @@ 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; } /** @@ -1140,10 +1201,19 @@ g_thread_yield (void) } void -g_system_thread_join (GRealThread *thread) +g_system_thread_wait (GRealThread *thread) { - gpointer ignore; - posix_check_cmd (pthread_join (*(pthread_t*)&(thread->system_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 @@ -1156,9 +1226,221 @@ void 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) +{ + 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); } -/* {{{1 Epilogue */ +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_cond_wait_until (GCond *cond, + GMutex *mutex, + gint64 end_time) +{ + 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; +} + +#endif + + /* {{{1 Epilogue */ /* vim:set foldmethod=marker: */