Reduce thread priority for test parsing

Adding API for that to the parallel map/reduce functions Change-Id: Ic7987d899c124dcb04c1ca110b09fc97576873fe Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2016-11-14 15:26:04 +01:00
parent cedf7a012e
commit 37076e8c33
3 changed files with 41 additions and 24 deletions
--- a/src/libs/utils/mapreduce.h
+++ b/src/libs/utils/mapreduce.h
@@ -369,9 +369,12 @@ template <typename ForwardIterator, typename InitFunction, typename MapFunction,
 QFuture<ReduceResult>
 mapReduce(ForwardIterator begin, ForwardIterator end, InitFunction &&init, MapFunction &&map,
          ReduceFunction &&reduce, CleanUpFunction &&cleanup,
-          MapReduceOption option = MapReduceOption::Unordered, int size = -1)
+          MapReduceOption option = MapReduceOption::Unordered,
+          QThread::Priority priority = QThread::InheritPriority,
+          int size = -1)
 {
-    return runAsync(Internal::blockingIteratorMapReduce<
+    return runAsync(priority,
+                    Internal::blockingIteratorMapReduce<
                        ForwardIterator,
                        typename std::decay<InitFunction>::type,
                        typename std::decay<MapFunction>::type,
@@ -438,9 +441,11 @@ template <typename Container, typename InitFunction, typename MapFunction,
 QFuture<ReduceResult>
 mapReduce(Container &&container, InitFunction &&init, MapFunction &&map,
          ReduceFunction &&reduce, CleanUpFunction &&cleanup,
-          MapReduceOption option = MapReduceOption::Unordered)
+          MapReduceOption option = MapReduceOption::Unordered,
+          QThread::Priority priority = QThread::InheritPriority)
 {
-    return runAsync(Internal::blockingContainerMapReduce<
+    return runAsync(priority,
+                    Internal::blockingContainerMapReduce<
                        typename std::decay<Container>::type,
                        typename std::decay<InitFunction>::type,
                        typename std::decay<MapFunction>::type,
@@ -458,9 +463,11 @@ template <typename Container, typename InitFunction, typename MapFunction,
 QFuture<ReduceResult>
 mapReduce(std::reference_wrapper<Container> containerWrapper, InitFunction &&init, MapFunction &&map,
          ReduceFunction &&reduce, CleanUpFunction &&cleanup,
-          MapReduceOption option = MapReduceOption::Unordered)
+          MapReduceOption option = MapReduceOption::Unordered,
+          QThread::Priority priority = QThread::InheritPriority)
 {
-    return runAsync(Internal::blockingContainerRefMapReduce<
+    return runAsync(priority,
+                    Internal::blockingContainerRefMapReduce<
                        Container,
                        typename std::decay<InitFunction>::type,
                        typename std::decay<MapFunction>::type,
@@ -478,14 +485,15 @@ template <typename ForwardIterator, typename MapFunction, typename State, typena
          typename MapResult = typename Internal::resultType<MapFunction>::type>
 QFuture<StateResult>
 mapReduce(ForwardIterator begin, ForwardIterator end, MapFunction &&map, State &&initialState,
-          ReduceFunction &&reduce, MapReduceOption option = MapReduceOption::Unordered, int size = -1)
+          ReduceFunction &&reduce, MapReduceOption option = MapReduceOption::Unordered,
+          QThread::Priority priority = QThread::InheritPriority, int size = -1)
 {
    return mapReduce(begin, end,
                     Internal::StateWrapper<State>(std::forward<State>(initialState)),
                     std::forward<MapFunction>(map),
                     Internal::ReduceWrapper<StateResult, MapResult, ReduceFunction>(std::forward<ReduceFunction>(reduce)),
                     &Internal::cleanupReportingState<StateResult>,
-                     option, size);
+                     option, priority, size);
 }

 template <typename Container, typename MapFunction, typename State, typename ReduceFunction,
@@ -493,14 +501,15 @@ template <typename Container, typename MapFunction, typename State, typename Red
          typename MapResult = typename Internal::resultType<MapFunction>::type>
 QFuture<StateResult>
 mapReduce(Container &&container, MapFunction &&map, State &&initialState, ReduceFunction &&reduce,
-          MapReduceOption option = MapReduceOption::Unordered)
+          MapReduceOption option = MapReduceOption::Unordered,
+          QThread::Priority priority = QThread::InheritPriority)
 {
    return mapReduce(std::forward<Container>(container),
                     Internal::StateWrapper<State>(std::forward<State>(initialState)),
                     std::forward<MapFunction>(map),
                     Internal::ReduceWrapper<StateResult, MapResult, ReduceFunction>(std::forward<ReduceFunction>(reduce)),
                     &Internal::cleanupReportingState<StateResult>,
-                     option);
+                     option, priority);
 }

 template <typename ForwardIterator, typename MapFunction, typename State, typename ReduceFunction,
@@ -509,12 +518,13 @@ template <typename ForwardIterator, typename MapFunction, typename State, typena
 Q_REQUIRED_RESULT
 StateResult
 mappedReduced(ForwardIterator begin, ForwardIterator end, MapFunction &&map, State &&initialState,
-              ReduceFunction &&reduce, MapReduceOption option = MapReduceOption::Unordered, int size = -1)
+              ReduceFunction &&reduce, MapReduceOption option = MapReduceOption::Unordered,
+              QThread::Priority priority = QThread::InheritPriority, int size = -1)
 {
    return mapReduce(begin, end,
                     std::forward<MapFunction>(map), std::forward<State>(initialState),
                     std::forward<ReduceFunction>(reduce),
-                     option, size).result();
+                     option, priority, size).result();
 }

 template <typename Container, typename MapFunction, typename State, typename ReduceFunction,
@@ -523,38 +533,41 @@ template <typename Container, typename MapFunction, typename State, typename Red
 Q_REQUIRED_RESULT
 StateResult
 mappedReduced(Container &&container, MapFunction &&map, State &&initialState, ReduceFunction &&reduce,
-              MapReduceOption option = MapReduceOption::Unordered)
+              MapReduceOption option = MapReduceOption::Unordered,
+              QThread::Priority priority = QThread::InheritPriority)
 {
    return mapReduce(std::forward<Container>(container), std::forward<MapFunction>(map),
                     std::forward<State>(initialState), std::forward<ReduceFunction>(reduce),
-                     option).result();
+                     option, priority).result();
 }

 template <typename ForwardIterator, typename MapFunction,
          typename MapResult = typename Internal::resultType<MapFunction>::type>
 QFuture<MapResult>
 map(ForwardIterator begin, ForwardIterator end, MapFunction &&map,
-    MapReduceOption option = MapReduceOption::Ordered, int size = -1)
+    MapReduceOption option = MapReduceOption::Ordered,
+    QThread::Priority priority = QThread::InheritPriority, int size = -1)
 {
    return mapReduce(begin, end,
                     &Internal::dummyInit<MapResult>,
                     std::forward<MapFunction>(map),
                     Internal::DummyReduce<MapResult>(),
                     &Internal::dummyCleanup<MapResult>,
-                     option, size);
+                     option, priority, size);
 }

 template <typename Container, typename MapFunction,
          typename MapResult = typename Internal::resultType<MapFunction>::type>
 QFuture<MapResult>
