This is the mail archive of the newlib@sourceware.org mailing list for the newlib project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: Patch to Add rwlock, barrier, and spinlock


Patch checked in.

-- Jeff J.

Joel Sherrill wrote:
Hi,

Attached is a patch to add the prototypes
and associated types for POSIX RWLocks,
Barriers, and Spinlocks.  This patch enables
them for the RTEMS targets.

The patch also fixes some naming style issues
in pthread.h that Jeff noticed while reviewing
an earlier version of this patch.
2006-09-13  Joel Sherrill <joel@oarcorp.com>

   * libc/include/pthread.h: Add pthread barriers,
   rwlocks, and spinlocks.  Change const to
   _CONST and prefix parameter names with
   an underscore.
   * libc/include/sys/types.h: Add id and attribute
   types for barriers, wrlocks, and spinlocks.
   * libc/include/sys/features.h: Enable barriers,
   wrlocks, and spinlocks for RTEMS.

--joel


------------------------------------------------------------------------


diff -uNr newlib-1.14.0-orig/newlib/libc/include/pthread.h newlib-1.14.0/newlib/libc/include/pthread.h
--- newlib-1.14.0-orig/newlib/libc/include/pthread.h 2006-08-11 10:51:04.000000000 -0500
+++ newlib-1.14.0/newlib/libc/include/pthread.h 2006-09-13 08:30:48.000000000 -0500
@@ -50,18 +50,18 @@
/* Mutex Initialization Attributes, P1003.1c/Draft 10, p. 81 */
-int _EXFUN(pthread_mutexattr_init, (pthread_mutexattr_t *attr));
-int _EXFUN(pthread_mutexattr_destroy, (pthread_mutexattr_t *attr));
+int _EXFUN(pthread_mutexattr_init, (pthread_mutexattr_t *__attr));
+int _EXFUN(pthread_mutexattr_destroy, (pthread_mutexattr_t *__attr));
int _EXFUN(pthread_mutexattr_getpshared,
- (const pthread_mutexattr_t *attr, int *pshared));
+ (_CONST pthread_mutexattr_t *__attr, int *__pshared));
int _EXFUN(pthread_mutexattr_setpshared,
- (pthread_mutexattr_t *attr, int pshared));
+ (pthread_mutexattr_t *__attr, int __pshared));
/* Initializing and Destroying a Mutex, P1003.1c/Draft 10, p. 87 */
int _EXFUN(pthread_mutex_init,
- (pthread_mutex_t *mutex, const pthread_mutexattr_t *attr));
-int _EXFUN(pthread_mutex_destroy, (pthread_mutex_t *mutex));
+ (pthread_mutex_t *__mutex, _CONST pthread_mutexattr_t *__attr));
+int _EXFUN(pthread_mutex_destroy, (pthread_mutex_t *__mutex));
/* This is used to statically initialize a pthread_mutex_t. Example:
@@ -73,31 +73,31 @@
/* Locking and Unlocking a Mutex, P1003.1c/Draft 10, p. 93
NOTE: P1003.4b/D8 adds pthread_mutex_timedlock(), p. 29 */
-int _EXFUN(pthread_mutex_lock, (pthread_mutex_t *mutex));
-int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *mutex));
-int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *mutex));
+int _EXFUN(pthread_mutex_lock, (pthread_mutex_t *__mutex));
+int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
+int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
- (pthread_mutex_t *mutex, const struct timespec *timeout));
+ (pthread_mutex_t *__mutex, _CONST struct timespec *__timeout));
#endif /* _POSIX_TIMEOUTS */
/* Condition Variable Initialization Attributes, P1003.1c/Draft 10, p. 96 */
-int _EXFUN(pthread_condattr_init, (pthread_condattr_t *attr));
-int _EXFUN(pthread_condattr_destroy, (pthread_condattr_t *attr));
+int _EXFUN(pthread_condattr_init, (pthread_condattr_t *__attr));
+int _EXFUN(pthread_condattr_destroy, (pthread_condattr_t *__attr));
int _EXFUN(pthread_condattr_getpshared,
- (const pthread_condattr_t *attr, int *pshared));
+ (_CONST pthread_condattr_t *__attr, int *__pshared));
int _EXFUN(pthread_condattr_setpshared,
- (pthread_condattr_t *attr, int pshared));
+ (pthread_condattr_t *__attr, int __pshared));
/* Initializing and Destroying a Condition Variable, P1003.1c/Draft 10, p. 87 */
int _EXFUN(pthread_cond_init,
- (pthread_cond_t *cond, const pthread_condattr_t *attr));
-int _EXFUN(pthread_cond_destroy, (pthread_cond_t *mutex));
+ (pthread_cond_t *__cond, _CONST pthread_condattr_t *__attr));
+int _EXFUN(pthread_cond_destroy, (pthread_cond_t *__mutex));
/* This is used to statically initialize a pthread_cond_t. Example:
@@ -108,49 +108,50 @@
/* Broadcasting and Signaling a Condition, P1003.1c/Draft 10, p. 101 */
-int _EXFUN(pthread_cond_signal, (pthread_cond_t *cond));
-int _EXFUN(pthread_cond_broadcast, (pthread_cond_t *cond));
+int _EXFUN(pthread_cond_signal, (pthread_cond_t *__cond));
+int _EXFUN(pthread_cond_broadcast, (pthread_cond_t *__cond));
/* Waiting on a Condition, P1003.1c/Draft 10, p. 105 */
int _EXFUN(pthread_cond_wait,
- (pthread_cond_t *cond, pthread_mutex_t *mutex));
+ (pthread_cond_t *__cond, pthread_mutex_t *__mutex));
int _EXFUN(pthread_cond_timedwait,
- (pthread_cond_t *cond, pthread_mutex_t *mutex,
- const struct timespec *abstime));
+ (pthread_cond_t *__cond, pthread_mutex_t *__mutex,
+ _CONST struct timespec *__abstime));
#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
/* Thread Creation Scheduling Attributes, P1003.1c/Draft 10, p. 120 */
int _EXFUN(pthread_attr_setscope,
- (pthread_attr_t *attr, int contentionscope));
+ (pthread_attr_t *__attr, int __contentionscope));
int _EXFUN(pthread_attr_getscope,
- (const pthread_attr_t *attr, int *contentionscope));
+ (_CONST pthread_attr_t *__attr, int *__contentionscope));
int _EXFUN(pthread_attr_setinheritsched,
- (pthread_attr_t *attr, int inheritsched));
+ (pthread_attr_t *__attr, int __inheritsched));
int _EXFUN(pthread_attr_getinheritsched,
- (const pthread_attr_t *attr, int *inheritsched));
-int _EXFUN(pthread_attr_setschedpolicy, (pthread_attr_t *attr, int policy));
+ (_CONST pthread_attr_t *__attr, int *__inheritsched));
+int _EXFUN(pthread_attr_setschedpolicy,
+ (pthread_attr_t *__attr, int __policy));
int _EXFUN(pthread_attr_getschedpolicy,
- (const pthread_attr_t *attr, int *policy));
+ (_CONST pthread_attr_t *__attr, int *__policy));
#endif /* defined(_POSIX_THREAD_PRIORITY_SCHEDULING) */
int _EXFUN(pthread_attr_setschedparam,
- (pthread_attr_t *attr, const struct sched_param *param));
+ (pthread_attr_t *__attr, _CONST struct sched_param *__param));
int _EXFUN(pthread_attr_getschedparam,
- (const pthread_attr_t *attr, struct sched_param *param));
+ (_CONST pthread_attr_t *__attr, struct sched_param *__param));
#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
/* Dynamic Thread Scheduling Parameters Access, P1003.1c/Draft 10, p. 124 */
int _EXFUN(pthread_getschedparam,
- (pthread_t thread, int *policy, struct sched_param *param));
+ (pthread_t __pthread, int *__policy, struct sched_param *__param));
int _EXFUN(pthread_setschedparam,
- (pthread_t thread, int policy, struct sched_param *param));
+ (pthread_t __pthread, int __policy, struct sched_param *__param));
#endif /* defined(_POSIX_THREAD_PRIORITY_SCHEDULING) */
@@ -159,13 +160,13 @@
/* Mutex Initialization Scheduling Attributes, P1003.1c/Draft 10, p. 128 */
int _EXFUN(pthread_mutexattr_setprotocol,
- (pthread_mutexattr_t *attr, int protocol));
+ (pthread_mutexattr_t *__attr, int __protocol));
int _EXFUN(pthread_mutexattr_getprotocol,
- (const pthread_mutexattr_t *attr, int *protocol));
+ (_CONST pthread_mutexattr_t *__attr, int *__protocol));
int _EXFUN(pthread_mutexattr_setprioceiling,
- (pthread_mutexattr_t *attr, int prioceiling));
+ (pthread_mutexattr_t *__attr, int __prioceiling));
int _EXFUN(pthread_mutexattr_getprioceiling,
- (const pthread_mutexattr_t *attr, int *prioceiling));
+ (_CONST pthread_mutexattr_t *__attr, int *__prioceiling));
#endif /* _POSIX_THREAD_PRIO_INHERIT || _POSIX_THREAD_PRIO_PROTECT */
@@ -174,46 +175,46 @@
/* Change the Priority Ceiling of a Mutex, P1003.1c/Draft 10, p. 131 */
int _EXFUN(pthread_mutex_setprioceiling,
- (pthread_mutex_t *mutex, int prioceiling, int *old_ceiling));
+ (pthread_mutex_t *__mutex, int __prioceiling, int *__old_ceiling));
int _EXFUN(pthread_mutex_getprioceiling,
- (pthread_mutex_t *mutex, int *prioceiling));
+ (pthread_mutex_t *__mutex, int *__prioceiling));
#endif /* _POSIX_THREAD_PRIO_PROTECT */
/* Thread Creation Attributes, P1003.1c/Draft 10, p, 140 */
-int _EXFUN(pthread_attr_init, (pthread_attr_t *attr));
-int _EXFUN(pthread_attr_destroy, (pthread_attr_t *attr));
+int _EXFUN(pthread_attr_init, (pthread_attr_t *__attr));
+int _EXFUN(pthread_attr_destroy, (pthread_attr_t *__attr));
int _EXFUN(pthread_attr_getstacksize,
- (const pthread_attr_t *attr, size_t *stacksize));
+ (_CONST pthread_attr_t *__attr, size_t *__stacksize));
int _EXFUN(pthread_attr_setstacksize,
- (pthread_attr_t *attr, size_t stacksize));
+ (pthread_attr_t *__attr, size_t stacksize));
int _EXFUN(pthread_attr_getstackaddr,
- (const pthread_attr_t *attr, void **stackaddr));
+ (_CONST pthread_attr_t *__attr, void **__stackaddr));
int _EXFUN(pthread_attr_setstackaddr,
- (pthread_attr_t *attr, void *stackaddr));
+ (pthread_attr_t *__attr, void *__stackaddr));
int _EXFUN(pthread_attr_getdetachstate,
- (const pthread_attr_t *attr, int *detachstate));
+ (_CONST pthread_attr_t *__attr, int *__detachstate));
int _EXFUN(pthread_attr_setdetachstate,
- (pthread_attr_t *attr, int detachstate));
+ (pthread_attr_t *__attr, int __detachstate));
/* Thread Creation, P1003.1c/Draft 10, p. 144 */
int _EXFUN(pthread_create,
- (pthread_t *thread, const pthread_attr_t *attr,
- void *(*start_routine)( void * ), void *arg));
+ (pthread_t *__pthread, _CONST pthread_attr_t *__attr,
+ void *(*__start_routine)( void * ), void *__arg));
/* Wait for Thread Termination, P1003.1c/Draft 10, p. 147 */
-int _EXFUN(pthread_join, (pthread_t thread, void **value_ptr));
+int _EXFUN(pthread_join, (pthread_t __pthread, void **__value_ptr));
/* Detaching a Thread, P1003.1c/Draft 10, p. 149 */
-int _EXFUN(pthread_detach, (pthread_t thread));
+int _EXFUN(pthread_detach, (pthread_t __pthread));
/* Thread Termination, p1003.1c/Draft 10, p. 150 */
-void _EXFUN(pthread_exit, (void *value_ptr));
+void _EXFUN(pthread_exit, (void *__value_ptr));
/* Get Calling Thread's ID, p1003.1c/Draft 10, p. XXX */
@@ -221,7 +222,7 @@
/* Compare Thread IDs, p1003.1c/Draft 10, p. 153 */
-int _EXFUN(pthread_equal, (pthread_t t1, pthread_t t2));
+int _EXFUN(pthread_equal, (pthread_t __t1, pthread_t __t2));
/* Dynamic Package Initialization */
@@ -234,21 +235,22 @@
#define PTHREAD_ONCE_INIT { 1, 0 } /* is initialized and not run */
int _EXFUN(pthread_once,
- (pthread_once_t *once_control, void (*init_routine)(void)));
+ (pthread_once_t *__once_control, void (*__init_routine)(void)));
/* Thread-Specific Data Key Create, P1003.1c/Draft 10, p. 163 */
int _EXFUN(pthread_key_create,
- (pthread_key_t *key, void (*destructor)( void * )));
+ (pthread_key_t *__key, void (*__destructor)( void * )));
/* Thread-Specific Data Management, P1003.1c/Draft 10, p. 165 */
-int _EXFUN(pthread_setspecific, (pthread_key_t key, const void *value));
-void * _EXFUN(pthread_getspecific, (pthread_key_t key));
+int _EXFUN(pthread_setspecific,
+ (pthread_key_t __key, _CONST void *__value));
+void * _EXFUN(pthread_getspecific, (pthread_key_t __key));
/* Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167 */
-int _EXFUN(pthread_key_delete, (pthread_key_t key));
+int _EXFUN(pthread_key_delete, (pthread_key_t __key));
/* Execution of a Thread, P1003.1c/Draft 10, p. 181 */
@@ -260,38 +262,94 @@
#define PTHREAD_CANCELED ((void *) -1)
-int _EXFUN(pthread_cancel, (pthread_t thread));
+int _EXFUN(pthread_cancel, (pthread_t __pthread));
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
-int _EXFUN(pthread_setcancelstate, (int state, int *oldstate));
-int _EXFUN(pthread_setcanceltype, (int type, int *oldtype));
+int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
+int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
/* Establishing Cancellation Handlers, P1003.1c/Draft 10, p. 184 */
-void _EXFUN(pthread_cleanup_push, (void (*routine)( void * ), void *arg));
-void _EXFUN(pthread_cleanup_pop, (int execute));
+void _EXFUN(pthread_cleanup_push,
+ (void (*__routine)( void * ), void *__arg));
+void _EXFUN(pthread_cleanup_pop, (int __execute));
#if defined(_POSIX_THREAD_CPUTIME)
/* Accessing a Thread CPU-time Clock, P1003.4b/D8, p. 58 */
int _EXFUN(pthread_getcpuclockid,
- (pthread_t thread_id, clockid_t *clock_id));
+ (pthread_t __pthread_id, clockid_t *__clock_id));
/* CPU-time Clock Thread Creation Attribute, P1003.4b/D8, p. 59 */
int _EXFUN(pthread_attr_setcputime,
- (pthread_attr_t *attr, int clock_allowed));
+ (pthread_attr_t *__attr, int __clock_allowed));
int _EXFUN(pthread_attr_getcputime,
- (pthread_attr_t *attr, int *clock_allowed));
+ (pthread_attr_t *__attr, int *__clock_allowed));
#endif /* defined(_POSIX_THREAD_CPUTIME) */
+
#endif /* defined(_POSIX_THREADS) */
+#if defined(_POSIX_BARRIERS)
+
+int _EXFUN(pthread_barrierattr_init, (pthread_barrierattr_t *__attr));
+int _EXFUN(pthread_barrierattr_destroy, (pthread_barrierattr_t *__attr));
+int _EXFUN(pthread_barrierattr_getpshared,
+ (_CONST pthread_barrierattr_t *__attr, int *__pshared));
+int _EXFUN(pthread_barrierattr_setpshared,
+ (pthread_barrierattr_t *__attr, int __pshared));
+
+#define PTHREAD_BARRIER_SERIAL_THREAD -1
+
+int _EXFUN(pthread_barrier_init,
+ (pthread_barrier_t *__barrier,
+ _CONST pthread_barrierattr_t *__attr, unsigned __count));
+int _EXFUN(pthread_barrier_destroy, (pthread_barrier_t *__barrier));
+int _EXFUN(pthread_barrier_wait,(pthread_barrier_t *__barrier));
+
+#endif /* defined(_POSIX_BARRIERS) */
+
+#if defined(_POSIX_SPIN_LOCKS)
+
+int _EXFUN(pthread_spin_init,
+ (pthread_spinlock_t *__spinlock, int __pshared));
+int _EXFUN(pthread_spin_destroy, (pthread_spinlock_t *__spinlock));
+int _EXFUN(pthread_spin_lock, (pthread_spinlock_t *__spinlock));
+int _EXFUN(pthread_spin_trylock, (pthread_spinlock_t *__spinlock));
+int _EXFUN(pthread_spin_unlock, (pthread_spinlock_t *__spinlock));
+
+#endif /* defined(_POSIX_SPIN_LOCKS) */
+
+#if defined(_POSIX_READER_WRITER_LOCKS)
+
+int _EXFUN(pthread_rwlockattr_init, (pthread_rwlockattr_t *__attr));
+int _EXFUN(pthread_rwlockattr_destroy, (pthread_rwlockattr_t *__attr));
+int _EXFUN(pthread_rwlockattr_getpshared,
+ (_CONST pthread_rwlockattr_t *__attr, int *__pshared));
+int _EXFUN(pthread_rwlockattr_setpshared,
+ (pthread_rwlockattr_t *__attr, int __pshared));
+
+int _EXFUN(pthread_rwlock_init,
+ (pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr));
+int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock));
+int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock));
+int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock));
+int _EXFUN(pthread_rwlock_timedrdlock,
+ (pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
+int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
+int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
+int _EXFUN(pthread_rwlock_timedwrlock,
+ (pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
+
+#endif /* defined(_POSIX_READER_WRITER_LOCKS) */
+
+
#ifdef __cplusplus
}
#endif
diff -uNr newlib-1.14.0-orig/newlib/libc/include/sys/features.h newlib-1.14.0/newlib/libc/include/sys/features.h
--- newlib-1.14.0-orig/newlib/libc/include/sys/features.h 2006-08-11 10:51:04.000000000 -0500
+++ newlib-1.14.0/newlib/libc/include/sys/features.h 2006-09-13 08:30:55.000000000 -0500
@@ -45,6 +45,9 @@
#define _POSIX_SHARED_MEMORY_OBJECTS 1
#define _POSIX_SYNCHRONIZED_IO 1
#define _POSIX_TIMERS 1
+#define _POSIX_BARRIERS 200112L
+#define _POSIX_READER_WRITER_LOCKS 200112L
+#define _POSIX_SPIN_LOCKS 200112L
/* In P1003.1b but defined by drafts at least as early as P1003.1c/D10 */
diff -uNr newlib-1.14.0-orig/newlib/libc/include/sys/types.h newlib-1.14.0/newlib/libc/include/sys/types.h
--- newlib-1.14.0-orig/newlib/libc/include/sys/types.h 2006-08-11 10:51:04.000000000 -0500
+++ newlib-1.14.0/newlib/libc/include/sys/types.h 2006-09-13 08:30:55.000000000 -0500
@@ -373,6 +373,36 @@
#endif
#endif /* defined(_POSIX_THREADS) */
+/* POSIX Barrier Types */
+
+#if defined(_POSIX_BARRIERS)
+typedef __uint32_t pthread_barrier_t; /* POSIX Barrier Object */
+typedef struct {
+ int is_initialized; /* is this structure initialized? */
+#if defined(_POSIX_THREAD_PROCESS_SHARED)
+ int process_shared; /* allow this to be shared amongst processes */
+#endif
+} pthread_barrierattr_t;
+#endif /* defined(_POSIX_BARRIERS) */
+
+/* POSIX Spin Lock Types */
+
+#if defined(_POSIX_SPIN_LOCKS)
+typedef __uint32_t pthread_spinlock_t; /* POSIX Spin Lock Object */
+#endif /* defined(_POSIX_SPIN_LOCKS) */
+
+/* POSIX Reader/Writer Lock Types */
+
+#if defined(_POSIX_READER_WRITER_LOCKS)
+typedef __uint32_t pthread_rwlock_t; /* POSIX RWLock Object */
+typedef struct {
+ int is_initialized; /* is this structure initialized? */
+#if defined(_POSIX_THREAD_PROCESS_SHARED)
+ int process_shared; /* allow this to be shared amongst processes */
+#endif
+} pthread_rwlockattr_t;
+#endif /* defined(_POSIX_READER_WRITER_LOCKS) */
+
#endif /* !__need_inttypes */
#undef __need_inttypes


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]