+2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
+
+ * 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 <wilhelmi@ira.uka.de>
* gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We
+2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
+
+ * 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 <wilhelmi@ira.uka.de>
* gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We
+2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
+
+ * 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 <wilhelmi@ira.uka.de>
* gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We
+2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
+
+ * 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 <wilhelmi@ira.uka.de>
* gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We
+2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
+
+ * 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 <wilhelmi@ira.uka.de>
* gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We
+2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
+
+ * 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 <wilhelmi@ira.uka.de>
* gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We
+2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
+
+ * 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 <wilhelmi@ira.uka.de>
* gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We
+2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
+
+ * 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 <wilhelmi@ira.uka.de>
* gqueue.c (g_queue_push_tail_link, g_queue_push_head_link): We
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."
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 ***************************************
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"
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.h>],
- [pthread_t t; pthread_join(t,NULL)],
+ AC_TRY_RUN([#include <pthread.h>
+ 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],
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.h>],
pthread_t,
system_thread)
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 \
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.h>],
+ thread_t,
+ system_thread)
fi
LIBS="$glib_save_LIBS"
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)
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,
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"
,
)
#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"
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*)
+
/* GLIB - Library of useful routines for C programming
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
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
+
/* GLIB - Library of useful routines for C programming
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
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
#include <unistd.h>
#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;
/* 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;
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 *
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)
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);
}
}
gboolean bound,
GThreadPriority priority)
{
- GRealThread* result = g_new0 (GRealThread,1);
+ GRealThread* result = g_new (GRealThread, 1);
g_return_val_if_fail (thread_func, NULL);
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,
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,
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));
{
/* 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;
}
#include <unistd.h>
#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;
/* 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;
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 *
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)
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);
}
}
gboolean bound,
GThreadPriority priority)
{
- GRealThread* result = g_new0 (GRealThread,1);
+ GRealThread* result = g_new (GRealThread, 1);
g_return_val_if_fail (thread_func, NULL);
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,
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,
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));
{
/* 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;
}
+2000-03-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
+
+ * 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 <wilhelmi@ira.uka.de>
* gthread-posix.c, gthread-solaris.c: check for sysconf
#include <unistd.h>
#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)
# 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 */
#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
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,
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,
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
#include <unistd.h>
#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;
}
/* 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[])
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;
}
projects / platform / upstream / glib.git / commitdiff