* Copyright 1998 Sebastian Wilhelmi; University of Karlsruhe
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
- * Modified by the GLib Team and others 1997-1999. See the AUTHORS
+ * Modified by the GLib Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GLib Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GLib at ftp://ftp.gtk.org/pub/gtk/.
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
+#ifdef HAVE_UNISTD_H
+#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 )
-#define posix_check_for_error( what ) G_STMT_START{ \
- int error = (what); \
- if( error ) { posix_print_error( what, error ); } \
- }G_STMT_END
+#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 ); } \
+ }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 ); } \
+ }G_STMT_END
+# define pthread_key_create(a, b) pthread_keycreate (a, b)
+# define pthread_attr_init(a) pthread_attr_create (a)
+# define pthread_attr_destroy(a) pthread_attr_delete (a)
+# define pthread_create(a, b, c, d) pthread_create(a, *b, c, d)
+# define mutexattr_default (pthread_mutexattr_default)
+# define condattr_default (pthread_condattr_default)
+#else /* neither G_THREADS_IMPL_POSIX nor G_THREADS_IMPL_DCE are defined */
+# 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 */
+}
static GMutex *
g_mutex_new_posix_impl (void)
{
GMutex *result = (GMutex *) g_new (pthread_mutex_t, 1);
- posix_check_for_error (pthread_mutex_init ((pthread_mutex_t *) result, NULL));
+ posix_check_for_error (pthread_mutex_init ((pthread_mutex_t *) result,
+ mutexattr_default));
return result;
}
int result;
result = pthread_mutex_trylock ((pthread_mutex_t *) mutex);
- if (result != EBUSY)
+
+#ifdef G_THREADS_IMPL_POSIX
+ if (result == EBUSY)
+ return FALSE;
+#else /* G_THREADS_IMPL_DCE */
+ if (result == 0)
return FALSE;
+#endif
posix_check_for_error (result);
return TRUE;
g_cond_new_posix_impl (void)
{
GCond *result = (GCond *) g_new (pthread_cond_t, 1);
- posix_check_for_error (pthread_cond_init ((pthread_cond_t *) result, NULL));
+ posix_check_for_error (pthread_cond_init ((pthread_cond_t *) result,
+ condattr_default));
return result;
}
result = pthread_cond_timedwait ((pthread_cond_t *) cond,
(pthread_mutex_t *) entered_mutex,
&end_time);
+
+#ifdef G_THREADS_IMPL_POSIX
timed_out = (result == ETIMEDOUT);
+#else /* G_THREADS_IMPL_DCE */
+ timed_out = (result == -1) && (errno = EAGAIN);
+#endif
+
if (!timed_out)
posix_check_for_error (result);
return !timed_out;
{
if (!private_key)
return;
-
pthread_setspecific (*(pthread_key_t *) private_key, value);
}
{
if (!private_key)
return NULL;
-#ifdef HAVE_PTHREAD_GETSPECIFIC_POSIX
+#ifdef G_THREADS_IMPL_POSIX
return pthread_getspecific (*(pthread_key_t *) private_key);
-#else /* HAVE_PTHREAD_GETSPECIFIC_POSIX */
+#else /* G_THREADS_IMPL_DCE */
{
void* data;
- pthread_getspecific (*(pthread_key_t *) private_key, &data);
+ posix_check_for_error (pthread_getspecific (*(pthread_key_t *)
+ private_key, &data));
return data;
}
-#endif /* HAVE_PTHREAD_GETSPECIFIC_POSIX */
+#endif
+}
+
+static void
+g_thread_create_posix_impl (GThreadFunc thread_func,
+ gpointer arg,
+ gulong stack_size,
+ gboolean joinable,
+ gboolean bound,
+ GThreadPriority priority,
+ gpointer thread,
+ GError **error)
+{
+ pthread_attr_t attr;
+ gint ret;
+
+ g_return_if_fail (thread_func);
+
+ posix_check_for_error (pthread_attr_init (&attr));
+
+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+ if (stack_size)
+ {
+ stack_size = MAX (g_thread_min_stack_size, stack_size);
+ posix_check_for_error (pthread_attr_setstacksize (&attr, stack_size));
+ }
+#endif /* HAVE_PTHREAD_ATTR_SETSTACKSIZE */
+
+#ifdef PTHREAD_SCOPE_SYSTEM
+ if (bound)
+ /* 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
+ posix_check_for_error (pthread_attr_setdetachstate (&attr,
+ joinable ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED));
+#endif /* 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 */
+ posix_check_for_error
+ (pthread_attr_setprio (&attr, g_thread_map_priority (priority)));
+# endif /* G_THREADS_IMPL_DCE */
+#endif /* HAVE_PRIORITIES */
+
+ ret = pthread_create (thread, &attr, (void* (*)(void*))thread_func, arg);
+
+#ifdef G_THREADS_IMPL_DCE
+ if (ret == -1)
+ ret = errno;
+ else
+ ret = 0;
+#endif /* G_THREADS_IMPL_DCE */
+
+ posix_check_for_error (pthread_attr_destroy (&attr));
+
+ if (ret)
+ {
+ g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN,
+ "Error creating thread: %s", g_strerror (ret));
+ return;
+ }
+
+#ifdef G_THREADS_IMPL_DCE
+ if (!joinable)
+ posix_check_for_error (pthread_detach (thread));
+#endif /* G_THREADS_IMPL_DCE */
+}
+
+static void
+g_thread_yield_posix_impl (void)
+{
+ POSIX_YIELD_FUNC;
+}
+
+static void
+g_thread_join_posix_impl (gpointer thread)
+{
+ gpointer ignore;
+ posix_check_for_error (pthread_join (*(pthread_t*)thread,
+ &ignore));
+}
+
+static void
+g_thread_exit_posix_impl (void)
+{
+ pthread_exit (NULL);
+}
+
+static void
+g_thread_set_priority_posix_impl (gpointer thread, GThreadPriority priority)
+{
+#ifdef HAVE_PRIORITIES
+# ifdef G_THREADS_IMPL_POSIX
+ struct sched_param sched;
+ int policy;
+ posix_check_for_error (pthread_getschedparam (*(pthread_t*)thread,
+ &policy, &sched));
+ sched.sched_priority = g_thread_map_priority (priority);
+ posix_check_for_error (pthread_setschedparam (*(pthread_t*)thread,
+ policy, &sched));
+# else /* G_THREADS_IMPL_DCE */
+ posix_check_for_error (pthread_setprio (*(pthread_t*)thread,
+ g_thread_map_priority (priority)));
+# endif
+#endif /* HAVE_PRIORITIES */
+}
+
+static void
+g_thread_self_posix_impl (gpointer thread)
+{
+ *(pthread_t*)thread = pthread_self();
}
static GThreadFunctions g_thread_functions_for_glib_use_default =
g_cond_free_posix_impl,
g_private_new_posix_impl,
g_private_get_posix_impl,
- g_private_set_posix_impl
+ g_private_set_posix_impl,
+ g_thread_create_posix_impl,
+ g_thread_yield_posix_impl,
+ g_thread_join_posix_impl,
+ g_thread_exit_posix_impl,
+ g_thread_set_priority_posix_impl,
+ g_thread_self_posix_impl
};
projects / platform / upstream / glib.git / blobdiff