-map(Container &&container, MapFunction &&map, MapReduceOption option = MapReduceOption::Ordered)
+map(Container &&container, MapFunction &&map, MapReduceOption option = MapReduceOption::Ordered,
+    QThread::Priority priority = QThread::InheritPriority)
 {
    return mapReduce(std::forward<Container>(container),
                     Internal::dummyInit<MapResult>,
                     std::forward<MapFunction>(map),
                     Internal::DummyReduce<MapResult>(),
                     Internal::dummyCleanup<MapResult>,
-                     option);
+                     option, priority);
 }

 template <template<typename> class ResultContainer, typename ForwardIterator, typename MapFunction,
@@ -562,11 +575,12 @@ template <template<typename> class ResultContainer, typename ForwardIterator, ty
 Q_REQUIRED_RESULT
 ResultContainer<MapResult>
 mapped(ForwardIterator begin, ForwardIterator end, MapFunction &&mapFun,
-    MapReduceOption option = MapReduceOption::Ordered, int size = -1)
+    MapReduceOption option = MapReduceOption::Ordered,
+       QThread::Priority priority = QThread::InheritPriority, int size = -1)
 {
    return Utils::transform<ResultContainer>(map(begin, end,
                                                 std::forward<MapFunction>(mapFun),
-                                                 option, size).results(),
+                                                 option, priority, size).results(),
                                             [](const MapResult &r) { return r; });
 }

@@ -574,11 +588,13 @@ template <template<typename> class ResultContainer, typename Container, typename
          typename MapResult = typename Internal::resultType<MapFunction>::type>
 Q_REQUIRED_RESULT
 ResultContainer<MapResult>
-mapped(Container &&container, MapFunction &&mapFun, MapReduceOption option = MapReduceOption::Ordered)
+mapped(Container &&container, MapFunction &&mapFun,
+       MapReduceOption option = MapReduceOption::Ordered,
+       QThread::Priority priority = QThread::InheritPriority)
 {
    return Utils::transform<ResultContainer>(map(container,
                                                 std::forward<MapFunction>(mapFun),
-                                                 option).results(),
+                                                 option, priority).results(),
                                             [](const MapResult &r) { return r; });
 }

--- a/src/plugins/autotest/testcodeparser.cpp
+++ b/src/plugins/autotest/testcodeparser.cpp
@@ -354,7 +354,8 @@ void TestCodeParser::scanForTests(const QStringList &fileList)
        [this](QFutureInterface<TestParseResultPtr> &fi, const QString &file) {
            parseFileForTests(m_testCodeParsers, fi, file);
        },
-        Utils::MapReduceOption::Unordered);
+        Utils::MapReduceOption::Unordered,
+        QThread::LowestPriority);
    m_futureWatcher.setFuture(future);
    if (list.size() > 5) {
        Core::ProgressManager::addTask(future, tr("Scanning for Tests"),
--- a/tests/auto/mapreduce/tst_mapreduce.cpp
+++ b/tests/auto/mapreduce/tst_mapreduce.cpp
@@ -214,7 +214,7 @@ void tst_MapReduce::map()
        QCOMPARE(container, QList<int>({4, 10, 2}));

        Utils::map(container.begin(), container.end(), [](int &x) { x *= 2; },
-            Utils::MapReduceOption::Unordered, 3).waitForFinished();
+            Utils::MapReduceOption::Unordered, QThread::InheritPriority, 3).waitForFinished();
        QCOMPARE(container, QList<int>({8, 20, 4}));
    }