Revert previous changes to thread pooling in br.cpp/meta.cpp

Since we no longer put Stream threads on the global thread pool, the previous changes are unnecessary. Also, in distribute, set up the QFutureSyncrhonizer with futures in the opposite order. In Qt 5.1, the waiting thread will wait for each future in the order they are added to the synchronizer, and thread execution will proceed in the same order. This prevents the waiting thread from every doing anything besides waiting. Reversing the QFuture order (so that it is the opposite of execution order) allows the waiting thread to steal work as intended

Revert previous changes to thread pooling in br.cpp/meta.cpp
Since we no longer put Stream threads on the global thread pool, the previous changes are unnecessary. Also, in distribute, set up the QFutureSyncrhonizer with futures in the opposite order. In Qt 5.1, the waiting thread will wait for each future in the order they are added to the synchronizer, and thread execution will proceed in the same order. This prevents the waiting thread from every doing anything besides waiting. Reversing the QFuture order (so that it is the opposite of execution order) allows the waiting thread to steal work as intended
Charles Otto
1 parent 7a47d58c
Showing 2 changed files with 14 additions and 29 deletions
app/br/br.cpp
openbr/plugins/meta.cpp
@@ -235,10 +235,8 @@ int main(int argc, char *argv[])
 {
     br_initialize(argc, argv);
  
-    QThreadPool separate;
-    separate.setMaxThreadCount(1);
     FakeMain *fakeMain = new FakeMain(argc, argv);
-    separate.start(fakeMain);
+    QThreadPool::globalInstance()->start(fakeMain);
     QCoreApplication::exec();
  
     br_finalize();
@@ -597,26 +597,6 @@ static void _projectList(const Transform *transform, const TemplateList *src, Te
     transform->project(*src, *dst);
 }
  
-class ProjectListJob : public QRunnable
-{
-public:
-    ProjectListJob(Transform * _transform, const TemplateList * _src, TemplateList * _dst)
-    {
-        transform = _transform;
-        src = _src;
-        dst = _dst;
-        this->setAutoDelete(true);
-    }
-
-    Transform * transform;
-    const TemplateList * src;
-    TemplateList * dst;
-    void run()
-    {
-        _projectList(transform, src, dst);
-    }
-};
-
 class DistributeTemplateTransform : public MetaTransform
 {
     Q_OBJECT
@@ -665,22 +645,29 @@ public:
         QList<TemplateList> input_buffer;
         input_buffer.reserve(src.size());
  
+        QFutureSynchronizer<void> futures;
+
         for (int i =0; i < src.size();i++) {
             input_buffer.append(TemplateList());
             output_buffer.append(TemplateList());
         }
-
+        QList<QFuture<void> > temp;
+        temp.reserve(src.size());
         for (int i=0; i<src.size(); i++) {
             input_buffer[i].append(src[i]);
  
-            if (Globals->parallelism)
-                QThreadPool::globalInstance()->start(new ProjectListJob(transform, &input_buffer[i], &output_buffer[i]), 0);
+            if (Globals->parallelism > 1) temp.append(QtConcurrent::run(_projectList, transform, &input_buffer[i], &output_buffer[i]));
             else _projectList(transform, &input_buffer[i], &output_buffer[i]);
         }
+        // We add the futures in reverse order, since in Qt 5.1 at least the
+        // waiting thread will wait on them in the order added (which for uniform priority
+        // threads is the order of execution), and we want the waiting thread to go in the opposite order
+        // so that it can steal runnables and do something besides wait.
+        for (int i = temp.size() - 1; i > 0; i--) {
+            futures.addFuture(temp[i]);
+        }
  
-        bool wait_res = QThreadPool::globalInstance()->waitForDone();
-        if (!wait_res)
-            qDebug("global thread pool wait failed!");
+        futures.waitForFinished();
  
         for (int i=0; i<src.size(); i++) dst.append(output_buffer[i]);
     }