Commit 5e713437 authored by Sebastian Wilhelmi's avatar Sebastian Wilhelmi Committed by Sebastian Wilhelmi

Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.

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.

	* 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.
parent 3540769b
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
......
......@@ -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.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],
......@@ -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.h>],
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.h>],
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*)
......
/* 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
......
/* 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
......
......@@ -39,62 +39,29 @@
#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;
......@@ -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;