From aca1628a31c2acca262a90af921501368f8cfcc2 Mon Sep 17 00:00:00 2001 From: "bernard.xiong" Date: Mon, 15 Nov 2010 09:46:50 +0000 Subject: [PATCH] cleanup pthread implementation code. git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1048 bbd45198-f89e-11dd-88c7-29a3b14d5316 --- components/pthreads/pthread.c | 26 +++ components/pthreads/pthread.h | 149 +++++++++++++++++- components/pthreads/pthread_attr.h | 20 --- components/pthreads/pthread_barrier.c | 79 ++++++++++ components/pthreads/pthread_barrier.h | 0 components/pthreads/pthread_cond.c | 2 +- components/pthreads/pthread_cond.h | 34 ---- components/pthreads/pthread_mutex.h | 25 --- components/pthreads/pthread_rwlock.c | 218 ++++++++++++++++++++++++-- components/pthreads/pthread_rwlock.h | 36 ----- components/pthreads/pthread_spin.c | 2 +- components/pthreads/pthread_spin.h | 19 --- components/pthreads/pthread_tls.c | 19 +++ components/pthreads/pthread_tls.h | 0 14 files changed, 469 insertions(+), 160 deletions(-) delete mode 100644 components/pthreads/pthread_attr.h delete mode 100644 components/pthreads/pthread_barrier.h delete mode 100644 components/pthreads/pthread_cond.h delete mode 100644 components/pthreads/pthread_mutex.h delete mode 100644 components/pthreads/pthread_rwlock.h delete mode 100644 components/pthreads/pthread_spin.h delete mode 100644 components/pthreads/pthread_tls.h diff --git a/components/pthreads/pthread.c b/components/pthreads/pthread.c index 8200b471e..964f57ad2 100644 --- a/components/pthreads/pthread.c +++ b/components/pthreads/pthread.c @@ -274,3 +274,29 @@ int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(vo return ENOTSUP; } +int pthread_kill(pthread_t thread, int sig) +{ + return ENOTSUP; +} + +void pthread_cleanup_pop(int execute) +{ +} + +void pthread_cleanup_push(void (*routine)(void*), void *arg) +{ +} + +int pthread_setcancelstate(int state, int *oldstate) +{ +} + +int pthread_setcanceltype(int type, int *oldtype) +{ + return 0; +} + +void pthread_testcancel(void) +{ +} + diff --git a/components/pthreads/pthread.h b/components/pthreads/pthread.h index 3ff723170..bd112b503 100644 --- a/components/pthreads/pthread.h +++ b/components/pthreads/pthread.h @@ -16,14 +16,13 @@ #include #include - -#include "pthread_attr.h" -#include "pthread_mutex.h" +#include typedef rt_thread_t pthread_t; - typedef long pthread_condattr_t; typedef long pthread_rwlockattr_t; +typedef long pthread_mutexattr_t; +typedef long pthread_barrierattr_t; typedef int pthread_key_t; typedef int pthread_once_t; @@ -74,7 +73,62 @@ enum { struct sched_param { int sched_priority; }; - + +struct pthread_attr +{ + void* stack_base; + rt_uint16_t stack_size; /* stack size of thread */ + + rt_uint8_t priority; /* priority of thread */ + rt_uint8_t detachstate; /* detach state */ + rt_uint8_t policy; /* scheduler policy */ + rt_uint8_t inheritsched; /* Inherit parent prio/policy */ +}; +typedef struct pthread_attr pthread_attr_t; + +struct pthread_mutex +{ + pthread_mutexattr_t attr; + struct rt_mutex lock; +}; +typedef struct pthread_mutex pthread_mutex_t; + +struct pthread_cond +{ + pthread_condattr_t attr; + struct rt_semaphore sem; +}; +typedef struct pthread_cond pthread_cond_t; + +struct pthread_rwlock +{ + pthread_rwlockattr_t attr; + + pthread_mutex_t rw_mutex; /* basic lock on this struct */ + pthread_cond_t rw_condreaders; /* for reader threads waiting */ + pthread_cond_t rw_condwriters; /* for writer threads waiting */ + + int rw_nwaitreaders; /* the number waiting */ + int rw_nwaitwriters; /* the number waiting */ + int rw_refcount; +}; +typedef struct pthread_rwlock pthread_rwlock_t; + +/* spinlock implementation, (ADVANCED REALTIME THREADS)*/ +struct pthread_spinlock +{ + int lock; +}; +typedef struct pthread_spinlock pthread_spinlock_t; + +struct pthread_barrier +{ + int count; + pthread_cond_t cond; + pthread_mutex_t mutex; +}; +typedef struct pthread_barrier pthread_barrier_t; + /* * Scheduling policies required by IEEE Std 1003.1-2001 */ @@ -82,6 +136,10 @@ struct sched_param { #define SCHED_FIFO 1 #define SCHED_RR 2 +/* pthread thread interface */ +int pthread_attr_destroy(pthread_attr_t *attr); +int pthread_attr_init(pthread_attr_t *attr); + int pthread_init (void); int pthread_create (pthread_t *tid, const pthread_attr_t *attr, void *(*start) (void *), void *arg); @@ -100,17 +158,94 @@ rt_inline pthread_t pthread_self (void) } void pthread_exit (void *value_ptr); - int pthread_once(pthread_once_t * once_control, void (*init_routine) (void)); +/* pthread cleanup */ +void pthread_cleanup_pop(int execute); +void pthread_cleanup_push(void (*routine)(void*), void *arg); + /* pthread cancel */ int pthread_cancel(pthread_t thread); void pthread_testcancel(void); - int pthread_setcancelstate(int state, int *oldstate); int pthread_setcanceltype(int type, int *oldtype); int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)); +int pthread_kill(pthread_t thread, int sig); + +/* pthread mutex interface */ +int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); +int pthread_mutex_destroy(pthread_mutex_t *mutex); +int pthread_mutex_lock(pthread_mutex_t *mutex); +int pthread_mutex_unlock(pthread_mutex_t *mutex); +int pthread_mutex_trylock(pthread_mutex_t *mutex); + +int pthread_mutexattr_init(pthread_mutexattr_t *attr); +int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); +int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type); +int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type); +int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared); +int pthread_mutexattr_getpshared(pthread_mutexattr_t *attr, int *pshared); + +/* pthread condition interface */ +int pthread_condattr_destroy(pthread_condattr_t *attr); +int pthread_condattr_init(pthread_condattr_t *attr); + +/* ADVANCED REALTIME feature in IEEE Std 1003.1, 2004 Edition */ +int pthread_condattr_getclock(const pthread_condattr_t *attr, + clockid_t *clock_id); +int pthread_condattr_setclock(pthread_condattr_t *attr, + clockid_t clock_id); + +int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); +int pthread_cond_destroy(pthread_cond_t *cond); +int pthread_cond_broadcast(pthread_cond_t *cond); +int pthread_cond_signal(pthread_cond_t *cond); + +int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); +int pthread_cond_timedwait(pthread_cond_t *cond, + pthread_mutex_t * mutex, + const struct timespec *abstime); + +/* pthread rwlock interface */ +int pthread_rwlockattr_init (pthread_rwlockattr_t *attr); +int pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr); +int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared); +int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared); + +int pthread_rwlock_init (pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr); +int pthread_rwlock_destroy (pthread_rwlock_t *rwlock); + +int pthread_rwlock_rdlock (pthread_rwlock_t *rwlock); +int pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock); + +int pthread_rwlock_timedrdlock (pthread_rwlock_t *rwlock, const struct timespec *abstime); +int pthread_rwlock_timedwrlock (pthread_rwlock_t *rwlock, const struct timespec *abstime); + +int pthread_rwlock_unlock (pthread_rwlock_t *rwlock); + +int pthread_rwlock_wrlock (pthread_rwlock_t *rwlock); +int pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock); + +/* pthread spinlock interface */ +int pthread_spin_init (pthread_spinlock_t *lock, int pshared); +int pthread_spin_destroy (pthread_spinlock_t *lock); + +int pthread_spin_lock (pthread_spinlock_t * lock); +int pthread_spin_trylock (pthread_spinlock_t * lock); +int pthread_spin_unlock (pthread_spinlock_t * lock); + +/* pthread barrier interface */ +int pthread_barrierattr_destroy(pthread_barrierattr_t *attr); +int pthread_barrierattr_init(pthread_barrierattr_t *attr); +int pthread_barrierattr_getpshared(const pthread_barrierattr_t *attr, int *pshared); +int pthread_barrierattr_setpshared(pthread_barrierattr_t *attr, int pshared); + +int pthread_barrier_destroy(pthread_barrier_t *barrier); +int pthread_barrier_init(pthread_barrier_t *barrier, + const pthread_barrierattr_t *attr, unsigned count); + +int pthread_barrier_wait(pthread_barrier_t *barrier); #endif diff --git a/components/pthreads/pthread_attr.h b/components/pthreads/pthread_attr.h deleted file mode 100644 index f4950e20b..000000000 --- a/components/pthreads/pthread_attr.h +++ /dev/null @@ -1,20 +0,0 @@ -#ifndef __PTHREAD_ATTR_H__ -#define __PTHREAD_ATTR_H__ - -struct pthread_attr -{ - void* stack_base; - rt_uint16_t stack_size; /* stack size of thread */ - - rt_uint8_t priority; /* priority of thread */ - rt_uint8_t detachstate; /* detach state */ - rt_uint8_t policy; /* scheduler policy */ - rt_uint8_t inheritsched; /* Inherit parent prio/policy */ -}; -typedef struct pthread_attr pthread_attr_t; -extern const pthread_attr_t pthread_default_attr; - -int pthread_attr_destroy(pthread_attr_t *attr); -int pthread_attr_init(pthread_attr_t *attr); - -#endif diff --git a/components/pthreads/pthread_barrier.c b/components/pthreads/pthread_barrier.c index e69de29bb..8908ab5d6 100644 --- a/components/pthreads/pthread_barrier.c +++ b/components/pthreads/pthread_barrier.c @@ -0,0 +1,79 @@ +#include + +int pthread_barrierattr_destroy(pthread_barrierattr_t *attr) +{ + if (!attr) return EINVAL; + return 0; +} + +int pthread_barrierattr_init(pthread_barrierattr_t *attr) +{ + if (!attr) return EINVAL; + *attr = PTHREAD_PROCESS_PRIVATE; + + return 0; +} + +int pthread_barrierattr_getpshared(const pthread_barrierattr_t *attr, int *pshared) +{ + if (!attr) return EINVAL; + *pshared = (int)*attr; + + return 0; +} + +int pthread_barrierattr_setpshared(pthread_barrierattr_t *attr, int pshared) +{ + if (!attr) return EINVAL; + if (pshared == PTHREAD_PROCESS_PRIVATE) attr = PTHREAD_PROCESS_PRIVATE; + + return EINVAL; +} + +int pthread_barrier_destroy(pthread_barrier_t *barrier) +{ + rt_err_t result; + + if (!barrier) return EINVAL; + + result = pthread_cond_destroy(&(barrier->cond)); + + return result; +} + +int pthread_barrier_init(pthread_barrier_t *barrier, + const pthread_barrierattr_t *attr, unsigned count) +{ + rt_err_t result; + if (!barrier) return EINVAL; + if (attr &&(*attr != PTHREAD_PROCESS_PRIVATE)) return EINVAL; + + barrier->count = count; + pthread_cond_init(&(barrier->cond), NULL); + pthread_mutex_init(&(barrier->mutex), NULL); + + return 0; +} + +int pthread_barrier_wait(pthread_barrier_t *barrier) +{ + rt_err_t result; + if (!barrier) return EINVAL; + + result = pthread_mutex_lock(&(barrier->mutex)); + if (result != 0) return EINVAL; + + if (barrier->count == 0) result = EINVAL; + else + { + barrier->count -= 1; + if (barrier->count == 0) /* broadcast condition */ + pthread_cond_broadcast(&(barrier->cond)); + else + pthread_cond_wait(&(barrier->cond), &(barrier->mutex)); + } + + pthread_mutex_unlock(&(barrier->mutex)); + return result; +} + diff --git a/components/pthreads/pthread_barrier.h b/components/pthreads/pthread_barrier.h deleted file mode 100644 index e69de29bb..000000000 diff --git a/components/pthreads/pthread_cond.c b/components/pthreads/pthread_cond.c index 315408664..c4e876f49 100644 --- a/components/pthreads/pthread_cond.c +++ b/components/pthreads/pthread_cond.c @@ -1,4 +1,4 @@ -#include "pthread_cond.h" +#include int pthread_condattr_destroy(pthread_condattr_t *attr) { diff --git a/components/pthreads/pthread_cond.h b/components/pthreads/pthread_cond.h deleted file mode 100644 index b81ca527d..000000000 --- a/components/pthreads/pthread_cond.h +++ /dev/null @@ -1,34 +0,0 @@ -#ifndef __PTHREAD_COND_H__ -#define __PTHREAD_COND_H__ - -#include -#include -#include - -struct pthread_cond -{ - pthread_condattr_t attr; - struct rt_semaphore sem; -}; -typedef struct pthread_cond pthread_cond_t; - -int pthread_condattr_destroy(pthread_condattr_t *attr); -int pthread_condattr_init(pthread_condattr_t *attr); - -/* ADVANCED REALTIME feature in IEEE Std 1003.1, 2004 Edition */ -int pthread_condattr_getclock(const pthread_condattr_t *attr, - clockid_t *clock_id); -int pthread_condattr_setclock(pthread_condattr_t *attr, - clockid_t clock_id); - -int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); -int pthread_cond_destroy(pthread_cond_t *cond); -int pthread_cond_broadcast(pthread_cond_t *cond); -int pthread_cond_signal(pthread_cond_t *cond); - -int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); -int pthread_cond_timedwait(pthread_cond_t *cond, - pthread_mutex_t * mutex, - const struct timespec *abstime); - -#endif diff --git a/components/pthreads/pthread_mutex.h b/components/pthreads/pthread_mutex.h deleted file mode 100644 index c12e9df0c..000000000 --- a/components/pthreads/pthread_mutex.h +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef __PTHREAD_MUTEX_H__ -#define __PTHREAD_MUTEX_H__ - -typedef long pthread_mutexattr_t; -struct pthread_mutex -{ - pthread_mutexattr_t attr; - struct rt_mutex lock; -}; -typedef struct pthread_mutex pthread_mutex_t; - -int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); -int pthread_mutex_destroy(pthread_mutex_t *mutex); -int pthread_mutex_lock(pthread_mutex_t *mutex); -int pthread_mutex_unlock(pthread_mutex_t *mutex); -int pthread_mutex_trylock(pthread_mutex_t *mutex); - -int pthread_mutexattr_init(pthread_mutexattr_t *attr); -int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); -int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type); -int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type); -int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared); -int pthread_mutexattr_getpshared(pthread_mutexattr_t *attr, int *pshared); - -#endif diff --git a/components/pthreads/pthread_rwlock.c b/components/pthreads/pthread_rwlock.c index 343b9a51a..5ee7a1353 100644 --- a/components/pthreads/pthread_rwlock.c +++ b/components/pthreads/pthread_rwlock.c @@ -1,4 +1,4 @@ -#include "pthread_rwlock.h" +#include int pthread_rwlockattr_init (pthread_rwlockattr_t * attr) { @@ -30,53 +30,237 @@ int pthread_rwlockattr_setpshared (pthread_rwlockattr_t * attr, int pshared) return 0; } -int pthread_rwlock_init (pthread_rwlock_t * rwlock, const pthread_rwlockattr_t * attr) +int pthread_rwlock_init (pthread_rwlock_t *rwlock, const pthread_rwlockattr_t * attr) { + if (!rwlock) return EINVAL; + + rwlock->attr = PTHREAD_PROCESS_PRIVATE; + pthread_mutex_init(&(rwlock->rw_mutex), NULL); + pthread_cond_init(&(rwlock->rw_condreaders), NULL); + pthread_cond_init(&(rwlock->rw_condwriters), NULL); + + rwlock->rw_nwaitwriters = 0; + rwlock->rw_nwaitreaders = 0; + rwlock->rw_refcount = 0; + return 0; } -int pthread_rwlock_destroy (pthread_rwlock_t * rwlock) +int pthread_rwlock_destroy (pthread_rwlock_t *rwlock) { - return 0; + int result; + + if (!rwlock) return EINVAL; + if (rwlock->attr == -1) return 0; /* rwlock is not initialized */ + + if ( (result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0) + return(result); + + if (rwlock->rw_refcount != 0 || + rwlock->rw_nwaitreaders != 0 || rwlock->rw_nwaitwriters != 0) + { + result = EBUSY; + return(EBUSY); + } + else + { + /* check whether busy */ + result = rt_sem_trytake(&(rwlock->rw_condreaders.sem)); + if (result == RT_EOK) + { + result = rt_sem_trytake(&(rwlock->rw_condwriters.sem)); + if (result == RT_EOK) + { + rt_sem_release(&(rwlock->rw_condreaders.sem)); + rt_sem_release(&(rwlock->rw_condwriters.sem)); + + pthread_cond_destroy(&rwlock->rw_condreaders); + pthread_cond_destroy(&rwlock->rw_condwriters); + } + else + { + rt_sem_release(&(rwlock->rw_condreaders.sem)); + result = EBUSY; + } + } + else result = EBUSY; + } + + pthread_mutex_unlock(&rwlock->rw_mutex); + if (result == 0) pthread_mutex_destroy(&rwlock->rw_mutex); + + return result; } -int pthread_rwlock_rdlock (pthread_rwlock_t * rwlock) +int pthread_rwlock_rdlock (pthread_rwlock_t *rwlock) { - return 0; + int result; + + if (!rwlock) return EINVAL; + if (rwlock->attr == -1) pthread_rwlock_init(rwlock, NULL); + + if ( (result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0) + return(result); + + /* give preference to waiting writers */ + while (rwlock->rw_refcount < 0 || rwlock->rw_nwaitwriters > 0) + { + rwlock->rw_nwaitreaders++; + result = pthread_cond_wait(&rwlock->rw_condreaders, &rwlock->rw_mutex); + rwlock->rw_nwaitreaders--; + if (result != 0) + break; + } + + /* another reader has a read lock */ + if (result == 0) rwlock->rw_refcount++; + + pthread_mutex_unlock(&rwlock->rw_mutex); + return (result); } -int pthread_rwlock_tryrdlock (pthread_rwlock_t * rwlock) +int pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock) { + int result; + if (!rwlock) return EINVAL; - return 0; + if (rwlock->attr == -1) pthread_rwlock_init(rwlock, NULL); + + if ((result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0) + return(result); + + if (rwlock->rw_refcount < 0 || rwlock->rw_nwaitwriters > 0) + result = EBUSY; /* held by a writer or waiting writers */ + else + rwlock->rw_refcount++; /* increment count of reader locks */ + + pthread_mutex_unlock(&rwlock->rw_mutex); + return(result); } int pthread_rwlock_timedrdlock (pthread_rwlock_t * rwlock, const struct timespec *abstime) { + int result; + if (!rwlock) return EINVAL; - return 0; + if (rwlock->attr == -1) pthread_rwlock_init(rwlock, NULL); + + if ( (result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0) + return(result); + + /* give preference to waiting writers */ + while (rwlock->rw_refcount < 0 || rwlock->rw_nwaitwriters > 0) + { + rwlock->rw_nwaitreaders++; + result = pthread_cond_timedwait(&rwlock->rw_condreaders, &rwlock->rw_mutex, abstime); + rwlock->rw_nwaitreaders--; + if (result != 0) + break; + } + + /* another reader has a read lock */ + if (result == 0) rwlock->rw_refcount++; + + pthread_mutex_unlock(&rwlock->rw_mutex); + return (result); } -int pthread_rwlock_timedwrlock (pthread_rwlock_t * rwlock, const struct timespec *abstime) +int pthread_rwlock_timedwrlock (pthread_rwlock_t *rwlock, const struct timespec *abstime) { + int result; + if (!rwlock) return EINVAL; - return 0; + if (rwlock->attr == -1) pthread_rwlock_init(rwlock, NULL); + + if ( (result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0) + return(result); + + while (rwlock->rw_refcount != 0) + { + rwlock->rw_nwaitwriters++; + result = pthread_cond_timedwait(&rwlock->rw_condwriters, &rwlock->rw_mutex, abstime); + rwlock->rw_nwaitwriters--; + + if (result != 0) break; + } + + if (result == 0) rwlock->rw_refcount = -1; + + pthread_mutex_unlock(&rwlock->rw_mutex); + return(result); } -int pthread_rwlock_trywrlock (pthread_rwlock_t * rwlock) +int pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock) { + int result; + if (!rwlock) return EINVAL; - return 0; + if (rwlock->attr == -1) pthread_rwlock_init(rwlock, NULL); + + if ( (result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0) + return(result); + + if (rwlock->rw_refcount != 0) + result = EBUSY; /* held by either writer or reader(s) */ + else + rwlock->rw_refcount = -1; /* available, indicate a writer has it */ + + pthread_mutex_unlock(&rwlock->rw_mutex); + return(result); } -int pthread_rwlock_unlock (pthread_rwlock_t * rwlock) +int pthread_rwlock_unlock (pthread_rwlock_t *rwlock) { + int result; + if (!rwlock) return EINVAL; + if (rwlock->attr == -1) pthread_rwlock_init(rwlock, NULL); - return 0; + if ( (result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0) + return(result); + + if (rwlock->rw_refcount > 0) + rwlock->rw_refcount--; /* releasing a reader */ + else if (rwlock->rw_refcount == -1) + rwlock->rw_refcount = 0; /* releasing a reader */ + + /* give preference to waiting writers over waiting readers */ + if (rwlock->rw_nwaitwriters > 0) + { + if (rwlock->rw_refcount == 0) + result = pthread_cond_signal(&rwlock->rw_condwriters); + } + else if (rwlock->rw_nwaitreaders > 0) + { + result = pthread_cond_broadcast(&rwlock->rw_condreaders); + } + + pthread_mutex_unlock(&rwlock->rw_mutex); + return(result); } -int pthread_rwlock_wrlock (pthread_rwlock_t * rwlock) +int pthread_rwlock_wrlock (pthread_rwlock_t *rwlock) { - return 0; + int result; + + if (!rwlock) return EINVAL; + if (rwlock->attr == -1) pthread_rwlock_init(rwlock, NULL); + + if ( (result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0) + return(result); + + while (rwlock->rw_refcount != 0) + { + rwlock->rw_nwaitwriters++; + result = pthread_cond_wait(&rwlock->rw_condwriters, &rwlock->rw_mutex); + rwlock->rw_nwaitwriters--; + + if (result != 0) break; + } + + if (result == 0) rwlock->rw_refcount = -1; + + pthread_mutex_unlock(&rwlock->rw_mutex); + return(result); } + diff --git a/components/pthreads/pthread_rwlock.h b/components/pthreads/pthread_rwlock.h deleted file mode 100644 index 9d308f1bc..000000000 --- a/components/pthreads/pthread_rwlock.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef __PTHREAD_RWLOCK_H__ -#define __PTHREAD_RWLOCK_H__ - -#include -#include -#include - -struct pthread_rwlock -{ - pthread_rwlockattr_t attr; - - struct rt_semaphore wrlock; - struct rt_semaphore rdlock; -}; -typedef struct pthread_rwlock pthread_rwlock_t; - -int pthread_rwlockattr_init (pthread_rwlockattr_t *attr); -int pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr); -int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared); -int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared); - -int pthread_rwlock_init (pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr); -int pthread_rwlock_destroy (pthread_rwlock_t *rwlock); - -int pthread_rwlock_rdlock (pthread_rwlock_t *rwlock); -int pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock); - -int pthread_rwlock_timedrdlock (pthread_rwlock_t *rwlock, const struct timespec *abstime); -int pthread_rwlock_timedwrlock (pthread_rwlock_t *rwlock, const struct timespec *abstime); - -int pthread_rwlock_unlock (pthread_rwlock_t *rwlock); - -int pthread_rwlock_wrlock (pthread_rwlock_t *rwlock); -int pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock); - -#endif diff --git a/components/pthreads/pthread_spin.c b/components/pthreads/pthread_spin.c index c38c61161..a9f0f4704 100644 --- a/components/pthreads/pthread_spin.c +++ b/components/pthreads/pthread_spin.c @@ -1,4 +1,4 @@ -#include "pthread_spin.h" +#include int pthread_spin_init (pthread_spinlock_t *lock, int pshared) { diff --git a/components/pthreads/pthread_spin.h b/components/pthreads/pthread_spin.h deleted file mode 100644 index b870c4524..000000000 --- a/components/pthreads/pthread_spin.h +++ /dev/null @@ -1,19 +0,0 @@ -#ifndef __PTHREAD_SPIN_H__ -#define __PTHREAD_SPIN_H__ -#include - -/* spinlock implementation, (ADVANCED REALTIME THREADS)*/ -struct pthread_spinlock -{ - int lock; -}; -typedef struct pthread_spinlock pthread_spinlock_t; - -int pthread_spin_init (pthread_spinlock_t *lock, int pshared); -int pthread_spin_destroy (pthread_spinlock_t *lock); - -int pthread_spin_lock (pthread_spinlock_t * lock); -int pthread_spin_trylock (pthread_spinlock_t * lock); -int pthread_spin_unlock (pthread_spinlock_t * lock); - -#endif diff --git a/components/pthreads/pthread_tls.c b/components/pthreads/pthread_tls.c index e69de29bb..7efb0b325 100644 --- a/components/pthreads/pthread_tls.c +++ b/components/pthreads/pthread_tls.c @@ -0,0 +1,19 @@ +#include + +void *pthread_getspecific(pthread_key_t key) +{ +} + +int pthread_setspecific(pthread_key_t key, const void *value) +{ +} + +int pthread_key_create(pthread_key_t *key, void (*destructor)(void*)) +{ + return 0; +} + +int pthread_key_delete(pthread_key_t key) +{ + return 0; +} diff --git a/components/pthreads/pthread_tls.h b/components/pthreads/pthread_tls.h deleted file mode 100644 index e69de29bb..000000000 -- GitLab