luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-02-20 01:02:10 +01:00
Code Issues Packages Projects Releases Wiki Activity

Added the missing POSIX_NO_YIELD and POSIX_NO_PRIORITIES warning messages.

Browse Source 
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.
This commit is contained in:
Sebastian Wilhelmi 2000-03-17 14:49:59 +00:00 committed by Sebastian Wilhelmi
parent 3540769b17
commit 5e7134375e
17 changed files with 613 additions and 273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
ChangeLog
View File

@ -1,3 +1,39 @@
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

36
ChangeLog.pre-2-0
View File

@ -1,3 +1,39 @@
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

36
ChangeLog.pre-2-10
View File

@ -1,3 +1,39 @@
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

36
ChangeLog.pre-2-12
View File

@ -1,3 +1,39 @@
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

36
ChangeLog.pre-2-2
View File

@ -1,3 +1,39 @@
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

36
ChangeLog.pre-2-4
View File

@ -1,3 +1,39 @@
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

36
ChangeLog.pre-2-6
View File

@ -1,3 +1,39 @@
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

36
ChangeLog.pre-2-8
View File

@ -1,3 +1,39 @@
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

105
configure.in
View File

@ -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*)

25
glib.h
View File

@ -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

25
glib/glib.h
View File

@ -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

178
glib/gthread.c
View File

@ -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;
}
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);
}
#endif /* g_static_rec_mutex_lock */
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;
}
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;
}

178
gthread.c
View File

@ -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;
}
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);
}
#endif /* g_static_rec_mutex_lock */
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;
}
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;
}

10
gthread/ChangeLog
View File

@ -1,3 +1,13 @@
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

43
gthread/gthread-posix.c
View File

@ -41,21 +41,21 @@
#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)
@ -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

12
gthread/gthread-solaris.c
View File

@ -39,14 +39,14 @@
#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;

22
tests/thread-test.c
View File

@ -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;
}