int main() { int rc; struct timespec abstime, reltime = { 0, NANOSEC_PER_SEC/2 }; assert(pthread_cond_init(&cnd, 0) == 0); assert(pthread_mutex_init(&mtx, 0) == 0); (void) pthread_win32_getabstime_np(&abstime, &reltime); /* Here pthread_cond_timedwait should time out after one second. */ assert(pthread_mutex_lock(&mtx) == 0); assert((rc = pthread_cond_timedwait(&cnd, &mtx, &abstime)) == ETIMEDOUT); assert(pthread_mutex_unlock(&mtx) == 0); /* Here, the condition variable is signalled, but there are no threads waiting on it. The signal should be lost and the next pthread_cond_timedwait should time out too. */ assert((rc = pthread_cond_signal(&cnd)) == 0); assert(pthread_mutex_lock(&mtx) == 0); (void) pthread_win32_getabstime_np(&abstime, &reltime); assert((rc = pthread_cond_timedwait(&cnd, &mtx, &abstime)) == ETIMEDOUT); assert(pthread_mutex_unlock(&mtx) == 0); return 0; }
int main() { pthread_t t[NUMTHREADS]; struct timespec abstime, reltime = { 5, 0 }; assert((t[0] = pthread_self()).p != NULL); assert(pthread_cond_init(&cv, NULL) == 0); assert(pthread_mutex_init(&mutex, NULL) == 0); assert(pthread_mutex_lock(&mutex) == 0); assert(pthread_create(&t[1], NULL, mythread, (void *) 1) == 0); (void) pthread_win32_getabstime_np(&abstime, &reltime); while (! (shared > 0)) assert(pthread_cond_timedwait(&cv, &mutex, &abstime) == 0); assert(shared > 0); assert(pthread_mutex_unlock(&mutex) == 0); assert(pthread_join(t[1], NULL) == 0); assert(pthread_cond_destroy(&cv) == 0); return 0; }
int main() { struct timespec abstime = { 0, 0 }, reltime = { 1, 0 }; assert(pthread_cond_init(&cv, NULL) == 0); assert(pthread_mutex_init(&mutex, NULL) == 0); assert(pthread_mutex_lock(&mutex) == 0); (void) pthread_win32_getabstime_np(&abstime, &reltime); assert(pthread_cond_timedwait(&cv, &mutex, &abstime) == ETIMEDOUT); assert(pthread_mutex_unlock(&mutex) == 0); { int result = pthread_cond_destroy(&cv); if (result != 0) { fprintf(stderr, "Result = %s\n", error_string[result]); fprintf(stderr, "\tWaitersBlocked = %ld\n", cv->nWaitersBlocked); fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone); fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock); fflush(stderr); } assert(result == 0); } return 0; }
int main(int argc, char * argv[]) { pthread_t id; struct timespec abstime, reltime = { 1, 0 }; void* result = (void*)-1; assert(pthread_create(&id, NULL, func, (void *)(size_t)999) == 0); /* * Let thread start before we attempt to join it. */ Sleep(100); (void) pthread_win32_getabstime_np(&abstime, &reltime); /* Test for pthread_timedjoin_np timeout */ assert(pthread_timedjoin_np(id, &result, &abstime) == ETIMEDOUT); assert((int)(size_t)result == -1); /* Test for pthread_tryjoin_np behaviour before thread has exited */ assert(pthread_tryjoin_np(id, &result) == EBUSY); assert((int)(size_t)result == -1); Sleep(500); /* Test for pthread_tryjoin_np behaviour after thread has exited */ assert(pthread_tryjoin_np(id, &result) == 0); assert((int)(size_t)result == 999); /* Success. */ return 0; }
void * slaveThread (void * arg) { struct timespec abstime, reltime; pthread_barrier_wait(&startBarrier); do { assert(pthread_mutex_lock(&control.mx) == 0); reltime.tv_sec = (control.value / 1000); reltime.tv_nsec = (control.value % 1000) * NANOSEC_PER_MILLISEC; if (pthread_cond_timedwait(&control.cv, &control.mx, pthread_win32_getabstime_np(&abstime, &reltime)) == ETIMEDOUT) { timeoutCount++; } else { signalsTakenCount++; } assert(pthread_mutex_unlock(&control.mx) == 0); pthread_barrier_wait(&holdBarrier); pthread_barrier_wait(&readyBarrier); } while (!allExit); return NULL; }
int main() { pthread_t t[NUMTHREADS]; struct timespec abstime, reltime = { 5, 0 }; cvthing.shared = 0; assert((t[0] = pthread_self()).p != NULL); assert(cvthing.notbusy == PTHREAD_COND_INITIALIZER); assert(cvthing.lock == PTHREAD_MUTEX_INITIALIZER); assert(pthread_mutex_lock(&cvthing.lock) == 0); assert(cvthing.lock != PTHREAD_MUTEX_INITIALIZER); (void) pthread_win32_getabstime_np(&abstime, &reltime); assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == ETIMEDOUT); assert(cvthing.notbusy != PTHREAD_COND_INITIALIZER); assert(pthread_create(&t[1], NULL, mythread, (void *) 1) == 0); (void) pthread_win32_getabstime_np(&abstime, &reltime); while (! (cvthing.shared > 0)) assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == 0); assert(cvthing.shared > 0); assert(pthread_mutex_unlock(&cvthing.lock) == 0); assert(pthread_join(t[1], NULL) == 0); assert(pthread_mutex_destroy(&cvthing.lock) == 0); assert(cvthing.lock == NULL); assert(pthread_cond_destroy(&cvthing.notbusy) == 0); assert(cvthing.notbusy == NULL); return 0; }
void * locker(void * arg) { struct timespec abstime, reltime = { 1, 0 }; (void) pthread_win32_getabstime_np(&abstime, &reltime); assert(pthread_mutex_timedlock(&mutex, &abstime) == ETIMEDOUT); lockCount++; return 0; }
int main() { pthread_t t; struct timespec abstime, reltime = { 1, 0 }; (void) pthread_win32_getabstime_np(&abstime, &reltime); assert(pthread_rwlock_timedwrlock(&rwlock1, &abstime) == 0); assert(pthread_create(&t, NULL, func, NULL) == 0); Sleep(2000); assert(pthread_rwlock_unlock(&rwlock1) == 0); assert(washere == 1); return 0; }
int main() { struct timespec abstime, reltime = { 1, 0 }; (void) pthread_win32_getabstime_np(&abstime, &reltime); assert(rwlock == PTHREAD_RWLOCK_INITIALIZER); assert(pthread_rwlock_timedrdlock(&rwlock, &abstime) == 0); assert(rwlock != PTHREAD_RWLOCK_INITIALIZER); assert(rwlock != NULL); assert(pthread_rwlock_unlock(&rwlock) == 0); assert(pthread_rwlock_destroy(&rwlock) == 0); assert(rwlock == NULL); return 0; }
int main() { int failed = 0; int i; int first, last; pthread_t t[NUMTHREADS + 1]; assert((t[0] = pthread_self()).p != NULL); assert(cvthing.notbusy == PTHREAD_COND_INITIALIZER); assert(cvthing.lock == PTHREAD_MUTEX_INITIALIZER); (void) pthread_win32_getabstime_np(&abstime, &reltime); assert((t[0] = pthread_self()).p != NULL); awoken = 0; for (first = 1, last = NUMTHREADS / 2; first < NUMTHREADS; first = last + 1, last = NUMTHREADS) { assert(pthread_mutex_lock(&start_flag) == 0); for (i = first; i <= last; i++) { threadbag[i].started = 0; threadbag[i].threadnum = i; assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0); } /* * Code to control or manipulate child threads should probably go here. */ cvthing.shared = 0; assert(pthread_mutex_unlock(&start_flag) == 0); /* * Give threads time to start. */ Sleep(100); assert(pthread_mutex_lock(&cvthing.lock) == 0); cvthing.shared++; assert(pthread_mutex_unlock(&cvthing.lock) == 0); assert(pthread_cond_broadcast(&cvthing.notbusy) == 0); /* * Give threads time to complete. */ for (i = first; i <= last; i++) { assert(pthread_join(t[i], NULL) == 0); } assert(awoken == (i - 1)); } /* * Standard check that all threads started. */ for (i = 1; i <= NUMTHREADS; i++) { failed = !threadbag[i].started; if (failed) { fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started); } } /* * Cleanup the CV. */ assert(pthread_mutex_destroy(&cvthing.lock) == 0); assert(cvthing.lock == NULL); assert(pthread_cond_destroy(&cvthing.notbusy) == 0); assert(cvthing.notbusy == NULL); assert(!failed); /* * Check any results here. */ assert(awoken == NUMTHREADS); /* * Success. */ return 0; }