1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * gthread.c: posix thread system implementation
5 * Copyright 1998 Sebastian Wilhelmi; University of Karlsruhe
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
22 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
23 * file for a list of people on the GLib Team. See the ChangeLog
24 * files for a list of changes. These files are distributed with
25 * GLib at ftp://ftp.gtk.org/pub/gtk/.
28 /* The GMutex, GCond and GPrivate implementations in this file are some
29 * of the lowest-level code in GLib. All other parts of GLib (messages,
30 * memory, slices, etc) assume that they can freely use these facilities
31 * without risking recursion.
33 * As such, these functions are NOT permitted to call any other part of
36 * The thread manipulation functions (create, exit, join, etc.) have
37 * more freedom -- they can do as they please.
44 #include "gthreadprivate.h"
46 #include "gmessages.h"
47 #include "gstrfuncs.h"
67 /* clang defines __ATOMIC_SEQ_CST but doesn't support the GCC extension */
68 #if defined(HAVE_FUTEX) && defined(__ATOMIC_SEQ_CST) && !defined(__clang__)
69 #define USE_NATIVE_MUTEX
73 g_thread_abort (gint status,
74 const gchar *function)
76 fprintf (stderr, "GLib (gthread-posix.c): Unexpected error from C library during '%s': %s. Aborting.\n",
77 function, strerror (status));
83 #if !defined(USE_NATIVE_MUTEX)
85 static pthread_mutex_t *
86 g_mutex_impl_new (void)
88 pthread_mutexattr_t *pattr = NULL;
89 pthread_mutex_t *mutex;
91 #ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
92 pthread_mutexattr_t attr;
95 mutex = malloc (sizeof (pthread_mutex_t));
96 if G_UNLIKELY (mutex == NULL)
97 g_thread_abort (errno, "malloc");
99 #ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
100 pthread_mutexattr_init (&attr);
101 pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
105 if G_UNLIKELY ((status = pthread_mutex_init (mutex, pattr)) != 0)
106 g_thread_abort (status, "pthread_mutex_init");
108 #ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
109 pthread_mutexattr_destroy (&attr);
116 g_mutex_impl_free (pthread_mutex_t *mutex)
118 pthread_mutex_destroy (mutex);
122 static inline pthread_mutex_t *
123 g_mutex_get_impl (GMutex *mutex)
125 pthread_mutex_t *impl = g_atomic_pointer_get (&mutex->p);
127 if G_UNLIKELY (impl == NULL)
129 impl = g_mutex_impl_new ();
130 if (!g_atomic_pointer_compare_and_exchange (&mutex->p, NULL, impl))
131 g_mutex_impl_free (impl);
141 * @mutex: an uninitialized #GMutex
143 * Initializes a #GMutex so that it can be used.
145 * This function is useful to initialize a mutex that has been
146 * allocated on the stack, or as part of a larger structure.
147 * It is not necessary to initialize a mutex that has been
148 * statically allocated.
150 * |[<!-- language="C" -->
158 * b = g_new (Blob, 1);
159 * g_mutex_init (&b->m);
162 * To undo the effect of g_mutex_init() when a mutex is no longer
163 * needed, use g_mutex_clear().
165 * Calling g_mutex_init() on an already initialized #GMutex leads
166 * to undefined behaviour.
171 g_mutex_init (GMutex *mutex)
173 mutex->p = g_mutex_impl_new ();
178 * @mutex: an initialized #GMutex
180 * Frees the resources allocated to a mutex with g_mutex_init().
182 * This function should not be used with a #GMutex that has been
183 * statically allocated.
185 * Calling g_mutex_clear() on a locked mutex leads to undefined
191 g_mutex_clear (GMutex *mutex)
193 g_mutex_impl_free (mutex->p);
200 * Locks @mutex. If @mutex is already locked by another thread, the
201 * current thread will block until @mutex is unlocked by the other
204 * #GMutex is neither guaranteed to be recursive nor to be
205 * non-recursive. As such, calling g_mutex_lock() on a #GMutex that has
206 * already been locked by the same thread results in undefined behaviour
207 * (including but not limited to deadlocks).
210 g_mutex_lock (GMutex *mutex)
214 if G_UNLIKELY ((status = pthread_mutex_lock (g_mutex_get_impl (mutex))) != 0)
215 g_thread_abort (status, "pthread_mutex_lock");
222 * Unlocks @mutex. If another thread is blocked in a g_mutex_lock()
223 * call for @mutex, it will become unblocked and can lock @mutex itself.
225 * Calling g_mutex_unlock() on a mutex that is not locked by the
226 * current thread leads to undefined behaviour.
229 g_mutex_unlock (GMutex *mutex)
233 if G_UNLIKELY ((status = pthread_mutex_unlock (g_mutex_get_impl (mutex))) != 0)
234 g_thread_abort (status, "pthread_mutex_unlock");
241 * Tries to lock @mutex. If @mutex is already locked by another thread,
242 * it immediately returns %FALSE. Otherwise it locks @mutex and returns
245 * #GMutex is neither guaranteed to be recursive nor to be
246 * non-recursive. As such, calling g_mutex_lock() on a #GMutex that has
247 * already been locked by the same thread results in undefined behaviour
248 * (including but not limited to deadlocks or arbitrary return values).
250 * Returns: %TRUE if @mutex could be locked
253 g_mutex_trylock (GMutex *mutex)
257 if G_LIKELY ((status = pthread_mutex_trylock (g_mutex_get_impl (mutex))) == 0)
260 if G_UNLIKELY (status != EBUSY)
261 g_thread_abort (status, "pthread_mutex_trylock");
266 #endif /* !defined(USE_NATIVE_MUTEX) */
270 static pthread_mutex_t *
271 g_rec_mutex_impl_new (void)
273 pthread_mutexattr_t attr;
274 pthread_mutex_t *mutex;
276 mutex = malloc (sizeof (pthread_mutex_t));
277 if G_UNLIKELY (mutex == NULL)
278 g_thread_abort (errno, "malloc");
280 pthread_mutexattr_init (&attr);
281 pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
282 pthread_mutex_init (mutex, &attr);
283 pthread_mutexattr_destroy (&attr);
289 g_rec_mutex_impl_free (pthread_mutex_t *mutex)
291 pthread_mutex_destroy (mutex);
295 static inline pthread_mutex_t *
296 g_rec_mutex_get_impl (GRecMutex *rec_mutex)
298 pthread_mutex_t *impl = g_atomic_pointer_get (&rec_mutex->p);
300 if G_UNLIKELY (impl == NULL)
302 impl = g_rec_mutex_impl_new ();
303 if (!g_atomic_pointer_compare_and_exchange (&rec_mutex->p, NULL, impl))
304 g_rec_mutex_impl_free (impl);
313 * @rec_mutex: an uninitialized #GRecMutex
315 * Initializes a #GRecMutex so that it can be used.
317 * This function is useful to initialize a recursive mutex
318 * that has been allocated on the stack, or as part of a larger
321 * It is not necessary to initialise a recursive mutex that has been
322 * statically allocated.
324 * |[<!-- language="C" -->
332 * b = g_new (Blob, 1);
333 * g_rec_mutex_init (&b->m);
336 * Calling g_rec_mutex_init() on an already initialized #GRecMutex
337 * leads to undefined behaviour.
339 * To undo the effect of g_rec_mutex_init() when a recursive mutex
340 * is no longer needed, use g_rec_mutex_clear().
345 g_rec_mutex_init (GRecMutex *rec_mutex)
347 rec_mutex->p = g_rec_mutex_impl_new ();
352 * @rec_mutex: an initialized #GRecMutex
354 * Frees the resources allocated to a recursive mutex with
355 * g_rec_mutex_init().
357 * This function should not be used with a #GRecMutex that has been
358 * statically allocated.
360 * Calling g_rec_mutex_clear() on a locked recursive mutex leads
361 * to undefined behaviour.
366 g_rec_mutex_clear (GRecMutex *rec_mutex)
368 g_rec_mutex_impl_free (rec_mutex->p);
373 * @rec_mutex: a #GRecMutex
375 * Locks @rec_mutex. If @rec_mutex is already locked by another
376 * thread, the current thread will block until @rec_mutex is
377 * unlocked by the other thread. If @rec_mutex is already locked
378 * by the current thread, the 'lock count' of @rec_mutex is increased.
379 * The mutex will only become available again when it is unlocked
380 * as many times as it has been locked.
385 g_rec_mutex_lock (GRecMutex *mutex)
387 pthread_mutex_lock (g_rec_mutex_get_impl (mutex));
391 * g_rec_mutex_unlock:
392 * @rec_mutex: a #GRecMutex
394 * Unlocks @rec_mutex. If another thread is blocked in a
395 * g_rec_mutex_lock() call for @rec_mutex, it will become unblocked
396 * and can lock @rec_mutex itself.
398 * Calling g_rec_mutex_unlock() on a recursive mutex that is not
399 * locked by the current thread leads to undefined behaviour.
404 g_rec_mutex_unlock (GRecMutex *rec_mutex)
406 pthread_mutex_unlock (rec_mutex->p);
410 * g_rec_mutex_trylock:
411 * @rec_mutex: a #GRecMutex
413 * Tries to lock @rec_mutex. If @rec_mutex is already locked
414 * by another thread, it immediately returns %FALSE. Otherwise
415 * it locks @rec_mutex and returns %TRUE.
417 * Returns: %TRUE if @rec_mutex could be locked
422 g_rec_mutex_trylock (GRecMutex *rec_mutex)
424 if (pthread_mutex_trylock (g_rec_mutex_get_impl (rec_mutex)) != 0)
432 static pthread_rwlock_t *
433 g_rw_lock_impl_new (void)
435 pthread_rwlock_t *rwlock;
438 rwlock = malloc (sizeof (pthread_rwlock_t));
439 if G_UNLIKELY (rwlock == NULL)
440 g_thread_abort (errno, "malloc");
442 if G_UNLIKELY ((status = pthread_rwlock_init (rwlock, NULL)) != 0)
443 g_thread_abort (status, "pthread_rwlock_init");
449 g_rw_lock_impl_free (pthread_rwlock_t *rwlock)
451 pthread_rwlock_destroy (rwlock);
455 static inline pthread_rwlock_t *
456 g_rw_lock_get_impl (GRWLock *lock)
458 pthread_rwlock_t *impl = g_atomic_pointer_get (&lock->p);
460 if G_UNLIKELY (impl == NULL)
462 impl = g_rw_lock_impl_new ();
463 if (!g_atomic_pointer_compare_and_exchange (&lock->p, NULL, impl))
464 g_rw_lock_impl_free (impl);
473 * @rw_lock: an uninitialized #GRWLock
475 * Initializes a #GRWLock so that it can be used.
477 * This function is useful to initialize a lock that has been
478 * allocated on the stack, or as part of a larger structure. It is not
479 * necessary to initialise a reader-writer lock that has been statically
482 * |[<!-- language="C" -->
490 * b = g_new (Blob, 1);
491 * g_rw_lock_init (&b->l);
494 * To undo the effect of g_rw_lock_init() when a lock is no longer
495 * needed, use g_rw_lock_clear().
497 * Calling g_rw_lock_init() on an already initialized #GRWLock leads
498 * to undefined behaviour.
503 g_rw_lock_init (GRWLock *rw_lock)
505 rw_lock->p = g_rw_lock_impl_new ();
510 * @rw_lock: an initialized #GRWLock
512 * Frees the resources allocated to a lock with g_rw_lock_init().
514 * This function should not be used with a #GRWLock that has been
515 * statically allocated.
517 * Calling g_rw_lock_clear() when any thread holds the lock
518 * leads to undefined behaviour.
523 g_rw_lock_clear (GRWLock *rw_lock)
525 g_rw_lock_impl_free (rw_lock->p);
529 * g_rw_lock_writer_lock:
530 * @rw_lock: a #GRWLock
532 * Obtain a write lock on @rw_lock. If any thread already holds
533 * a read or write lock on @rw_lock, the current thread will block
534 * until all other threads have dropped their locks on @rw_lock.
539 g_rw_lock_writer_lock (GRWLock *rw_lock)
541 int retval = pthread_rwlock_wrlock (g_rw_lock_get_impl (rw_lock));
544 g_critical ("Failed to get RW lock %p: %s", rw_lock, g_strerror (retval));
548 * g_rw_lock_writer_trylock:
549 * @rw_lock: a #GRWLock
551 * Tries to obtain a write lock on @rw_lock. If any other thread holds
552 * a read or write lock on @rw_lock, it immediately returns %FALSE.
553 * Otherwise it locks @rw_lock and returns %TRUE.
555 * Returns: %TRUE if @rw_lock could be locked
560 g_rw_lock_writer_trylock (GRWLock *rw_lock)
562 if (pthread_rwlock_trywrlock (g_rw_lock_get_impl (rw_lock)) != 0)
569 * g_rw_lock_writer_unlock:
570 * @rw_lock: a #GRWLock
572 * Release a write lock on @rw_lock.
574 * Calling g_rw_lock_writer_unlock() on a lock that is not held
575 * by the current thread leads to undefined behaviour.
580 g_rw_lock_writer_unlock (GRWLock *rw_lock)
582 pthread_rwlock_unlock (g_rw_lock_get_impl (rw_lock));
586 * g_rw_lock_reader_lock:
587 * @rw_lock: a #GRWLock
589 * Obtain a read lock on @rw_lock. If another thread currently holds
590 * the write lock on @rw_lock, the current thread will block. If another thread
591 * does not hold the write lock, but is waiting for it, it is implementation
592 * defined whether the reader or writer will block. Read locks can be taken
595 * It is implementation-defined how many threads are allowed to
596 * hold read locks on the same lock simultaneously. If the limit is hit,
597 * or if a deadlock is detected, a critical warning will be emitted.
602 g_rw_lock_reader_lock (GRWLock *rw_lock)
604 int retval = pthread_rwlock_rdlock (g_rw_lock_get_impl (rw_lock));
607 g_critical ("Failed to get RW lock %p: %s", rw_lock, g_strerror (retval));
611 * g_rw_lock_reader_trylock:
612 * @rw_lock: a #GRWLock
614 * Tries to obtain a read lock on @rw_lock and returns %TRUE if
615 * the read lock was successfully obtained. Otherwise it
618 * Returns: %TRUE if @rw_lock could be locked
623 g_rw_lock_reader_trylock (GRWLock *rw_lock)
625 if (pthread_rwlock_tryrdlock (g_rw_lock_get_impl (rw_lock)) != 0)
632 * g_rw_lock_reader_unlock:
633 * @rw_lock: a #GRWLock
635 * Release a read lock on @rw_lock.
637 * Calling g_rw_lock_reader_unlock() on a lock that is not held
638 * by the current thread leads to undefined behaviour.
643 g_rw_lock_reader_unlock (GRWLock *rw_lock)
645 pthread_rwlock_unlock (g_rw_lock_get_impl (rw_lock));
650 #if !defined(USE_NATIVE_MUTEX)
652 static pthread_cond_t *
653 g_cond_impl_new (void)
655 pthread_condattr_t attr;
656 pthread_cond_t *cond;
659 pthread_condattr_init (&attr);
661 #ifdef HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP
662 #elif defined (HAVE_PTHREAD_CONDATTR_SETCLOCK) && defined (CLOCK_MONOTONIC)
663 if G_UNLIKELY ((status = pthread_condattr_setclock (&attr, CLOCK_MONOTONIC)) != 0)
664 g_thread_abort (status, "pthread_condattr_setclock");
666 #error Cannot support GCond on your platform.
669 cond = malloc (sizeof (pthread_cond_t));
670 if G_UNLIKELY (cond == NULL)
671 g_thread_abort (errno, "malloc");
673 if G_UNLIKELY ((status = pthread_cond_init (cond, &attr)) != 0)
674 g_thread_abort (status, "pthread_cond_init");
676 pthread_condattr_destroy (&attr);
682 g_cond_impl_free (pthread_cond_t *cond)
684 pthread_cond_destroy (cond);
688 static inline pthread_cond_t *
689 g_cond_get_impl (GCond *cond)
691 pthread_cond_t *impl = g_atomic_pointer_get (&cond->p);
693 if G_UNLIKELY (impl == NULL)
695 impl = g_cond_impl_new ();
696 if (!g_atomic_pointer_compare_and_exchange (&cond->p, NULL, impl))
697 g_cond_impl_free (impl);
706 * @cond: an uninitialized #GCond
708 * Initialises a #GCond so that it can be used.
710 * This function is useful to initialise a #GCond that has been
711 * allocated as part of a larger structure. It is not necessary to
712 * initialise a #GCond that has been statically allocated.
714 * To undo the effect of g_cond_init() when a #GCond is no longer
715 * needed, use g_cond_clear().
717 * Calling g_cond_init() on an already-initialised #GCond leads
718 * to undefined behaviour.
723 g_cond_init (GCond *cond)
725 cond->p = g_cond_impl_new ();
730 * @cond: an initialised #GCond
732 * Frees the resources allocated to a #GCond with g_cond_init().
734 * This function should not be used with a #GCond that has been
735 * statically allocated.
737 * Calling g_cond_clear() for a #GCond on which threads are
738 * blocking leads to undefined behaviour.
743 g_cond_clear (GCond *cond)
745 g_cond_impl_free (cond->p);
751 * @mutex: a #GMutex that is currently locked
753 * Atomically releases @mutex and waits until @cond is signalled.
754 * When this function returns, @mutex is locked again and owned by the
757 * When using condition variables, it is possible that a spurious wakeup
758 * may occur (ie: g_cond_wait() returns even though g_cond_signal() was
759 * not called). It's also possible that a stolen wakeup may occur.
760 * This is when g_cond_signal() is called, but another thread acquires
761 * @mutex before this thread and modifies the state of the program in
762 * such a way that when g_cond_wait() is able to return, the expected
763 * condition is no longer met.
765 * For this reason, g_cond_wait() must always be used in a loop. See
766 * the documentation for #GCond for a complete example.
769 g_cond_wait (GCond *cond,
774 if G_UNLIKELY ((status = pthread_cond_wait (g_cond_get_impl (cond), g_mutex_get_impl (mutex))) != 0)
775 g_thread_abort (status, "pthread_cond_wait");
782 * If threads are waiting for @cond, at least one of them is unblocked.
783 * If no threads are waiting for @cond, this function has no effect.
784 * It is good practice to hold the same lock as the waiting thread
785 * while calling this function, though not required.
788 g_cond_signal (GCond *cond)
792 if G_UNLIKELY ((status = pthread_cond_signal (g_cond_get_impl (cond))) != 0)
793 g_thread_abort (status, "pthread_cond_signal");
800 * If threads are waiting for @cond, all of them are unblocked.
801 * If no threads are waiting for @cond, this function has no effect.
802 * It is good practice to lock the same mutex as the waiting threads
803 * while calling this function, though not required.
806 g_cond_broadcast (GCond *cond)
810 if G_UNLIKELY ((status = pthread_cond_broadcast (g_cond_get_impl (cond))) != 0)
811 g_thread_abort (status, "pthread_cond_broadcast");
817 * @mutex: a #GMutex that is currently locked
818 * @end_time: the monotonic time to wait until
820 * Waits until either @cond is signalled or @end_time has passed.
822 * As with g_cond_wait() it is possible that a spurious or stolen wakeup
823 * could occur. For that reason, waiting on a condition variable should
824 * always be in a loop, based on an explicitly-checked predicate.
826 * %TRUE is returned if the condition variable was signalled (or in the
827 * case of a spurious wakeup). %FALSE is returned if @end_time has
830 * The following code shows how to correctly perform a timed wait on a
831 * condition variable (extending the example presented in the
832 * documentation for #GCond):
834 * |[<!-- language="C" -->
836 * pop_data_timed (void)
841 * g_mutex_lock (&data_mutex);
843 * end_time = g_get_monotonic_time () + 5 * G_TIME_SPAN_SECOND;
844 * while (!current_data)
845 * if (!g_cond_wait_until (&data_cond, &data_mutex, end_time))
847 * // timeout has passed.
848 * g_mutex_unlock (&data_mutex);
852 * // there is data for us
853 * data = current_data;
854 * current_data = NULL;
856 * g_mutex_unlock (&data_mutex);
862 * Notice that the end time is calculated once, before entering the
863 * loop and reused. This is the motivation behind the use of absolute
864 * time on this API -- if a relative time of 5 seconds were passed
865 * directly to the call and a spurious wakeup occurred, the program would
866 * have to start over waiting again (which would lead to a total wait
867 * time of more than 5 seconds).
869 * Returns: %TRUE on a signal, %FALSE on a timeout
873 g_cond_wait_until (GCond *cond,
880 #ifdef HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP
881 /* end_time is given relative to the monotonic clock as returned by
882 * g_get_monotonic_time().
884 * Since this pthreads wants the relative time, convert it back again.
887 gint64 now = g_get_monotonic_time ();
893 relative = end_time - now;
895 ts.tv_sec = relative / 1000000;
896 ts.tv_nsec = (relative % 1000000) * 1000;
898 if ((status = pthread_cond_timedwait_relative_np (g_cond_get_impl (cond), g_mutex_get_impl (mutex), &ts)) == 0)
901 #elif defined (HAVE_PTHREAD_CONDATTR_SETCLOCK) && defined (CLOCK_MONOTONIC)
902 /* This is the exact check we used during init to set the clock to
903 * monotonic, so if we're in this branch, timedwait() will already be
904 * expecting a monotonic clock.
907 ts.tv_sec = end_time / 1000000;
908 ts.tv_nsec = (end_time % 1000000) * 1000;
910 if ((status = pthread_cond_timedwait (g_cond_get_impl (cond), g_mutex_get_impl (mutex), &ts)) == 0)
914 #error Cannot support GCond on your platform.
917 if G_UNLIKELY (status != ETIMEDOUT)
918 g_thread_abort (status, "pthread_cond_timedwait");
923 #endif /* defined(USE_NATIVE_MUTEX) */
930 * The #GPrivate struct is an opaque data structure to represent a
931 * thread-local data key. It is approximately equivalent to the
932 * pthread_setspecific()/pthread_getspecific() APIs on POSIX and to
933 * TlsSetValue()/TlsGetValue() on Windows.
935 * If you don't already know why you might want this functionality,
936 * then you probably don't need it.
938 * #GPrivate is a very limited resource (as far as 128 per program,
939 * shared between all libraries). It is also not possible to destroy a
940 * #GPrivate after it has been used. As such, it is only ever acceptable
941 * to use #GPrivate in static scope, and even then sparingly so.
943 * See G_PRIVATE_INIT() for a couple of examples.
945 * The #GPrivate structure should be considered opaque. It should only
946 * be accessed via the g_private_ functions.
951 * @notify: a #GDestroyNotify
953 * A macro to assist with the static initialisation of a #GPrivate.
955 * This macro is useful for the case that a #GDestroyNotify function
956 * should be associated with the key. This is needed when the key will be
957 * used to point at memory that should be deallocated when the thread
960 * Additionally, the #GDestroyNotify will also be called on the previous
961 * value stored in the key when g_private_replace() is used.
963 * If no #GDestroyNotify is needed, then use of this macro is not
964 * required -- if the #GPrivate is declared in static scope then it will
965 * be properly initialised by default (ie: to all zeros). See the
968 * |[<!-- language="C" -->
969 * static GPrivate name_key = G_PRIVATE_INIT (g_free);
971 * // return value should not be freed
973 * get_local_name (void)
975 * return g_private_get (&name_key);
979 * set_local_name (const gchar *name)
981 * g_private_replace (&name_key, g_strdup (name));
985 * static GPrivate count_key; // no free function
988 * get_local_count (void)
990 * return GPOINTER_TO_INT (g_private_get (&count_key));
994 * set_local_count (gint count)
996 * g_private_set (&count_key, GINT_TO_POINTER (count));
1003 static pthread_key_t *
1004 g_private_impl_new (GDestroyNotify notify)
1009 key = malloc (sizeof (pthread_key_t));
1010 if G_UNLIKELY (key == NULL)
1011 g_thread_abort (errno, "malloc");
1012 status = pthread_key_create (key, notify);
1013 if G_UNLIKELY (status != 0)
1014 g_thread_abort (status, "pthread_key_create");
1020 g_private_impl_free (pthread_key_t *key)
1024 status = pthread_key_delete (*key);
1025 if G_UNLIKELY (status != 0)
1026 g_thread_abort (status, "pthread_key_delete");
1030 static inline pthread_key_t *
1031 g_private_get_impl (GPrivate *key)
1033 pthread_key_t *impl = g_atomic_pointer_get (&key->p);
1035 if G_UNLIKELY (impl == NULL)
1037 impl = g_private_impl_new (key->notify);
1038 if (!g_atomic_pointer_compare_and_exchange (&key->p, NULL, impl))
1040 g_private_impl_free (impl);
1052 * Returns the current value of the thread local variable @key.
1054 * If the value has not yet been set in this thread, %NULL is returned.
1055 * Values are never copied between threads (when a new thread is
1056 * created, for example).
1058 * Returns: the thread-local value
1061 g_private_get (GPrivate *key)
1063 /* quote POSIX: No errors are returned from pthread_getspecific(). */
1064 return pthread_getspecific (*g_private_get_impl (key));
1070 * @value: the new value
1072 * Sets the thread local variable @key to have the value @value in the
1075 * This function differs from g_private_replace() in the following way:
1076 * the #GDestroyNotify for @key is not called on the old value.
1079 g_private_set (GPrivate *key,
1084 if G_UNLIKELY ((status = pthread_setspecific (*g_private_get_impl (key), value)) != 0)
1085 g_thread_abort (status, "pthread_setspecific");
1089 * g_private_replace:
1091 * @value: the new value
1093 * Sets the thread local variable @key to have the value @value in the
1096 * This function differs from g_private_set() in the following way: if
1097 * the previous value was non-%NULL then the #GDestroyNotify handler for
1098 * @key is run on it.
1103 g_private_replace (GPrivate *key,
1106 pthread_key_t *impl = g_private_get_impl (key);
1110 old = pthread_getspecific (*impl);
1111 if (old && key->notify)
1114 if G_UNLIKELY ((status = pthread_setspecific (*impl, value)) != 0)
1115 g_thread_abort (status, "pthread_setspecific");
1120 #define posix_check_err(err, name) G_STMT_START{ \
1121 int error = (err); \
1123 g_error ("file %s: line %d (%s): error '%s' during '%s'", \
1124 __FILE__, __LINE__, G_STRFUNC, \
1125 g_strerror (error), name); \
1128 #define posix_check_cmd(cmd) posix_check_err (cmd, #cmd)
1134 pthread_t system_thread;
1140 g_system_thread_free (GRealThread *thread)
1142 GThreadPosix *pt = (GThreadPosix *) thread;
1145 pthread_detach (pt->system_thread);
1147 g_mutex_clear (&pt->lock);
1149 g_slice_free (GThreadPosix, pt);
1153 g_system_thread_new (GThreadFunc proxy,
1160 GThreadPosix *thread;
1161 GRealThread *base_thread;
1162 pthread_attr_t attr;
1165 thread = g_slice_new0 (GThreadPosix);
1166 base_thread = (GRealThread*)thread;
1167 base_thread->ref_count = 2;
1168 base_thread->ours = TRUE;
1169 base_thread->thread.joinable = TRUE;
1170 base_thread->thread.func = func;
1171 base_thread->thread.data = data;
1172 base_thread->name = g_strdup (name);
1174 posix_check_cmd (pthread_attr_init (&attr));
1176 #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
1179 #ifdef _SC_THREAD_STACK_MIN
1180 long min_stack_size = sysconf (_SC_THREAD_STACK_MIN);
1181 if (min_stack_size >= 0)
1182 stack_size = MAX ((gulong) min_stack_size, stack_size);
1183 #endif /* _SC_THREAD_STACK_MIN */
1184 /* No error check here, because some systems can't do it and
1185 * we simply don't want threads to fail because of that. */
1186 pthread_attr_setstacksize (&attr, stack_size);
1188 #endif /* HAVE_PTHREAD_ATTR_SETSTACKSIZE */
1190 ret = pthread_create (&thread->system_thread, &attr, (void* (*)(void*))proxy, thread);
1192 posix_check_cmd (pthread_attr_destroy (&attr));
1196 g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN,
1197 "Error creating thread: %s", g_strerror (ret));
1198 g_slice_free (GThreadPosix, thread);
1202 posix_check_err (ret, "pthread_create");
1204 g_mutex_init (&thread->lock);
1206 return (GRealThread *) thread;
1212 * Causes the calling thread to voluntarily relinquish the CPU, so
1213 * that other threads can run.
1215 * This function is often used as a method to make busy wait less evil.
1218 g_thread_yield (void)
1224 g_system_thread_wait (GRealThread *thread)
1226 GThreadPosix *pt = (GThreadPosix *) thread;
1228 g_mutex_lock (&pt->lock);
1232 posix_check_cmd (pthread_join (pt->system_thread, NULL));
1236 g_mutex_unlock (&pt->lock);
1240 g_system_thread_exit (void)
1242 pthread_exit (NULL);
1246 g_system_thread_set_name (const gchar *name)
1248 #if defined(HAVE_PTHREAD_SETNAME_NP_WITH_TID)
1249 pthread_setname_np (pthread_self(), name); /* on Linux and Solaris */
1250 #elif defined(HAVE_PTHREAD_SETNAME_NP_WITHOUT_TID)
1251 pthread_setname_np (name); /* on OS X and iOS */
1255 /* {{{1 GMutex and GCond futex implementation */
1257 #if defined(USE_NATIVE_MUTEX)
1259 #include <linux/futex.h>
1260 #include <sys/syscall.h>
1262 #ifndef FUTEX_WAIT_PRIVATE
1263 #define FUTEX_WAIT_PRIVATE FUTEX_WAIT
1264 #define FUTEX_WAKE_PRIVATE FUTEX_WAKE
1267 /* We should expand the set of operations available in gatomic once we
1268 * have better C11 support in GCC in common distributions (ie: 4.9).
1270 * Before then, let's define a couple of useful things for our own
1274 #define exchange_acquire(ptr, new) \
1275 __atomic_exchange_4((ptr), (new), __ATOMIC_ACQUIRE)
1276 #define compare_exchange_acquire(ptr, old, new) \
1277 __atomic_compare_exchange_4((ptr), (old), (new), 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)
1279 #define exchange_release(ptr, new) \
1280 __atomic_exchange_4((ptr), (new), __ATOMIC_RELEASE)
1281 #define store_release(ptr, new) \
1282 __atomic_store_4((ptr), (new), __ATOMIC_RELEASE)
1284 /* Our strategy for the mutex is pretty simple:
1288 * 1: acquired by one thread only, no contention
1293 * As such, attempting to acquire the lock should involve an increment.
1294 * If we find that the previous value was 0 then we can return
1297 * On unlock, we always store 0 to indicate that the lock is available.
1298 * If the value there was 1 before then we didn't have contention and
1299 * can return immediately. If the value was something other than 1 then
1300 * we have the contended case and need to wake a waiter.
1302 * If it was not 0 then there is another thread holding it and we must
1303 * wait. We must always ensure that we mark a value >1 while we are
1304 * waiting in order to instruct the holder to do a wake operation on
1309 g_mutex_init (GMutex *mutex)
1315 g_mutex_clear (GMutex *mutex)
1317 if G_UNLIKELY (mutex->i[0] != 0)
1319 fprintf (stderr, "g_mutex_clear() called on uninitialised or locked mutex\n");
1324 static void __attribute__((noinline))
1325 g_mutex_lock_slowpath (GMutex *mutex)
1327 /* Set to 2 to indicate contention. If it was zero before then we
1328 * just acquired the lock.
1330 * Otherwise, sleep for as long as the 2 remains...
1332 while (exchange_acquire (&mutex->i[0], 2) != 0)
1333 syscall (__NR_futex, &mutex->i[0], (gsize) FUTEX_WAIT_PRIVATE, (gsize) 2, NULL);
1336 static void __attribute__((noinline))
1337 g_mutex_unlock_slowpath (GMutex *mutex,
1340 /* We seem to get better code for the uncontended case by splitting
1343 if G_UNLIKELY (prev == 0)
1345 fprintf (stderr, "Attempt to unlock mutex that was not locked\n");
1349 syscall (__NR_futex, &mutex->i[0], (gsize) FUTEX_WAKE_PRIVATE, (gsize) 1, NULL);
1353 g_mutex_lock (GMutex *mutex)
1355 /* 0 -> 1 and we're done. Anything else, and we need to wait... */
1356 if G_UNLIKELY (g_atomic_int_add (&mutex->i[0], 1) != 0)
1357 g_mutex_lock_slowpath (mutex);
1361 g_mutex_unlock (GMutex *mutex)
1365 prev = exchange_release (&mutex->i[0], 0);
1367 /* 1-> 0 and we're done. Anything else and we need to signal... */
1368 if G_UNLIKELY (prev != 1)
1369 g_mutex_unlock_slowpath (mutex, prev);
1373 g_mutex_trylock (GMutex *mutex)
1377 /* We don't want to touch the value at all unless we can move it from
1380 return compare_exchange_acquire (&mutex->i[0], &zero, 1);
1383 /* Condition variables are implemented in a rather simple way as well.
1384 * In many ways, futex() as an abstraction is even more ideally suited
1385 * to condition variables than it is to mutexes.
1387 * We store a generation counter. We sample it with the lock held and
1388 * unlock before sleeping on the futex.
1390 * Signalling simply involves increasing the counter and making the
1391 * appropriate futex call.
1393 * The only thing that is the slightest bit complicated is timed waits
1394 * because we must convert our absolute time to relative.
1398 g_cond_init (GCond *cond)
1404 g_cond_clear (GCond *cond)
1409 g_cond_wait (GCond *cond,
1412 guint sampled = g_atomic_int_get (&cond->i[0]);
1414 g_mutex_unlock (mutex);
1415 syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAIT_PRIVATE, (gsize) sampled, NULL);
1416 g_mutex_lock (mutex);
1420 g_cond_signal (GCond *cond)
1422 g_atomic_int_inc (&cond->i[0]);
1424 syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAKE_PRIVATE, (gsize) 1, NULL);
1428 g_cond_broadcast (GCond *cond)
1430 g_atomic_int_inc (&cond->i[0]);
1432 syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAKE_PRIVATE, (gsize) INT_MAX, NULL);
1436 g_cond_wait_until (GCond *cond,
1440 struct timespec now;
1441 struct timespec span;
1449 clock_gettime (CLOCK_MONOTONIC, &now);
1450 span.tv_sec = (end_time / 1000000) - now.tv_sec;
1451 span.tv_nsec = ((end_time % 1000000) * 1000) - now.tv_nsec;
1452 if (span.tv_nsec < 0)
1454 span.tv_nsec += 1000000000;
1458 if (span.tv_sec < 0)
1461 sampled = cond->i[0];
1462 g_mutex_unlock (mutex);
1463 res = syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAIT_PRIVATE, (gsize) sampled, &span);
1464 success = (res < 0 && errno == ETIMEDOUT) ? FALSE : TRUE;
1465 g_mutex_lock (mutex);
1473 /* vim:set foldmethod=marker: */