unsigned int Album::id() const { Q_D( const Album ); s_idMutex.lockForRead(); const bool waiting = d->waitingForId; unsigned int finalId = d->id; s_idMutex.unlock(); if ( waiting ) { finalId = d->idFuture.result(); s_idMutex.lockForWrite(); d->id = finalId; d->waitingForId = false; if ( d->id > 0 ) s_albumsById.insert( d->id, d->ownRef.toStrongRef() ); s_idMutex.unlock(); } return finalId; }
unsigned int TrackData::trackId() const { s_dataidMutex.lockForRead(); const bool waiting = m_waitingForId; unsigned int finalId = m_trackId; s_dataidMutex.unlock(); if ( waiting ) { finalId = m_idFuture.result(); s_dataidMutex.lockForWrite(); m_trackId = finalId; m_waitingForId = false; if ( m_trackId > 0 ) { s_trackDatasById.insert( m_trackId, m_ownRef.toStrongRef() ); } s_dataidMutex.unlock(); } return finalId; }
int mythdir_opendir(const char *dirname) { LOG(VB_FILE, LOG_DEBUG, LOC + QString("mythdir_opendir(%1)").arg(dirname)); int id = 0; if (strncmp(dirname, "myth://", 7)) { DIR *dir = opendir(dirname); m_dirWrapperLock.lockForWrite(); id = getNextDirID(); m_localdirs[id] = dir; m_dirnames[id] = dirname; m_dirWrapperLock.unlock(); } else { QStringList list; QUrl qurl(dirname); QString storageGroup = qurl.userName(); list.clear(); if (storageGroup.isEmpty()) storageGroup = "Default"; list << "QUERY_SG_GETFILELIST"; list << qurl.host(); list << storageGroup; QString path = qurl.path(); if (!qurl.fragment().isEmpty()) path += "#" + qurl.fragment(); list << path; list << "1"; bool ok = gCoreContext->SendReceiveStringList(list); if ((!ok) || ((list.size() == 1) && (list[0] == "EMPTY LIST"))) list.clear(); m_dirWrapperLock.lockForWrite(); id = getNextDirID(); m_remotedirs[id] = list; m_remotedirPositions[id] = 0; m_dirnames[id] = dirname; m_dirWrapperLock.unlock(); } return id; }
void tst_QReadWriteLock::readWriteLockUnlockLoop() { QReadWriteLock rwlock; int runs=10000; int i; for (i=0; i<runs; ++i) { rwlock.lockForRead(); rwlock.unlock(); rwlock.lockForWrite(); rwlock.unlock(); } }
void run() { readWriteLock.lockForWrite(); cond.wakeOne(); cond.wait(&readWriteLock); readWriteLock.unlock(); }
int mythfile_close(int fileID) { int result = -1; LOG(VB_FILE, LOG_DEBUG, LOC + QString("mythfile_close(%1)").arg(fileID)); m_fileWrapperLock.lockForRead(); if (m_ringbuffers.contains(fileID)) { RingBuffer *rb = m_ringbuffers[fileID]; m_ringbuffers.remove(fileID); delete rb; result = 0; } else if (m_remotefiles.contains(fileID)) { RemoteFile *rf = m_remotefiles[fileID]; m_remotefiles.remove(fileID); delete rf; result = 0; } else if (m_localfiles.contains(fileID)) { close(m_localfiles[fileID]); m_localfiles.remove(fileID); result = 0; } m_fileWrapperLock.unlock(); return result; }
int mythfile_stat_fd(int fileID, struct stat *buf) { LOG(VB_FILE, LOG_DEBUG, QString("mythfile_stat_fd(%1, %2)") .arg(fileID).arg((long long)buf)); m_fileWrapperLock.lockForRead(); if (!m_filenames.contains(fileID)) { m_fileWrapperLock.unlock(); return -1; } QString filename = m_filenames[fileID]; m_fileWrapperLock.unlock(); return mythfile_stat(filename.toLocal8Bit().constData(), buf); }
char *mythdir_readdir(int dirID) { char *result = NULL; LOG(VB_FILE, LOG_DEBUG, LOC + QString("mythdir_readdir(%1)").arg(dirID)); m_dirWrapperLock.lockForRead(); if (m_remotedirs.contains(dirID)) { int pos = m_remotedirPositions[dirID]; if (m_remotedirs[dirID].size() >= (pos+1)) { result = strdup(m_remotedirs[dirID][pos].toLocal8Bit().constData()); pos++; m_remotedirPositions[dirID] = pos; } } else if (m_localdirs.contains(dirID)) { struct dirent *entry = readdir(m_localdirs[dirID]); if (entry) { result = strdup(entry->d_name); } } m_dirWrapperLock.unlock(); return result; }
static void accuracyChanged(JNIEnv * /*env*/, jobject /*thiz*/, jint sensor, jint accuracy) { listenersLocker.lockForRead(); foreach (AndroidSensors::AndroidSensorsListenerInterface *listener, listenersHash[sensor]) listener->onAccuracyChanged(accuracy); listenersLocker.unlock(); }
void MainWindow::newQueue() { QueueDlg dlg(this); if(dlg.exec() == QDialog::Accepted) { Queue* q = new Queue; q->setName(dlg.m_strName); q->setSpeedLimits(dlg.m_nDownLimit,dlg.m_nUpLimit); if(dlg.m_bLimit) q->setTransferLimits(dlg.m_nDownTransfersLimit,dlg.m_nUpTransfersLimit); else q->setTransferLimits(-1, -1); q->setUpAsDown(dlg.m_bUpAsDown); q->setDefaultDirectory(dlg.m_strDefaultDirectory); q->setMoveDirectory(dlg.m_strMoveDirectory); g_queuesLock.lockForWrite(); g_queues << q; g_queuesLock.unlock(); Queue::saveQueuesAsync(); refreshQueues(); } }
void run() { readWriteLock->lockForRead(); started.wakeOne(); cond->wait(readWriteLock); readWriteLock->unlock(); }
void WriterThread::run() { ... lock.lockForWrite(); write_file(); lock.unlock(); ... }
void ReaderThread::run() { ... lock.lockForRead(); read_file(); lock.unlock(); ... }
void MainWindow::refreshQueues() { g_queuesLock.lockForRead(); int i; for(i=0;i<g_queues.size();i++) { QTreeWidgetItem* item; if(i>=treeQueues->topLevelItemCount()) { item = new QTreeWidgetItem(treeQueues, QStringList(g_queues[i]->name())); item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsDropEnabled | Qt::ItemIsEnabled); treeQueues->addTopLevelItem(item); } else { item = treeQueues->topLevelItem(i); item->setText(0, g_queues[i]->name()); } item->setData(0, Qt::UserRole, qVariantFromValue((void*) g_queues[i])); } while(i<treeQueues->topLevelItemCount()) qDebug() << "Removing item" << i << treeQueues->takeTopLevelItem(i); int upt = 0, downt = 0; int upq = 0, downq = 0; int cur = getSelectedQueue(); for(int j=0;j<g_queues.size();j++) { Queue* q = g_queues[j]; q->lock(); for(int i=0;i<q->size();i++) { int up,down; q->at(i)->speeds(down,up); downt += down; upt += up; if(j == cur) { downq += down; upq += up; } } q->unlock(); } g_queuesLock.unlock(); m_labelStatus.setText( QString(tr("Queue's speed: %1 down, %2 up")).arg(formatSize(downq,true)).arg(formatSize(upq,true)) ); }
int main(int argc, char** argv) { int i; const int n_threads = 10; std::vector<QThread*> tid(n_threads); s_iterations = argc > 1 ? atoi(argv[1]) : 1000; fprintf(stderr, "Start of test.\n"); { // Stack-allocated reader-writer lock. QReadWriteLock RWL; RWL.lockForRead(); RWL.unlock(); RWL.lockForWrite(); RWL.unlock(); } pthread_barrier_init(&s_barrier, 0, n_threads); s_pRWlock = new QReadWriteLock(); for (i = 0; i < n_threads; i++) { tid[i] = new IncThread; tid[i]->start(); } for (i = 0; i < n_threads; i++) { tid[i]->wait(); delete tid[i]; } delete s_pRWlock; s_pRWlock = 0; pthread_barrier_destroy(&s_barrier); if (s_counter == n_threads * s_iterations) fprintf(stderr, "Test successful.\n"); else fprintf(stderr, "Test failed: counter = %d, should be %d\n", s_counter, n_threads * s_iterations); return 0; }
void run() { readWriteLock->lockForWrite(); ready = true; startup->wakeOne(); returnValue = waitCondition->wait(readWriteLock, timeout); readWriteLock->unlock(); }
static void sensorChanged(JNIEnv *env, jobject /*thiz*/, jint sensor, jlong timeStamp, jfloatArray array) { uint size = env->GetArrayLength(array); jfloat *values = env->GetFloatArrayElements(array, 0); listenersLocker.lockForRead(); foreach (AndroidSensors::AndroidSensorsListenerInterface *listener, listenersHash[sensor]) listener->onSensorChanged(timeStamp, values, size); listenersLocker.unlock(); env->ReleaseFloatArrayElements(array, values, JNI_ABORT); // don't copy back the elements }
void run() { readWriteLock->lockForWrite(); ++count; dummy.wakeOne(); // this wakeup should be lost started.wakeOne(); dummy.wakeAll(); // this one too cond->wait(readWriteLock); --count; readWriteLock->unlock(); }
void run() { testsTurn.release(); threadsTurn.acquire(); QVERIFY(!readWriteLock.tryLockForRead()); testsTurn.release(); threadsTurn.acquire(); QVERIFY(readWriteLock.tryLockForRead()); lockCount.ref(); QVERIFY(readWriteLock.tryLockForRead()); lockCount.ref(); lockCount.deref(); readWriteLock.unlock(); lockCount.deref(); readWriteLock.unlock(); testsTurn.release(); threadsTurn.acquire(); QTime timer; timer.start(); QVERIFY(!readWriteLock.tryLockForRead(1000)); QVERIFY(timer.elapsed() >= 1000); testsTurn.release(); threadsTurn.acquire(); timer.start(); QVERIFY(readWriteLock.tryLockForRead(1000)); QVERIFY(timer.elapsed() <= 1000); lockCount.ref(); QVERIFY(readWriteLock.tryLockForRead(1000)); lockCount.ref(); lockCount.deref(); readWriteLock.unlock(); lockCount.deref(); readWriteLock.unlock(); testsTurn.release(); threadsTurn.acquire(); }
void TonemapperThread::terminateRequested() { if (forciblyTerminated) return; lock.lockForWrite(); pregamma=-1; xsize=-1; lock.unlock(); forciblyTerminated=true; //HACK oddly enough for the other operators we cannot emit finished (it segfaults) if (opts.tmoperator==mantiuk || opts.tmoperator==ashikhmin || opts.tmoperator==pattanaik ) emit finished(); terminate(); }
trackdata_ptr TrackData::get( unsigned int id, const QString& artist, const QString& track ) { s_dataidMutex.lockForRead(); if ( s_trackDatasById.contains( id ) ) { trackdata_wptr track = s_trackDatasById.value( id ); s_dataidMutex.unlock(); if ( track ) return track; } s_dataidMutex.unlock(); QMutexLocker lock( &s_datanameCacheMutex ); const QString key = cacheKey( artist, track ); if ( s_trackDatasByName.contains( key ) ) { trackdata_wptr track = s_trackDatasByName.value( key ); if ( track ) return track; } trackdata_ptr t = trackdata_ptr( new TrackData( id, artist, track ), &TrackData::deleteLater ); t->moveToThread( QCoreApplication::instance()->thread() ); t->setWeakRef( t.toWeakRef() ); s_trackDatasByName.insert( key, t ); if ( id > 0 ) { s_dataidMutex.lockForWrite(); s_trackDatasById.insert( id, t ); s_dataidMutex.unlock(); } else t->loadId( false ); return t; }
QList<QString> RuleList::dnsRequest(QString host) { static QReadWriteLock rwLock; static QMap<QString, QList<QString> > dnsCache; rwLock.lockForRead(); QList<QString> ipsCache=dnsCache[host]; rwLock.unlock(); if(ipsCache.size() > 0) { //qDebug("On a %i ips dans le cache pour l'host '%s'", ipsCache.size(), qPrintable(host)); return ipsCache; } else { QList<QString> ips; struct hostent *s_host; if((s_host = gethostbyname(qPrintable(host)))!=NULL) { struct in_addr **a; for (a=(struct in_addr **)s_host->h_addr_list; *a; a++) { ips.push_back(inet_ntoa(**a)); } // add the ips to the cache rwLock.lockForWrite(); dnsCache[host].clear(); dnsCache[host].append(ips); rwLock.unlock(); } else EventDispatcher::instance().sendCritical(QObject::tr("Error while querying the DNS server(Host='%1')").arg(host)); return ips; } }
int mythdir_check(int id) { LOG(VB_FILE, LOG_DEBUG, QString("mythdir_check(%1)").arg(id)); int result = 0; m_dirWrapperLock.lockForWrite(); if (m_localdirs.contains(id)) result = 1; else if (m_remotedirs.contains(id)) result = 1; m_dirWrapperLock.unlock(); return result; }
void run() { testsTurn.release(); threadsTurn.acquire(); if (readWriteLock.tryLockForWrite()) failureCount++; testsTurn.release(); threadsTurn.acquire(); if (!readWriteLock.tryLockForWrite()) failureCount++; if (!lockCount.testAndSetRelaxed(0, 1)) failureCount++; if (!lockCount.testAndSetRelaxed(1, 0)) failureCount++; readWriteLock.unlock(); testsTurn.release(); threadsTurn.acquire(); if (readWriteLock.tryLockForWrite(1000)) failureCount++; testsTurn.release(); threadsTurn.acquire(); if (!readWriteLock.tryLockForWrite(1000)) failureCount++; if (!lockCount.testAndSetRelaxed(0, 1)) failureCount++; if (!lockCount.testAndSetRelaxed(1, 0)) failureCount++; readWriteLock.unlock(); testsTurn.release(); threadsTurn.acquire(); }
//! Entrypoint for LogThread //! Check to see if there are things to log and if so, write them to disk. //! Otherwise, wait 100ms and check again. //! Exit only when "go" is false AND all queued events are written void LogThread::run() { while(! actionLog.isEmpty() || go) { while(! actionLog.isEmpty()) { // Write all queued log entries lock.lockForRead(); LogEntry entry = actionLog.dequeue(); lock.unlock(); outStream << entry.dat.asInt << entry.position; ++logEntryCountByServo[entry.dat.asBitfield.servoIndex]; yieldCurrentThread(); } msleep(100); } exit(0); }
unsigned int Album::id() const { s_idMutex.lockForRead(); const bool waiting = m_waitingForId; unsigned int finalId = m_id; s_idMutex.unlock(); if ( waiting ) { finalId = m_idFuture.result(); s_idMutex.lockForWrite(); m_id = finalId; m_waitingForId = false; if ( m_id > 0 ) s_albumsById.insert( m_id, m_ownRef.toStrongRef() ); s_idMutex.unlock(); } return finalId; }
album_ptr Album::get( unsigned int id, const QString& name, const Tomahawk::artist_ptr& artist ) { s_idMutex.lockForRead(); if ( s_albumsById.contains( id ) ) { album_wptr album = s_albumsById.value( id ); s_idMutex.unlock(); if ( album ) return album; } s_idMutex.unlock(); QMutexLocker lock( &s_nameCacheMutex ); const QString key = albumCacheKey( artist, name ); if ( s_albumsByName.contains( key ) ) { album_wptr album = s_albumsByName.value( key ); if ( album ) return album; } album_ptr a = album_ptr( new Album( id, name, artist ), &Album::deleteLater ); a->setWeakRef( a.toWeakRef() ); s_albumsByName.insert( key, a ); if ( id > 0 ) { s_idMutex.lockForWrite(); s_albumsById.insert( id, a ); s_idMutex.unlock(); } return a; }
int mythfile_check(int id) { VERBOSE(VB_FILE+VB_EXTRA, QString("mythfile_check(%1)").arg(id)); int result = 0; m_fileWrapperLock.lockForWrite(); if (m_localfiles.contains(id)) result = 1; else if (m_remotefiles.contains(id)) result = 1; else if (m_ringbuffers.contains(id)) result = 1; m_fileWrapperLock.unlock(); return result; }
off_t mythfile_tell(int fileID) { off_t result = -1; LOG(VB_FILE, LOG_DEBUG, LOC + QString("mythfile_tell(%1)").arg(fileID)); m_fileWrapperLock.lockForRead(); if (m_ringbuffers.contains(fileID)) result = m_ringbuffers[fileID]->Seek(0, SEEK_CUR); else if (m_remotefiles.contains(fileID)) result = m_remotefiles[fileID]->Seek(0, SEEK_CUR); else if (m_localfiles.contains(fileID)) result = lseek(m_localfiles[fileID], 0, SEEK_CUR); m_fileWrapperLock.unlock(); return result; }
ssize_t mythfile_write(int fileID, void *buf, size_t count) { ssize_t result = -1; LOG(VB_FILE, LOG_DEBUG, LOC + QString("mythfile_write(%1, %2, %3)") .arg(fileID) .arg((long long)buf).arg(count)); m_fileWrapperLock.lockForRead(); if (m_ringbuffers.contains(fileID)) result = m_ringbuffers[fileID]->Write(buf, count); else if (m_remotefiles.contains(fileID)) result = m_remotefiles[fileID]->Write(buf, count); else if (m_localfiles.contains(fileID)) result = write(m_localfiles[fileID], buf, count); m_fileWrapperLock.unlock(); return result; }