/** * Initializes a condition variable. */ void vlc_cond_init (vlc_cond_t *p_condvar) { pthread_condattr_t attr; if (unlikely(pthread_condattr_init (&attr))) abort (); #if !defined (_POSIX_CLOCK_SELECTION) /* Fairly outdated POSIX support (that was defined in 2001) */ # define _POSIX_CLOCK_SELECTION (-1) #endif #if (_POSIX_CLOCK_SELECTION >= 0) /* NOTE: This must be the same clock as the one in mtime.c */ pthread_condattr_setclock (&attr, CLOCK_MONOTONIC); #endif if (unlikely(pthread_cond_init (p_condvar, &attr))) abort (); pthread_condattr_destroy (&attr); }
void r_cond_init (RCond * cond) { #if defined (R_OS_WIN32) PCONDITION_VARIABLE pc = *cond = r_mem_new (CONDITION_VARIABLE); InitializeConditionVariable (pc); #elif defined (HAVE_PTHREAD_H) pthread_condattr_t attr; pthread_cond_t * pc; pthread_condattr_init (&attr); pc = *cond = r_mem_new (pthread_cond_t); pthread_cond_init (pc, &attr); pthread_condattr_destroy (&attr); #else (void) cond; #endif }
int traceobj_init(struct traceobj *trobj, const char *label, int nr_marks) { pthread_mutexattr_t mattr; pthread_condattr_t cattr; int ret; pthread_mutexattr_init(&mattr); pthread_mutexattr_settype(&mattr, mutex_type_attribute); pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT); pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_PRIVATE); ret = __bt(-__RT(pthread_mutex_init(&trobj->lock, &mattr))); pthread_mutexattr_destroy(&mattr); if (ret) return ret; pthread_condattr_init(&cattr); pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_PRIVATE); ret = __bt(-__RT(pthread_cond_init(&trobj->join, &cattr))); pthread_condattr_destroy(&cattr); if (ret) { __RT(pthread_mutex_destroy(&trobj->lock)); return ret; } /* * We make sure not to unblock from threadobj_join() until at * least one thread has called trace_enter() for this trace * object. */ trobj->nr_threads = -1; trobj->label = label; trobj->nr_marks = nr_marks; trobj->cur_mark = 0; if (nr_marks > 0) { trobj->marks = pvmalloc(sizeof(struct tracemark) * nr_marks); if (trobj->marks == NULL) panic("cannot allocate mark table for tracing"); } return 0; }
int main() { /* Make sure there is process-shared capability. */ #ifndef PTHREAD_PROCESS_SHARED fprintf(stderr, "process-shared attribute is not available for testing\n"); return PTS_UNRESOLVED; #endif pthread_condattr_t attr; int ret; /* Initialize a cond attributes object */ if (pthread_condattr_init(&attr) != 0) { perror("Error at pthread_condattr_init()\n"); return PTS_UNRESOLVED; } /* Set 'pshared' to INVALID_PSHARED_VALUE. */ ret = pthread_condattr_setpshared(&attr, INVALID_PSHARED_VALUE); if (ret != 0) { if (ret == EINVAL) { printf("Test PASSED\n"); return PTS_PASS; } printf ("Test FAILED: Invalid return code, expected 0 or EINVAL, but got: %d\n", ret); return PTS_FAIL; } /* Destory the cond attributes object */ if (pthread_condattr_destroy(&attr) != 0) { perror("Error at pthread_condattr_destroy()\n"); return PTS_UNRESOLVED; } printf ("Test PASSED: NOTE*: Returned 0 when passed an invalid 'pshared', but standard says 'may' fail.\n"); return PTS_PASS; }
int xsim_barrier_init(xsim_barrier_t *barrier, int needed) { pthread_mutexattr_t mattr; pthread_condattr_t cattr; barrier->count = needed; barrier->current = 0; pthread_mutexattr_init(&mattr); pthread_mutexattr_setpshared(&mattr, 1); pthread_mutex_init(&barrier->lock, &mattr); pthread_condattr_init(&cattr); pthread_condattr_setpshared(&cattr, 1); pthread_cond_init(&barrier->cond, &cattr); return XSIM_SUCCESS; }
inline interprocess_condition::interprocess_condition() { int res; pthread_condattr_t cond_attr; res = pthread_condattr_init(&cond_attr); if(res != 0){ throw interprocess_exception(); } res = pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED); if(res != 0){ pthread_condattr_destroy(&cond_attr); throw interprocess_exception(res); } res = pthread_cond_init(&m_condition, &cond_attr); pthread_condattr_destroy(&cond_attr); if(res != 0){ throw interprocess_exception(res); } }
ca_cond ca_cond_new(void) { ca_cond retVal = NULL; ca_cond_internal *eventInfo = (ca_cond_internal*) OICMalloc(sizeof(ca_cond_internal)); if (NULL != eventInfo) { int ret = pthread_condattr_init(&(eventInfo->condattr)); if(0 != ret) { OIC_LOG_V(ERROR, TAG, "%s: Failed to initialize condition variable attribute %d!", __func__, ret); OICFree(eventInfo); return retVal; } #if defined(__ANDROID__) || _POSIX_TIMERS > 0 ret = pthread_condattr_setclock(&(eventInfo->condattr), CLOCK_MONOTONIC); if(0 != ret) { OIC_LOG_V(ERROR, TAG, "%s: Failed to set condition variable clock %d!", __func__, ret); pthread_condattr_destroy(&(eventInfo->condattr)); OICFree(eventInfo); return retVal; } #endif ret = pthread_cond_init(&(eventInfo->cond), &(eventInfo->condattr)); if (0 == ret) { retVal = (ca_cond) eventInfo; } else { OIC_LOG_V(ERROR, TAG, "%s: Failed to initialize condition variable %d!", __func__, ret); pthread_condattr_destroy(&(eventInfo->condattr)); OICFree(eventInfo); } } return retVal; }
SemaphoreImpl::SemaphoreImpl(int n, int max): _n(n), _max(max) { poco_assert (n >= 0 && max > 0 && n <= max); #if defined(POCO_VXWORKS) // This workaround is for VxWorks 5.x where // pthread_mutex_init() won't properly initialize the mutex // resulting in a subsequent freeze in pthread_mutex_destroy() // if the mutex has never been used. std::memset(&_mutex, 0, sizeof(_mutex)); #endif if (pthread_mutex_init(&_mutex, NULL)) throw SystemException("cannot create semaphore (mutex)"); #if defined(POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT) pthread_condattr_t attr; if (pthread_condattr_init(&attr)) { pthread_mutex_destroy(&_mutex); throw SystemException("cannot create semaphore (condition attribute)"); } if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC)) { pthread_condattr_destroy(&attr); pthread_mutex_destroy(&_mutex); throw SystemException("cannot create semaphore (condition attribute clock)"); } if (pthread_cond_init(&_cond, &attr)) { pthread_condattr_destroy(&attr); pthread_mutex_destroy(&_mutex); throw SystemException("cannot create semaphore (condition)"); } pthread_condattr_destroy(&attr); #else if (pthread_cond_init(&_cond, NULL)) { pthread_mutex_destroy(&_mutex); throw SystemException("cannot create semaphore (condition)"); } #endif }
struct OsCond * os_cond_create(void) { struct OsCond *cond = allocate_zero<OsCond>(1); if (!cond) { os_cond_destroy(cond); return NULL; } #if defined(GENESIS_OS_WINDOWS) InitializeConditionVariable(&cond->id); InitializeCriticalSection(&cond->default_cs_id); #elif defined(GENESIS_OS_KQUEUE) cond->kq_id = kqueue(); if (cond->kq_id == -1) return NULL; #else if (pthread_condattr_init(&cond->attr)) { os_cond_destroy(cond); return NULL; } cond->attr_init = true; if (pthread_condattr_setclock(&cond->attr, CLOCK_MONOTONIC)) { os_cond_destroy(cond); return NULL; } if (pthread_cond_init(&cond->id, &cond->attr)) { os_cond_destroy(cond); return NULL; } cond->id_init = true; if ((pthread_mutex_init(&cond->default_mutex_id, NULL))) { os_cond_destroy(cond); return NULL; } cond->default_mutex_init = true; #endif return cond; }
struct SoundIoOsCond * soundio_os_cond_create(void) { struct SoundIoOsCond *cond = ALLOCATE(struct SoundIoOsCond, 1); if (!cond) { soundio_os_cond_destroy(cond); return NULL; } #if defined(SOUNDIO_OS_WINDOWS) InitializeConditionVariable(&cond->id); InitializeCriticalSection(&cond->default_cs_id); #elif defined(SOUNDIO_OS_KQUEUE) cond->kq_id = kqueue(); if (cond->kq_id == -1) return NULL; #else if (pthread_condattr_init(&cond->attr)) { soundio_os_cond_destroy(cond); return NULL; } cond->attr_init = true; if (pthread_condattr_setclock(&cond->attr, CLOCK_MONOTONIC)) { soundio_os_cond_destroy(cond); return NULL; } if (pthread_cond_init(&cond->id, &cond->attr)) { soundio_os_cond_destroy(cond); return NULL; } cond->id_init = true; if ((pthread_mutex_init(&cond->default_mutex_id, NULL))) { soundio_os_cond_destroy(cond); return NULL; } cond->default_mutex_init = true; #endif return cond; }
/* * On first invocation, allocates a condition variable attributes * structure and initializes it with appropriate attributes. In * all cases, returns a pointer to the structure. */ pthread_condattr_t * ipc_condattr(void) { if (condattr == NULL) { if ((condattr = malloc(sizeof (pthread_condattr_t))) == NULL) { filebench_log(LOG_ERROR, "cannot alloc cond attr"); filebench_shutdown(1); } (void) pthread_condattr_init(condattr); #ifdef HAVE_PTHREAD_MUTEXATTR_SETPSHARED if (pthread_condattr_setpshared(condattr, PTHREAD_PROCESS_SHARED) != 0) { filebench_log(LOG_ERROR, "cannot set cond attr PROCESS_SHARED"); // filebench_shutdown(1); } #endif /* HAVE_PTHREAD_MUTEXATTR_SETPSHARED */ } return (condattr); }
int thread_pool_create(thread_pool *new_pool, long max_running_threads) { thread_id i; if((new_pool->threads = (pthread_t *) calloc((size_t) max_running_threads, sizeof(pthread_t))) == NULL) return -1; if((new_pool->working = (bool *) calloc((size_t) max_running_threads, sizeof(bool))) == NULL) return -1; if(pthread_condattr_init(&(new_pool->cond_attr)) != 0) return -1; if(pthread_cond_init(&new_pool->sleeping, &(new_pool->cond_attr)) != 0) return -1; new_pool->running_threads = 0; new_pool->max_running_threads = max_running_threads; new_pool->unused = NULL; for(i = 0; i < max_running_threads; i ++) new_pool->unused = stack_push(new_pool->unused, i); new_pool->sleeping_quantity = 0; return 0; }
OSCond::OSCond() : fWaitCount(0) { #ifdef __Win32__ fCondition = ::CreateEvent(NULL, FALSE, FALSE, NULL); Assert(fCondition != NULL); #elif __PTHREADS_MUTEXES__ #if __MacOSX__ int ret = pthread_cond_init(&fCondition, NULL); Assert(ret == 0); #else pthread_condattr_t cond_attr; pthread_condattr_init(&cond_attr); int ret = pthread_cond_init(&fCondition, &cond_attr); Assert(ret == 0); #endif #else fCondition = mycondition_alloc(); Assert(fCondition != NULL); #endif }
int uv_cond_init(uv_cond_t* cond) { pthread_condattr_t attr; if (pthread_condattr_init(&attr)) return -1; #if !(defined(__ANDROID__) && defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC)) if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC)) goto error2; #endif if (pthread_cond_init(cond, &attr)) goto error2; if (pthread_condattr_destroy(&attr)) goto error; return 0; error: pthread_cond_destroy(cond); error2: pthread_condattr_destroy(&attr); return -1; }
void xshmfence_init(int fd) { struct xshmfence *f = xshmfence_map_shm(fd); pthread_mutexattr_t mutex_attr; pthread_condattr_t cond_attr; if (!f) return; pthread_mutexattr_init(&mutex_attr); pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED); pthread_mutex_init(&f->lock, &mutex_attr); pthread_condattr_init(&cond_attr); pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED); pthread_cond_init(&f->wakeup, &cond_attr); f->value = 0; f->waiting = 0; xshmfence_unmap_shm(f); }
int sysv_barrier_create(sysv_barrier_t barrier, int num_procs) { pthread_mutexattr_t mutex_shared_attr; PTHREAD_SAFE(pthread_mutexattr_init(&mutex_shared_attr)); PTHREAD_SAFE(pthread_mutexattr_setpshared(&mutex_shared_attr, PTHREAD_PROCESS_SHARED)); PTHREAD_SAFE(pthread_mutex_init(&(barrier->mutex), &mutex_shared_attr)); PTHREAD_SAFE(pthread_mutexattr_destroy(&mutex_shared_attr)); pthread_condattr_t cond_shared_attr; PTHREAD_SAFE(pthread_condattr_init(&cond_shared_attr)); PTHREAD_SAFE(pthread_condattr_setpshared(&cond_shared_attr, PTHREAD_PROCESS_SHARED)); PTHREAD_SAFE(pthread_cond_init(&(barrier->cond), &cond_shared_attr)); PTHREAD_SAFE(pthread_condattr_destroy(&cond_shared_attr)); barrier->num_procs = num_procs; barrier->num_waiting = 0; return 0; }
/* * On first invocation, allocates a condition variable attributes * structure and initializes it with appropriate attributes. In * all cases, returns a pointer to the structure. */ pthread_condattr_t * ipc_condattr(void) { #ifdef USE_PROCESS_MODEL if (condattr == NULL) { if ((condattr = malloc(sizeof (pthread_condattr_t))) == NULL) { filebench_log(LOG_ERROR, "cannot alloc cond attr"); filebench_shutdown(1); } #ifdef HAVE_PROCSCOPE_PTHREADS (void) pthread_condattr_init(condattr); if (pthread_condattr_setpshared(condattr, PTHREAD_PROCESS_SHARED) != 0) { filebench_log(LOG_ERROR, "cannot set cond attr PROCESS_SHARED"); filebench_shutdown(1); } #endif /* HAVE_PROCSCOPE_PTHREADS */ } #endif /* USE_PROCESS_MODEL */ return (condattr); }
clsThread::clsThread() { m_idThread = 0; m_chThread = ChannelCreate(0); m_coidThread = ConnectAttach(ND_LOCAL_NODE, 0, m_chThread, _NTO_SIDE_CHANNEL, 0); pthread_condattr_t attrCond; pthread_condattr_init(&attrCond); pthread_cond_init(&m_condThread, &attrCond); pthread_mutexattr_t attrMtx; pthread_mutexattr_init(&attrMtx); pthread_mutex_init(&m_mtxThread, &attrMtx); pthread_mutex_lock(&m_mtxThread); m_bReady = FALSE; m_nCount = 0; }
ion_semaphore_t * IonImageSem::Create(const char *semaphore_name) { int fd; ion_semaphore_t *semap; fd = open(semaphore_name, O_RDWR | O_CREAT /*| O_EXCL*/, 0666); if (fd < 0){ ISMLOG("%s: failed, %s\n",__FUNCTION__,strerror(errno)); return (NULL); } if( ftruncate(fd, sizeof(ion_semaphore_t))) {} #ifdef USE_ION_PTHREAD_SEM pthread_mutexattr_t psharedm; pthread_condattr_t psharedc; (void) pthread_mutexattr_init(&psharedm); // int robustness=0; // (void) pthread_mutexattr_getrobust_np(&psharedm,&robustness); // DTRACEP("%s: robust: %d\n",__FUNCTION__,robustness); (void) pthread_mutexattr_setpshared(&psharedm, PTHREAD_PROCESS_SHARED); (void)pthread_mutexattr_setrobust_np(&psharedm, PTHREAD_MUTEX_ROBUST_NP); (void) pthread_condattr_init(&psharedc); (void) pthread_condattr_setpshared(&psharedc, PTHREAD_PROCESS_SHARED); #endif semap = (ion_semaphore_t *) mmap(NULL, sizeof(ion_semaphore_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); close (fd); if(semap) { memset(semap,0,sizeof(ion_semaphore_t)); #ifdef USE_ION_PTHREAD_SEM (void) pthread_mutex_init(&semap->lock, &psharedm); #endif // (void) pthread_cond_init(&semap->nonzero, &psharedc); } return (semap); }
int OSA_flgCreate(OSA_FlgHndl *hndl, Uint32 initPattern) { pthread_mutexattr_t mutex_attr; pthread_condattr_t cond_attr; int status=OSA_SOK; status |= pthread_mutexattr_init(&mutex_attr); status |= pthread_condattr_init(&cond_attr); status |= pthread_mutex_init(&hndl->lock, &mutex_attr); status |= pthread_cond_init(&hndl->cond, &cond_attr); hndl->pattern = initPattern; if(status!=OSA_SOK) OSA_ERROR("OSA_flgCreate() = %d \r\n", status); pthread_condattr_destroy(&cond_attr); pthread_mutexattr_destroy(&mutex_attr); return status; }
int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr) { pthread_mutexattr_t* lock_attr = NULL; pthread_condattr_t* cond_attr = NULL; pthread_mutexattr_t lock_attr0; pthread_condattr_t cond_attr0; int ret; if (rwlock == NULL) return EINVAL; if (attr && *attr == PTHREAD_PROCESS_SHARED) { lock_attr = &lock_attr0; pthread_mutexattr_init(lock_attr); pthread_mutexattr_setpshared(lock_attr, PTHREAD_PROCESS_SHARED); cond_attr = &cond_attr0; pthread_condattr_init(cond_attr); pthread_condattr_setpshared(cond_attr, PTHREAD_PROCESS_SHARED); } ret = pthread_mutex_init(&rwlock->lock, lock_attr); if (ret != 0) return ret; ret = pthread_cond_init(&rwlock->cond, cond_attr); if (ret != 0) { pthread_mutex_destroy(&rwlock->lock); return ret; } rwlock->numLocks = 0; rwlock->pendingReaders = 0; rwlock->pendingWriters = 0; rwlock->writerThreadId = 0; return 0; }
int main() { pthread_condattr_t condattr; /* Initialize a condition variable attributes object */ if(pthread_condattr_init(&condattr) != 0) { fprintf(stderr,"Cannot initialize condition variable attributes object\n"); return PTS_UNRESOLVED; } /* Destroy the condition variable attributes object */ if(pthread_condattr_destroy(&condattr) != 0) { printf("Test FAILED\n"); return PTS_FAIL; } else { printf("Test PASSED\n"); return PTS_PASS; } }
BOOL InitializeConditionVariables ( void ) { int err; if ( (err = pthread_condattr_init( &(shmp->shmem_cv_attr) ) ) != 0 ) { DbgLog(DL0,"InitializeConditionVariables: pthread_condattr_init returned %s (%d; %#x)\n", SysConst(err), err, err); return FALSE; } if ( (err = pthread_cond_init( &(shmp->shmem_cv), &(shmp->shmem_cv_attr) ) ) != 0 ) { DbgLog(DL0,"InitializeConditionVariables: pthread_cond_init returned %s (%d; %#x)\n", SysConst(err), err, err); return FALSE; } if ( (err = pthread_mutex_init( &(shmp->shmem_cv_mutex), &mtxattr ) ) != 0 ) { DbgLog(DL0,"InitializeConditionVariables: pthread_mutex_init returned %s (%d; %#x)\n", SysConst(err), err, err); return FALSE; } return TRUE; }
void init_ring_buffer(struct ring_buffer* rbuff) { rbuff->request_writes = 0; rbuff->request_reads = 0; rbuff->response_writes = 0; rbuff->response_reads = 0; pthread_mutexattr_t mattr; pthread_mutexattr_init(&mattr); pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED); pthread_mutex_init(&rbuff->data_mutex, &mattr); pthread_condattr_t cattr; pthread_condattr_init(&cattr); pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED); pthread_cond_init(&rbuff->nonempty, &cattr); int i; for(i = 0; i < MAXSIZE; i++) { pthread_cond_init(&rbuff->response_ready[i], &cattr); rbuff->request_buffer[i].response = i; } }
int uv_cond_init(uv_cond_t* cond) { pthread_condattr_t attr; if (pthread_condattr_init(&attr)) return -1; if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC)) goto error2; if (pthread_cond_init(cond, &attr)) goto error2; if (pthread_condattr_destroy(&attr)) goto error; return 0; error: pthread_cond_destroy(cond); error2: pthread_condattr_destroy(&attr); return -1; }
int main() { pthread_condattr_t condattr; int rc; /* Initialize a cond attributes object */ if ((rc=pthread_condattr_init(&condattr)) != 0) { fprintf(stderr,"Error at pthread_condattr_init(), rc=%d\n",rc); printf("Test FAILED\n"); return PTS_FAIL; } rc = pthread_condattr_setclock(&condattr, CLOCK_REALTIME); if (rc != 0) { printf("Test FAILED: Could not set clock to CLOCK_REALTIME\n"); return PTS_FAIL; } printf("Test PASSED\n"); return PTS_PASS; }
int main() { pthread_condattr_t condattr; int rc; /* Initialize a condition variable attributes object */ if((rc=pthread_condattr_init(&condattr)) != 0) { fprintf(stderr,"Cannot initialize condition variable attributes object\n"); return PTS_UNRESOLVED; } /* Destroy the condition variable attributes object */ if(pthread_condattr_destroy(&condattr) != 0) { fprintf(stderr,"Error at pthread_condattr_destroy(), rc=%d\n", rc); printf("Test FAILED\n"); return PTS_FAIL; } printf("Test PASSED\n"); return PTS_PASS; }
int main() { pthread_condattr_t condattr; int rc; /* Initialize a cond attributes object */ if ((rc=pthread_condattr_init(&condattr)) != 0) { fprintf(stderr,"Error at pthread_condattr_init(), rc=%d\n",rc); printf("Test FAILED\n"); return PTS_FAIL; } rc = pthread_condattr_setclock(&condattr, INVALID_CLOCKID); if (rc != EINVAL) { printf("Test PASSED: *NOTE: Test passed while passing an invalid clockid, but the standard says 'may' fail\n"); return PTS_PASS; } printf("Test PASSED\n"); return PTS_PASS; }
int main(void) { pthread_condattr_t condattr; clockid_t clockid; int rc; /* Initialize a cond attributes object */ if ((rc = pthread_condattr_init(&condattr)) != 0) { fprintf(stderr, "Error at pthread_condattr_init(), rc=%d\n", rc); printf("Test FAILED\n"); return PTS_FAIL; } rc = pthread_condattr_getclock(&condattr, &clockid); if (rc != 0) { printf("Test FAILED: Could not get the clock attribute\n"); return PTS_FAIL; } printf("Test PASSED\n"); return PTS_PASS; }
int main(void) { pthread_condattr_t condattr; int rc; /* Initialize a condition variable attributes object */ if ((rc = pthread_condattr_init(&condattr)) == 0) { printf("Test PASSED\n"); return PTS_PASS; } /* Insufficient memory exists to initialize the condition variable attributes object */ else if (rc == ENOMEM) { fprintf(stderr, "pthread_condattr_init() returns ENOMEM\n"); return PTS_UNRESOLVED; } /* Any other returned value means the test failed */ else { printf("Test FAILED\n"); return PTS_FAIL; } }