void tst_QThreadPool::setMaxThreadCount()
{
QFETCH(int, limit);
QThreadPool *threadPool = QThreadPool::globalInstance();
int savedLimit = threadPool->maxThreadCount();
// maxThreadCount() should always return the previous argument to
// setMaxThreadCount(), regardless of input
threadPool->setMaxThreadCount(limit);
QCOMPARE(threadPool->maxThreadCount(), limit);
// the value returned from maxThreadCount() should always be valid input for setMaxThreadCount()
threadPool->setMaxThreadCount(savedLimit);
QCOMPARE(threadPool->maxThreadCount(), savedLimit);
// setting the limit on children should have no effect on the parent
{
QThreadPool threadPool2(threadPool);
savedLimit = threadPool2.maxThreadCount();
// maxThreadCount() should always return the previous argument to
// setMaxThreadCount(), regardless of input
threadPool2.setMaxThreadCount(limit);
QCOMPARE(threadPool2.maxThreadCount(), limit);
// the value returned from maxThreadCount() should always be valid input for setMaxThreadCount()
threadPool2.setMaxThreadCount(savedLimit);
QCOMPARE(threadPool2.maxThreadCount(), savedLimit);
}
}
void tst_QThreadPool::reserveThread()
{
QFETCH(int, limit);
QThreadPool *threadpool = QThreadPool::globalInstance();
int savedLimit = threadpool->maxThreadCount();
threadpool->setMaxThreadCount(limit);
// reserve up to the limit
for (int i = 0; i < limit; ++i)
threadpool->reserveThread();
// reserveThread() should always reserve a thread, regardless of
// how many have been previously reserved
threadpool->reserveThread();
QCOMPARE(threadpool->activeThreadCount(), (limit > 0 ? limit : 0) + 1);
threadpool->reserveThread();
QCOMPARE(threadpool->activeThreadCount(), (limit > 0 ? limit : 0) + 2);
// cleanup
threadpool->releaseThread();
threadpool->releaseThread();
for (int i = 0; i < limit; ++i)
threadpool->releaseThread();
// reserving threads in children should not effect the parent
{
QThreadPool threadpool2(threadpool);
threadpool2.setMaxThreadCount(limit);
// reserve up to the limit
for (int i = 0; i < limit; ++i)
threadpool2.reserveThread();
// reserveThread() should always reserve a thread, regardless
// of how many have been previously reserved
threadpool2.reserveThread();
QCOMPARE(threadpool2.activeThreadCount(), (limit > 0 ? limit : 0) + 1);
threadpool2.reserveThread();
QCOMPARE(threadpool2.activeThreadCount(), (limit > 0 ? limit : 0) + 2);
threadpool->reserveThread();
QCOMPARE(threadpool->activeThreadCount(), 1);
threadpool->reserveThread();
QCOMPARE(threadpool->activeThreadCount(), 2);
// cleanup
threadpool2.releaseThread();
threadpool2.releaseThread();
threadpool->releaseThread();
threadpool->releaseThread();
while (threadpool2.activeThreadCount() > 0)
threadpool2.releaseThread();
}
// reset limit on global QThreadPool
threadpool->setMaxThreadCount(savedLimit);
}
void tst_QThreadPool::releaseThread()
{
QFETCH(int, limit);
QThreadPool *threadpool = QThreadPool::globalInstance();
int savedLimit = threadpool->maxThreadCount();
threadpool->setMaxThreadCount(limit);
// reserve up to the limit
for (int i = 0; i < limit; ++i)
threadpool->reserveThread();
// release should decrease the number of reserved threads
int reserved = threadpool->activeThreadCount();
while (reserved-- > 0) {
threadpool->releaseThread();
QCOMPARE(threadpool->activeThreadCount(), reserved);
}
QCOMPARE(threadpool->activeThreadCount(), 0);
// releaseThread() can release more than have been reserved
threadpool->releaseThread();
QCOMPARE(threadpool->activeThreadCount(), -1);
threadpool->reserveThread();
QCOMPARE(threadpool->activeThreadCount(), 0);
// releasing threads in children should not effect the parent
{
QThreadPool threadpool2(threadpool);
threadpool2.setMaxThreadCount(limit);
// reserve up to the limit
for (int i = 0; i < limit; ++i)
threadpool2.reserveThread();
// release should decrease the number of reserved threads
int reserved = threadpool2.activeThreadCount();
while (reserved-- > 0) {
threadpool2.releaseThread();
QCOMPARE(threadpool2.activeThreadCount(), reserved);
QCOMPARE(threadpool->activeThreadCount(), 0);
}
QCOMPARE(threadpool2.activeThreadCount(), 0);
QCOMPARE(threadpool->activeThreadCount(), 0);
// releaseThread() can release more than have been reserved
threadpool2.releaseThread();
QCOMPARE(threadpool2.activeThreadCount(), -1);
QCOMPARE(threadpool->activeThreadCount(), 0);
threadpool2.reserveThread();
QCOMPARE(threadpool2.activeThreadCount(), 0);
QCOMPARE(threadpool->activeThreadCount(), 0);
}
// reset limit on global QThreadPool
threadpool->setMaxThreadCount(savedLimit);
}
float ClusteringCoefficient::Compute() {
QList<FeaturesComplexNetwork::Node> ids;
ids.reserve(cn.getNumNodes());
for(FeaturesComplexNetwork::NodeIt it(cn); it != INVALID; ++it){
ids.append( it );
}
std::random_shuffle(ids.begin(), ids.end());
QList<QList<FeaturesComplexNetwork::Node>> lists;
lists.append(QList<FeaturesComplexNetwork::Node>());
int j=0;
for(int i=0;i< ids.size()*ratio; i++){
lists.last().append(ids[i]);
j++;
if( j > 50 ){
j=0;
lists.append(QList<FeaturesComplexNetwork::Node>());
}
}
FeaturesComplexNetwork::ArcMap<double> weights(cn);
GraphUtilities::getWeights(cn, weights);
GraphUtilities::normalizeWeights(cn,weights,weights);
QThreadPool pool;
pool.setMaxThreadCount(this->threads);
for(auto &list : lists) {
pool.start(new ClusteringCoefficientTask(this, cn, weights, list));
}
pool.waitForDone();
return std::accumulate(ccs.begin(),ccs.end(),0.f, [](const float &a, const ClusteringCoefficient::NodeCC &b){return a+b.cc;})/ccs.size();
}
void tst_QThreadPool::expiryTimeout()
{
ExpiryTimeoutTask task;
QThreadPool threadPool;
threadPool.setMaxThreadCount(1);
int expiryTimeout = threadPool.expiryTimeout();
threadPool.setExpiryTimeout(1000);
QCOMPARE(threadPool.expiryTimeout(), 1000);
// run the task
threadPool.start(&task);
QVERIFY(task.semaphore.tryAcquire(1, 10000));
QCOMPARE(task.runCount, 1);
QVERIFY(!task.thread->wait(100));
// thread should expire
QThread *firstThread = task.thread;
QVERIFY(task.thread->wait(10000));
// run task again, thread should be restarted
threadPool.start(&task);
QVERIFY(task.semaphore.tryAcquire(1, 10000));
QCOMPARE(task.runCount, 2);
QVERIFY(!task.thread->wait(100));
// thread should expire again
QVERIFY(task.thread->wait(10000));
// thread pool should have reused the expired thread (instead of
// starting a new one)
QCOMPARE(firstThread, task.thread);
threadPool.setExpiryTimeout(expiryTimeout);
QCOMPARE(threadPool.expiryTimeout(), expiryTimeout);
}
void Task::start( Task::action action,function_t function )
{
m_function = function ;
m_action = action ;
QThreadPool * thread = QThreadPool::globalInstance() ;
thread->setMaxThreadCount( 10 ) ;
thread->start( this ) ;
}
void KisMemoryPoolTest::benchmarkAlloc()
{
QThreadPool pool;
pool.setMaxThreadCount(NUM_THREADS);
QBENCHMARK {
for(qint32 i = 0; i < NUM_THREADS; i++) {
KisAllocStressJob *job = new KisAllocStressJob();
pool.start(job);
}
pool.waitForDone();
}
}
void FavIconTest::concurrentRequestsShouldWork()
{
const int numThreads = 3;
QThreadPool tp;
tp.setMaxThreadCount(numThreads);
QVector<QFuture<QString>> futures(numThreads);
for (int i = 0; i < numThreads; ++i) {
futures[i] = QtConcurrent::run(&tp, getAltIconUrl);
}
QVERIFY(tp.waitForDone(60000));
const QString firstResult = futures.at(0).result();
for (int i = 1; i < numThreads; ++i) {
QCOMPARE(futures.at(i).result(), firstResult);
}
QVERIFY(!QPixmap(firstResult).isNull());
}
void ConvolutionFilter::process(const QList<float> &matrix, int radius) {
QThreadPool threadPool;
threadPool.setMaxThreadCount(16);
int height = image.height();
for (int y = 0; y < height; y++) {
ConvolutionFilterRunner *runner = new ConvolutionFilterRunner(&image);
runner->setMatrix(matrix, radius);
runner->setScanLine((QRgb *) processed.scanLine(y), y);
runner->setAutoDelete(true);
threadPool.start(runner);
}
printf("waiting for convolution filter...");
threadPool.waitForDone();
}
void KisPaintDeviceTest::testCacheState()
{
TestingCache cache;
QList<CacheStressJob*> jobsList;
CacheStressJob *job;
for(qint32 i = 0; i < NUM_THREADS; i++) {
//job = new CacheStressJob(value, cacheValue, cacheState);
job = new CacheStressJob(cache);
job->setAutoDelete(true);
jobsList.append(job);
}
QThreadPool pool;
pool.setMaxThreadCount(NUM_THREADS);
foreach(job, jobsList) {
pool.start(job);
}
int main(int argc, char *argv[]) {
QCoreApplication a(argc, argv);
PayLoad *payLoad = new PayLoad(QCoreApplication::arguments());
QThreadPool *qThreadPool = QThreadPool::globalInstance();
qThreadPool->setMaxThreadCount(payLoad->getThreads());
if(payLoad->verify()) {
for(int i = 0; i < payLoad->getThreads(); i++){
qThreadPool->start(new RequestThread(i, payLoad));
}
qDebug() << "All threads started ..";
} else {
qDebug() <<"Parameters missing";
}
qThreadPool->waitForDone();
qDebug() << "Done";
return a.exec();
}
void KisLowMemoryTests::readWriteOnSharedTiles()
{
quint8 defaultPixel = 0;
KisTiledDataManager srcDM(1, &defaultPixel);
KisTiledDataManager dstDM(1, &defaultPixel);
const int NUM_TILES = 10;
const int NUM_CYCLES = 10000;
QThreadPool pool;
pool.setMaxThreadCount(10);
pool.start(new DeadlockyThread(DeadlockyThread::PRODUCER,
srcDM, dstDM, NUM_TILES, NUM_CYCLES));
for (int i = 0; i < 4; i++) {
pool.start(new DeadlockyThread(DeadlockyThread::CONSUMER_SRC,
srcDM, dstDM, NUM_TILES, NUM_CYCLES));
pool.start(new DeadlockyThread(DeadlockyThread::CONSUMER_DST,
srcDM, dstDM, NUM_TILES, NUM_CYCLES));
}
pool.waitForDone();
}
void FileAnalyzer::run()
{
m_abortFlag = false;
m_bAborted = false;
m_bSuccess = false;
int nFiles = m_inputFiles.count();
emit progressMaxChanged(nFiles);
emit progressValChanged(0);
lamexp_natural_string_sort(m_inputFiles, true); //.sort();
if(!m_templateFile)
{
if(!createTemplate())
{
qWarning("Failed to create template file!");
return;
}
}
AnalyzeTask::reset();
QThreadPool *pool = new QThreadPool();
QThread::msleep(333);
pool->setMaxThreadCount(qBound(2, ((QThread::idealThreadCount() * 3) / 2), 12));
while(!(m_inputFiles.isEmpty() || m_bAborted))
{
while(!(m_inputFiles.isEmpty() || m_bAborted))
{
if(!AnalyzeTask::waitForFreeSlot(&m_abortFlag))
{
qWarning("Timeout in AnalyzeTask::waitForFreeSlot() !!!");
}
if(m_abortFlag)
{
MessageBeep(MB_ICONERROR);
m_bAborted = true;
break;
}
if(!m_bAborted)
{
const QString currentFile = QDir::fromNativeSeparators(m_inputFiles.takeFirst());
AnalyzeTask *task = new AnalyzeTask(currentFile, m_templateFile->filePath(), &m_abortFlag);
connect(task, SIGNAL(fileSelected(QString)), this, SIGNAL(fileSelected(QString)), Qt::DirectConnection);
connect(task, SIGNAL(progressValChanged(unsigned int)), this, SIGNAL(progressValChanged(unsigned int)), Qt::DirectConnection);
connect(task, SIGNAL(progressMaxChanged(unsigned int)), this, SIGNAL(progressMaxChanged(unsigned int)), Qt::DirectConnection);
connect(task, SIGNAL(fileAnalyzed(AudioFileModel)), this, SIGNAL(fileAnalyzed(AudioFileModel)), Qt::DirectConnection);
pool->start(task);
if(int count = AnalyzeTask::getAdditionalFiles(m_inputFiles))
{
emit progressMaxChanged(nFiles += count);
}
}
}
//One of the Analyze tasks may have gathered additional files from a playlist!
if(!m_bAborted)
{
pool->waitForDone();
if(int count = AnalyzeTask::getAdditionalFiles(m_inputFiles))
{
emit progressMaxChanged(nFiles += count);
}
}
}
pool->waitForDone();
LAMEXP_DELETE(pool);
if(m_bAborted)
{
qWarning("Operation cancelled by user!");
return;
}
qDebug("All files added.\n");
m_bSuccess = true;
}
void tst_QThreadPool::setMaxThreadCountStartsAndStopsThreads()
{
class WaitingTask : public QRunnable
{
public:
QSemaphore waitForStarted, waitToFinish;
WaitingTask() { setAutoDelete(false); }
void run()
{
waitForStarted.release();
waitToFinish.acquire();
}
};
QThreadPool threadPool;
threadPool.setMaxThreadCount(1);
WaitingTask *task = new WaitingTask;
threadPool.start(task);
QVERIFY(task->waitForStarted.tryAcquire(1, 1000));
// thread limit is 1, cannot start more tasks
threadPool.start(task);
QVERIFY(!task->waitForStarted.tryAcquire(1, 1000));
// increasing the limit by 1 should start the task immediately
threadPool.setMaxThreadCount(2);
QVERIFY(task->waitForStarted.tryAcquire(1, 1000));
// ... but we still cannot start more tasks
threadPool.start(task);
QVERIFY(!task->waitForStarted.tryAcquire(1, 1000));
// increasing the limit should be able to start more than one at a time
threadPool.start(task);
threadPool.setMaxThreadCount(4);
QVERIFY(task->waitForStarted.tryAcquire(2, 1000));
// ... but we still cannot start more tasks
threadPool.start(task);
threadPool.start(task);
QVERIFY(!task->waitForStarted.tryAcquire(2, 1000));
// decreasing the thread limit should cause the active thread count to go down
threadPool.setMaxThreadCount(2);
QCOMPARE(threadPool.activeThreadCount(), 4);
task->waitToFinish.release(2);
QTest::qWait(1000);
QCOMPARE(threadPool.activeThreadCount(), 2);
// ... and we still cannot start more tasks
threadPool.start(task);
threadPool.start(task);
QVERIFY(!task->waitForStarted.tryAcquire(2, 1000));
// start all remaining tasks
threadPool.start(task);
threadPool.start(task);
threadPool.start(task);
threadPool.start(task);
threadPool.setMaxThreadCount(8);
QVERIFY(task->waitForStarted.tryAcquire(6, 1000));
task->waitToFinish.release(10);
// delete task;
}