Enable setting custom QThreadPool for QtConcurrent methods

Task-number: QTBUG-53465
Change-Id: Icff05d5f65dce453ff702502b85c35e20fca86a9
Reviewed-by: Sona Kurazyan <sona.kurazyan@qt.io>

1 files changed, 473 insertions, 145 deletions

diff --git a/src/concurrent/qtconcurrentmap.h b/src/concurrent/qtconcurrentmap.h
index 9b8ccc3eaf..7076d9ecde 100644
--- a/src/concurrent/qtconcurrentmap.h
+++ b/src/concurrent/qtconcurrentmap.h
@@ -57,119 +57,254 @@ namespace QtConcurrent {
 
 // map() on sequences
 template <typename Sequence, typename MapFunctor>
+QFuture<void> map(QThreadPool *pool, Sequence &sequence, MapFunctor map)
+{
+    return startMap(pool, sequence.begin(), sequence.end(), map);
+}
+
+template <typename Sequence, typename MapFunctor>
 QFuture<void> map(Sequence &sequence, MapFunctor map)
 {
-    return startMap(sequence.begin(), sequence.end(), map);
+    return startMap(QThreadPool::globalInstance(), sequence.begin(), sequence.end(), map);
 }
 
 // map() on iterators
 template <typename Iterator, typename MapFunctor>
+QFuture<void> map(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor map)
+{
+    return startMap(pool, begin, end, map);
+}
+
+template <typename Iterator, typename MapFunctor>
 QFuture<void> map(Iterator begin, Iterator end, MapFunctor map)
 {
-    return startMap(begin, end, map);
+    return startMap(QThreadPool::globalInstance(), begin, end, map);
 }
 
 // mappedReduced() for sequences.
 template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  const Sequence &sequence,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (pool, sequence, map, reduce, options);
+}
+
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
 QFuture<ResultType> mappedReduced(const Sequence &sequence,
                                   MapFunctor map,
                                   ReduceFunctor reduce,
-                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
 {
     return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
-        (sequence,
-         map,
-         reduce,
+        (QThreadPool::globalInstance(), sequence, map, reduce, options);
+}
+
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  const Sequence &sequence,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (pool, sequence, map, reduce, ResultType(std::forward<InitialValueType>(initialValue)),
          options);
 }
 
 template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
-QFuture<ResultType> mappedReduced(const Sequence &sequence, MapFunctor map, ReduceFunctor reduce,
+QFuture<ResultType> mappedReduced(const Sequence &sequence,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
                                   InitialValueType &&initialValue,
                                   ReduceOptions options = ReduceOptions(UnorderedReduce
                                                                         | SequentialReduce))
 {
+    return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), sequence, map, reduce,
+         ResultType(std::forward<InitialValueType>(initialValue)),  options);
+}
+
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor>
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(
+                                  QThreadPool *pool,
+                                  const Sequence &sequence,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
     return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>,
-                              ResultType>(sequence, map,
-                                          reduce,
-                                          ResultType(std::forward<InitialValueType>(initialValue)),
-                                          options);
+                              typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (pool, sequence, map, reduce, options);
 }
 
 template <typename Sequence, typename MapFunctor, typename ReduceFunctor>
-QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(const Sequence &sequence,
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(
+                                  const Sequence &sequence,
                                   MapFunctor map,
                                   ReduceFunctor reduce,
-                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
 {
     return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>,
                               typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
-        (sequence,
-         map,
-         reduce,
-         options);
+        (QThreadPool::globalInstance(), sequence, map, reduce, options);
 }
 
 template <typename Sequence, typename MapFunctor, typename ReduceFunctor,
           typename ResultType = typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
-QFuture<ResultType> mappedReduced(const Sequence &sequence, MapFunctor map, ReduceFunctor reduce,
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  const Sequence &sequence,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
                                   InitialValueType &&initialValue,
                                   ReduceOptions options = ReduceOptions(UnorderedReduce
                                                                         | SequentialReduce))
 {
     return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>,
-                              typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>(
-            sequence, map,
-            reduce,
-            ResultType(std::forward<InitialValueType>(initialValue)), options);
+                              typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (pool, sequence, map, reduce, ResultType(std::forward<InitialValueType>(initialValue)),
+         options);
+}
+
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType,
+          typename InitialValueType,
+          std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
+QFuture<ResultType> mappedReduced(const Sequence &sequence,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced
+        <QtPrivate::MapResultType<Sequence, MapFunctor>,
+         typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (QThreadPool::globalInstance(), sequence, map, reduce,
+         ResultType(std::forward<InitialValueType>(initialValue)), options);
 }
 
 // mappedReduced() for iterators
 template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (pool, begin, end, map, reduce, options);
+}
+
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
 QFuture<ResultType> mappedReduced(Iterator begin,
                                   Iterator end,
                                   MapFunctor map,
                                   ReduceFunctor reduce,
-                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
 {
     return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
-        (begin, end,
-         map,
-         reduce,
-         options);
+        (QThreadPool::globalInstance(), begin, end, map, reduce, options);
 }
 
 template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
-QFuture<ResultType> mappedReduced(Iterator begin, Iterator end, MapFunctor map,
-                                  ReduceFunctor reduce, InitialValueType &&initialValue,
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (pool, begin, end, map, reduce,
+         ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
+QFuture<ResultType> mappedReduced(Iterator begin,
+                                  Iterator end,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), begin, end, map, reduce,
+         ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(
+                                  QThreadPool *pool,
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
                                   ReduceOptions options = ReduceOptions(UnorderedReduce
                                                                         | SequentialReduce))
 {
     return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>,
-                              ResultType>(begin, end, map,
-                                          reduce,
-                                          ResultType(std::forward<InitialValueType>(initialValue)),
-                                          options);
+                              typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (pool, begin, end, map, reduce, options);
 }
 
 template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
-QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(Iterator begin,
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(
+                                  Iterator begin,
                                   Iterator end,
                                   MapFunctor map,
                                   ReduceFunctor reduce,
-                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
 {
     return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>,
                               typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
-        (begin, end,
-         map,
-         reduce,
+        (QThreadPool::globalInstance(), begin, end, map, reduce, options);
+}
+
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType,
+          typename InitialValueType,
+          std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(
+                                  QThreadPool *pool,
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced
+        <QtPrivate::MapResultType<Iterator, MapFunctor>,
+         typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (pool, begin, end, map, reduce, ResultType(std::forward<InitialValueType>(initialValue)),
          options);
 }
 
@@ -178,156 +313,328 @@ template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(
-        Iterator begin, Iterator end, MapFunctor map, ReduceFunctor reduce,
-        InitialValueType &&initialValue,
-        ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
 {
-    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>,
-                              typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>(
-            begin, end, map,
-            reduce,
-            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return startMappedReduced
+        <QtPrivate::MapResultType<Iterator, MapFunctor>,
+         typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (QThreadPool::globalInstance(), begin, end, map, reduce,
+         ResultType(std::forward<InitialValueType>(initialValue)), options);
 }
 
 // mapped() for sequences
 template <typename Sequence, typename MapFunctor>
-QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> mapped(const Sequence &sequence, MapFunctor map)
+QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> mapped(
+                                  QThreadPool *pool,
+                                  const Sequence &sequence,
+                                  MapFunctor map)
+{
+    return startMapped<QtPrivate::MapResultType<Sequence, MapFunctor>>(pool, sequence, map);
+}
+
+template <typename Sequence, typename MapFunctor>
+QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> mapped(
+                                  const Sequence &sequence,
+                                  MapFunctor map)
 {
-    return startMapped<QtPrivate::MapResultType<Sequence, MapFunctor>>(sequence, map);
+    return startMapped<QtPrivate::MapResultType<Sequence, MapFunctor>>
+        (QThreadPool::globalInstance(), sequence, map);
 }
 
 // mapped() for iterator ranges.
 template <typename Iterator, typename MapFunctor>
-QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> mapped(Iterator begin, Iterator end, MapFunctor map)
+QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> mapped(
+                                  QThreadPool *pool,
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor map)
 {
-    return startMapped<QtPrivate::MapResultType<Iterator, MapFunctor>>(begin, end, map);
+    return startMapped<QtPrivate::MapResultType<Iterator, MapFunctor>>(pool, begin, end, map);
+}
+
+template <typename Iterator, typename MapFunctor>
+QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> mapped(
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor map)
+{
+    return startMapped<QtPrivate::MapResultType<Iterator, MapFunctor>>
+        (QThreadPool::globalInstance(), begin, end, map);
 }
 
 // blockingMap() for sequences
 template <typename Sequence, typename MapFunctor>
+void blockingMap(QThreadPool *pool, Sequence &sequence, MapFunctor map)
+{
+    startMap(pool, sequence.begin(), sequence.end(), map).startBlocking();
+}
+
+template <typename Sequence, typename MapFunctor>
 void blockingMap(Sequence &sequence, MapFunctor map)
 {
-    startMap(sequence.begin(), sequence.end(), map).startBlocking();
+    startMap(QThreadPool::globalInstance(), sequence.begin(), sequence.end(), map).startBlocking();
 }
 
 // blockingMap() for iterator ranges
 template <typename Iterator, typename MapFunctor>
+void blockingMap(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor map)
+{
+    startMap(pool, begin, end, map).startBlocking();
+}
+
+template <typename Iterator, typename MapFunctor>
 void blockingMap(Iterator begin, Iterator end, MapFunctor map)
 {
-    startMap(begin, end, map).startBlocking();
+    startMap(QThreadPool::globalInstance(), begin, end, map).startBlocking();
 }
 
 // blockingMappedReduced() for sequences
 template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 const Sequence &sequence,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (pool, sequence, map, reduce, options).startBlocking();
+}
+
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
 ResultType blockingMappedReduced(const Sequence &sequence,
                                  MapFunctor map,
                                  ReduceFunctor reduce,
-                                 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
 {
-    return QtConcurrent::startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
-        (sequence,
-         map,
-         reduce,
-         options)
-        .startBlocking();
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), sequence, map, reduce, options).startBlocking();
 }
 
 template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
-ResultType blockingMappedReduced(const Sequence &sequence, MapFunctor map, ReduceFunctor reduce,
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 const Sequence &sequence,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
                                  InitialValueType &&initialValue,
                                  ReduceOptions options = ReduceOptions(UnorderedReduce
                                                                        | SequentialReduce))
 {
-    return QtConcurrent::startMappedReduced<
-                   QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>(
-                   sequence, map,
-                   reduce,
-                   ResultType(std::forward<InitialValueType>(initialValue)), options)
-            .startBlocking();
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (pool, sequence, map, reduce, ResultType(std::forward<InitialValueType>(initialValue)),
+         options).startBlocking();
 }
 
-template <typename MapFunctor, typename ReduceFunctor, typename Sequence>
-typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(const Sequence &sequence,
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
+ResultType blockingMappedReduced(const Sequence &sequence,
                                  MapFunctor map,
                                  ReduceFunctor reduce,
-                                 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>,
-                                            typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
-        (sequence,
-         map,
-         reduce,
-         options)
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), sequence, map, reduce,
+         ResultType(std::forward<InitialValueType>(initialValue)), options)
         .startBlocking();
 }
 
+template <typename MapFunctor, typename ReduceFunctor, typename Sequence>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(
+                                 QThreadPool *pool,
+                                 const Sequence &sequence,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Sequence, MapFunctor>,
+         typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (pool, sequence, map, reduce, options).startBlocking();
+}
+
+template <typename MapFunctor, typename ReduceFunctor, typename Sequence>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(
+                                 const Sequence &sequence,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Sequence, MapFunctor>,
+         typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (QThreadPool::globalInstance(), sequence, map, reduce, options).startBlocking();
+}
+
+template <typename MapFunctor, typename ReduceFunctor, typename Sequence,
+          typename ResultType = typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType,
+          typename InitialValueType,
+          std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(
+                                 QThreadPool *pool,
+                                 const Sequence &sequence,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Sequence, MapFunctor>,
+         typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (pool, sequence, map, reduce, ResultType(std::forward<InitialValueType>(initialValue)),
+         options).startBlocking();
+}
+
 template <typename MapFunctor, typename ReduceFunctor, typename Sequence,
           typename ResultType = typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(
-        const Sequence &sequence, MapFunctor map, ReduceFunctor reduce,
-        InitialValueType &&initialValue,
-        ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+                                 const Sequence &sequence,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
 {
-    return QtConcurrent::startMappedReduced<
-                   QtPrivate::MapResultType<Sequence, MapFunctor>,
-                   typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>(
-                   sequence, map,
-                   reduce,
-                   ResultType(std::forward<InitialValueType>(initialValue)), options)
-            .startBlocking();
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Sequence, MapFunctor>,
+         typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (QThreadPool::globalInstance(), sequence, map, reduce,
+         ResultType(std::forward<InitialValueType>(initialValue)), options).startBlocking();
 }
 
 // blockingMappedReduced() for iterator ranges
 template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 Iterator begin,
+                                 Iterator end,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (pool, begin, end, map, reduce, options).startBlocking();
+}
+
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
 ResultType blockingMappedReduced(Iterator begin,
                                  Iterator end,
                                  MapFunctor map,
                                  ReduceFunctor reduce,
-                                 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
 {
-    return QtConcurrent::startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
-        (begin, end,
-         map,
-         reduce,
-         options)
-        .startBlocking();
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), begin, end, map, reduce, options).startBlocking();
+}
+
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 Iterator begin,
+                                 Iterator end,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (pool, begin, end, map, reduce, ResultType(std::forward<InitialValueType>(initialValue)),
+         options).startBlocking();
 }
 
 template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
-ResultType blockingMappedReduced(Iterator begin, Iterator end, MapFunctor map, ReduceFunctor reduce,
+ResultType blockingMappedReduced(Iterator begin,
+                                 Iterator end,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
                                  InitialValueType &&initialValue,
-                                 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(
-                                         QtConcurrent::UnorderedReduce
-                                         | QtConcurrent::SequentialReduce))
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
 {
-    return QtConcurrent::startMappedReduced<
-                   QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>(
-                   begin, end, map,
-                   reduce,
-                   ResultType(std::forward<InitialValueType>(initialValue)), options)
-            .startBlocking();
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), begin, end, map, reduce,
+         ResultType(std::forward<InitialValueType>(initialValue)), options).startBlocking();
 }
 
 template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
-typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(Iterator begin,
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(
+                                 QThreadPool *pool,
+                                 Iterator begin,
                                  Iterator end,
                                  MapFunctor map,
                                  ReduceFunctor reduce,
-                                 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
-{
-    return QtConcurrent::startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>,
-                                            typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
-        (begin, end,
-         map,
-         reduce,
-         options)
-        .startBlocking();
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Iterator, MapFunctor>,
+         typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (pool, begin, end, map, reduce, options).startBlocking();
+}
+
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(
+                                 Iterator begin,
+                                 Iterator end,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Iterator, MapFunctor>,
+         typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (QThreadPool::globalInstance(), begin, end, map, reduce, options).startBlocking();
+}
+
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType,
+          typename InitialValueType,
+          std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(
+                                 QThreadPool *pool,
+                                 Iterator begin,
+                                 Iterator end,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Iterator, MapFunctor>,
+         typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (pool, begin, end, map, reduce, ResultType(std::forward<InitialValueType>(initialValue)),
+         options).startBlocking();
 }
 
 template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
@@ -335,62 +642,83 @@ template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(
-        Iterator begin, Iterator end, MapFunctor map, ReduceFunctor reduce,
-        InitialValueType &&initialValue,
-        QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(
-                QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
+                                 Iterator begin,
+                                 Iterator end,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
 {
-    return QtConcurrent::startMappedReduced<
-                   QtPrivate::MapResultType<Iterator, MapFunctor>,
-                   typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>(
-                   begin, end, map,
-                   reduce,
-                   ResultType(std::forward<InitialValueType>(initialValue)), options)
-            .startBlocking();
+    return QtConcurrent::startMappedReduced
+        <QtPrivate::MapResultType<Iterator, MapFunctor>,
+         typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (QThreadPool::globalInstance(), begin, end, map, reduce,
+         ResultType(std::forward<InitialValueType>(initialValue)), options).startBlocking();
 }
 
 // mapped() for sequences with a different putput sequence type.
 template <typename OutputSequence, typename InputSequence, typename MapFunctor>
+OutputSequence blockingMapped(QThreadPool *pool, const InputSequence &sequence, MapFunctor map)
+{
+    return blockingMappedReduced<OutputSequence>(pool, sequence, map,
+        QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename OutputSequence, typename InputSequence, typename MapFunctor>
 OutputSequence blockingMapped(const InputSequence &sequence, MapFunctor map)
 {
-    return blockingMappedReduced<OutputSequence>
-        (sequence,
-         map,
-         QtPrivate::PushBackWrapper(),
-         QtConcurrent::OrderedReduce);
+    return blockingMappedReduced<OutputSequence>(QThreadPool::globalInstance(), sequence, map,
+        QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename MapFunctor, typename InputSequence>
+auto blockingMapped(QThreadPool *pool, const InputSequence &sequence, MapFunctor map)
+{
+    using OutputSequence = typename QtPrivate::MapSequenceResultType<InputSequence,
+                                               MapFunctor>::ResultType;
+    return blockingMappedReduced<OutputSequence>(pool, sequence, map, QtPrivate::PushBackWrapper(),
+        OrderedReduce);
 }
 
 template <typename MapFunctor, typename InputSequence>
 auto blockingMapped(const InputSequence &sequence, MapFunctor map)
 {
-    using OutputSequence = typename QtPrivate::MapSequenceResultType<InputSequence, MapFunctor>::ResultType;
-    return blockingMappedReduced<OutputSequence>
-        (sequence,
-         map,
-         QtPrivate::PushBackWrapper(),
-         QtConcurrent::OrderedReduce);
+    using OutputSequence = typename QtPrivate::MapSequenceResultType<InputSequence,
+                                               MapFunctor>::ResultType;
+    return blockingMappedReduced<OutputSequence>(QThreadPool::globalInstance(), sequence, map,
+        QtPrivate::PushBackWrapper(), OrderedReduce);
 }
 
 // mapped()  for iterator ranges
 template <typename Sequence, typename Iterator, typename MapFunctor>
+Sequence blockingMapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor map)
+{
+    return blockingMappedReduced<Sequence>(pool, begin, end, map,
+        QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename Sequence, typename Iterator, typename MapFunctor>
 Sequence blockingMapped(Iterator begin, Iterator end, MapFunctor map)
 {
-    return blockingMappedReduced<Sequence>
-        (begin, end,
-         map,
-         QtPrivate::PushBackWrapper(),
-         QtConcurrent::OrderedReduce);
+    return blockingMappedReduced<Sequence>(QThreadPool::globalInstance(), begin, end, map,
+        QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename Iterator, typename MapFunctor>
+auto blockingMapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor map)
+{
+    using OutputSequence = QtPrivate::MapResultType<Iterator, MapFunctor>;
+    return blockingMappedReduced<OutputSequence>(pool, begin, end, map,
+        QtPrivate::PushBackWrapper(), OrderedReduce);
 }
 
 template <typename Iterator, typename MapFunctor>
 auto blockingMapped(Iterator begin, Iterator end, MapFunctor map)
 {
     using OutputSequence = QtPrivate::MapResultType<Iterator, MapFunctor>;
-    return blockingMappedReduced<OutputSequence>
-        (begin, end,
-         map,
-         QtPrivate::PushBackWrapper(),
-         QtConcurrent::OrderedReduce);
+    return blockingMappedReduced<OutputSequence>(QThreadPool::globalInstance(), begin, end, map,
+        QtPrivate::PushBackWrapper(), OrderedReduce);
 }
 
 } // namespace QtConcurrent