diff options
Diffstat (limited to 'src/corelib/concurrent/qtconcurrentmapkernel.h')
-rw-r--r-- | src/corelib/concurrent/qtconcurrentmapkernel.h | 273 |
1 files changed, 273 insertions, 0 deletions
diff --git a/src/corelib/concurrent/qtconcurrentmapkernel.h b/src/corelib/concurrent/qtconcurrentmapkernel.h new file mode 100644 index 0000000..0c6a5ad --- /dev/null +++ b/src/corelib/concurrent/qtconcurrentmapkernel.h @@ -0,0 +1,273 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain +** additional rights. These rights are described in the Nokia Qt LGPL +** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QTCONCURRENT_MAPKERNEL_H +#define QTCONCURRENT_MAPKERNEL_H + +#include <QtCore/qglobal.h> + +#ifndef QT_NO_CONCURRENT + +#include <QtCore/qtconcurrentiteratekernel.h> +#include <QtCore/qtconcurrentreducekernel.h> + +QT_BEGIN_HEADER +QT_BEGIN_NAMESPACE + +QT_MODULE(Core) + +#ifndef qdoc +namespace QtConcurrent { + +// map kernel, works with both parallel-for and parallel-while +template <typename Iterator, typename MapFunctor> +class MapKernel : public IterateKernel<Iterator, void> +{ + MapFunctor map; +public: + typedef void ReturnType; + MapKernel(Iterator begin, Iterator end, MapFunctor _map) + : IterateKernel<Iterator, void>(begin, end), map(_map) + { } + + bool runIteration(Iterator it, int, void *) + { + map(*it); + return false; + } + + bool runIterations(Iterator sequenceBeginIterator, int beginIndex, int endIndex, void *) + { + Iterator it = sequenceBeginIterator; + advance(it, beginIndex); + for (int i = beginIndex; i < endIndex; ++i) { + runIteration(it, i, 0); + advance(it, 1); + } + + return false; + } +}; + +template <typename ReducedResultType, + typename Iterator, + typename MapFunctor, + typename ReduceFunctor, + typename Reducer = ReduceKernel<ReduceFunctor, + ReducedResultType, + typename MapFunctor::result_type> > +class MappedReducedKernel : public IterateKernel<Iterator, ReducedResultType> +{ + ReducedResultType reducedResult; + MapFunctor map; + ReduceFunctor reduce; + Reducer reducer; +public: + typedef ReducedResultType ReturnType; + MappedReducedKernel(Iterator begin, Iterator end, MapFunctor _map, ReduceFunctor _reduce, ReduceOptions reduceOptions) + : IterateKernel<Iterator, ReducedResultType>(begin, end), reducedResult(), map(_map), reduce(_reduce), reducer(reduceOptions) + { } + + MappedReducedKernel(ReducedResultType initialValue, + MapFunctor _map, + ReduceFunctor _reduce) + : reducedResult(initialValue), map(_map), reduce(_reduce) + { } + + bool runIteration(Iterator it, int index, ReducedResultType *) + { + IntermediateResults<typename MapFunctor::result_type> results; + results.begin = index; + results.end = index + 1; + + results.vector.append(map(*it)); + reducer.runReduce(reduce, reducedResult, results); + return false; + } + + bool runIterations(Iterator sequenceBeginIterator, int begin, int end, ReducedResultType *) + { + IntermediateResults<typename MapFunctor::result_type> results; + results.begin = begin; + results.end = end; + results.vector.reserve(end - begin); + + Iterator it = sequenceBeginIterator; + advance(it, begin); + for (int i = begin; i < end; ++i) { + results.vector.append(map(*(it))); + advance(it, 1); + } + + reducer.runReduce(reduce, reducedResult, results); + return false; + } + + void finish() + { + reducer.finish(reduce, reducedResult); + } + + bool shouldThrottleThread() + { + return IterateKernel<Iterator, ReducedResultType>::shouldThrottleThread() || reducer.shouldThrottle(); + } + + bool shouldStartThread() + { + return IterateKernel<Iterator, ReducedResultType>::shouldStartThread() && reducer.shouldStartThread(); + } + + typedef ReducedResultType ResultType; + ReducedResultType *result() + { + return &reducedResult; + } +}; + +template <typename Iterator, typename MapFunctor> +class MappedEachKernel : public IterateKernel<Iterator, typename MapFunctor::result_type> +{ + MapFunctor map; + typedef typename MapFunctor::result_type T; +public: + typedef T ReturnType; + typedef T ResultType; + + MappedEachKernel(Iterator begin, Iterator end, MapFunctor _map) + : IterateKernel<Iterator, T>(begin, end), map(_map) { } + + bool runIteration(Iterator it, int, T *result) + { + *result = map(*it); + return true; + } + + bool runIterations(Iterator sequenceBeginIterator, int begin, int end, T *results) + { + + Iterator it = sequenceBeginIterator; + advance(it, begin); + for (int i = begin; i < end; ++i) { + runIteration(it, i, results + (i - begin)); + advance(it, 1); + } + + return true; + } +}; + +template <typename Iterator, typename Functor> +inline ThreadEngineStarter<void> startMap(Iterator begin, Iterator end, Functor functor) +{ + return startThreadEngine(new MapKernel<Iterator, Functor>(begin, end, functor)); +} + +template <typename T, typename Iterator, typename Functor> +inline ThreadEngineStarter<T> startMapped(Iterator begin, Iterator end, Functor functor) +{ + return startThreadEngine(new MappedEachKernel<Iterator, Functor>(begin, end, functor)); +} + +/* + The SequnceHolder class is used to hold a reference to the + sequence we are working on. +*/ +template <typename Sequence, typename Base, typename Functor> +struct SequenceHolder1 : public Base +{ + SequenceHolder1(const Sequence &_sequence, Functor functor) + : Base(_sequence.begin(), _sequence.end(), functor), sequence(_sequence) + { } + + Sequence sequence; + + void finish() + { + Base::finish(); + // Clear the sequence to make sure all temporaries are destroyed + // before finished is signaled. + sequence = Sequence(); + } +}; + +template <typename T, typename Sequence, typename Functor> +inline ThreadEngineStarter<T> startMapped(const Sequence &sequence, Functor functor) +{ + typedef SequenceHolder1<Sequence, + MappedEachKernel<typename Sequence::const_iterator , Functor>, Functor> + SequenceHolderType; + + return startThreadEngine(new SequenceHolderType(sequence, functor)); +} + +template <typename IntermediateType, typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor> +inline ThreadEngineStarter<ResultType> startMappedReduced(const Sequence & sequence, + MapFunctor mapFunctor, ReduceFunctor reduceFunctor, + ReduceOptions options) +{ + typedef typename Sequence::const_iterator Iterator; + typedef ReduceKernel<ReduceFunctor, ResultType, IntermediateType> Reducer; + typedef MappedReducedKernel<ResultType, Iterator, MapFunctor, ReduceFunctor, Reducer> MappedReduceType; + typedef SequenceHolder2<Sequence, MappedReduceType, MapFunctor, ReduceFunctor> SequenceHolderType; + return startThreadEngine(new SequenceHolderType(sequence, mapFunctor, reduceFunctor, options)); +} + +template <typename IntermediateType, typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor> +inline ThreadEngineStarter<ResultType> startMappedReduced(Iterator begin, Iterator end, + MapFunctor mapFunctor, ReduceFunctor reduceFunctor, + ReduceOptions options) +{ + typedef ReduceKernel<ReduceFunctor, ResultType, IntermediateType> Reducer; + typedef MappedReducedKernel<ResultType, Iterator, MapFunctor, ReduceFunctor, Reducer> MappedReduceType; + return startThreadEngine(new MappedReduceType(begin, end, mapFunctor, reduceFunctor, options)); +} + +} // namespace QtConcurrent + +#endif //qdoc + +QT_END_NAMESPACE +QT_END_HEADER + +#endif // QT_NO_CONCURRENT + +#endif |