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;
}
