| // -*- C++ -*- | |
| // Copyright (C) 2007-2019 Free Software Foundation, Inc. | |
| // | |
| // This file is part of the GNU ISO C++ Library. This library is free | |
| // software; you can redistribute it and/or modify it under the terms | |
| // of the GNU General Public License as published by the Free Software | |
| // Foundation; either version 3, or (at your option) any later | |
| // version. | |
| // This library is distributed in the hope that it will be useful, but | |
| // WITHOUT ANY WARRANTY; without even the implied warranty of | |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| // General Public License for more details. | |
| // Under Section 7 of GPL version 3, you are granted additional | |
| // permissions described in the GCC Runtime Library Exception, version | |
| // 3.1, as published by the Free Software Foundation. | |
| // You should have received a copy of the GNU General Public License and | |
| // a copy of the GCC Runtime Library Exception along with this program; | |
| // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
| // <http://www.gnu.org/licenses/>. | |
| /** @file parallel/algo.h | |
| * @brief Parallel STL function calls corresponding to the stl_algo.h header. | |
| * | |
| * The functions defined here mainly do case switches and | |
| * call the actual parallelized versions in other files. | |
| * Inlining policy: Functions that basically only contain one function call, | |
| * are declared inline. | |
| * This file is a GNU parallel extension to the Standard C++ Library. | |
| */ | |
| // Written by Johannes Singler and Felix Putze. | |
| #ifndef _GLIBCXX_PARALLEL_ALGO_H | |
| #define _GLIBCXX_PARALLEL_ALGO_H 1 | |
| #include <parallel/algorithmfwd.h> | |
| #include <bits/stl_algobase.h> | |
| #include <bits/stl_algo.h> | |
| #include <parallel/iterator.h> | |
| #include <parallel/base.h> | |
| #include <parallel/sort.h> | |
| #include <parallel/workstealing.h> | |
| #include <parallel/par_loop.h> | |
| #include <parallel/omp_loop.h> | |
| #include <parallel/omp_loop_static.h> | |
| #include <parallel/for_each_selectors.h> | |
| #include <parallel/for_each.h> | |
| #include <parallel/find.h> | |
| #include <parallel/find_selectors.h> | |
| #include <parallel/search.h> | |
| #include <parallel/random_shuffle.h> | |
| #include <parallel/partition.h> | |
| #include <parallel/merge.h> | |
| #include <parallel/unique_copy.h> | |
| #include <parallel/set_operations.h> | |
| namespace std _GLIBCXX_VISIBILITY(default) | |
| { | |
| namespace __parallel | |
| { | |
| // Sequential fallback | |
| template<typename _IIter, typename _Function> | |
| inline _Function | |
| for_each(_IIter __begin, _IIter __end, _Function __f, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::for_each(__begin, __end, __f); } | |
| // Sequential fallback for input iterator case | |
| template<typename _IIter, typename _Function, typename _IteratorTag> | |
| inline _Function | |
| __for_each_switch(_IIter __begin, _IIter __end, _Function __f, | |
| _IteratorTag) | |
| { return for_each(__begin, __end, __f, __gnu_parallel::sequential_tag()); } | |
| // Parallel algorithm for random access iterators | |
| template<typename _RAIter, typename _Function> | |
| _Function | |
| __for_each_switch(_RAIter __begin, _RAIter __end, | |
| _Function __f, random_access_iterator_tag, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().for_each_minimal_n | |
| && __gnu_parallel::__is_parallel(__parallelism_tag))) | |
| { | |
| bool __dummy; | |
| __gnu_parallel::__for_each_selector<_RAIter> __functionality; | |
| return __gnu_parallel:: | |
| __for_each_template_random_access( | |
| __begin, __end, __f, __functionality, | |
| __gnu_parallel::_DummyReduct(), true, __dummy, -1, | |
| __parallelism_tag); | |
| } | |
| else | |
| return for_each(__begin, __end, __f, __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface | |
| template<typename _Iterator, typename _Function> | |
| inline _Function | |
| for_each(_Iterator __begin, _Iterator __end, _Function __f, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| return __for_each_switch(__begin, __end, __f, | |
| std::__iterator_category(__begin), | |
| __parallelism_tag); | |
| } | |
| template<typename _Iterator, typename _Function> | |
| inline _Function | |
| for_each(_Iterator __begin, _Iterator __end, _Function __f) | |
| { | |
| return __for_each_switch(__begin, __end, __f, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback | |
| template<typename _IIter, typename _Tp> | |
| inline _IIter | |
| find(_IIter __begin, _IIter __end, const _Tp& __val, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::find(__begin, __end, __val); } | |
| // Sequential fallback for input iterator case | |
| template<typename _IIter, typename _Tp, typename _IteratorTag> | |
| inline _IIter | |
| __find_switch(_IIter __begin, _IIter __end, const _Tp& __val, | |
| _IteratorTag) | |
| { return _GLIBCXX_STD_A::find(__begin, __end, __val); } | |
| // Parallel find for random access iterators | |
| template<typename _RAIter, typename _Tp> | |
| _RAIter | |
| __find_switch(_RAIter __begin, _RAIter __end, | |
| const _Tp& __val, random_access_iterator_tag) | |
| { | |
| typedef iterator_traits<_RAIter> _TraitsType; | |
| typedef typename _TraitsType::value_type _ValueType; | |
| if (_GLIBCXX_PARALLEL_CONDITION(true)) | |
| { | |
| __gnu_parallel::__binder2nd<__gnu_parallel::_EqualTo<_ValueType, | |
| const _Tp&>, | |
| _ValueType, const _Tp&, bool> | |
| __comp(__gnu_parallel::_EqualTo<_ValueType, const _Tp&>(), __val); | |
| return __gnu_parallel::__find_template( | |
| __begin, __end, __begin, __comp, | |
| __gnu_parallel::__find_if_selector()).first; | |
| } | |
| else | |
| return _GLIBCXX_STD_A::find(__begin, __end, __val); | |
| } | |
| // Public interface | |
| template<typename _IIter, typename _Tp> | |
| inline _IIter | |
| find(_IIter __begin, _IIter __end, const _Tp& __val) | |
| { | |
| return __find_switch(__begin, __end, __val, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback | |
| template<typename _IIter, typename _Predicate> | |
| inline _IIter | |
| find_if(_IIter __begin, _IIter __end, _Predicate __pred, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::find_if(__begin, __end, __pred); } | |
| // Sequential fallback for input iterator case | |
| template<typename _IIter, typename _Predicate, typename _IteratorTag> | |
| inline _IIter | |
| __find_if_switch(_IIter __begin, _IIter __end, _Predicate __pred, | |
| _IteratorTag) | |
| { return _GLIBCXX_STD_A::find_if(__begin, __end, __pred); } | |
| // Parallel find_if for random access iterators | |
| template<typename _RAIter, typename _Predicate> | |
| _RAIter | |
| __find_if_switch(_RAIter __begin, _RAIter __end, | |
| _Predicate __pred, random_access_iterator_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION(true)) | |
| return __gnu_parallel::__find_template(__begin, __end, __begin, __pred, | |
| __gnu_parallel:: | |
| __find_if_selector()).first; | |
| else | |
| return _GLIBCXX_STD_A::find_if(__begin, __end, __pred); | |
| } | |
| // Public interface | |
| template<typename _IIter, typename _Predicate> | |
| inline _IIter | |
| find_if(_IIter __begin, _IIter __end, _Predicate __pred) | |
| { | |
| return __find_if_switch(__begin, __end, __pred, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback | |
| template<typename _IIter, typename _FIterator> | |
| inline _IIter | |
| find_first_of(_IIter __begin1, _IIter __end1, | |
| _FIterator __begin2, _FIterator __end2, | |
| __gnu_parallel::sequential_tag) | |
| { | |
| return _GLIBCXX_STD_A::find_first_of(__begin1, __end1, __begin2, __end2); | |
| } | |
| // Sequential fallback | |
| template<typename _IIter, typename _FIterator, | |
| typename _BinaryPredicate> | |
| inline _IIter | |
| find_first_of(_IIter __begin1, _IIter __end1, | |
| _FIterator __begin2, _FIterator __end2, | |
| _BinaryPredicate __comp, __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::find_first_of( | |
| __begin1, __end1, __begin2, __end2, __comp); } | |
| // Sequential fallback for input iterator type | |
| template<typename _IIter, typename _FIterator, | |
| typename _IteratorTag1, typename _IteratorTag2> | |
| inline _IIter | |
| __find_first_of_switch(_IIter __begin1, _IIter __end1, | |
| _FIterator __begin2, _FIterator __end2, | |
| _IteratorTag1, _IteratorTag2) | |
| { return find_first_of(__begin1, __end1, __begin2, __end2, | |
| __gnu_parallel::sequential_tag()); } | |
| // Parallel algorithm for random access iterators | |
| template<typename _RAIter, typename _FIterator, | |
| typename _BinaryPredicate, typename _IteratorTag> | |
| inline _RAIter | |
| __find_first_of_switch(_RAIter __begin1, | |
| _RAIter __end1, | |
| _FIterator __begin2, _FIterator __end2, | |
| _BinaryPredicate __comp, random_access_iterator_tag, | |
| _IteratorTag) | |
| { | |
| return __gnu_parallel:: | |
| __find_template(__begin1, __end1, __begin1, __comp, | |
| __gnu_parallel::__find_first_of_selector | |
| <_FIterator>(__begin2, __end2)).first; | |
| } | |
| // Sequential fallback for input iterator type | |
| template<typename _IIter, typename _FIterator, | |
| typename _BinaryPredicate, typename _IteratorTag1, | |
| typename _IteratorTag2> | |
| inline _IIter | |
| __find_first_of_switch(_IIter __begin1, _IIter __end1, | |
| _FIterator __begin2, _FIterator __end2, | |
| _BinaryPredicate __comp, _IteratorTag1, _IteratorTag2) | |
| { return find_first_of(__begin1, __end1, __begin2, __end2, __comp, | |
| __gnu_parallel::sequential_tag()); } | |
| // Public interface | |
| template<typename _IIter, typename _FIterator, | |
| typename _BinaryPredicate> | |
| inline _IIter | |
| find_first_of(_IIter __begin1, _IIter __end1, | |
| _FIterator __begin2, _FIterator __end2, | |
| _BinaryPredicate __comp) | |
| { | |
| return __find_first_of_switch(__begin1, __end1, __begin2, __end2, __comp, | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2)); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _IIter, typename _FIterator> | |
| inline _IIter | |
| find_first_of(_IIter __begin1, _IIter __end1, | |
| _FIterator __begin2, _FIterator __end2) | |
| { | |
| typedef typename std::iterator_traits<_IIter>::value_type _IValueType; | |
| typedef typename std::iterator_traits<_FIterator>::value_type _FValueType; | |
| return __gnu_parallel::find_first_of(__begin1, __end1, __begin2, __end2, | |
| __gnu_parallel::_EqualTo<_IValueType, _FValueType>()); | |
| } | |
| // Sequential fallback | |
| template<typename _IIter, typename _OutputIterator> | |
| inline _OutputIterator | |
| unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out); } | |
| // Sequential fallback | |
| template<typename _IIter, typename _OutputIterator, | |
| typename _Predicate> | |
| inline _OutputIterator | |
| unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out, | |
| _Predicate __pred, __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out, __pred); } | |
| // Sequential fallback for input iterator case | |
| template<typename _IIter, typename _OutputIterator, | |
| typename _Predicate, typename _IteratorTag1, typename _IteratorTag2> | |
| inline _OutputIterator | |
| __unique_copy_switch(_IIter __begin, _IIter __last, | |
| _OutputIterator __out, _Predicate __pred, | |
| _IteratorTag1, _IteratorTag2) | |
| { return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred); } | |
| // Parallel unique_copy for random access iterators | |
| template<typename _RAIter, typename RandomAccessOutputIterator, | |
| typename _Predicate> | |
| RandomAccessOutputIterator | |
| __unique_copy_switch(_RAIter __begin, _RAIter __last, | |
| RandomAccessOutputIterator __out, _Predicate __pred, | |
| random_access_iterator_tag, random_access_iterator_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__last - __begin) | |
| > __gnu_parallel::_Settings::get().unique_copy_minimal_n)) | |
| return __gnu_parallel::__parallel_unique_copy( | |
| __begin, __last, __out, __pred); | |
| else | |
| return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred); | |
| } | |
| // Public interface | |
| template<typename _IIter, typename _OutputIterator> | |
| inline _OutputIterator | |
| unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out) | |
| { | |
| typedef typename std::iterator_traits<_IIter>::value_type _ValueType; | |
| return __unique_copy_switch( | |
| __begin1, __end1, __out, equal_to<_ValueType>(), | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__out)); | |
| } | |
| // Public interface | |
| template<typename _IIter, typename _OutputIterator, typename _Predicate> | |
| inline _OutputIterator | |
| unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out, | |
| _Predicate __pred) | |
| { | |
| return __unique_copy_switch( | |
| __begin1, __end1, __out, __pred, | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__out)); | |
| } | |
| // Sequential fallback | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator> | |
| inline _OutputIterator | |
| set_union(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::set_union( | |
| __begin1, __end1, __begin2, __end2, __out); } | |
| // Sequential fallback | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _Predicate> | |
| inline _OutputIterator | |
| set_union(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, _Predicate __pred, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::set_union(__begin1, __end1, | |
| __begin2, __end2, __out, __pred); } | |
| // Sequential fallback for input iterator case | |
| template<typename _IIter1, typename _IIter2, typename _Predicate, | |
| typename _OutputIterator, typename _IteratorTag1, | |
| typename _IteratorTag2, typename _IteratorTag3> | |
| inline _OutputIterator | |
| __set_union_switch( | |
| _IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __result, _Predicate __pred, | |
| _IteratorTag1, _IteratorTag2, _IteratorTag3) | |
| { return _GLIBCXX_STD_A::set_union(__begin1, __end1, | |
| __begin2, __end2, __result, __pred); } | |
| // Parallel set_union for random access iterators | |
| template<typename _RAIter1, typename _RAIter2, | |
| typename _Output_RAIter, typename _Predicate> | |
| _Output_RAIter | |
| __set_union_switch(_RAIter1 __begin1, _RAIter1 __end1, | |
| _RAIter2 __begin2, _RAIter2 __end2, | |
| _Output_RAIter __result, _Predicate __pred, | |
| random_access_iterator_tag, random_access_iterator_tag, | |
| random_access_iterator_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) | |
| >= __gnu_parallel::_Settings::get().set_union_minimal_n | |
| || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2) | |
| >= __gnu_parallel::_Settings::get().set_union_minimal_n)) | |
| return __gnu_parallel::__parallel_set_union( | |
| __begin1, __end1, __begin2, __end2, __result, __pred); | |
| else | |
| return _GLIBCXX_STD_A::set_union(__begin1, __end1, | |
| __begin2, __end2, __result, __pred); | |
| } | |
| // Public interface | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator> | |
| inline _OutputIterator | |
| set_union(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out) | |
| { | |
| typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1; | |
| typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2; | |
| return __set_union_switch( | |
| __begin1, __end1, __begin2, __end2, __out, | |
| __gnu_parallel::_Less<_ValueType1, _ValueType2>(), | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2), | |
| std::__iterator_category(__out)); | |
| } | |
| // Public interface | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _Predicate> | |
| inline _OutputIterator | |
| set_union(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, _Predicate __pred) | |
| { | |
| return __set_union_switch( | |
| __begin1, __end1, __begin2, __end2, __out, __pred, | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2), | |
| std::__iterator_category(__out)); | |
| } | |
| // Sequential fallback. | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator> | |
| inline _OutputIterator | |
| set_intersection(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::set_intersection(__begin1, __end1, | |
| __begin2, __end2, __out); } | |
| // Sequential fallback. | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _Predicate> | |
| inline _OutputIterator | |
| set_intersection(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, _Predicate __pred, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::set_intersection( | |
| __begin1, __end1, __begin2, __end2, __out, __pred); } | |
| // Sequential fallback for input iterator case | |
| template<typename _IIter1, typename _IIter2, | |
| typename _Predicate, typename _OutputIterator, | |
| typename _IteratorTag1, typename _IteratorTag2, | |
| typename _IteratorTag3> | |
| inline _OutputIterator | |
| __set_intersection_switch(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __result, _Predicate __pred, | |
| _IteratorTag1, _IteratorTag2, _IteratorTag3) | |
| { return _GLIBCXX_STD_A::set_intersection(__begin1, __end1, __begin2, | |
| __end2, __result, __pred); } | |
| // Parallel set_intersection for random access iterators | |
| template<typename _RAIter1, typename _RAIter2, | |
| typename _Output_RAIter, typename _Predicate> | |
| _Output_RAIter | |
| __set_intersection_switch(_RAIter1 __begin1, | |
| _RAIter1 __end1, | |
| _RAIter2 __begin2, | |
| _RAIter2 __end2, | |
| _Output_RAIter __result, | |
| _Predicate __pred, | |
| random_access_iterator_tag, | |
| random_access_iterator_tag, | |
| random_access_iterator_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) | |
| >= __gnu_parallel::_Settings::get().set_union_minimal_n | |
| || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2) | |
| >= __gnu_parallel::_Settings::get().set_union_minimal_n)) | |
| return __gnu_parallel::__parallel_set_intersection( | |
| __begin1, __end1, __begin2, __end2, __result, __pred); | |
| else | |
| return _GLIBCXX_STD_A::set_intersection( | |
| __begin1, __end1, __begin2, __end2, __result, __pred); | |
| } | |
| // Public interface | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator> | |
| inline _OutputIterator | |
| set_intersection(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out) | |
| { | |
| typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1; | |
| typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2; | |
| return __set_intersection_switch( | |
| __begin1, __end1, __begin2, __end2, __out, | |
| __gnu_parallel::_Less<_ValueType1, _ValueType2>(), | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2), | |
| std::__iterator_category(__out)); | |
| } | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _Predicate> | |
| inline _OutputIterator | |
| set_intersection(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, _Predicate __pred) | |
| { | |
| return __set_intersection_switch( | |
| __begin1, __end1, __begin2, __end2, __out, __pred, | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2), | |
| std::__iterator_category(__out)); | |
| } | |
| // Sequential fallback | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator> | |
| inline _OutputIterator | |
| set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::set_symmetric_difference( | |
| __begin1, __end1, __begin2, __end2, __out); } | |
| // Sequential fallback | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _Predicate> | |
| inline _OutputIterator | |
| set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, _Predicate __pred, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::set_symmetric_difference( | |
| __begin1, __end1, __begin2, __end2, __out, __pred); } | |
| // Sequential fallback for input iterator case | |
| template<typename _IIter1, typename _IIter2, | |
| typename _Predicate, typename _OutputIterator, | |
| typename _IteratorTag1, typename _IteratorTag2, | |
| typename _IteratorTag3> | |
| inline _OutputIterator | |
| __set_symmetric_difference_switch( | |
| _IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __result, _Predicate __pred, | |
| _IteratorTag1, _IteratorTag2, _IteratorTag3) | |
| { return _GLIBCXX_STD_A::set_symmetric_difference( | |
| __begin1, __end1, __begin2, __end2, __result, __pred); } | |
| // Parallel set_symmetric_difference for random access iterators | |
| template<typename _RAIter1, typename _RAIter2, | |
| typename _Output_RAIter, typename _Predicate> | |
| _Output_RAIter | |
| __set_symmetric_difference_switch(_RAIter1 __begin1, | |
| _RAIter1 __end1, | |
| _RAIter2 __begin2, | |
| _RAIter2 __end2, | |
| _Output_RAIter __result, | |
| _Predicate __pred, | |
| random_access_iterator_tag, | |
| random_access_iterator_tag, | |
| random_access_iterator_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) | |
| >= __gnu_parallel::_Settings::get().set_symmetric_difference_minimal_n | |
| || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2) | |
| >= __gnu_parallel::_Settings::get().set_symmetric_difference_minimal_n)) | |
| return __gnu_parallel::__parallel_set_symmetric_difference( | |
| __begin1, __end1, __begin2, __end2, __result, __pred); | |
| else | |
| return _GLIBCXX_STD_A::set_symmetric_difference( | |
| __begin1, __end1, __begin2, __end2, __result, __pred); | |
| } | |
| // Public interface. | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator> | |
| inline _OutputIterator | |
| set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out) | |
| { | |
| typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1; | |
| typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2; | |
| return __set_symmetric_difference_switch( | |
| __begin1, __end1, __begin2, __end2, __out, | |
| __gnu_parallel::_Less<_ValueType1, _ValueType2>(), | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2), | |
| std::__iterator_category(__out)); | |
| } | |
| // Public interface. | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _Predicate> | |
| inline _OutputIterator | |
| set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, _Predicate __pred) | |
| { | |
| return __set_symmetric_difference_switch( | |
| __begin1, __end1, __begin2, __end2, __out, __pred, | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2), | |
| std::__iterator_category(__out)); | |
| } | |
| // Sequential fallback. | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator> | |
| inline _OutputIterator | |
| set_difference(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::set_difference( | |
| __begin1,__end1, __begin2, __end2, __out); } | |
| // Sequential fallback. | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _Predicate> | |
| inline _OutputIterator | |
| set_difference(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, _Predicate __pred, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::set_difference(__begin1, __end1, | |
| __begin2, __end2, __out, __pred); } | |
| // Sequential fallback for input iterator case. | |
| template<typename _IIter1, typename _IIter2, typename _Predicate, | |
| typename _OutputIterator, typename _IteratorTag1, | |
| typename _IteratorTag2, typename _IteratorTag3> | |
| inline _OutputIterator | |
| __set_difference_switch(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __result, _Predicate __pred, | |
| _IteratorTag1, _IteratorTag2, _IteratorTag3) | |
| { return _GLIBCXX_STD_A::set_difference( | |
| __begin1, __end1, __begin2, __end2, __result, __pred); } | |
| // Parallel set_difference for random access iterators | |
| template<typename _RAIter1, typename _RAIter2, | |
| typename _Output_RAIter, typename _Predicate> | |
| _Output_RAIter | |
| __set_difference_switch(_RAIter1 __begin1, | |
| _RAIter1 __end1, | |
| _RAIter2 __begin2, | |
| _RAIter2 __end2, | |
| _Output_RAIter __result, _Predicate __pred, | |
| random_access_iterator_tag, | |
| random_access_iterator_tag, | |
| random_access_iterator_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) | |
| >= __gnu_parallel::_Settings::get().set_difference_minimal_n | |
| || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2) | |
| >= __gnu_parallel::_Settings::get().set_difference_minimal_n)) | |
| return __gnu_parallel::__parallel_set_difference( | |
| __begin1, __end1, __begin2, __end2, __result, __pred); | |
| else | |
| return _GLIBCXX_STD_A::set_difference( | |
| __begin1, __end1, __begin2, __end2, __result, __pred); | |
| } | |
| // Public interface | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator> | |
| inline _OutputIterator | |
| set_difference(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out) | |
| { | |
| typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1; | |
| typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2; | |
| return __set_difference_switch( | |
| __begin1, __end1, __begin2, __end2, __out, | |
| __gnu_parallel::_Less<_ValueType1, _ValueType2>(), | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2), | |
| std::__iterator_category(__out)); | |
| } | |
| // Public interface | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _Predicate> | |
| inline _OutputIterator | |
| set_difference(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __out, _Predicate __pred) | |
| { | |
| return __set_difference_switch( | |
| __begin1, __end1, __begin2, __end2, __out, __pred, | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2), | |
| std::__iterator_category(__out)); | |
| } | |
| // Sequential fallback | |
| template<typename _FIterator> | |
| inline _FIterator | |
| adjacent_find(_FIterator __begin, _FIterator __end, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::adjacent_find(__begin, __end); } | |
| // Sequential fallback | |
| template<typename _FIterator, typename _BinaryPredicate> | |
| inline _FIterator | |
| adjacent_find(_FIterator __begin, _FIterator __end, | |
| _BinaryPredicate __binary_pred, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::adjacent_find(__begin, __end, __binary_pred); } | |
| // Parallel algorithm for random access iterators | |
| template<typename _RAIter> | |
| _RAIter | |
| __adjacent_find_switch(_RAIter __begin, _RAIter __end, | |
| random_access_iterator_tag) | |
| { | |
| typedef iterator_traits<_RAIter> _TraitsType; | |
| typedef typename _TraitsType::value_type _ValueType; | |
| if (_GLIBCXX_PARALLEL_CONDITION(true)) | |
| { | |
| _RAIter __spot = __gnu_parallel:: | |
| __find_template( | |
| __begin, __end - 1, __begin, equal_to<_ValueType>(), | |
| __gnu_parallel::__adjacent_find_selector()) | |
| .first; | |
| if (__spot == (__end - 1)) | |
| return __end; | |
| else | |
| return __spot; | |
| } | |
| else | |
| return adjacent_find(__begin, __end, __gnu_parallel::sequential_tag()); | |
| } | |
| // Sequential fallback for input iterator case | |
| template<typename _FIterator, typename _IteratorTag> | |
| inline _FIterator | |
| __adjacent_find_switch(_FIterator __begin, _FIterator __end, | |
| _IteratorTag) | |
| { return adjacent_find(__begin, __end, __gnu_parallel::sequential_tag()); } | |
| // Public interface | |
| template<typename _FIterator> | |
| inline _FIterator | |
| adjacent_find(_FIterator __begin, _FIterator __end) | |
| { | |
| return __adjacent_find_switch(__begin, __end, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback for input iterator case | |
| template<typename _FIterator, typename _BinaryPredicate, | |
| typename _IteratorTag> | |
| inline _FIterator | |
| __adjacent_find_switch(_FIterator __begin, _FIterator __end, | |
| _BinaryPredicate __pred, _IteratorTag) | |
| { return adjacent_find(__begin, __end, __pred, | |
| __gnu_parallel::sequential_tag()); } | |
| // Parallel algorithm for random access iterators | |
| template<typename _RAIter, typename _BinaryPredicate> | |
| _RAIter | |
| __adjacent_find_switch(_RAIter __begin, _RAIter __end, | |
| _BinaryPredicate __pred, random_access_iterator_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION(true)) | |
| return __gnu_parallel::__find_template(__begin, __end, __begin, __pred, | |
| __gnu_parallel:: | |
| __adjacent_find_selector()).first; | |
| else | |
| return adjacent_find(__begin, __end, __pred, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface | |
| template<typename _FIterator, typename _BinaryPredicate> | |
| inline _FIterator | |
| adjacent_find(_FIterator __begin, _FIterator __end, | |
| _BinaryPredicate __pred) | |
| { | |
| return __adjacent_find_switch(__begin, __end, __pred, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback | |
| template<typename _IIter, typename _Tp> | |
| inline typename iterator_traits<_IIter>::difference_type | |
| count(_IIter __begin, _IIter __end, const _Tp& __value, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::count(__begin, __end, __value); } | |
| // Parallel code for random access iterators | |
| template<typename _RAIter, typename _Tp> | |
| typename iterator_traits<_RAIter>::difference_type | |
| __count_switch(_RAIter __begin, _RAIter __end, | |
| const _Tp& __value, random_access_iterator_tag, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| typedef iterator_traits<_RAIter> _TraitsType; | |
| typedef typename _TraitsType::value_type _ValueType; | |
| typedef typename _TraitsType::difference_type _DifferenceType; | |
| typedef __gnu_parallel::_SequenceIndex _SequenceIndex; | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().count_minimal_n | |
| && __gnu_parallel::__is_parallel(__parallelism_tag))) | |
| { | |
| __gnu_parallel::__count_selector<_RAIter, _DifferenceType> | |
| __functionality; | |
| _DifferenceType __res = 0; | |
| __gnu_parallel:: | |
| __for_each_template_random_access( | |
| __begin, __end, __value, __functionality, | |
| std::plus<_SequenceIndex>(), __res, __res, -1, | |
| __parallelism_tag); | |
| return __res; | |
| } | |
| else | |
| return count(__begin, __end, __value, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Sequential fallback for input iterator case. | |
| template<typename _IIter, typename _Tp, typename _IteratorTag> | |
| inline typename iterator_traits<_IIter>::difference_type | |
| __count_switch(_IIter __begin, _IIter __end, const _Tp& __value, | |
| _IteratorTag) | |
| { return count(__begin, __end, __value, __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface. | |
| template<typename _IIter, typename _Tp> | |
| inline typename iterator_traits<_IIter>::difference_type | |
| count(_IIter __begin, _IIter __end, const _Tp& __value, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| return __count_switch(__begin, __end, __value, | |
| std::__iterator_category(__begin), | |
| __parallelism_tag); | |
| } | |
| template<typename _IIter, typename _Tp> | |
| inline typename iterator_traits<_IIter>::difference_type | |
| count(_IIter __begin, _IIter __end, const _Tp& __value) | |
| { | |
| return __count_switch(__begin, __end, __value, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback. | |
| template<typename _IIter, typename _Predicate> | |
| inline typename iterator_traits<_IIter>::difference_type | |
| count_if(_IIter __begin, _IIter __end, _Predicate __pred, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::count_if(__begin, __end, __pred); } | |
| // Parallel count_if for random access iterators | |
| template<typename _RAIter, typename _Predicate> | |
| typename iterator_traits<_RAIter>::difference_type | |
| __count_if_switch(_RAIter __begin, _RAIter __end, | |
| _Predicate __pred, random_access_iterator_tag, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| typedef iterator_traits<_RAIter> _TraitsType; | |
| typedef typename _TraitsType::value_type _ValueType; | |
| typedef typename _TraitsType::difference_type _DifferenceType; | |
| typedef __gnu_parallel::_SequenceIndex _SequenceIndex; | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().count_minimal_n | |
| && __gnu_parallel::__is_parallel(__parallelism_tag))) | |
| { | |
| _DifferenceType __res = 0; | |
| __gnu_parallel:: | |
| __count_if_selector<_RAIter, _DifferenceType> | |
| __functionality; | |
| __gnu_parallel:: | |
| __for_each_template_random_access( | |
| __begin, __end, __pred, __functionality, | |
| std::plus<_SequenceIndex>(), __res, __res, -1, | |
| __parallelism_tag); | |
| return __res; | |
| } | |
| else | |
| return count_if(__begin, __end, __pred, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Sequential fallback for input iterator case. | |
| template<typename _IIter, typename _Predicate, typename _IteratorTag> | |
| inline typename iterator_traits<_IIter>::difference_type | |
| __count_if_switch(_IIter __begin, _IIter __end, _Predicate __pred, | |
| _IteratorTag) | |
| { return count_if(__begin, __end, __pred, | |
| __gnu_parallel::sequential_tag()); } | |
| // Public interface. | |
| template<typename _IIter, typename _Predicate> | |
| inline typename iterator_traits<_IIter>::difference_type | |
| count_if(_IIter __begin, _IIter __end, _Predicate __pred, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| return __count_if_switch(__begin, __end, __pred, | |
| std::__iterator_category(__begin), | |
| __parallelism_tag); | |
| } | |
| template<typename _IIter, typename _Predicate> | |
| inline typename iterator_traits<_IIter>::difference_type | |
| count_if(_IIter __begin, _IIter __end, _Predicate __pred) | |
| { | |
| return __count_if_switch(__begin, __end, __pred, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback. | |
| template<typename _FIterator1, typename _FIterator2> | |
| inline _FIterator1 | |
| search(_FIterator1 __begin1, _FIterator1 __end1, | |
| _FIterator2 __begin2, _FIterator2 __end2, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::search(__begin1, __end1, __begin2, __end2); } | |
| // Parallel algorithm for random access iterator | |
| template<typename _RAIter1, typename _RAIter2> | |
| _RAIter1 | |
| __search_switch(_RAIter1 __begin1, _RAIter1 __end1, | |
| _RAIter2 __begin2, _RAIter2 __end2, | |
| random_access_iterator_tag, random_access_iterator_tag) | |
| { | |
| typedef typename std::iterator_traits<_RAIter1>::value_type _ValueType1; | |
| typedef typename std::iterator_traits<_RAIter2>::value_type _ValueType2; | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) | |
| >= __gnu_parallel::_Settings::get().search_minimal_n)) | |
| return __gnu_parallel:: | |
| __search_template( | |
| __begin1, __end1, __begin2, __end2, | |
| __gnu_parallel::_EqualTo<_ValueType1, _ValueType2>()); | |
| else | |
| return search(__begin1, __end1, __begin2, __end2, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Sequential fallback for input iterator case | |
| template<typename _FIterator1, typename _FIterator2, | |
| typename _IteratorTag1, typename _IteratorTag2> | |
| inline _FIterator1 | |
| __search_switch(_FIterator1 __begin1, _FIterator1 __end1, | |
| _FIterator2 __begin2, _FIterator2 __end2, | |
| _IteratorTag1, _IteratorTag2) | |
| { return search(__begin1, __end1, __begin2, __end2, | |
| __gnu_parallel::sequential_tag()); } | |
| // Public interface. | |
| template<typename _FIterator1, typename _FIterator2> | |
| inline _FIterator1 | |
| search(_FIterator1 __begin1, _FIterator1 __end1, | |
| _FIterator2 __begin2, _FIterator2 __end2) | |
| { | |
| return __search_switch(__begin1, __end1, __begin2, __end2, | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2)); | |
| } | |
| // Public interface. | |
| template<typename _FIterator1, typename _FIterator2, | |
| typename _BinaryPredicate> | |
| inline _FIterator1 | |
| search(_FIterator1 __begin1, _FIterator1 __end1, | |
| _FIterator2 __begin2, _FIterator2 __end2, | |
| _BinaryPredicate __pred, __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::search( | |
| __begin1, __end1, __begin2, __end2, __pred); } | |
| // Parallel algorithm for random access iterator. | |
| template<typename _RAIter1, typename _RAIter2, | |
| typename _BinaryPredicate> | |
| _RAIter1 | |
| __search_switch(_RAIter1 __begin1, _RAIter1 __end1, | |
| _RAIter2 __begin2, _RAIter2 __end2, | |
| _BinaryPredicate __pred, | |
| random_access_iterator_tag, random_access_iterator_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) | |
| >= __gnu_parallel::_Settings::get().search_minimal_n)) | |
| return __gnu_parallel::__search_template(__begin1, __end1, | |
| __begin2, __end2, __pred); | |
| else | |
| return search(__begin1, __end1, __begin2, __end2, __pred, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Sequential fallback for input iterator case | |
| template<typename _FIterator1, typename _FIterator2, | |
| typename _BinaryPredicate, typename _IteratorTag1, | |
| typename _IteratorTag2> | |
| inline _FIterator1 | |
| __search_switch(_FIterator1 __begin1, _FIterator1 __end1, | |
| _FIterator2 __begin2, _FIterator2 __end2, | |
| _BinaryPredicate __pred, _IteratorTag1, _IteratorTag2) | |
| { return search(__begin1, __end1, __begin2, __end2, __pred, | |
| __gnu_parallel::sequential_tag()); } | |
| // Public interface | |
| template<typename _FIterator1, typename _FIterator2, | |
| typename _BinaryPredicate> | |
| inline _FIterator1 | |
| search(_FIterator1 __begin1, _FIterator1 __end1, | |
| _FIterator2 __begin2, _FIterator2 __end2, | |
| _BinaryPredicate __pred) | |
| { | |
| return __search_switch(__begin1, __end1, __begin2, __end2, __pred, | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2)); | |
| } | |
| // Sequential fallback | |
| template<typename _FIterator, typename _Integer, typename _Tp> | |
| inline _FIterator | |
| search_n(_FIterator __begin, _FIterator __end, _Integer __count, | |
| const _Tp& __val, __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val); } | |
| // Sequential fallback | |
| template<typename _FIterator, typename _Integer, typename _Tp, | |
| typename _BinaryPredicate> | |
| inline _FIterator | |
| search_n(_FIterator __begin, _FIterator __end, _Integer __count, | |
| const _Tp& __val, _BinaryPredicate __binary_pred, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::search_n( | |
| __begin, __end, __count, __val, __binary_pred); } | |
| // Public interface. | |
| template<typename _FIterator, typename _Integer, typename _Tp> | |
| inline _FIterator | |
| search_n(_FIterator __begin, _FIterator __end, _Integer __count, | |
| const _Tp& __val) | |
| { | |
| typedef typename iterator_traits<_FIterator>::value_type _ValueType; | |
| return __gnu_parallel::search_n(__begin, __end, __count, __val, | |
| __gnu_parallel::_EqualTo<_ValueType, _Tp>()); | |
| } | |
| // Parallel algorithm for random access iterators. | |
| template<typename _RAIter, typename _Integer, | |
| typename _Tp, typename _BinaryPredicate> | |
| _RAIter | |
| __search_n_switch(_RAIter __begin, _RAIter __end, _Integer __count, | |
| const _Tp& __val, _BinaryPredicate __binary_pred, | |
| random_access_iterator_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().search_minimal_n)) | |
| { | |
| __gnu_parallel::_PseudoSequence<_Tp, _Integer> __ps(__val, __count); | |
| return __gnu_parallel::__search_template( | |
| __begin, __end, __ps.begin(), __ps.end(), __binary_pred); | |
| } | |
| else | |
| return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val, | |
| __binary_pred); | |
| } | |
| // Sequential fallback for input iterator case. | |
| template<typename _FIterator, typename _Integer, typename _Tp, | |
| typename _BinaryPredicate, typename _IteratorTag> | |
| inline _FIterator | |
| __search_n_switch(_FIterator __begin, _FIterator __end, _Integer __count, | |
| const _Tp& __val, _BinaryPredicate __binary_pred, | |
| _IteratorTag) | |
| { return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val, | |
| __binary_pred); } | |
| // Public interface. | |
| template<typename _FIterator, typename _Integer, typename _Tp, | |
| typename _BinaryPredicate> | |
| inline _FIterator | |
| search_n(_FIterator __begin, _FIterator __end, _Integer __count, | |
| const _Tp& __val, _BinaryPredicate __binary_pred) | |
| { | |
| return __search_n_switch(__begin, __end, __count, __val, __binary_pred, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback. | |
| template<typename _IIter, typename _OutputIterator, | |
| typename _UnaryOperation> | |
| inline _OutputIterator | |
| transform(_IIter __begin, _IIter __end, _OutputIterator __result, | |
| _UnaryOperation __unary_op, __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::transform(__begin, __end, __result, __unary_op); } | |
| // Parallel unary transform for random access iterators. | |
| template<typename _RAIter1, typename _RAIter2, | |
| typename _UnaryOperation> | |
| _RAIter2 | |
| __transform1_switch(_RAIter1 __begin, _RAIter1 __end, | |
| _RAIter2 __result, _UnaryOperation __unary_op, | |
| random_access_iterator_tag, random_access_iterator_tag, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().transform_minimal_n | |
| && __gnu_parallel::__is_parallel(__parallelism_tag))) | |
| { | |
| bool __dummy = true; | |
| typedef __gnu_parallel::_IteratorPair<_RAIter1, | |
| _RAIter2, random_access_iterator_tag> _ItTrip; | |
| _ItTrip __begin_pair(__begin, __result), | |
| __end_pair(__end, __result + (__end - __begin)); | |
| __gnu_parallel::__transform1_selector<_ItTrip> __functionality; | |
| __gnu_parallel:: | |
| __for_each_template_random_access( | |
| __begin_pair, __end_pair, __unary_op, __functionality, | |
| __gnu_parallel::_DummyReduct(), | |
| __dummy, __dummy, -1, __parallelism_tag); | |
| return __functionality._M_finish_iterator; | |
| } | |
| else | |
| return transform(__begin, __end, __result, __unary_op, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Sequential fallback for input iterator case. | |
| template<typename _RAIter1, typename _RAIter2, | |
| typename _UnaryOperation, typename _IteratorTag1, | |
| typename _IteratorTag2> | |
| inline _RAIter2 | |
| __transform1_switch(_RAIter1 __begin, _RAIter1 __end, | |
| _RAIter2 __result, _UnaryOperation __unary_op, | |
| _IteratorTag1, _IteratorTag2) | |
| { return transform(__begin, __end, __result, __unary_op, | |
| __gnu_parallel::sequential_tag()); } | |
| // Public interface. | |
| template<typename _IIter, typename _OutputIterator, | |
| typename _UnaryOperation> | |
| inline _OutputIterator | |
| transform(_IIter __begin, _IIter __end, _OutputIterator __result, | |
| _UnaryOperation __unary_op, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| return __transform1_switch(__begin, __end, __result, __unary_op, | |
| std::__iterator_category(__begin), | |
| std::__iterator_category(__result), | |
| __parallelism_tag); | |
| } | |
| template<typename _IIter, typename _OutputIterator, | |
| typename _UnaryOperation> | |
| inline _OutputIterator | |
| transform(_IIter __begin, _IIter __end, _OutputIterator __result, | |
| _UnaryOperation __unary_op) | |
| { | |
| return __transform1_switch(__begin, __end, __result, __unary_op, | |
| std::__iterator_category(__begin), | |
| std::__iterator_category(__result)); | |
| } | |
| // Sequential fallback | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _BinaryOperation> | |
| inline _OutputIterator | |
| transform(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _OutputIterator __result, | |
| _BinaryOperation __binary_op, __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::transform(__begin1, __end1, | |
| __begin2, __result, __binary_op); } | |
| // Parallel binary transform for random access iterators. | |
| template<typename _RAIter1, typename _RAIter2, | |
| typename _RAIter3, typename _BinaryOperation> | |
| _RAIter3 | |
| __transform2_switch(_RAIter1 __begin1, _RAIter1 __end1, | |
| _RAIter2 __begin2, | |
| _RAIter3 __result, _BinaryOperation __binary_op, | |
| random_access_iterator_tag, random_access_iterator_tag, | |
| random_access_iterator_tag, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| (__end1 - __begin1) >= | |
| __gnu_parallel::_Settings::get().transform_minimal_n | |
| && __gnu_parallel::__is_parallel(__parallelism_tag))) | |
| { | |
| bool __dummy = true; | |
| typedef __gnu_parallel::_IteratorTriple<_RAIter1, | |
| _RAIter2, _RAIter3, | |
| random_access_iterator_tag> _ItTrip; | |
| _ItTrip __begin_triple(__begin1, __begin2, __result), | |
| __end_triple(__end1, __begin2 + (__end1 - __begin1), | |
| __result + (__end1 - __begin1)); | |
| __gnu_parallel::__transform2_selector<_ItTrip> __functionality; | |
| __gnu_parallel:: | |
| __for_each_template_random_access(__begin_triple, __end_triple, | |
| __binary_op, __functionality, | |
| __gnu_parallel::_DummyReduct(), | |
| __dummy, __dummy, -1, | |
| __parallelism_tag); | |
| return __functionality._M_finish_iterator; | |
| } | |
| else | |
| return transform(__begin1, __end1, __begin2, __result, __binary_op, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Sequential fallback for input iterator case. | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _BinaryOperation, | |
| typename _Tag1, typename _Tag2, typename _Tag3> | |
| inline _OutputIterator | |
| __transform2_switch(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _OutputIterator __result, | |
| _BinaryOperation __binary_op, _Tag1, _Tag2, _Tag3) | |
| { return transform(__begin1, __end1, __begin2, __result, __binary_op, | |
| __gnu_parallel::sequential_tag()); } | |
| // Public interface. | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _BinaryOperation> | |
| inline _OutputIterator | |
| transform(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _OutputIterator __result, | |
| _BinaryOperation __binary_op, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| return __transform2_switch( | |
| __begin1, __end1, __begin2, __result, __binary_op, | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2), | |
| std::__iterator_category(__result), | |
| __parallelism_tag); | |
| } | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _BinaryOperation> | |
| inline _OutputIterator | |
| transform(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _OutputIterator __result, | |
| _BinaryOperation __binary_op) | |
| { | |
| return __transform2_switch( | |
| __begin1, __end1, __begin2, __result, __binary_op, | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2), | |
| std::__iterator_category(__result)); | |
| } | |
| // Sequential fallback | |
| template<typename _FIterator, typename _Tp> | |
| inline void | |
| replace(_FIterator __begin, _FIterator __end, const _Tp& __old_value, | |
| const _Tp& __new_value, __gnu_parallel::sequential_tag) | |
| { _GLIBCXX_STD_A::replace(__begin, __end, __old_value, __new_value); } | |
| // Sequential fallback for input iterator case | |
| template<typename _FIterator, typename _Tp, typename _IteratorTag> | |
| inline void | |
| __replace_switch(_FIterator __begin, _FIterator __end, | |
| const _Tp& __old_value, const _Tp& __new_value, | |
| _IteratorTag) | |
| { replace(__begin, __end, __old_value, __new_value, | |
| __gnu_parallel::sequential_tag()); } | |
| // Parallel replace for random access iterators | |
| template<typename _RAIter, typename _Tp> | |
| inline void | |
| __replace_switch(_RAIter __begin, _RAIter __end, | |
| const _Tp& __old_value, const _Tp& __new_value, | |
| random_access_iterator_tag, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| // XXX parallel version is where? | |
| replace(__begin, __end, __old_value, __new_value, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface | |
| template<typename _FIterator, typename _Tp> | |
| inline void | |
| replace(_FIterator __begin, _FIterator __end, const _Tp& __old_value, | |
| const _Tp& __new_value, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| __replace_switch(__begin, __end, __old_value, __new_value, | |
| std::__iterator_category(__begin), | |
| __parallelism_tag); | |
| } | |
| template<typename _FIterator, typename _Tp> | |
| inline void | |
| replace(_FIterator __begin, _FIterator __end, const _Tp& __old_value, | |
| const _Tp& __new_value) | |
| { | |
| __replace_switch(__begin, __end, __old_value, __new_value, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback | |
| template<typename _FIterator, typename _Predicate, typename _Tp> | |
| inline void | |
| replace_if(_FIterator __begin, _FIterator __end, _Predicate __pred, | |
| const _Tp& __new_value, __gnu_parallel::sequential_tag) | |
| { _GLIBCXX_STD_A::replace_if(__begin, __end, __pred, __new_value); } | |
| // Sequential fallback for input iterator case | |
| template<typename _FIterator, typename _Predicate, typename _Tp, | |
| typename _IteratorTag> | |
| inline void | |
| __replace_if_switch(_FIterator __begin, _FIterator __end, | |
| _Predicate __pred, const _Tp& __new_value, _IteratorTag) | |
| { replace_if(__begin, __end, __pred, __new_value, | |
| __gnu_parallel::sequential_tag()); } | |
| // Parallel algorithm for random access iterators. | |
| template<typename _RAIter, typename _Predicate, typename _Tp> | |
| void | |
| __replace_if_switch(_RAIter __begin, _RAIter __end, | |
| _Predicate __pred, const _Tp& __new_value, | |
| random_access_iterator_tag, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().replace_minimal_n | |
| && __gnu_parallel::__is_parallel(__parallelism_tag))) | |
| { | |
| bool __dummy; | |
| __gnu_parallel:: | |
| __replace_if_selector<_RAIter, _Predicate, _Tp> | |
| __functionality(__new_value); | |
| __gnu_parallel:: | |
| __for_each_template_random_access( | |
| __begin, __end, __pred, __functionality, | |
| __gnu_parallel::_DummyReduct(), | |
| true, __dummy, -1, __parallelism_tag); | |
| } | |
| else | |
| replace_if(__begin, __end, __pred, __new_value, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface. | |
| template<typename _FIterator, typename _Predicate, typename _Tp> | |
| inline void | |
| replace_if(_FIterator __begin, _FIterator __end, | |
| _Predicate __pred, const _Tp& __new_value, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| __replace_if_switch(__begin, __end, __pred, __new_value, | |
| std::__iterator_category(__begin), | |
| __parallelism_tag); | |
| } | |
| template<typename _FIterator, typename _Predicate, typename _Tp> | |
| inline void | |
| replace_if(_FIterator __begin, _FIterator __end, | |
| _Predicate __pred, const _Tp& __new_value) | |
| { | |
| __replace_if_switch(__begin, __end, __pred, __new_value, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback | |
| template<typename _FIterator, typename _Generator> | |
| inline void | |
| generate(_FIterator __begin, _FIterator __end, _Generator __gen, | |
| __gnu_parallel::sequential_tag) | |
| { _GLIBCXX_STD_A::generate(__begin, __end, __gen); } | |
| // Sequential fallback for input iterator case. | |
| template<typename _FIterator, typename _Generator, typename _IteratorTag> | |
| inline void | |
| __generate_switch(_FIterator __begin, _FIterator __end, _Generator __gen, | |
| _IteratorTag) | |
| { generate(__begin, __end, __gen, __gnu_parallel::sequential_tag()); } | |
| // Parallel algorithm for random access iterators. | |
| template<typename _RAIter, typename _Generator> | |
| void | |
| __generate_switch(_RAIter __begin, _RAIter __end, | |
| _Generator __gen, random_access_iterator_tag, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().generate_minimal_n | |
| && __gnu_parallel::__is_parallel(__parallelism_tag))) | |
| { | |
| bool __dummy; | |
| __gnu_parallel::__generate_selector<_RAIter> | |
| __functionality; | |
| __gnu_parallel:: | |
| __for_each_template_random_access( | |
| __begin, __end, __gen, __functionality, | |
| __gnu_parallel::_DummyReduct(), | |
| true, __dummy, -1, __parallelism_tag); | |
| } | |
| else | |
| generate(__begin, __end, __gen, __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface. | |
| template<typename _FIterator, typename _Generator> | |
| inline void | |
| generate(_FIterator __begin, _FIterator __end, | |
| _Generator __gen, __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| __generate_switch(__begin, __end, __gen, | |
| std::__iterator_category(__begin), | |
| __parallelism_tag); | |
| } | |
| template<typename _FIterator, typename _Generator> | |
| inline void | |
| generate(_FIterator __begin, _FIterator __end, _Generator __gen) | |
| { | |
| __generate_switch(__begin, __end, __gen, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback. | |
| template<typename _OutputIterator, typename _Size, typename _Generator> | |
| inline _OutputIterator | |
| generate_n(_OutputIterator __begin, _Size __n, _Generator __gen, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::generate_n(__begin, __n, __gen); } | |
| // Sequential fallback for input iterator case. | |
| template<typename _OutputIterator, typename _Size, typename _Generator, | |
| typename _IteratorTag> | |
| inline _OutputIterator | |
| __generate_n_switch(_OutputIterator __begin, _Size __n, _Generator __gen, | |
| _IteratorTag) | |
| { return generate_n(__begin, __n, __gen, | |
| __gnu_parallel::sequential_tag()); } | |
| // Parallel algorithm for random access iterators. | |
| template<typename _RAIter, typename _Size, typename _Generator> | |
| inline _RAIter | |
| __generate_n_switch(_RAIter __begin, _Size __n, _Generator __gen, | |
| random_access_iterator_tag, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| // XXX parallel version is where? | |
| return generate_n(__begin, __n, __gen, __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface. | |
| template<typename _OutputIterator, typename _Size, typename _Generator> | |
| inline _OutputIterator | |
| generate_n(_OutputIterator __begin, _Size __n, _Generator __gen, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| return __generate_n_switch(__begin, __n, __gen, | |
| std::__iterator_category(__begin), | |
| __parallelism_tag); | |
| } | |
| template<typename _OutputIterator, typename _Size, typename _Generator> | |
| inline _OutputIterator | |
| generate_n(_OutputIterator __begin, _Size __n, _Generator __gen) | |
| { | |
| return __generate_n_switch(__begin, __n, __gen, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback. | |
| template<typename _RAIter> | |
| inline void | |
| random_shuffle(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::sequential_tag) | |
| { _GLIBCXX_STD_A::random_shuffle(__begin, __end); } | |
| // Sequential fallback. | |
| template<typename _RAIter, typename _RandomNumberGenerator> | |
| inline void | |
| random_shuffle(_RAIter __begin, _RAIter __end, | |
| _RandomNumberGenerator& __rand, | |
| __gnu_parallel::sequential_tag) | |
| { _GLIBCXX_STD_A::random_shuffle(__begin, __end, __rand); } | |
| /** @brief Functor wrapper for std::rand(). */ | |
| template<typename _MustBeInt = int> | |
| struct _CRandNumber | |
| { | |
| int | |
| operator()(int __limit) | |
| { return rand() % __limit; } | |
| }; | |
| // Fill in random number generator. | |
| template<typename _RAIter> | |
| inline void | |
| random_shuffle(_RAIter __begin, _RAIter __end) | |
| { | |
| _CRandNumber<> __r; | |
| // Parallelization still possible. | |
| __gnu_parallel::random_shuffle(__begin, __end, __r); | |
| } | |
| // Parallel algorithm for random access iterators. | |
| template<typename _RAIter, typename _RandomNumberGenerator> | |
| void | |
| random_shuffle(_RAIter __begin, _RAIter __end, | |
| #if __cplusplus >= 201103L | |
| _RandomNumberGenerator&& __rand) | |
| #else | |
| _RandomNumberGenerator& __rand) | |
| #endif | |
| { | |
| if (__begin == __end) | |
| return; | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().random_shuffle_minimal_n)) | |
| __gnu_parallel::__parallel_random_shuffle(__begin, __end, __rand); | |
| else | |
| __gnu_parallel::__sequential_random_shuffle(__begin, __end, __rand); | |
| } | |
| // Sequential fallback. | |
| template<typename _FIterator, typename _Predicate> | |
| inline _FIterator | |
| partition(_FIterator __begin, _FIterator __end, | |
| _Predicate __pred, __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::partition(__begin, __end, __pred); } | |
| // Sequential fallback for input iterator case. | |
| template<typename _FIterator, typename _Predicate, typename _IteratorTag> | |
| inline _FIterator | |
| __partition_switch(_FIterator __begin, _FIterator __end, | |
| _Predicate __pred, _IteratorTag) | |
| { return partition(__begin, __end, __pred, | |
| __gnu_parallel::sequential_tag()); } | |
| // Parallel algorithm for random access iterators. | |
| template<typename _RAIter, typename _Predicate> | |
| _RAIter | |
| __partition_switch(_RAIter __begin, _RAIter __end, | |
| _Predicate __pred, random_access_iterator_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().partition_minimal_n)) | |
| { | |
| typedef typename std::iterator_traits<_RAIter>:: | |
| difference_type _DifferenceType; | |
| _DifferenceType __middle = __gnu_parallel:: | |
| __parallel_partition(__begin, __end, __pred, | |
| __gnu_parallel::__get_max_threads()); | |
| return __begin + __middle; | |
| } | |
| else | |
| return partition(__begin, __end, __pred, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface. | |
| template<typename _FIterator, typename _Predicate> | |
| inline _FIterator | |
| partition(_FIterator __begin, _FIterator __end, _Predicate __pred) | |
| { | |
| return __partition_switch(__begin, __end, __pred, | |
| std::__iterator_category(__begin)); | |
| } | |
| // sort interface | |
| // Sequential fallback | |
| template<typename _RAIter> | |
| inline void | |
| sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::sequential_tag) | |
| { _GLIBCXX_STD_A::sort(__begin, __end); } | |
| // Sequential fallback | |
| template<typename _RAIter, typename _Compare> | |
| inline void | |
| sort(_RAIter __begin, _RAIter __end, _Compare __comp, | |
| __gnu_parallel::sequential_tag) | |
| { _GLIBCXX_STD_A::sort<_RAIter, _Compare>(__begin, __end, | |
| __comp); } | |
| // Public interface | |
| template<typename _RAIter, typename _Compare, | |
| typename _Parallelism> | |
| void | |
| sort(_RAIter __begin, _RAIter __end, _Compare __comp, | |
| _Parallelism __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| if (__begin != __end) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= | |
| __gnu_parallel::_Settings::get().sort_minimal_n)) | |
| __gnu_parallel::__parallel_sort<false>( | |
| __begin, __end, __comp, __parallelism); | |
| else | |
| sort(__begin, __end, __comp, __gnu_parallel::sequential_tag()); | |
| } | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| sort(_RAIter __begin, _RAIter __end) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| sort(__begin, __end, std::less<_ValueType>(), | |
| __gnu_parallel::default_parallel_tag()); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::default_parallel_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::parallel_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::multiway_mergesort_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::multiway_mergesort_sampling_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::multiway_mergesort_exact_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::quicksort_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::balanced_quicksort_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface | |
| template<typename _RAIter, typename _Compare> | |
| void | |
| sort(_RAIter __begin, _RAIter __end, _Compare __comp) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| sort(__begin, __end, __comp, __gnu_parallel::default_parallel_tag()); | |
| } | |
| // stable_sort interface | |
| // Sequential fallback | |
| template<typename _RAIter> | |
| inline void | |
| stable_sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::sequential_tag) | |
| { _GLIBCXX_STD_A::stable_sort(__begin, __end); } | |
| // Sequential fallback | |
| template<typename _RAIter, typename _Compare> | |
| inline void | |
| stable_sort(_RAIter __begin, _RAIter __end, | |
| _Compare __comp, __gnu_parallel::sequential_tag) | |
| { _GLIBCXX_STD_A::stable_sort<_RAIter, _Compare>(__begin, __end, __comp); } | |
| // Public interface | |
| template<typename _RAIter, typename _Compare, | |
| typename _Parallelism> | |
| void | |
| stable_sort(_RAIter __begin, _RAIter __end, | |
| _Compare __comp, _Parallelism __parallelism) | |
| { | |
| typedef iterator_traits<_RAIter> _TraitsType; | |
| typedef typename _TraitsType::value_type _ValueType; | |
| if (__begin != __end) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= | |
| __gnu_parallel::_Settings::get().sort_minimal_n)) | |
| __gnu_parallel::__parallel_sort<true>(__begin, __end, | |
| __comp, __parallelism); | |
| else | |
| stable_sort(__begin, __end, __comp, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| stable_sort(_RAIter __begin, _RAIter __end) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| stable_sort(__begin, __end, std::less<_ValueType>(), | |
| __gnu_parallel::default_parallel_tag()); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| stable_sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::default_parallel_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| stable_sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::parallel_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| stable_sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::multiway_mergesort_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| stable_sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::quicksort_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| stable_sort(_RAIter __begin, _RAIter __end, | |
| __gnu_parallel::balanced_quicksort_tag __parallelism) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism); | |
| } | |
| // Public interface | |
| template<typename _RAIter, typename _Compare> | |
| void | |
| stable_sort(_RAIter __begin, _RAIter __end, _Compare __comp) | |
| { | |
| stable_sort( | |
| __begin, __end, __comp, __gnu_parallel::default_parallel_tag()); | |
| } | |
| // Sequential fallback | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator> | |
| inline _OutputIterator | |
| merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, | |
| _IIter2 __end2, _OutputIterator __result, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::merge( | |
| __begin1, __end1, __begin2, __end2, __result); } | |
| // Sequential fallback | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _Compare> | |
| inline _OutputIterator | |
| merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, | |
| _IIter2 __end2, _OutputIterator __result, _Compare __comp, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::merge( | |
| __begin1, __end1, __begin2, __end2, __result, __comp); } | |
| // Sequential fallback for input iterator case | |
| template<typename _IIter1, typename _IIter2, typename _OutputIterator, | |
| typename _Compare, typename _IteratorTag1, | |
| typename _IteratorTag2, typename _IteratorTag3> | |
| inline _OutputIterator | |
| __merge_switch(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __result, _Compare __comp, | |
| _IteratorTag1, _IteratorTag2, _IteratorTag3) | |
| { return _GLIBCXX_STD_A::merge(__begin1, __end1, __begin2, __end2, | |
| __result, __comp); } | |
| // Parallel algorithm for random access iterators | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _Compare> | |
| _OutputIterator | |
| __merge_switch(_IIter1 __begin1, _IIter1 __end1, | |
| _IIter2 __begin2, _IIter2 __end2, | |
| _OutputIterator __result, _Compare __comp, | |
| random_access_iterator_tag, random_access_iterator_tag, | |
| random_access_iterator_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| (static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) | |
| >= __gnu_parallel::_Settings::get().merge_minimal_n | |
| || static_cast<__gnu_parallel::_SequenceIndex>(__end2 - __begin2) | |
| >= __gnu_parallel::_Settings::get().merge_minimal_n))) | |
| return __gnu_parallel::__parallel_merge_advance( | |
| __begin1, __end1, __begin2, __end2, __result, | |
| (__end1 - __begin1) + (__end2 - __begin2), __comp); | |
| else | |
| return __gnu_parallel::__merge_advance( | |
| __begin1, __end1, __begin2, __end2, __result, | |
| (__end1 - __begin1) + (__end2 - __begin2), __comp); | |
| } | |
| // Public interface | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator, typename _Compare> | |
| inline _OutputIterator | |
| merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, | |
| _IIter2 __end2, _OutputIterator __result, _Compare __comp) | |
| { | |
| return __merge_switch( | |
| __begin1, __end1, __begin2, __end2, __result, __comp, | |
| std::__iterator_category(__begin1), | |
| std::__iterator_category(__begin2), | |
| std::__iterator_category(__result)); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _IIter1, typename _IIter2, | |
| typename _OutputIterator> | |
| inline _OutputIterator | |
| merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, | |
| _IIter2 __end2, _OutputIterator __result) | |
| { | |
| typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1; | |
| typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2; | |
| return __gnu_parallel::merge(__begin1, __end1, __begin2, __end2, | |
| __result, __gnu_parallel::_Less<_ValueType1, _ValueType2>()); | |
| } | |
| // Sequential fallback | |
| template<typename _RAIter> | |
| inline void | |
| nth_element(_RAIter __begin, _RAIter __nth, | |
| _RAIter __end, __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::nth_element(__begin, __nth, __end); } | |
| // Sequential fallback | |
| template<typename _RAIter, typename _Compare> | |
| inline void | |
| nth_element(_RAIter __begin, _RAIter __nth, | |
| _RAIter __end, _Compare __comp, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::nth_element(__begin, __nth, __end, __comp); } | |
| // Public interface | |
| template<typename _RAIter, typename _Compare> | |
| inline void | |
| nth_element(_RAIter __begin, _RAIter __nth, | |
| _RAIter __end, _Compare __comp) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().nth_element_minimal_n)) | |
| __gnu_parallel::__parallel_nth_element(__begin, __nth, __end, __comp); | |
| else | |
| nth_element(__begin, __nth, __end, __comp, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| nth_element(_RAIter __begin, _RAIter __nth, | |
| _RAIter __end) | |
| { | |
| typedef typename iterator_traits<_RAIter>::value_type _ValueType; | |
| __gnu_parallel::nth_element(__begin, __nth, __end, | |
| std::less<_ValueType>()); | |
| } | |
| // Sequential fallback | |
| template<typename _RAIter, typename _Compare> | |
| inline void | |
| partial_sort(_RAIter __begin, _RAIter __middle, | |
| _RAIter __end, _Compare __comp, | |
| __gnu_parallel::sequential_tag) | |
| { _GLIBCXX_STD_A::partial_sort(__begin, __middle, __end, __comp); } | |
| // Sequential fallback | |
| template<typename _RAIter> | |
| inline void | |
| partial_sort(_RAIter __begin, _RAIter __middle, | |
| _RAIter __end, __gnu_parallel::sequential_tag) | |
| { _GLIBCXX_STD_A::partial_sort(__begin, __middle, __end); } | |
| // Public interface, parallel algorithm for random access iterators | |
| template<typename _RAIter, typename _Compare> | |
| void | |
| partial_sort(_RAIter __begin, _RAIter __middle, | |
| _RAIter __end, _Compare __comp) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().partial_sort_minimal_n)) | |
| __gnu_parallel:: | |
| __parallel_partial_sort(__begin, __middle, __end, __comp); | |
| else | |
| partial_sort(__begin, __middle, __end, __comp, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _RAIter> | |
| inline void | |
| partial_sort(_RAIter __begin, _RAIter __middle, | |
| _RAIter __end) | |
| { | |
| typedef iterator_traits<_RAIter> _TraitsType; | |
| typedef typename _TraitsType::value_type _ValueType; | |
| __gnu_parallel::partial_sort(__begin, __middle, __end, | |
| std::less<_ValueType>()); | |
| } | |
| // Sequential fallback | |
| template<typename _FIterator> | |
| inline _FIterator | |
| max_element(_FIterator __begin, _FIterator __end, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::max_element(__begin, __end); } | |
| // Sequential fallback | |
| template<typename _FIterator, typename _Compare> | |
| inline _FIterator | |
| max_element(_FIterator __begin, _FIterator __end, _Compare __comp, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::max_element(__begin, __end, __comp); } | |
| // Sequential fallback for input iterator case | |
| template<typename _FIterator, typename _Compare, typename _IteratorTag> | |
| inline _FIterator | |
| __max_element_switch(_FIterator __begin, _FIterator __end, | |
| _Compare __comp, _IteratorTag) | |
| { return max_element(__begin, __end, __comp, | |
| __gnu_parallel::sequential_tag()); } | |
| // Parallel algorithm for random access iterators | |
| template<typename _RAIter, typename _Compare> | |
| _RAIter | |
| __max_element_switch(_RAIter __begin, _RAIter __end, | |
| _Compare __comp, random_access_iterator_tag, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().max_element_minimal_n | |
| && __gnu_parallel::__is_parallel(__parallelism_tag))) | |
| { | |
| _RAIter __res(__begin); | |
| __gnu_parallel::__identity_selector<_RAIter> | |
| __functionality; | |
| __gnu_parallel:: | |
| __for_each_template_random_access( | |
| __begin, __end, __gnu_parallel::_Nothing(), __functionality, | |
| __gnu_parallel::__max_element_reduct<_Compare, _RAIter>(__comp), | |
| __res, __res, -1, __parallelism_tag); | |
| return __res; | |
| } | |
| else | |
| return max_element(__begin, __end, __comp, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _FIterator> | |
| inline _FIterator | |
| max_element(_FIterator __begin, _FIterator __end, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| typedef typename iterator_traits<_FIterator>::value_type _ValueType; | |
| return max_element(__begin, __end, std::less<_ValueType>(), | |
| __parallelism_tag); | |
| } | |
| template<typename _FIterator> | |
| inline _FIterator | |
| max_element(_FIterator __begin, _FIterator __end) | |
| { | |
| typedef typename iterator_traits<_FIterator>::value_type _ValueType; | |
| return __gnu_parallel::max_element(__begin, __end, | |
| std::less<_ValueType>()); | |
| } | |
| // Public interface | |
| template<typename _FIterator, typename _Compare> | |
| inline _FIterator | |
| max_element(_FIterator __begin, _FIterator __end, _Compare __comp, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| return __max_element_switch(__begin, __end, __comp, | |
| std::__iterator_category(__begin), | |
| __parallelism_tag); | |
| } | |
| template<typename _FIterator, typename _Compare> | |
| inline _FIterator | |
| max_element(_FIterator __begin, _FIterator __end, _Compare __comp) | |
| { | |
| return __max_element_switch(__begin, __end, __comp, | |
| std::__iterator_category(__begin)); | |
| } | |
| // Sequential fallback | |
| template<typename _FIterator> | |
| inline _FIterator | |
| min_element(_FIterator __begin, _FIterator __end, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::min_element(__begin, __end); } | |
| // Sequential fallback | |
| template<typename _FIterator, typename _Compare> | |
| inline _FIterator | |
| min_element(_FIterator __begin, _FIterator __end, _Compare __comp, | |
| __gnu_parallel::sequential_tag) | |
| { return _GLIBCXX_STD_A::min_element(__begin, __end, __comp); } | |
| // Sequential fallback for input iterator case | |
| template<typename _FIterator, typename _Compare, typename _IteratorTag> | |
| inline _FIterator | |
| __min_element_switch(_FIterator __begin, _FIterator __end, | |
| _Compare __comp, _IteratorTag) | |
| { return min_element(__begin, __end, __comp, | |
| __gnu_parallel::sequential_tag()); } | |
| // Parallel algorithm for random access iterators | |
| template<typename _RAIter, typename _Compare> | |
| _RAIter | |
| __min_element_switch(_RAIter __begin, _RAIter __end, | |
| _Compare __comp, random_access_iterator_tag, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| if (_GLIBCXX_PARALLEL_CONDITION( | |
| static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) | |
| >= __gnu_parallel::_Settings::get().min_element_minimal_n | |
| && __gnu_parallel::__is_parallel(__parallelism_tag))) | |
| { | |
| _RAIter __res(__begin); | |
| __gnu_parallel::__identity_selector<_RAIter> | |
| __functionality; | |
| __gnu_parallel:: | |
| __for_each_template_random_access( | |
| __begin, __end, __gnu_parallel::_Nothing(), __functionality, | |
| __gnu_parallel::__min_element_reduct<_Compare, _RAIter>(__comp), | |
| __res, __res, -1, __parallelism_tag); | |
| return __res; | |
| } | |
| else | |
| return min_element(__begin, __end, __comp, | |
| __gnu_parallel::sequential_tag()); | |
| } | |
| // Public interface, insert default comparator | |
| template<typename _FIterator> | |
| inline _FIterator | |
| min_element(_FIterator __begin, _FIterator __end, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| typedef typename iterator_traits<_FIterator>::value_type _ValueType; | |
| return min_element(__begin, __end, std::less<_ValueType>(), | |
| __parallelism_tag); | |
| } | |
| template<typename _FIterator> | |
| inline _FIterator | |
| min_element(_FIterator __begin, _FIterator __end) | |
| { | |
| typedef typename iterator_traits<_FIterator>::value_type _ValueType; | |
| return __gnu_parallel::min_element(__begin, __end, | |
| std::less<_ValueType>()); | |
| } | |
| // Public interface | |
| template<typename _FIterator, typename _Compare> | |
| inline _FIterator | |
| min_element(_FIterator __begin, _FIterator __end, _Compare __comp, | |
| __gnu_parallel::_Parallelism __parallelism_tag) | |
| { | |
| return __min_element_switch(__begin, __end, __comp, | |
| std::__iterator_category(__begin), | |
| __parallelism_tag); | |
| } | |
| template<typename _FIterator, typename _Compare> | |
| inline _FIterator | |
| min_element(_FIterator __begin, _FIterator __end, _Compare __comp) | |
| { | |
| return __min_element_switch(__begin, __end, __comp, | |
| std::__iterator_category(__begin)); | |
| } | |
| } // end namespace | |
| } // end namespace | |
| #endif /* _GLIBCXX_PARALLEL_ALGO_H */ |