From: Sebastian Wilhelmi Date: Fri, 17 Mar 2000 14:49:59 +0000 (+0000) Subject: Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages. X-Git-Url: http://git.openbox.org/?a=commitdiff_plain;h=5e7134375eea0543c998715e03a458411906e89c;p=dana%2Fcg-glib.git Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages. 2000-03-17 Sebastian Wilhelmi * configure.in: Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages. * configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for real thread support. On solaris pthread_create can be linked to even in -lc, but it doesn't work then. * configure.in: Don't use priorities for threads, when the minimal/maximal priorities couldn't be determined at configure time. * configure.in, gthread.c: Always define GSystemThread in glibconfig.h to represent a system thread. * configure.in: Do not use native recursive threads, when possibe. We use some features, that they do not expose (namely the depth counter). * glib.h, gthread.c: Redefined GStaticRecMutex. The functions are now implemented in a different way, which should be way faster. Alsothere are now functions g_static_rec_mutex_unlock_full and g_static_rec_mutex_lock_full to leave/enter a recursive mutex completly. * gthread.c (g_thread_self): Do not test the system_thread to be non-zero to speed things up. * gthread.c (g_mutex_init): Therefore set the system_thread of the main thread here. * tests/thread-test.c: Rerun all tests once again, but this time we fool the system into thinking, that the available thread system is not native, but userprovided. * gthread/gthread-posix.c: Don't use priorities for threads, when the minimal/maximal priorities couldn't be determined at configure time. * gthread/gthread-posix.c: Don't check for errors, when setting the scope of a tread to system, as some posix implementations can't do that and we don't want the thing to fail because of that. --- diff --git a/ChangeLog b/ChangeLog index 21408275..c998e48d 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,39 @@ +2000-03-17 Sebastian Wilhelmi + + * configure.in: Added the missing POSIX_NO_YIELD and + POSIX_NO_PRIORITIES warning messages. + + * configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for + real thread support. On solaris pthread_create can be linked to + even in -lc, but it doesn't work then. + + * configure.in: Don't use priorities for threads, when the + minimal/maximal priorities couldn't be determined at configure + time. + + * configure.in, gthread.c: Always define GSystemThread in + glibconfig.h to represent a system thread. + + * configure.in: Do not use native recursive threads, when + possibe. We use some features, that they do not expose (namely the + depth counter). + + * glib.h, gthread.c: Redefined GStaticRecMutex. The functions are + now implemented in a different way, which should be way + faster. Alsothere are now functions g_static_rec_mutex_unlock_full + and g_static_rec_mutex_lock_full to leave/enter a recursive mutex + completly. + + * gthread.c (g_thread_self): Do not test the system_thread to be + non-zero to speed things up. + + * gthread.c (g_mutex_init): Therefore set the system_thread of the + main thread here. + + * tests/thread-test.c: Rerun all tests once again, but this time + we fool the system into thinking, that the available thread system + is not native, but userprovided. + 2000-03-13 Sebastian Wilhelmi * gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0 index 21408275..c998e48d 100644 --- a/ChangeLog.pre-2-0 +++ b/ChangeLog.pre-2-0 @@ -1,3 +1,39 @@ +2000-03-17 Sebastian Wilhelmi + + * configure.in: Added the missing POSIX_NO_YIELD and + POSIX_NO_PRIORITIES warning messages. + + * configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for + real thread support. On solaris pthread_create can be linked to + even in -lc, but it doesn't work then. + + * configure.in: Don't use priorities for threads, when the + minimal/maximal priorities couldn't be determined at configure + time. + + * configure.in, gthread.c: Always define GSystemThread in + glibconfig.h to represent a system thread. + + * configure.in: Do not use native recursive threads, when + possibe. We use some features, that they do not expose (namely the + depth counter). + + * glib.h, gthread.c: Redefined GStaticRecMutex. The functions are + now implemented in a different way, which should be way + faster. Alsothere are now functions g_static_rec_mutex_unlock_full + and g_static_rec_mutex_lock_full to leave/enter a recursive mutex + completly. + + * gthread.c (g_thread_self): Do not test the system_thread to be + non-zero to speed things up. + + * gthread.c (g_mutex_init): Therefore set the system_thread of the + main thread here. + + * tests/thread-test.c: Rerun all tests once again, but this time + we fool the system into thinking, that the available thread system + is not native, but userprovided. + 2000-03-13 Sebastian Wilhelmi * gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10 index 21408275..c998e48d 100644 --- a/ChangeLog.pre-2-10 +++ b/ChangeLog.pre-2-10 @@ -1,3 +1,39 @@ +2000-03-17 Sebastian Wilhelmi + + * configure.in: Added the missing POSIX_NO_YIELD and + POSIX_NO_PRIORITIES warning messages. + + * configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for + real thread support. On solaris pthread_create can be linked to + even in -lc, but it doesn't work then. + + * configure.in: Don't use priorities for threads, when the + minimal/maximal priorities couldn't be determined at configure + time. + + * configure.in, gthread.c: Always define GSystemThread in + glibconfig.h to represent a system thread. + + * configure.in: Do not use native recursive threads, when + possibe. We use some features, that they do not expose (namely the + depth counter). + + * glib.h, gthread.c: Redefined GStaticRecMutex. The functions are + now implemented in a different way, which should be way + faster. Alsothere are now functions g_static_rec_mutex_unlock_full + and g_static_rec_mutex_lock_full to leave/enter a recursive mutex + completly. + + * gthread.c (g_thread_self): Do not test the system_thread to be + non-zero to speed things up. + + * gthread.c (g_mutex_init): Therefore set the system_thread of the + main thread here. + + * tests/thread-test.c: Rerun all tests once again, but this time + we fool the system into thinking, that the available thread system + is not native, but userprovided. + 2000-03-13 Sebastian Wilhelmi * gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We diff --git a/ChangeLog.pre-2-12 b/ChangeLog.pre-2-12 index 21408275..c998e48d 100644 --- a/ChangeLog.pre-2-12 +++ b/ChangeLog.pre-2-12 @@ -1,3 +1,39 @@ +2000-03-17 Sebastian Wilhelmi + + * configure.in: Added the missing POSIX_NO_YIELD and + POSIX_NO_PRIORITIES warning messages. + + * configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for + real thread support. On solaris pthread_create can be linked to + even in -lc, but it doesn't work then. + + * configure.in: Don't use priorities for threads, when the + minimal/maximal priorities couldn't be determined at configure + time. + + * configure.in, gthread.c: Always define GSystemThread in + glibconfig.h to represent a system thread. + + * configure.in: Do not use native recursive threads, when + possibe. We use some features, that they do not expose (namely the + depth counter). + + * glib.h, gthread.c: Redefined GStaticRecMutex. The functions are + now implemented in a different way, which should be way + faster. Alsothere are now functions g_static_rec_mutex_unlock_full + and g_static_rec_mutex_lock_full to leave/enter a recursive mutex + completly. + + * gthread.c (g_thread_self): Do not test the system_thread to be + non-zero to speed things up. + + * gthread.c (g_mutex_init): Therefore set the system_thread of the + main thread here. + + * tests/thread-test.c: Rerun all tests once again, but this time + we fool the system into thinking, that the available thread system + is not native, but userprovided. + 2000-03-13 Sebastian Wilhelmi * gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2 index 21408275..c998e48d 100644 --- a/ChangeLog.pre-2-2 +++ b/ChangeLog.pre-2-2 @@ -1,3 +1,39 @@ +2000-03-17 Sebastian Wilhelmi + + * configure.in: Added the missing POSIX_NO_YIELD and + POSIX_NO_PRIORITIES warning messages. + + * configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for + real thread support. On solaris pthread_create can be linked to + even in -lc, but it doesn't work then. + + * configure.in: Don't use priorities for threads, when the + minimal/maximal priorities couldn't be determined at configure + time. + + * configure.in, gthread.c: Always define GSystemThread in + glibconfig.h to represent a system thread. + + * configure.in: Do not use native recursive threads, when + possibe. We use some features, that they do not expose (namely the + depth counter). + + * glib.h, gthread.c: Redefined GStaticRecMutex. The functions are + now implemented in a different way, which should be way + faster. Alsothere are now functions g_static_rec_mutex_unlock_full + and g_static_rec_mutex_lock_full to leave/enter a recursive mutex + completly. + + * gthread.c (g_thread_self): Do not test the system_thread to be + non-zero to speed things up. + + * gthread.c (g_mutex_init): Therefore set the system_thread of the + main thread here. + + * tests/thread-test.c: Rerun all tests once again, but this time + we fool the system into thinking, that the available thread system + is not native, but userprovided. + 2000-03-13 Sebastian Wilhelmi * gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4 index 21408275..c998e48d 100644 --- a/ChangeLog.pre-2-4 +++ b/ChangeLog.pre-2-4 @@ -1,3 +1,39 @@ +2000-03-17 Sebastian Wilhelmi + + * configure.in: Added the missing POSIX_NO_YIELD and + POSIX_NO_PRIORITIES warning messages. + + * configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for + real thread support. On solaris pthread_create can be linked to + even in -lc, but it doesn't work then. + + * configure.in: Don't use priorities for threads, when the + minimal/maximal priorities couldn't be determined at configure + time. + + * configure.in, gthread.c: Always define GSystemThread in + glibconfig.h to represent a system thread. + + * configure.in: Do not use native recursive threads, when + possibe. We use some features, that they do not expose (namely the + depth counter). + + * glib.h, gthread.c: Redefined GStaticRecMutex. The functions are + now implemented in a different way, which should be way + faster. Alsothere are now functions g_static_rec_mutex_unlock_full + and g_static_rec_mutex_lock_full to leave/enter a recursive mutex + completly. + + * gthread.c (g_thread_self): Do not test the system_thread to be + non-zero to speed things up. + + * gthread.c (g_mutex_init): Therefore set the system_thread of the + main thread here. + + * tests/thread-test.c: Rerun all tests once again, but this time + we fool the system into thinking, that the available thread system + is not native, but userprovided. + 2000-03-13 Sebastian Wilhelmi * gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6 index 21408275..c998e48d 100644 --- a/ChangeLog.pre-2-6 +++ b/ChangeLog.pre-2-6 @@ -1,3 +1,39 @@ +2000-03-17 Sebastian Wilhelmi + + * configure.in: Added the missing POSIX_NO_YIELD and + POSIX_NO_PRIORITIES warning messages. + + * configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for + real thread support. On solaris pthread_create can be linked to + even in -lc, but it doesn't work then. + + * configure.in: Don't use priorities for threads, when the + minimal/maximal priorities couldn't be determined at configure + time. + + * configure.in, gthread.c: Always define GSystemThread in + glibconfig.h to represent a system thread. + + * configure.in: Do not use native recursive threads, when + possibe. We use some features, that they do not expose (namely the + depth counter). + + * glib.h, gthread.c: Redefined GStaticRecMutex. The functions are + now implemented in a different way, which should be way + faster. Alsothere are now functions g_static_rec_mutex_unlock_full + and g_static_rec_mutex_lock_full to leave/enter a recursive mutex + completly. + + * gthread.c (g_thread_self): Do not test the system_thread to be + non-zero to speed things up. + + * gthread.c (g_mutex_init): Therefore set the system_thread of the + main thread here. + + * tests/thread-test.c: Rerun all tests once again, but this time + we fool the system into thinking, that the available thread system + is not native, but userprovided. + 2000-03-13 Sebastian Wilhelmi * gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8 index 21408275..c998e48d 100644 --- a/ChangeLog.pre-2-8 +++ b/ChangeLog.pre-2-8 @@ -1,3 +1,39 @@ +2000-03-17 Sebastian Wilhelmi + + * configure.in: Added the missing POSIX_NO_YIELD and + POSIX_NO_PRIORITIES warning messages. + + * configure.in: Use AC_TRY_RUN instead of AC_TRY_LINK, to test for + real thread support. On solaris pthread_create can be linked to + even in -lc, but it doesn't work then. + + * configure.in: Don't use priorities for threads, when the + minimal/maximal priorities couldn't be determined at configure + time. + + * configure.in, gthread.c: Always define GSystemThread in + glibconfig.h to represent a system thread. + + * configure.in: Do not use native recursive threads, when + possibe. We use some features, that they do not expose (namely the + depth counter). + + * glib.h, gthread.c: Redefined GStaticRecMutex. The functions are + now implemented in a different way, which should be way + faster. Alsothere are now functions g_static_rec_mutex_unlock_full + and g_static_rec_mutex_lock_full to leave/enter a recursive mutex + completly. + + * gthread.c (g_thread_self): Do not test the system_thread to be + non-zero to speed things up. + + * gthread.c (g_mutex_init): Therefore set the system_thread of the + main thread here. + + * tests/thread-test.c: Rerun all tests once again, but this time + we fool the system into thinking, that the available thread system + is not native, but userprovided. + 2000-03-13 Sebastian Wilhelmi * gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We diff --git a/configure.in b/configure.in index 11f2f50e..ebc5669a 100644 --- a/configure.in +++ b/configure.in @@ -648,7 +648,7 @@ dnl ************************* THREAD_NO_IMPLEMENTATION="You do not have any known thread system on your computer. GLib will not have a default thread implementation." -FLAG_DOES_NOT_WORK="I can't find the MACRO, that enables thread safety on your +FLAG_DOES_NOT_WORK="I can't find the MACRO to enable thread safety on your platform (normaly it's "_REENTRANT"). I'll not use any flag on compilation now, but then your programs might not work. Please provide information on how it is done on your system." @@ -668,6 +668,17 @@ FUNC_NO_GETPWUID_R="the 'g_get_(user_name|real_name|home_dir|tmp_dir)' FUNC_NO_LOCALTIME_R="the 'g_date_set_time' function will not be MT-safe because there is no 'localtime_r' on your system." +POSIX_NO_YIELD="I can not find a yield functions for your platform. A rather + crude surrogate will be used. If you happen to know a + yield function for your system, please inform the GLib + developers." + +POSIX_NO_PRIORITIES="I can not find the minimal and maximal priorities for + threads on your system. Thus threads can only have the default + priority. If you happen to know these main/max + priorities, please inform the GLib developers." + + dnl determination of thread implementation dnl *************************************** @@ -682,7 +693,7 @@ fi if test "x$want_threads" = xyes || test "x$want_threads" = xposix \ || test "x$want_threads" = xdce; then # -D_POSIX4A_DRAFT10_SOURCE is for DG/UX - # -U_OSF_SOURCE if for Digital UNIX 4.0d + # -U_OSF_SOURCE is for Digital UNIX 4.0d GTHREAD_COMPILE_IMPL_DEFINES="-D_POSIX4A_DRAFT10_SOURCE -U_OSF_SOURCE" glib_save_CPPFLAGS="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES" @@ -731,12 +742,22 @@ case $have_threads in add_thread_lib="-l$thread_lib" IN=" in -l$thread_lib" fi + if test x"$have_threads" = xposix; then + defattr=NULL + else + defattr=pthread_attr_default + fi LIBS="$glib_save_LIBS $add_thread_lib" AC_MSG_CHECKING(for pthread_join$IN) - AC_TRY_LINK([#include ], - [pthread_t t; pthread_join(t,NULL)], + AC_TRY_RUN([#include + void* func(void* data) {} + main() + { pthread_t t; + exit(pthread_create (&t, $defattr, func, + NULL)); + }], [AC_MSG_RESULT(yes) G_THREAD_LIBS="$add_thread_lib" break], @@ -874,6 +895,8 @@ if test x"$enable_threads" = xyes; then fi LIBS="$LIBS $G_THREAD_LIBS" if test x"$have_threads" = xposix; then + glib_save_CPPFLAGS="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES" GLIB_SIZEOF([#include ], pthread_t, system_thread) @@ -917,13 +940,13 @@ if test x"$enable_threads" = xyes; then if test x"$posix_priority_min" = xnone; then AC_MSG_RESULT(none found) AC_MSG_WARN($POSIX_NO_PRIORITIES) - posix_priority_min=1 - posix_priority_max=1 + posix_priority_min=-1 + posix_priority_max=-1 else AC_MSG_RESULT($posix_priority_min/$posix_priority_max) + AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min) + AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max) fi - AC_DEFINE_UNQUOTED(POSIX_MIN_PRIORITY,$posix_priority_min) - AC_DEFINE_UNQUOTED(POSIX_MAX_PRIORITY,$posix_priority_max) posix_yield_func=none AC_MSG_CHECKING(for posix yield function) for yield_func in pthread_yield_np pthread_yield sched_yield \ @@ -942,10 +965,11 @@ if test x"$enable_threads" = xyes; then posix_yield_func="$posix_yield_func()" fi AC_DEFINE_UNQUOTED(POSIX_YIELD_FUNC,$posix_yield_func) - else - # for now, the only other implementation is solaris - # -> there 4 bytes are enough - AC_DEFINE_UNQUOTED(GLIB_SIZEOF_SYSTEM_THREAD, 4) + CPPFLAGS="$glib_save_CPPFLAGS" + else # solaris threads + GLIB_SIZEOF([#include ], + thread_t, + system_thread) fi LIBS="$glib_save_LIBS" @@ -958,7 +982,11 @@ if test x"$enable_threads" = xyes; then if test "$ac_cv_func_localtime_r" != "yes"; then AC_MSG_WARN($FUNC_NO_LOCALTIME_R) fi -fi +else + # If no thread implementation exists, we will provide enough + # space for a pointer + GLIB_SIZEOF(, void*, system_thread) +fi AC_DEFINE_UNQUOTED(G_THREAD_SOURCE,"gthread-$have_threads.c") AC_SUBST(G_THREAD_CFLAGS) @@ -974,6 +1002,10 @@ dnl dnl if mutex_has_default = yes, we also got dnl mutex_default_type, mutex_default_init and mutex_header_file GLIB_IF_VAR_EQ(mutex_has_default, yes, + glib_save_CPPFLAGS="$CPPFLAGS" + glib_save_LIBS="$LIBS" + LIBS="$LIBS $G_THREAD_LIBS" + CPPFLAGS="$CPPFLAGS $GTHREAD_COMPILE_IMPL_DEFINES" GLIB_SIZEOF([#include <$mutex_header_file>], $mutex_default_type, gmutex, @@ -986,14 +1018,8 @@ GLIB_IF_VAR_EQ(mutex_has_default, yes, if test x"$glib_cv_byte_contents_gmutex" = xno; then mutex_has_default=no fi - if test x"$have_threads" = xposix; then - GLIB_BYTE_CONTENTS([#define __USE_GNU -#include <$mutex_header_file>], - $mutex_default_type, - grecmutex, - $glib_cv_sizeof_gmutex, - PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) - fi + CPPFLAGS="$glib_save_CPPFLAGS" + LIBS="$glib_save_LIBS" , ) @@ -1184,32 +1210,21 @@ typedef struct _GMutex* GStaticMutex; #define g_static_mutex_get_mutex(mutex) (g_static_mutex_get_mutex_impl (mutex)) _______EOF fi - if test x$g_recmutex_contents != xno -a \ - x$g_recmutex_contents != x; then - # the definition of GStaticRecMutex is not done via - # typedef GStaticMutex GStaticRecMutex to avoid silent - # compilation, when a GStaticRecMutex is used where a - # GStaticMutex should have been used and vice versa, - # because that might fail on other platforms. - cat >>$outfile <<_______EOF -typedef struct _GStaticRecMutex GStaticRecMutex; -struct _GStaticRecMutex + + cat >>$outfile <<_______EOF +/* This represents a system thread as used by the implementation. An + * alien implementaion, as loaded by g_thread_init can only count on + * "sizeof (gpointer)" bytes to store their info. We however need more + * for some of our native implementations. */ +typedef union _GSystemThread GSystemThread; +union _GSystemThread { - struct _GMutex *runtime_mutex; - union { - char pad[$g_mutex_sizeof]; - double dummy_double; - void *dummy_pointer; - long dummy_long; - } aligned_pad_u; + char data[$g_system_thread_sizeof]; + double dummy_double; + void *dummy_pointer; + long dummy_long; }; -#define G_STATIC_REC_MUTEX_INIT { NULL, { { $g_recmutex_contents} } } -#define g_static_rec_mutex_lock(mutex) g_static_mutex_lock (mutex) -#define g_static_rec_mutex_trylock(mutex) g_static_mutex_trylock (mutex) -#define g_static_rec_mutex_unlock(mutex) g_static_mutex_unlock (mutex) -#define g_static_rec_mutex_get_mutex(mutex) (mutex) _______EOF - fi echo >>$outfile g_bit_sizes="16 32" @@ -1456,8 +1471,8 @@ g_threads_impl_def=$g_threads_impl g_mutex_has_default="$mutex_has_default" g_mutex_sizeof="$glib_cv_sizeof_gmutex" +g_system_thread_sizeof="$glib_cv_sizeof_system_thread" g_mutex_contents="$glib_cv_byte_contents_gmutex" -g_recmutex_contents="$glib_cv_byte_contents_grecmutex" case $host in *-*-beos*) diff --git a/glib.h b/glib.h index 07145348..e4e6a639 100644 --- a/glib.h +++ b/glib.h @@ -1,3 +1,4 @@ + /* GLIB - Library of useful routines for C programming * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * @@ -3062,24 +3063,22 @@ void g_static_private_set_for_thread (GStaticPrivate *private_key, GThread *thread, gpointer data, GDestroyNotify notify); -#ifndef G_STATIC_REC_MUTEX_INIT -/* if GStaticRecMutex is not just a differently initialized GStaticMutex, - * the following is done: - * This can't be done in glibconfig.h, as GStaticPrivate and gboolean - * are not yet known there - */ + typedef struct _GStaticRecMutex GStaticRecMutex; struct _GStaticRecMutex { GStaticMutex mutex; - GStaticPrivate counter; + unsigned int depth; + GSystemThread owner; }; -#define G_STATIC_REC_MUTEX_INIT { G_STATIC_MUTEX_INIT, G_STATIC_PRIVATE_INIT } -void g_static_rec_mutex_lock (GStaticRecMutex* mutex); -gboolean g_static_rec_mutex_trylock (GStaticRecMutex* mutex); -void g_static_rec_mutex_unlock (GStaticRecMutex* mutex); -#define g_static_rec_mutex_get_mutex(mutex) ((mutex)->mutex) -#endif /* G_STATIC_REC_MUTEX_INIT */ + +#define G_STATIC_REC_MUTEX_INIT { G_STATIC_MUTEX_INIT } +void g_static_rec_mutex_lock (GStaticRecMutex *mutex); +gboolean g_static_rec_mutex_trylock (GStaticRecMutex *mutex); +void g_static_rec_mutex_unlock (GStaticRecMutex *mutex); +void g_static_rec_mutex_lock_full (GStaticRecMutex *mutex, + guint depth); +guint g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex); typedef struct _GStaticRWLock GStaticRWLock; struct _GStaticRWLock diff --git a/glib/glib.h b/glib/glib.h index 07145348..e4e6a639 100644 --- a/glib/glib.h +++ b/glib/glib.h @@ -1,3 +1,4 @@ + /* GLIB - Library of useful routines for C programming * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * @@ -3062,24 +3063,22 @@ void g_static_private_set_for_thread (GStaticPrivate *private_key, GThread *thread, gpointer data, GDestroyNotify notify); -#ifndef G_STATIC_REC_MUTEX_INIT -/* if GStaticRecMutex is not just a differently initialized GStaticMutex, - * the following is done: - * This can't be done in glibconfig.h, as GStaticPrivate and gboolean - * are not yet known there - */ + typedef struct _GStaticRecMutex GStaticRecMutex; struct _GStaticRecMutex { GStaticMutex mutex; - GStaticPrivate counter; + unsigned int depth; + GSystemThread owner; }; -#define G_STATIC_REC_MUTEX_INIT { G_STATIC_MUTEX_INIT, G_STATIC_PRIVATE_INIT } -void g_static_rec_mutex_lock (GStaticRecMutex* mutex); -gboolean g_static_rec_mutex_trylock (GStaticRecMutex* mutex); -void g_static_rec_mutex_unlock (GStaticRecMutex* mutex); -#define g_static_rec_mutex_get_mutex(mutex) ((mutex)->mutex) -#endif /* G_STATIC_REC_MUTEX_INIT */ + +#define G_STATIC_REC_MUTEX_INIT { G_STATIC_MUTEX_INIT } +void g_static_rec_mutex_lock (GStaticRecMutex *mutex); +gboolean g_static_rec_mutex_trylock (GStaticRecMutex *mutex); +void g_static_rec_mutex_unlock (GStaticRecMutex *mutex); +void g_static_rec_mutex_lock_full (GStaticRecMutex *mutex, + guint depth); +guint g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex); typedef struct _GStaticRWLock GStaticRWLock; struct _GStaticRWLock diff --git a/glib/gthread.c b/glib/gthread.c index bf539f1e..954edfed 100644 --- a/glib/gthread.c +++ b/glib/gthread.c @@ -39,62 +39,29 @@ #include #endif -typedef union _SystemThread SystemThread; - -/* This represents a system thread as used by the implementation. An - * alien implementaion, as loaded by g_thread_init can only count on - * "sizeof (gpointer)" bytes to store their info. We however need more - * for some of our native implementations. */ -union _SystemThread -{ - guchar data[GLIB_SIZEOF_SYSTEM_THREAD]; - gdouble double_dummy; /* These are used for the right alignment */ - gpointer pointer_dummy; -#ifdef G_HAVE_GINT64 - guint64 long_dummy; -#else - guint32 long_dummy; -#endif -}; +#if GLIB_SIZEOF_SYSTEM_THREAD == SIZEOF_VOID_P +# define g_system_thread_equal(thread1, thread2) \ + (thread1.dummy_pointer == thread2.dummy_pointer) +# define g_system_thread_assign(dest, src) \ + (dest.dummy_pointer = src.dummy_pointer) +#else /* GLIB_SIZEOF_SYSTEM_THREAD != SIZEOF_VOID_P */ +# define g_system_thread_equal(thread1, thread2) \ + (memcmp (&thread1, &thread2, GLIB_SIZEOF_SYSTEM_THREAD) == 0) +# define g_system_thread_assign(dest, src) \ + (memcpy (&dest, &src, GLIB_SIZEOF_SYSTEM_THREAD)) +#endif /* GLIB_SIZEOF_SYSTEM_THREAD == SIZEOF_VOID_P */ typedef struct _GRealThread GRealThread; - struct _GRealThread { GThread thread; GThreadFunc func; gpointer arg; gpointer private_data; - SystemThread system_thread; + GSystemThread system_thread; }; -#if (GLIB_SIZEOF_SYSTEM_THREAD <= 8 && defined(G_HAVE_GINT64)) \ - || (GLIB_SIZEOF_SYSTEM_THREAD <= 4) -/* We can use fast setting and checks */ -# define set_system_thread_to_zero(t) (t->system_thread.long_dummy=0) -# define system_thread_is_not_zero(t) (t->system_thread.long_dummy) -#else -/* We have to do it the hard way and hope the compiler will optimize a bit */ -static inline void -set_system_thread_to_zero(GRealThread* thread) -{ - int i; - for (i = 0; i < GLIB_SIZEOF_SYSTEM_THREAD; i++) - thread->system_thread.data[i] = 0; -} - -static inline gboolean -system_thread_is_not_zero(GRealThread* thread) -{ - int i; - for (i = 0; i < GLIB_SIZEOF_SYSTEM_THREAD; i++) - if (thread->system_thread.data[i]) return FALSE; - return TRUE; -} -#endif - typedef struct _GStaticPrivateNode GStaticPrivateNode; - struct _GStaticPrivateNode { gpointer data; @@ -106,6 +73,7 @@ static void g_thread_fail (void); /* Global variables */ +static GSystemThread zero_thread; /* This is initialized to all zero */ gboolean g_thread_use_default_impl = TRUE; gboolean g_threads_got_initialized = FALSE; @@ -149,24 +117,19 @@ static GPrivate *g_thread_specific_private = NULL; void g_mutex_init (void) { - gpointer private_old; + GRealThread* main_thread; /* We let the main thread (the one that calls g_thread_init) inherit * the data, that it set before calling g_thread_init */ - private_old = g_thread_specific_private; + main_thread = (GRealThread*) g_thread_self (); g_thread_specific_private = g_private_new (g_thread_cleanup); - - /* we can not use g_private_set here, as g_threads_got_initialized is not - * yet set TRUE, whereas the private_set function is already set. - */ - g_thread_functions_for_glib_use.private_set (g_thread_specific_private, - private_old); + G_THREAD_UF (private_set, (g_thread_specific_private, main_thread)); + G_THREAD_UF (thread_self, (&main_thread->system_thread)); g_mutex_protect_static_mutex_allocation = g_mutex_new(); g_thread_specific_mutex = g_mutex_new(); - } GMutex * @@ -187,47 +150,87 @@ g_static_mutex_get_mutex_impl (GMutex** mutex) return *mutex; } -#ifndef g_static_rec_mutex_lock -/* That means, that g_static_rec_mutex_lock is not defined to be - * g_static_mutex_lock, we have to provide an implementation ourselves. - */ void g_static_rec_mutex_lock (GStaticRecMutex* mutex) { - guint counter = GPOINTER_TO_UINT (g_static_private_get (&mutex->counter)); - if (counter == 0) + GSystemThread self; + + g_return_if_fail (mutex); + + G_THREAD_UF (thread_self, (&self)); + + if (g_system_thread_equal (self, mutex->owner)) { - g_static_mutex_lock (&mutex->mutex); + mutex->depth++; + return; } - counter++; - g_static_private_set (&mutex->counter, GUINT_TO_POINTER (counter), NULL); + g_static_mutex_lock (&mutex->mutex); + g_system_thread_assign (mutex->owner, self); + mutex->depth = 1; } gboolean g_static_rec_mutex_trylock (GStaticRecMutex* mutex) { - guint counter = GPOINTER_TO_UINT (g_static_private_get (&mutex->counter)); - if (counter == 0) + GSystemThread self; + + g_return_val_if_fail (mutex, FALSE); + + G_THREAD_UF (thread_self, (&self)); + + if (g_system_thread_equal (self, mutex->owner)) { - if (!g_static_mutex_trylock (&mutex->mutex)) return FALSE; + mutex->depth++; + return TRUE; } - counter++; - g_static_private_set (&mutex->counter, GUINT_TO_POINTER (counter), NULL); + + if (!g_static_mutex_trylock (&mutex->mutex)) + return FALSE; + + g_system_thread_assign (mutex->owner, self); + mutex->depth = 1; return TRUE; } void g_static_rec_mutex_unlock (GStaticRecMutex* mutex) { - guint counter = GPOINTER_TO_UINT (g_static_private_get (&mutex->counter)); - if (counter == 1) + g_return_if_fail (mutex); + + if (mutex->depth > 1) { - g_static_mutex_unlock (&mutex->mutex); + mutex->depth--; + return; } - counter--; - g_static_private_set (&mutex->counter, GUINT_TO_POINTER (counter), NULL); + g_system_thread_assign (mutex->owner, zero_thread); + g_static_mutex_unlock (&mutex->mutex); +} + +void +g_static_rec_mutex_lock_full (GStaticRecMutex *mutex, + guint depth) +{ + g_return_if_fail (mutex); + + g_static_mutex_lock (&mutex->mutex); + G_THREAD_UF (thread_self, (&mutex->owner)); + mutex->depth = depth; +} + +guint +g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex) +{ + gint depth = mutex->depth; + + g_return_val_if_fail (mutex, 0); + + g_system_thread_assign (mutex->owner, zero_thread); + mutex->depth = 0; + g_static_mutex_unlock (&mutex->mutex); + + return depth; } -#endif /* g_static_rec_mutex_lock */ + gpointer g_static_private_get (GStaticPrivate *private_key) @@ -341,7 +344,7 @@ g_thread_cleanup (gpointer data) if (!thread->thread.joinable) { /* Just to make sure, this isn't used any more */ - set_system_thread_to_zero(thread); + g_system_thread_assign (thread->system_thread, zero_thread); g_free (thread); } } @@ -380,7 +383,7 @@ g_thread_create (GThreadFunc thread_func, gboolean bound, GThreadPriority priority) { - GRealThread* result = g_new0 (GRealThread,1); + GRealThread* result = g_new (GRealThread, 1); g_return_val_if_fail (thread_func, NULL); @@ -389,6 +392,7 @@ g_thread_create (GThreadFunc thread_func, result->thread.priority = priority; result->func = thread_func; result->arg = arg; + result->private_data = NULL; G_LOCK (g_thread_create); G_THREAD_UF (thread_create, (g_thread_create_proxy, result, stack_size, joinable, bound, priority, @@ -405,13 +409,13 @@ g_thread_join (GThread* thread) g_return_if_fail (thread); g_return_if_fail (thread->joinable); - g_return_if_fail (system_thread_is_not_zero (real)); + g_return_if_fail (!g_system_thread_equal (real->system_thread, zero_thread)); G_THREAD_UF (thread_join, (&real->system_thread)); /* Just to make sure, this isn't used any more */ thread->joinable = 0; - set_system_thread_to_zero (real); + g_system_thread_assign (real->system_thread, zero_thread); /* the thread structure for non-joinable threads is freed upon thread end. We free the memory here. This will leave loose end, @@ -427,7 +431,7 @@ g_thread_set_priority (GThread* thread, GRealThread* real = (GRealThread*) thread; g_return_if_fail (thread); - g_return_if_fail (system_thread_is_not_zero (real)); + g_return_if_fail (!g_system_thread_equal (real->system_thread, zero_thread)); thread->priority = priority; G_THREAD_CF (thread_set_priority, (void)0, (&real->system_thread, priority)); @@ -442,24 +446,22 @@ g_thread_self() { /* If no thread data is available, provide and set one. This can happen for the main thread and for threads, that are not - created by glib. */ - thread = g_new (GRealThread,1); + created by GLib. */ + thread = g_new (GRealThread, 1); thread->thread.joinable = FALSE; /* This is a save guess */ thread->thread.bound = TRUE; /* This isn't important at all */ thread->thread.priority = G_THREAD_PRIORITY_NORMAL; /* This is just a guess */ thread->func = NULL; thread->arg = NULL; - set_system_thread_to_zero (thread); thread->private_data = NULL; + + if (g_thread_supported ()) + G_THREAD_UF (thread_self, (&thread->system_thread)); + g_private_set (g_thread_specific_private, thread); } - - if (g_thread_supported () && !system_thread_is_not_zero(thread)) - { - g_thread_functions_for_glib_use.thread_self(&thread->system_thread); - } - + return (GThread*)thread; } diff --git a/gthread.c b/gthread.c index bf539f1e..954edfed 100644 --- a/gthread.c +++ b/gthread.c @@ -39,62 +39,29 @@ #include #endif -typedef union _SystemThread SystemThread; - -/* This represents a system thread as used by the implementation. An - * alien implementaion, as loaded by g_thread_init can only count on - * "sizeof (gpointer)" bytes to store their info. We however need more - * for some of our native implementations. */ -union _SystemThread -{ - guchar data[GLIB_SIZEOF_SYSTEM_THREAD]; - gdouble double_dummy; /* These are used for the right alignment */ - gpointer pointer_dummy; -#ifdef G_HAVE_GINT64 - guint64 long_dummy; -#else - guint32 long_dummy; -#endif -}; +#if GLIB_SIZEOF_SYSTEM_THREAD == SIZEOF_VOID_P +# define g_system_thread_equal(thread1, thread2) \ + (thread1.dummy_pointer == thread2.dummy_pointer) +# define g_system_thread_assign(dest, src) \ + (dest.dummy_pointer = src.dummy_pointer) +#else /* GLIB_SIZEOF_SYSTEM_THREAD != SIZEOF_VOID_P */ +# define g_system_thread_equal(thread1, thread2) \ + (memcmp (&thread1, &thread2, GLIB_SIZEOF_SYSTEM_THREAD) == 0) +# define g_system_thread_assign(dest, src) \ + (memcpy (&dest, &src, GLIB_SIZEOF_SYSTEM_THREAD)) +#endif /* GLIB_SIZEOF_SYSTEM_THREAD == SIZEOF_VOID_P */ typedef struct _GRealThread GRealThread; - struct _GRealThread { GThread thread; GThreadFunc func; gpointer arg; gpointer private_data; - SystemThread system_thread; + GSystemThread system_thread; }; -#if (GLIB_SIZEOF_SYSTEM_THREAD <= 8 && defined(G_HAVE_GINT64)) \ - || (GLIB_SIZEOF_SYSTEM_THREAD <= 4) -/* We can use fast setting and checks */ -# define set_system_thread_to_zero(t) (t->system_thread.long_dummy=0) -# define system_thread_is_not_zero(t) (t->system_thread.long_dummy) -#else -/* We have to do it the hard way and hope the compiler will optimize a bit */ -static inline void -set_system_thread_to_zero(GRealThread* thread) -{ - int i; - for (i = 0; i < GLIB_SIZEOF_SYSTEM_THREAD; i++) - thread->system_thread.data[i] = 0; -} - -static inline gboolean -system_thread_is_not_zero(GRealThread* thread) -{ - int i; - for (i = 0; i < GLIB_SIZEOF_SYSTEM_THREAD; i++) - if (thread->system_thread.data[i]) return FALSE; - return TRUE; -} -#endif - typedef struct _GStaticPrivateNode GStaticPrivateNode; - struct _GStaticPrivateNode { gpointer data; @@ -106,6 +73,7 @@ static void g_thread_fail (void); /* Global variables */ +static GSystemThread zero_thread; /* This is initialized to all zero */ gboolean g_thread_use_default_impl = TRUE; gboolean g_threads_got_initialized = FALSE; @@ -149,24 +117,19 @@ static GPrivate *g_thread_specific_private = NULL; void g_mutex_init (void) { - gpointer private_old; + GRealThread* main_thread; /* We let the main thread (the one that calls g_thread_init) inherit * the data, that it set before calling g_thread_init */ - private_old = g_thread_specific_private; + main_thread = (GRealThread*) g_thread_self (); g_thread_specific_private = g_private_new (g_thread_cleanup); - - /* we can not use g_private_set here, as g_threads_got_initialized is not - * yet set TRUE, whereas the private_set function is already set. - */ - g_thread_functions_for_glib_use.private_set (g_thread_specific_private, - private_old); + G_THREAD_UF (private_set, (g_thread_specific_private, main_thread)); + G_THREAD_UF (thread_self, (&main_thread->system_thread)); g_mutex_protect_static_mutex_allocation = g_mutex_new(); g_thread_specific_mutex = g_mutex_new(); - } GMutex * @@ -187,47 +150,87 @@ g_static_mutex_get_mutex_impl (GMutex** mutex) return *mutex; } -#ifndef g_static_rec_mutex_lock -/* That means, that g_static_rec_mutex_lock is not defined to be - * g_static_mutex_lock, we have to provide an implementation ourselves. - */ void g_static_rec_mutex_lock (GStaticRecMutex* mutex) { - guint counter = GPOINTER_TO_UINT (g_static_private_get (&mutex->counter)); - if (counter == 0) + GSystemThread self; + + g_return_if_fail (mutex); + + G_THREAD_UF (thread_self, (&self)); + + if (g_system_thread_equal (self, mutex->owner)) { - g_static_mutex_lock (&mutex->mutex); + mutex->depth++; + return; } - counter++; - g_static_private_set (&mutex->counter, GUINT_TO_POINTER (counter), NULL); + g_static_mutex_lock (&mutex->mutex); + g_system_thread_assign (mutex->owner, self); + mutex->depth = 1; } gboolean g_static_rec_mutex_trylock (GStaticRecMutex* mutex) { - guint counter = GPOINTER_TO_UINT (g_static_private_get (&mutex->counter)); - if (counter == 0) + GSystemThread self; + + g_return_val_if_fail (mutex, FALSE); + + G_THREAD_UF (thread_self, (&self)); + + if (g_system_thread_equal (self, mutex->owner)) { - if (!g_static_mutex_trylock (&mutex->mutex)) return FALSE; + mutex->depth++; + return TRUE; } - counter++; - g_static_private_set (&mutex->counter, GUINT_TO_POINTER (counter), NULL); + + if (!g_static_mutex_trylock (&mutex->mutex)) + return FALSE; + + g_system_thread_assign (mutex->owner, self); + mutex->depth = 1; return TRUE; } void g_static_rec_mutex_unlock (GStaticRecMutex* mutex) { - guint counter = GPOINTER_TO_UINT (g_static_private_get (&mutex->counter)); - if (counter == 1) + g_return_if_fail (mutex); + + if (mutex->depth > 1) { - g_static_mutex_unlock (&mutex->mutex); + mutex->depth--; + return; } - counter--; - g_static_private_set (&mutex->counter, GUINT_TO_POINTER (counter), NULL); + g_system_thread_assign (mutex->owner, zero_thread); + g_static_mutex_unlock (&mutex->mutex); +} + +void +g_static_rec_mutex_lock_full (GStaticRecMutex *mutex, + guint depth) +{ + g_return_if_fail (mutex); + + g_static_mutex_lock (&mutex->mutex); + G_THREAD_UF (thread_self, (&mutex->owner)); + mutex->depth = depth; +} + +guint +g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex) +{ + gint depth = mutex->depth; + + g_return_val_if_fail (mutex, 0); + + g_system_thread_assign (mutex->owner, zero_thread); + mutex->depth = 0; + g_static_mutex_unlock (&mutex->mutex); + + return depth; } -#endif /* g_static_rec_mutex_lock */ + gpointer g_static_private_get (GStaticPrivate *private_key) @@ -341,7 +344,7 @@ g_thread_cleanup (gpointer data) if (!thread->thread.joinable) { /* Just to make sure, this isn't used any more */ - set_system_thread_to_zero(thread); + g_system_thread_assign (thread->system_thread, zero_thread); g_free (thread); } } @@ -380,7 +383,7 @@ g_thread_create (GThreadFunc thread_func, gboolean bound, GThreadPriority priority) { - GRealThread* result = g_new0 (GRealThread,1); + GRealThread* result = g_new (GRealThread, 1); g_return_val_if_fail (thread_func, NULL); @@ -389,6 +392,7 @@ g_thread_create (GThreadFunc thread_func, result->thread.priority = priority; result->func = thread_func; result->arg = arg; + result->private_data = NULL; G_LOCK (g_thread_create); G_THREAD_UF (thread_create, (g_thread_create_proxy, result, stack_size, joinable, bound, priority, @@ -405,13 +409,13 @@ g_thread_join (GThread* thread) g_return_if_fail (thread); g_return_if_fail (thread->joinable); - g_return_if_fail (system_thread_is_not_zero (real)); + g_return_if_fail (!g_system_thread_equal (real->system_thread, zero_thread)); G_THREAD_UF (thread_join, (&real->system_thread)); /* Just to make sure, this isn't used any more */ thread->joinable = 0; - set_system_thread_to_zero (real); + g_system_thread_assign (real->system_thread, zero_thread); /* the thread structure for non-joinable threads is freed upon thread end. We free the memory here. This will leave loose end, @@ -427,7 +431,7 @@ g_thread_set_priority (GThread* thread, GRealThread* real = (GRealThread*) thread; g_return_if_fail (thread); - g_return_if_fail (system_thread_is_not_zero (real)); + g_return_if_fail (!g_system_thread_equal (real->system_thread, zero_thread)); thread->priority = priority; G_THREAD_CF (thread_set_priority, (void)0, (&real->system_thread, priority)); @@ -442,24 +446,22 @@ g_thread_self() { /* If no thread data is available, provide and set one. This can happen for the main thread and for threads, that are not - created by glib. */ - thread = g_new (GRealThread,1); + created by GLib. */ + thread = g_new (GRealThread, 1); thread->thread.joinable = FALSE; /* This is a save guess */ thread->thread.bound = TRUE; /* This isn't important at all */ thread->thread.priority = G_THREAD_PRIORITY_NORMAL; /* This is just a guess */ thread->func = NULL; thread->arg = NULL; - set_system_thread_to_zero (thread); thread->private_data = NULL; + + if (g_thread_supported ()) + G_THREAD_UF (thread_self, (&thread->system_thread)); + g_private_set (g_thread_specific_private, thread); } - - if (g_thread_supported () && !system_thread_is_not_zero(thread)) - { - g_thread_functions_for_glib_use.thread_self(&thread->system_thread); - } - + return (GThread*)thread; } diff --git a/gthread/ChangeLog b/gthread/ChangeLog index 1a6740d5..42038ba6 100644 --- a/gthread/ChangeLog +++ b/gthread/ChangeLog @@ -1,3 +1,13 @@ +2000-03-17 Sebastian Wilhelmi + + * gthread-posix.c: Don't use priorities for threads, when the + minimal/maximal priorities couldn't be determined at configure + time. + + * gthread-posix.c: Don't check for errors, when setting the scope + of a tread to system, as some posix implementations can't do that + and we don't want the thing to fail because of that. + 2000-02-22 Sebastian Wilhelmi * gthread-posix.c, gthread-solaris.c: check for sysconf diff --git a/gthread/gthread-posix.c b/gthread/gthread-posix.c index e68ebbf6..aeaac461 100644 --- a/gthread/gthread-posix.c +++ b/gthread/gthread-posix.c @@ -41,21 +41,21 @@ #include #endif -#define posix_print_error( name, num ) \ - g_error( "file %s: line %d (%s): error %s during %s", \ - __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \ +#define posix_print_error( name, num ) \ + g_error( "file %s: line %d (%s): error %s during %s", \ + __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \ g_strerror((num)), #name ) #if defined(G_THREADS_IMPL_POSIX) -# define posix_check_for_error( what ) G_STMT_START{ \ - int error = (what); \ - if( error ) { posix_print_error( what, error ); } \ +# define posix_check_for_error( what ) G_STMT_START{ \ + int error = (what); \ + if( error ) { posix_print_error( what, error ); } \ }G_STMT_END # define mutexattr_default NULL # define condattr_default NULL #elif defined(G_THREADS_IMPL_DCE) -# define posix_check_for_error( what ) G_STMT_START{ \ - if( (what) == -1 ) { posix_print_error( what, errno ); } \ +# define posix_check_for_error( what ) G_STMT_START{ \ + if( (what) == -1 ) { posix_print_error( what, errno ); \ }G_STMT_END # define pthread_key_create(a, b) pthread_keycreate (a, b) # define pthread_attr_init(a) pthread_attr_create (a) @@ -67,14 +67,20 @@ # error This should not happen. Contact the GLib team. #endif +#if defined(POSIX_MIN_PRIORITY) && defined(POSIX_MAX_PRIORITY) +# define HAVE_PRIORITIES 1 +#endif + gulong g_thread_min_stack_size = 0; #define HAVE_G_THREAD_IMPL_INIT static void g_thread_impl_init() { +#ifdef HAVE_PRIORITIES g_thread_min_priority = POSIX_MIN_PRIORITY; g_thread_max_priority = POSIX_MAX_PRIORITY; +#endif /* HAVE_PRIORITIES */ #ifdef _SC_THREAD_STACK_MIN g_thread_min_stack_size = MAX (sysconf (_SC_THREAD_STACK_MIN), 0); #endif /* _SC_THREAD_STACK_MIN */ @@ -244,8 +250,9 @@ g_thread_create_posix_impl (GThreadFunc thread_func, #ifdef PTHREAD_SCOPE_SYSTEM if (bound) - posix_check_for_error (pthread_attr_setscope (&attr, - PTHREAD_SCOPE_SYSTEM)); + /* No error check here, because some systems can't do it and we + * simply don't want threads to fail because of that. */ + pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM); #endif /* PTHREAD_SCOPE_SYSTEM */ #ifdef G_THREADS_IMPL_POSIX @@ -253,17 +260,19 @@ g_thread_create_posix_impl (GThreadFunc thread_func, joinable ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED)); #endif /* G_THREADS_IMPL_POSIX */ -#ifdef G_THREADS_IMPL_POSIX +#ifdef HAVE_PRIORITIES +# ifdef G_THREADS_IMPL_POSIX { struct sched_param sched; posix_check_for_error (pthread_attr_getschedparam (&attr, &sched)); sched.sched_priority = g_thread_map_priority (priority); posix_check_for_error (pthread_attr_setschedparam (&attr, &sched)); } -#else /* G_THREADS_IMPL_DCE */ +# else /* G_THREADS_IMPL_DCE */ posix_check_for_error (pthread_attr_setprio (&attr, g_thread_map_priority (priority))); -#endif /* G_THREADS_IMPL_DCE */ +# endif /* G_THREADS_IMPL_DCE */ +#endif /* HAVE_PRIORITIES */ posix_check_for_error (pthread_create (thread, &attr, (void* (*)(void*))thread_func, @@ -300,7 +309,8 @@ g_thread_exit_posix_impl (void) static void g_thread_set_priority_posix_impl (gpointer thread, GThreadPriority priority) { -#ifdef G_THREADS_IMPL_POSIX +#ifdef HAVE_PRIORITIES +# ifdef G_THREADS_IMPL_POSIX struct sched_param sched; int policy; posix_check_for_error (pthread_getschedparam (*(pthread_t*)thread, @@ -308,10 +318,11 @@ g_thread_set_priority_posix_impl (gpointer thread, GThreadPriority priority) sched.sched_priority = g_thread_map_priority (priority); posix_check_for_error (pthread_setschedparam (*(pthread_t*)thread, policy, &sched)); -#else /* G_THREADS_IMPL_DCE */ +# else /* G_THREADS_IMPL_DCE */ posix_check_for_error (pthread_setprio (*(pthread_t*)thread, g_thread_map_priority (priority))); -#endif +# endif +#endif /* HAVE_PRIORITIES */ } static void diff --git a/gthread/gthread-solaris.c b/gthread/gthread-solaris.c index 4de8180c..38aac1fc 100644 --- a/gthread/gthread-solaris.c +++ b/gthread/gthread-solaris.c @@ -39,14 +39,14 @@ #include #endif -#define solaris_print_error( name, num ) \ - g_error( "file %s: line %d (%s): error %s during %s", \ - __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \ +#define solaris_print_error( name, num ) \ + g_error( "file %s: line %d (%s): error %s during %s", \ + __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \ g_strerror((num)), #name ) -#define solaris_check_for_error( what ) G_STMT_START{ \ - int error = (what); \ - if( error ) { solaris_print_error( what, error ); } \ +#define solaris_check_for_error( what ) G_STMT_START{ \ + int error = (what); \ + if( error ) { solaris_print_error( what, error ); } \ }G_STMT_END gulong g_thread_min_stack_size = 0; diff --git a/tests/thread-test.c b/tests/thread-test.c index 300e55e9..2cf30f01 100644 --- a/tests/thread-test.c +++ b/tests/thread-test.c @@ -221,6 +221,15 @@ test_g_static_rw_lock () } /* run all the tests */ +void +run_all_tests() +{ + test_g_mutex (); + test_g_static_rec_mutex (); + test_g_static_private (); + test_g_static_rw_lock (); +} + int main (int argc, char *argv[]) @@ -229,10 +238,15 @@ main (int argc, implementation is available */ #if defined(G_THREADS_ENABLED) && ! defined(G_THREADS_IMPL_NONE) g_thread_init (NULL); - test_g_mutex (); - test_g_static_rec_mutex (); - test_g_static_private (); - test_g_static_rw_lock (); + run_all_tests (); + + /* Now we rerun all tests, but this time we fool the system into + * thinking, that the available thread system is not native, but + * userprovided. */ + + g_thread_use_default_impl = FALSE; + run_all_tests (); + #endif return 0; }