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]

Patch to Add rwlock, barrier, and spinlock


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]