int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
Worker worker;
worker.setAutoDelete(false);
QThreadPool *threadPool = QThreadPool::globalInstance();
threadPool->start(&worker);
qDebug() << "Hello from GUI thread. ID is " << (int)QThread::currentThreadId();
threadPool->waitForDone();
return 0;
}
void tst_QThreadPool::runMultiple()
{
const int runs = 10;
{
QThreadPool manager;
testFunctionCount = 0;
for (int i = 0; i < runs; ++i) {
manager.start(createTask(sleepTestFunctionMutex));
}
}
QCOMPARE(testFunctionCount, runs);
{
QThreadPool manager;
testFunctionCount = 0;
for (int i = 0; i < runs; ++i) {
manager.start(createTask(noSleepTestFunctionMutex));
}
}
QCOMPARE(testFunctionCount, runs);
{
QThreadPool manager;
for (int i = 0; i < 500; ++i)
manager.start(createTask(emptyFunct));
}
}
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 tst_QThreadPool::destroyingWaitsForTasksToFinish()
{
QTime total, pass;
total.start();
while (total.elapsed() < 10000) {
int runs;
count.store(runs = 0);
{
QThreadPool threadPool;
pass.restart();
while (pass.elapsed() < 100) {
threadPool.start(new CountingRunnable());
++runs;
}
}
QCOMPARE(count.load(), runs);
count.store(runs = 0);
{
QThreadPool threadPool;
pass.restart();
while (pass.elapsed() < 100) {
threadPool.start(new CountingRunnable());
threadPool.start(new CountingRunnable());
runs += 2;
}
}
QCOMPARE(count.load(), runs);
}
}
void tst_QThreadPool::waitForDone()
{
QTime total, pass;
total.start();
QThreadPool threadPool;
while (total.elapsed() < 10000) {
int runs;
count.store(runs = 0);
pass.restart();
while (pass.elapsed() < 100) {
threadPool.start(new CountingRunnable());
++runs;
}
threadPool.waitForDone();
QCOMPARE(count.load(), runs);
count.store(runs = 0);
pass.restart();
while (pass.elapsed() < 100) {
threadPool.start(new CountingRunnable());
threadPool.start(new CountingRunnable());
runs += 2;
}
threadPool.waitForDone();
QCOMPARE(count.load(), runs);
}
}
void GDALGeometricAttributes::run()
{
//return;
if (useSQL) {
//run_sql();
run_sql_threaded();
return;
}
OGRFeature * f;
vc.resetReading();
QThreadPool pool;
std::vector<OGRFeature*> container;
int counter = 0;
while( f = vc.getNextFeature() ) {
container.push_back(f);
if (counter%10000 == 0){
GeometricAttributeWorker * gw = new GeometricAttributeWorker(this, container, isCalculateArea, isAspectRationBB , isPercentageFilled);
pool.start(gw);
container = std::vector<OGRFeature*>();
}
}
pool.waitForDone();
}
void tst_QThreadPool::tryStart()
{
class WaitingTask : public QRunnable
{
public:
QSemaphore semaphore;
WaitingTask() { setAutoDelete(false); }
void run()
{
semaphore.acquire();
count.ref();
}
};
count.store(0);
WaitingTask task;
QThreadPool threadPool;
for (int i = 0; i < threadPool.maxThreadCount(); ++i) {
threadPool.start(&task);
}
QVERIFY(!threadPool.tryStart(&task));
task.semaphore.release(threadPool.maxThreadCount());
threadPool.waitForDone();
QCOMPARE(count.load(), threadPool.maxThreadCount());
}
void tst_QThreadPool::waitForDoneTimeout()
{
class BlockedTask : public QRunnable
{
public:
QMutex mutex;
BlockedTask() { setAutoDelete(false); }
void run()
{
mutex.lock();
mutex.unlock();
QTest::qSleep(50);
}
};
QThreadPool threadPool;
BlockedTask *task = new BlockedTask;
task->mutex.lock();
threadPool.start(task);
QVERIFY(!threadPool.waitForDone(100));
task->mutex.unlock();
QVERIFY(threadPool.waitForDone(400));
}
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 MainWindow::detectMinutiae()
{
MinutiaeDetect* md = new MinutiaeDetect(_canvas);
QThreadPool *threadPool = QThreadPool::globalInstance();
threadPool->start(md);
}
void tst_QThreadPool::runTask()
{
QThreadPool manager;
ran = false;
manager.start(new TestTask());
QTRY_VERIFY(ran);
}
void QmitkMatchPointRegistrationManipulator::OnStoreBtnPushed()
{
mitk::MAPRegistrationWrapper::Pointer newRegWrapper = mitk::MAPRegistrationWrapper::New();
MAPRegistrationType::Pointer newReg = MAPRegistrationType::New();
newRegWrapper->SetRegistration(newReg);
::map::core::RegistrationManipulator<MAPRegistrationType> manipulator(newReg);
::map::core::PreCachedRegistrationKernel<3, 3>::Pointer kernel = ::map::core::PreCachedRegistrationKernel<3, 3>::New();
kernel->setTransformModel(m_InverseCurrentTransform);
::map::core::PreCachedRegistrationKernel<3, 3>::Pointer kernel2 = ::map::core::PreCachedRegistrationKernel<3, 3>::New();
kernel2->setTransformModel(m_InverseCurrentTransform->GetInverseTransform());
manipulator.setInverseMapping(kernel);
manipulator.setDirectMapping(kernel2);
if (this->m_Controls.radioSelectedReg->isChecked())
{ //compine registration with selected pre registration as baseline
typedef ::map::core::RegistrationCombinator<MAPRegistrationType, MAPRegistrationType> CombinatorType;
CombinatorType::Pointer combinator = CombinatorType::New();
newReg = combinator->process(*m_SelectedPreReg,*newReg);
newRegWrapper->SetRegistration(newReg);
}
mitk::DataNode::Pointer spResultRegistrationNode = mitk::generateRegistrationResultNode(
this->m_Controls.lbNewRegName->text().toStdString(), newRegWrapper, "org.mitk::manual_registration",
mitk::EnsureUID(m_SelectedMovingNode->GetData()), mitk::EnsureUID(m_SelectedTargetNode->GetData()));
this->GetDataStorage()->Add(spResultRegistrationNode);
if (m_Controls.checkMapEntity->checkState() == Qt::Checked)
{
QmitkMappingJob* pMapJob = new QmitkMappingJob();
pMapJob->setAutoDelete(true);
pMapJob->m_spInputData = this->m_SelectedMovingNode->GetData();
pMapJob->m_InputDataUID = mitk::EnsureUID(m_SelectedMovingNode->GetData());
pMapJob->m_spRegNode = spResultRegistrationNode;
pMapJob->m_doGeometryRefinement = false;
pMapJob->m_spRefGeometry = this->m_SelectedTargetNode->GetData()->GetGeometry()->Clone().GetPointer();
pMapJob->m_MappedName = this->m_Controls.lbNewRegName->text().toStdString() + std::string(" mapped moving data");
pMapJob->m_allowUndefPixels = true;
pMapJob->m_paddingValue = 100;
pMapJob->m_allowUnregPixels = true;
pMapJob->m_errorValue = 200;
pMapJob->m_InterpolatorLabel = "Linear Interpolation";
pMapJob->m_InterpolatorType = mitk::ImageMappingInterpolator::Linear;
connect(pMapJob, SIGNAL(Error(QString)), this, SLOT(OnMapJobError(QString)));
connect(pMapJob, SIGNAL(MapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
this, SLOT(OnMapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
Qt::BlockingQueuedConnection);
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pMapJob);
}
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 VESPERSRoperCCDDetector::loadImageFromFileImplementation(const QString &filename)
{
VESPERSRoperQRunnableImageLoader *runner = new VESPERSRoperQRunnableImageLoader(filename, imageData_.size());
runner->setAutoDelete(true);
QThreadPool *threads = QThreadPool::globalInstance();
connect(runner, SIGNAL(imageData(QVector<int>)), this, SLOT(onImageDataChanged(QVector<int>)));
threads->start(runner);
}
void tst_QThreadPool::runFunction()
{
{
QThreadPool manager;
testFunctionCount = 0;
manager.start(createTask(noSleepTestFunction));
}
QCOMPARE(testFunctionCount, 1);
}
void tst_QThreadPool::runTask()
{
QThreadPool manager;
ran = false;
manager.start(new TestTask());
// Hang if task is not runned.
while (ran == false)
QTest::qSleep(100); // no busy loop - this doesn't work with FIFO schedulers
}
void tst_QThreadPool::waitcomplete()
{
testFunctionCount = 0;
const int runs = 500;
for (int i = 0; i < 500; ++i) {
QThreadPool pool;
pool.start(createTask(noSleepTestFunction));
}
QCOMPARE(testFunctionCount, runs);
}
/*
Test that the ThreadManager destructor waits until
all threads have completed.
*/
void tst_QThreadPool::destruction()
{
value = new int;
QThreadPool *threadManager = new QThreadPool();
threadManager->start(new IntAccessor());
threadManager->start(new IntAccessor());
delete threadManager;
delete value;
value = 0;
}
void MainWindow::openAn2k()
{
QString file = QFileDialog::getOpenFileName(this, tr("qwsqviewer"), QString(), tr("AN2K images (*.an2)"));
if (file.isEmpty())
return;
_loader->setFile(file);
QThreadPool *threadPool = QThreadPool::globalInstance();
threadPool->start(_loader);
}
void tst_QThreadPool::start()
{
const int runs = 1000;
count.store(0);
{
QThreadPool threadPool;
for (int i = 0; i< runs; ++i) {
threadPool.start(new CountingRunnable());
}
}
QCOMPARE(count.load(), runs);
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
Work work;
work.setAutoDelete(false);
QThreadPool *threadPool = QThreadPool::globalInstance();
threadPool->start(&work);
qDebug() << "hello from GUI thread " << QThread::currentThread();
threadPool->waitForDone();
}
/*
Test that the thread pool really reuses threads.
*/
void tst_QThreadPool::threadRecycling()
{
QThreadPool threadPool;
threadPool.start(new ThreadRecorderTask());
threadRecyclingSemaphore.acquire();
QThread *thread1 = recycledThread;
QTest::qSleep(100);
threadPool.start(new ThreadRecorderTask());
threadRecyclingSemaphore.acquire();
QThread *thread2 = recycledThread;
QCOMPARE(thread1, thread2);
QTest::qSleep(100);
threadPool.start(new ThreadRecorderTask());
threadRecyclingSemaphore.acquire();
QThread *thread3 = recycledThread;
QCOMPARE(thread2, thread3);
}
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 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 QmitkMatchPoint::OnRegResultIsAvailable(mitk::MAPRegistrationWrapper::Pointer
spResultRegistration, const QmitkRegistrationJob* pRegJob)
{
mitk::DataNode::Pointer spResultRegistrationNode = mitk::generateRegistrationResultNode(
pRegJob->m_JobName, spResultRegistration, pRegJob->GetLoadedAlgorithm()->getUID()->toStr(),
pRegJob->m_MovingDataUID, pRegJob->m_TargetDataUID);
if (pRegJob->m_StoreReg)
{
m_Controls.m_teLog->append(
QString("<b><font color='blue'> Storing registration object in data manager ... </font></b>"));
this->GetDataStorage()->Add(spResultRegistrationNode);
this->GetRenderWindowPart()->RequestUpdate();
}
if (m_Controls.m_checkMapEntity->checkState() == Qt::Checked)
{
QmitkMappingJob* pMapJob = new QmitkMappingJob();
pMapJob->setAutoDelete(true);
pMapJob->m_spInputData = pRegJob->m_spMovingData;
pMapJob->m_InputDataUID = pRegJob->m_MovingDataUID;
pMapJob->m_spRegNode = spResultRegistrationNode;
pMapJob->m_doGeometryRefinement = false;
pMapJob->m_spRefGeometry = pRegJob->m_spTargetData->GetGeometry()->Clone().GetPointer();
pMapJob->m_MappedName = pRegJob->m_JobName + std::string(" mapped moving data");
pMapJob->m_allowUndefPixels = true;
pMapJob->m_paddingValue = 100;
pMapJob->m_allowUnregPixels = true;
pMapJob->m_errorValue = 200;
pMapJob->m_InterpolatorLabel = "Linear Interpolation";
pMapJob->m_InterpolatorType = mitk::ImageMappingInterpolator::Linear;
connect(pMapJob, SIGNAL(Error(QString)), this, SLOT(OnMapJobError(QString)));
connect(pMapJob, SIGNAL(MapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
this, SLOT(OnMapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
Qt::BlockingQueuedConnection);
connect(pMapJob, SIGNAL(AlgorithmInfo(QString)), this, SLOT(OnAlgorithmInfo(QString)));
m_Controls.m_teLog->append(
QString("<b><font color='blue'>Started mapping input data...</font></b>"));
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pMapJob);
}
void GDALParcelSplit::run()
{
cityblocks.resetReading();
OGRFeature *poFeature;
this->counter_added = 0;
QThreadPool pool;
while( (poFeature = cityblocks.getNextFeature()) != NULL ) {
char* geo;
poFeature->GetGeometryRef()->exportToWkt(&geo); //Geo destroyed by worker
ParcelSplitWorker * ps = new ParcelSplitWorker(poFeature->GetFID(), this, this->width, this->target_length, this->splitFirst, geo);
pool.start(ps);
}
pool.waitForDone();
this->generated = counter_added;
}
void tst_QPointer::threadSafety()
{
QThread owner;
owner.start();
QThreadPool pool;
for (int i = 0; i < 300; i++) {
QPointer<TestRunnable> task = new TestRunnable;
task->setAutoDelete(true);
task->moveToThread(&owner);
pool.start(task);
}
pool.waitForDone();
owner.quit();
owner.wait();
}
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();
}