From 1acba85b3706fd7063cbccded2d0c635ee76c445 Mon Sep 17 00:00:00 2001 From: Johannes Singler Date: Wed, 16 Sep 2009 09:47:25 +0000 Subject: [PATCH] algobase.h: Uglify internal identifiers. 2009-09-16 Johannes Singler * include/parallel/algobase.h: Uglify internal identifiers. * include/parallel/algo.h: Likewise. * include/parallel/algorithmfwd.h: Likewise. * include/parallel/balanced_quicksort.h: Likewise. * include/parallel/base.h: Likewise. * include/parallel/checkers.h: Likewise. * include/parallel/compatibility.h: Likewise. * include/parallel/compiletime_settings.: Likewise. * include/parallel/equally_split.h: Likewise. * include/parallel/features.h: Likewise. * include/parallel/find.h: Likewise. * include/parallel/find_selectors.h: Likewise. * include/parallel/for_each.h: Likewise. * include/parallel/for_each_selectors.h: Likewise. * include/parallel/iterator.h: Likewise. * include/parallel/list_partition.h: Likewise. * include/parallel/losertree.h: Likewise. * include/parallel/merge.h: Likewise. * include/parallel/multiseq_selection.h: Likewise. * include/parallel/multiway_merge.h: Likewise. * include/parallel/multiway_mergesort.h: Likewise. * include/parallel/numeric: Likewise. * include/parallel/numericfwd.h: Likewise. * include/parallel/omp_loop.h: Likewise. * include/parallel/omp_loop_static.h: Likewise. * include/parallel/par_loop.h: Likewise. * include/parallel/partial_sum.h: Likewise. * include/parallel/partition.h: Likewise. * include/parallel/queue.h: Likewise. * include/parallel/quicksort.h: Likewise. * include/parallel/random_number.h: Likewise. * include/parallel/random_shuffle.h: Likewise. * include/parallel/search.h: Likewise. * include/parallel/set_operations.h: Likewise. * include/parallel/settings.h: Likewise. * include/parallel/sort.h: Likewise. * include/parallel/tags.h: Likewise. * include/parallel/types.h: Likewise. * include/parallel/unique_copy.h: Likewise. * include/parallel/workstealing.h: Likewise. From-SVN: r151741 --- libstdc++-v3/ChangeLog | 46 + libstdc++-v3/include/parallel/algo.h | 2876 ++++++++--------- libstdc++-v3/include/parallel/algobase.h | 274 +- libstdc++-v3/include/parallel/algorithmfwd.h | 176 +- .../include/parallel/balanced_quicksort.h | 416 +-- libstdc++-v3/include/parallel/base.h | 338 +- libstdc++-v3/include/parallel/checkers.h | 128 +- libstdc++-v3/include/parallel/compatibility.h | 248 +- .../include/parallel/compiletime_settings.h | 14 +- libstdc++-v3/include/parallel/equally_split.h | 72 +- libstdc++-v3/include/parallel/features.h | 6 +- libstdc++-v3/include/parallel/find.h | 356 +- .../include/parallel/find_selectors.h | 200 +- libstdc++-v3/include/parallel/for_each.h | 90 +- .../include/parallel/for_each_selectors.h | 294 +- libstdc++-v3/include/parallel/iterator.h | 150 +- .../include/parallel/list_partition.h | 164 +- libstdc++-v3/include/parallel/losertree.h | 834 ++--- libstdc++-v3/include/parallel/merge.h | 306 +- .../include/parallel/multiseq_selection.h | 618 ++-- .../include/parallel/multiway_merge.h | 2206 ++++++------- .../include/parallel/multiway_mergesort.h | 472 +-- libstdc++-v3/include/parallel/numeric | 580 ++-- libstdc++-v3/include/parallel/numericfwd.h | 24 +- libstdc++-v3/include/parallel/omp_loop.h | 82 +- .../include/parallel/omp_loop_static.h | 80 +- libstdc++-v3/include/parallel/par_loop.h | 106 +- libstdc++-v3/include/parallel/partial_sum.h | 206 +- libstdc++-v3/include/parallel/partition.h | 404 +-- libstdc++-v3/include/parallel/queue.h | 90 +- libstdc++-v3/include/parallel/quicksort.h | 158 +- libstdc++-v3/include/parallel/random_number.h | 80 +- .../include/parallel/random_shuffle.h | 522 +-- libstdc++-v3/include/parallel/search.h | 144 +- .../include/parallel/set_operations.h | 556 ++-- libstdc++-v3/include/parallel/settings.h | 96 +- libstdc++-v3/include/parallel/sort.h | 164 +- libstdc++-v3/include/parallel/tags.h | 62 +- libstdc++-v3/include/parallel/types.h | 22 +- libstdc++-v3/include/parallel/unique_copy.h | 164 +- libstdc++-v3/include/parallel/workstealing.h | 254 +- 41 files changed, 7062 insertions(+), 7016 deletions(-) diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index f47356699c11..9d46458f3d4e 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,49 @@ +2009-09-16 Johannes Singler + + * include/parallel/algobase.h: Uglify internal identifiers. + * include/parallel/algo.h: Likewise. + * include/parallel/algorithm: Likewise. + * include/parallel/algorithmfwd.h: Likewise. + * include/parallel/balanced_quicksort.h: Likewise. + * include/parallel/base.h: Likewise. + * include/parallel/basic_iterator.h: Likewise. + * include/parallel/checkers.h: Likewise. + * include/parallel/compatibility.h: Likewise. + * include/parallel/compiletime_settings.: Likewise. + * include/parallel/equally_split.h: Likewise. + * include/parallel/features.h: Likewise. + * include/parallel/find.h: Likewise. + * include/parallel/find_selectors.h: Likewise. + * include/parallel/for_each.h: Likewise. + * include/parallel/for_each_selectors.h: Likewise. + * include/parallel/iterator.h: Likewise. + * include/parallel/list_partition.h: Likewise. + * include/parallel/losertree.h: Likewise. + * include/parallel/merge.h: Likewise. + * include/parallel/multiseq_selection.h: Likewise. + * include/parallel/multiway_merge.h: Likewise. + * include/parallel/multiway_mergesort.h: Likewise. + * include/parallel/numeric: Likewise. + * include/parallel/numericfwd.h: Likewise. + * include/parallel/omp_loop.h: Likewise. + * include/parallel/omp_loop_static.h: Likewise. + * include/parallel/parallel.h: Likewise. + * include/parallel/par_loop.h: Likewise. + * include/parallel/partial_sum.h: Likewise. + * include/parallel/partition.h: Likewise. + * include/parallel/queue.h: Likewise. + * include/parallel/quicksort.h: Likewise. + * include/parallel/random_number.h: Likewise. + * include/parallel/random_shuffle.h: Likewise. + * include/parallel/search.h: Likewise. + * include/parallel/set_operations.h: Likewise. + * include/parallel/settings.h: Likewise. + * include/parallel/sort.h: Likewise. + * include/parallel/tags.h: Likewise. + * include/parallel/types.h: Likewise. + * include/parallel/unique_copy.h: Likewise. + * include/parallel/workstealing.h: Likewise. + 2009-09-14 Paolo Carlini PR libstdc++/41037 diff --git a/libstdc++-v3/include/parallel/algo.h b/libstdc++-v3/include/parallel/algo.h index a0fbd8d91d65..7f32036aec6c 100644 --- a/libstdc++-v3/include/parallel/algo.h +++ b/libstdc++-v3/include/parallel/algo.h @@ -63,1784 +63,1784 @@ namespace std namespace __parallel { // Sequential fallback - template - inline Function - for_each(InputIterator begin, InputIterator end, Function f, + template + inline _Function + for_each(_IIter __begin, _IIter __end, _Function __f, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::for_each(begin, end, f); } + { return _GLIBCXX_STD_P::for_each(__begin, __end, __f); } // Sequential fallback for input iterator case - template - inline Function - for_each_switch(InputIterator begin, InputIterator end, Function f, - IteratorTag) - { return for_each(begin, end, f, __gnu_parallel::sequential_tag()); } + template + 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 - Function - for_each_switch(RandomAccessIterator begin, RandomAccessIterator end, - Function f, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + template + _Function + __for_each_switch(_RAIter __begin, _RAIter __end, + _Function __f, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_balanced) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().for_each_minimal_n - && __gnu_parallel::is_parallel(parallelism_tag))) + && __gnu_parallel::__is_parallel(__parallelism_tag))) { - bool dummy; - __gnu_parallel::for_each_selector functionality; + bool __dummy; + __gnu_parallel::__for_each_selector<_RAIter> __functionality; return __gnu_parallel:: - for_each_template_random_access(begin, end, f, functionality, - __gnu_parallel::dummy_reduct(), - true, dummy, -1, parallelism_tag); + __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()); + return for_each(__begin, __end, __f, __gnu_parallel::sequential_tag()); } // Public interface - template - inline Function - for_each(Iterator begin, Iterator end, Function f, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _Function + for_each(_Iterator __begin, _Iterator __end, _Function __f, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - return for_each_switch(begin, end, f, iterator_category(), - parallelism_tag); + typedef std::iterator_traits<_Iterator> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + return __for_each_switch(__begin, __end, __f, _IteratorCategory(), + __parallelism_tag); } - template - inline Function - for_each(Iterator begin, Iterator end, Function f) + template + inline _Function + for_each(_Iterator __begin, _Iterator __end, _Function __f) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - return for_each_switch(begin, end, f, iterator_category()); + typedef std::iterator_traits<_Iterator> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + return __for_each_switch(__begin, __end, __f, _IteratorCategory()); } // Sequential fallback - template - inline InputIterator - find(InputIterator begin, InputIterator end, const T& val, + template + inline _IIter + find(_IIter __begin, _IIter __end, const _Tp& __val, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::find(begin, end, val); } + { return _GLIBCXX_STD_P::find(__begin, __end, __val); } // Sequential fallback for input iterator case - template - inline InputIterator - find_switch(InputIterator begin, InputIterator end, const T& val, - IteratorTag) - { return _GLIBCXX_STD_P::find(begin, end, val); } + template + inline _IIter + __find_switch(_IIter __begin, _IIter __end, const _Tp& __val, + _IteratorTag) + { return _GLIBCXX_STD_P::find(__begin, __end, __val); } // Parallel find for random access iterators - template - RandomAccessIterator - find_switch(RandomAccessIterator begin, RandomAccessIterator end, - const T& val, random_access_iterator_tag) + template + _RAIter + __find_switch(_RAIter __begin, _RAIter __end, + const _Tp& __val, random_access_iterator_tag) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; if (_GLIBCXX_PARALLEL_CONDITION(true)) { - binder2nd<__gnu_parallel::equal_to > - comp(__gnu_parallel::equal_to(), val); - return __gnu_parallel::find_template(begin, end, begin, comp, + binder2nd<__gnu_parallel::equal_to<_ValueType, const _Tp&> > + __comp(__gnu_parallel::equal_to<_ValueType, const _Tp&>(), __val); + return __gnu_parallel::__find_template(__begin, __end, __begin, __comp, __gnu_parallel:: - find_if_selector()).first; + __find_if_selector()).first; } else - return _GLIBCXX_STD_P::find(begin, end, val); + return _GLIBCXX_STD_P::find(__begin, __end, __val); } // Public interface - template - inline InputIterator - find(InputIterator begin, InputIterator end, const T& val) + template + inline _IIter + find(_IIter __begin, _IIter __end, const _Tp& __val) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - return find_switch(begin, end, val, iterator_category()); + typedef std::iterator_traits<_IIter> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + return __find_switch(__begin, __end, __val, _IteratorCategory()); } // Sequential fallback - template - inline InputIterator - find_if(InputIterator begin, InputIterator end, Predicate pred, + template + inline _IIter + find_if(_IIter __begin, _IIter __end, _Predicate __pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::find_if(begin, end, pred); } + { return _GLIBCXX_STD_P::find_if(__begin, __end, __pred); } // Sequential fallback for input iterator case - template - inline InputIterator - find_if_switch(InputIterator begin, InputIterator end, Predicate pred, - IteratorTag) - { return _GLIBCXX_STD_P::find_if(begin, end, pred); } + template + inline _IIter + __find_if_switch(_IIter __begin, _IIter __end, _Predicate __pred, + _IteratorTag) + { return _GLIBCXX_STD_P::find_if(__begin, __end, __pred); } // Parallel find_if for random access iterators - template - RandomAccessIterator - find_if_switch(RandomAccessIterator begin, RandomAccessIterator end, - Predicate pred, random_access_iterator_tag) + template + _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, + return __gnu_parallel::__find_template(__begin, __end, __begin, __pred, __gnu_parallel:: - find_if_selector()).first; + __find_if_selector()).first; else - return _GLIBCXX_STD_P::find_if(begin, end, pred); + return _GLIBCXX_STD_P::find_if(__begin, __end, __pred); } // Public interface - template - inline InputIterator - find_if(InputIterator begin, InputIterator end, Predicate pred) + template + inline _IIter + find_if(_IIter __begin, _IIter __end, _Predicate __pred) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - return find_if_switch(begin, end, pred, iterator_category()); + typedef std::iterator_traits<_IIter> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + return __find_if_switch(__begin, __end, __pred, _IteratorCategory()); } // Sequential fallback - template - inline InputIterator - find_first_of(InputIterator begin1, InputIterator end1, - ForwardIterator begin2, ForwardIterator end2, + template + inline _IIter + find_first_of(_IIter __begin1, _IIter __end1, + _ForwardIterator __begin2, _ForwardIterator __end2, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::find_first_of(begin1, end1, begin2, end2); } + { return _GLIBCXX_STD_P::find_first_of(__begin1, __end1, __begin2, __end2); } // Sequential fallback - template - inline InputIterator - find_first_of(InputIterator begin1, InputIterator end1, - ForwardIterator begin2, ForwardIterator end2, - BinaryPredicate comp, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::find_first_of(begin1, end1, begin2, end2, comp); } - - // Sequential fallback for input iterator type - template - inline InputIterator - find_first_of_switch(InputIterator begin1, InputIterator end1, - ForwardIterator begin2, ForwardIterator end2, - IteratorTag1, IteratorTag2) - { return find_first_of(begin1, end1, begin2, end2, + template + inline _IIter + find_first_of(_IIter __begin1, _IIter __end1, + _ForwardIterator __begin2, _ForwardIterator __end2, + _BinaryPredicate __comp, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::find_first_of(__begin1, __end1, __begin2, __end2, __comp); } + + // Sequential fallback for input iterator _Self + template + inline _IIter + __find_first_of_switch(_IIter __begin1, _IIter __end1, + _ForwardIterator __begin2, _ForwardIterator __end2, + _IteratorTag1, _IteratorTag2) + { return find_first_of(__begin1, __end1, __begin2, __end2, __gnu_parallel::sequential_tag()); } // Parallel algorithm for random access iterators - template - inline RandomAccessIterator - find_first_of_switch(RandomAccessIterator begin1, - RandomAccessIterator end1, - ForwardIterator begin2, ForwardIterator end2, - BinaryPredicate comp, random_access_iterator_tag, - IteratorTag) + template + inline _RAIter + __find_first_of_switch(_RAIter __begin1, + _RAIter __end1, + _ForwardIterator __begin2, _ForwardIterator __end2, + _BinaryPredicate __comp, random_access_iterator_tag, + _IteratorTag) { return __gnu_parallel:: - find_template(begin1, end1, begin1, comp, - __gnu_parallel::find_first_of_selector - (begin2, end2)).first; - } - - // Sequential fallback for input iterator type - template - inline InputIterator - find_first_of_switch(InputIterator begin1, InputIterator end1, - ForwardIterator begin2, ForwardIterator end2, - BinaryPredicate comp, IteratorTag1, IteratorTag2) - { return find_first_of(begin1, end1, begin2, end2, comp, + __find_template(__begin1, __end1, __begin1, __comp, + __gnu_parallel::__find_first_of_selector + <_ForwardIterator>(__begin2, __end2)).first; + } + + // Sequential fallback for input iterator _Self + template + inline _IIter + __find_first_of_switch(_IIter __begin1, _IIter __end1, + _ForwardIterator __begin2, _ForwardIterator __end2, + _BinaryPredicate __comp, _IteratorTag1, _IteratorTag2) + { return find_first_of(__begin1, __end1, __begin2, __end2, __comp, __gnu_parallel::sequential_tag()); } // Public interface - template - inline InputIterator - find_first_of(InputIterator begin1, InputIterator end1, - ForwardIterator begin2, ForwardIterator end2, - BinaryPredicate comp) - { - typedef std::iterator_traits iteratori_traits; - typedef std::iterator_traits iteratorf_traits; - typedef typename iteratori_traits::iterator_category iteratori_category; + template + inline _IIter + find_first_of(_IIter __begin1, _IIter __end1, + _ForwardIterator __begin2, _ForwardIterator __end2, + _BinaryPredicate __comp) + { + typedef std::iterator_traits<_IIter> _IIterTraits; + typedef std::iterator_traits<_ForwardIterator> iteratorf_traits; + typedef typename _IIterTraits::iterator_category _IIteratorCategory; typedef typename iteratorf_traits::iterator_category iteratorf_category; - return find_first_of_switch(begin1, end1, begin2, end2, comp, - iteratori_category(), iteratorf_category()); + return __find_first_of_switch(__begin1, __end1, __begin2, __end2, __comp, + _IIteratorCategory(), iteratorf_category()); } // Public interface, insert default comparator - template - inline InputIterator - find_first_of(InputIterator begin1, InputIterator end1, - ForwardIterator begin2, ForwardIterator end2) + template + inline _IIter + find_first_of(_IIter __begin1, _IIter __end1, + _ForwardIterator __begin2, _ForwardIterator __end2) { - typedef std::iterator_traits iteratori_traits; - typedef std::iterator_traits iteratorf_traits; - typedef typename iteratori_traits::value_type valuei_type; - typedef typename iteratorf_traits::value_type valuef_type; + typedef std::iterator_traits<_IIter> _IIterTraits; + typedef std::iterator_traits<_ForwardIterator> iteratorf_traits; + typedef typename _IIterTraits::value_type _IValueType; + typedef typename iteratorf_traits::value_type _FValueType; - return find_first_of(begin1, end1, begin2, end2, __gnu_parallel:: - equal_to()); + return find_first_of(__begin1, __end1, __begin2, __end2, __gnu_parallel:: + equal_to<_IValueType, _FValueType>()); } // Sequential fallback - template - inline OutputIterator - unique_copy(InputIterator begin1, InputIterator end1, OutputIterator out, + template + inline _OutputIterator + unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::unique_copy(begin1, end1, out); } + { return _GLIBCXX_STD_P::unique_copy(__begin1, __end1, __out); } // Sequential fallback - template - inline OutputIterator - unique_copy(InputIterator begin1, InputIterator end1, OutputIterator out, - Predicate pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::unique_copy(begin1, end1, out, pred); } + template + inline _OutputIterator + unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out, + _Predicate __pred, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::unique_copy(__begin1, __end1, __out, __pred); } // Sequential fallback for input iterator case - template - inline OutputIterator - unique_copy_switch(InputIterator begin, InputIterator last, - OutputIterator out, Predicate pred, - IteratorTag1, IteratorTag2) - { return _GLIBCXX_STD_P::unique_copy(begin, last, out, pred); } + template + inline _OutputIterator + __unique_copy_switch(_IIter __begin, _IIter __last, + _OutputIterator __out, _Predicate __pred, + _IteratorTag1, _IteratorTag2) + { return _GLIBCXX_STD_P::unique_copy(__begin, __last, __out, __pred); } // Parallel unique_copy for random access iterators - template + template RandomAccessOutputIterator - unique_copy_switch(RandomAccessIterator begin, RandomAccessIterator last, - RandomAccessOutputIterator out, Predicate pred, + __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::sequence_index_t>(last - begin) + 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); + return __gnu_parallel::__parallel_unique_copy(__begin, __last, __out, __pred); else - return _GLIBCXX_STD_P::unique_copy(begin, last, out, pred); + return _GLIBCXX_STD_P::unique_copy(__begin, __last, __out, __pred); } // Public interface - template - inline OutputIterator - unique_copy(InputIterator begin1, InputIterator end1, OutputIterator out) + template + inline _OutputIterator + unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out) { - typedef std::iterator_traits iteratori_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori_traits::iterator_category iteratori_category; - typedef typename iteratori_traits::value_type value_type; - typedef typename iteratoro_traits::iterator_category iteratoro_category; + typedef std::iterator_traits<_IIter> _IIterTraits; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits::iterator_category _IIteratorCategory; + typedef typename _IIterTraits::value_type _ValueType; + typedef typename _OIterTraits::iterator_category _OIterCategory; - return unique_copy_switch(begin1, end1, out, equal_to(), - iteratori_category(), iteratoro_category()); + return __unique_copy_switch(__begin1, __end1, __out, equal_to<_ValueType>(), + _IIteratorCategory(), _OIterCategory()); } // Public interface - template - inline OutputIterator - unique_copy(InputIterator begin1, InputIterator end1, OutputIterator out, - Predicate pred) + template + inline _OutputIterator + unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out, + _Predicate __pred) { - typedef std::iterator_traits iteratori_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori_traits::iterator_category iteratori_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; + typedef std::iterator_traits<_IIter> _IIterTraits; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits::iterator_category _IIteratorCategory; + typedef typename _OIterTraits::iterator_category _OIterCategory; - return unique_copy_switch(begin1, end1, out, pred, iteratori_category(), - iteratoro_category()); + return __unique_copy_switch(__begin1, __end1, __out, __pred, _IIteratorCategory(), + _OIterCategory()); } // Sequential fallback - template - inline OutputIterator - set_union(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::set_union(begin1, end1, begin2, end2, out); } + template + inline _OutputIterator + set_union(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::set_union(__begin1, __end1, __begin2, __end2, __out); } // Sequential fallback - template - inline OutputIterator - set_union(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, Predicate pred, + template + inline _OutputIterator + set_union(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, _Predicate __pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::set_union(begin1, end1, - begin2, end2, out, pred); } + { return _GLIBCXX_STD_P::set_union(__begin1, __end1, + __begin2, __end2, __out, __pred); } // Sequential fallback for input iterator case - template - inline OutputIterator - set_union_switch(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator result, Predicate pred, IteratorTag1, - IteratorTag2, IteratorTag3) - { return _GLIBCXX_STD_P::set_union(begin1, end1, - begin2, end2, result, pred); } + template + inline _OutputIterator + __set_union_switch(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __result, _Predicate __pred, _IteratorTag1, + _IteratorTag2, _IteratorTag3) + { return _GLIBCXX_STD_P::set_union(__begin1, __end1, + __begin2, __end2, __result, __pred); } // Parallel set_union for random access iterators - template - OutputRandomAccessIterator - set_union_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, RandomAccessIterator2 end2, - OutputRandomAccessIterator result, Predicate pred, + template + _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::sequence_index_t>(end1 - begin1) + static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) >= __gnu_parallel::_Settings::get().set_union_minimal_n - || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) + || 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); + return __gnu_parallel::__parallel_set_union(__begin1, __end1, + __begin2, __end2, __result, __pred); else - return _GLIBCXX_STD_P::set_union(begin1, end1, - begin2, end2, result, pred); + return _GLIBCXX_STD_P::set_union(__begin1, __end1, + __begin2, __end2, __result, __pred); } // Public interface - template - inline OutputIterator - set_union(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, OutputIterator out) - { - typedef std::iterator_traits iteratori1_traits; - typedef std::iterator_traits iteratori2_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori1_traits::iterator_category - iteratori1_category; - typedef typename iteratori2_traits::iterator_category - iteratori2_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; - typedef typename iteratori1_traits::value_type value1_type; - typedef typename iteratori2_traits::value_type value2_type; - - return set_union_switch(begin1, end1, begin2, end2, out, - __gnu_parallel::less(), - iteratori1_category(), iteratori2_category(), - iteratoro_category()); + template + inline _OutputIterator + set_union(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out) + { + typedef std::iterator_traits<_IIter1> _IIterTraits1; + typedef std::iterator_traits<_IIter2> _IIterTraits2; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits1::iterator_category + _IIterCategory1; + typedef typename _IIterTraits2::iterator_category + _IIterCategory2; + typedef typename _OIterTraits::iterator_category _OIterCategory; + typedef typename _IIterTraits1::value_type _ValueType1; + typedef typename _IIterTraits2::value_type _ValueType2; + + return __set_union_switch(__begin1, __end1, __begin2, __end2, __out, + __gnu_parallel::_Less<_ValueType1, _ValueType2>(), + _IIterCategory1(), _IIterCategory2(), + _OIterCategory()); } // Public interface - template - inline OutputIterator - set_union(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, Predicate pred) - { - typedef std::iterator_traits iteratori1_traits; - typedef std::iterator_traits iteratori2_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori1_traits::iterator_category - iteratori1_category; - typedef typename iteratori2_traits::iterator_category - iteratori2_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; - - return set_union_switch(begin1, end1, begin2, end2, out, pred, - iteratori1_category(), iteratori2_category(), - iteratoro_category()); + template + inline _OutputIterator + set_union(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, _Predicate __pred) + { + typedef std::iterator_traits<_IIter1> _IIterTraits1; + typedef std::iterator_traits<_IIter2> _IIterTraits2; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits1::iterator_category + _IIterCategory1; + typedef typename _IIterTraits2::iterator_category + _IIterCategory2; + typedef typename _OIterTraits::iterator_category _OIterCategory; + + return __set_union_switch(__begin1, __end1, __begin2, __end2, __out, __pred, + _IIterCategory1(), _IIterCategory2(), + _OIterCategory()); } // Sequential fallback. - template - inline OutputIterator - set_intersection(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::set_intersection(begin1, end1, - begin2, end2, out); } + template + inline _OutputIterator + set_intersection(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::set_intersection(__begin1, __end1, + __begin2, __end2, __out); } // Sequential fallback. - template - inline OutputIterator - set_intersection(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, Predicate pred, + template + inline _OutputIterator + set_intersection(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, _Predicate __pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2, end2, - out, pred); } + { return _GLIBCXX_STD_P::set_intersection(__begin1, __end1, __begin2, __end2, + __out, __pred); } // Sequential fallback for input iterator case - template - inline OutputIterator - set_intersection_switch(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator result, Predicate pred, - IteratorTag1, IteratorTag2, IteratorTag3) - { return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2, - end2, result, pred); } + template + inline _OutputIterator + __set_intersection_switch(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __result, _Predicate __pred, + _IteratorTag1, _IteratorTag2, _IteratorTag3) + { return _GLIBCXX_STD_P::set_intersection(__begin1, __end1, __begin2, + __end2, __result, __pred); } // Parallel set_intersection for random access iterators - template - OutputRandomAccessIterator - set_intersection_switch(RandomAccessIterator1 begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, - RandomAccessIterator2 end2, - OutputRandomAccessIterator result, - Predicate pred, + template + _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::sequence_index_t>(end1 - begin1) + static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) >= __gnu_parallel::_Settings::get().set_union_minimal_n - || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) + || 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); + return __gnu_parallel::__parallel_set_intersection(__begin1, __end1, __begin2, + __end2, __result, __pred); else - return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2, - end2, result, pred); + return _GLIBCXX_STD_P::set_intersection(__begin1, __end1, __begin2, + __end2, __result, __pred); } // Public interface - template - inline OutputIterator - set_intersection(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out) - { - typedef std::iterator_traits iteratori1_traits; - typedef std::iterator_traits iteratori2_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori1_traits::iterator_category - iteratori1_category; - typedef typename iteratori2_traits::iterator_category - iteratori2_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; - typedef typename iteratori1_traits::value_type value1_type; - typedef typename iteratori2_traits::value_type value2_type; - - return set_intersection_switch(begin1, end1, begin2, end2, out, + template + inline _OutputIterator + set_intersection(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out) + { + typedef std::iterator_traits<_IIter1> _IIterTraits1; + typedef std::iterator_traits<_IIter2> _IIterTraits2; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits1::iterator_category + _IIterCategory1; + typedef typename _IIterTraits2::iterator_category + _IIterCategory2; + typedef typename _OIterTraits::iterator_category _OIterCategory; + typedef typename _IIterTraits1::value_type _ValueType1; + typedef typename _IIterTraits2::value_type _ValueType2; + + return __set_intersection_switch(__begin1, __end1, __begin2, __end2, __out, __gnu_parallel:: - less(), - iteratori1_category(), - iteratori2_category(), - iteratoro_category()); - } - - template - inline OutputIterator - set_intersection(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, Predicate pred) - { - typedef std::iterator_traits iteratori1_traits; - typedef std::iterator_traits iteratori2_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori1_traits::iterator_category - iteratori1_category; - typedef typename iteratori2_traits::iterator_category - iteratori2_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; - - return set_intersection_switch(begin1, end1, begin2, end2, out, pred, - iteratori1_category(), - iteratori2_category(), - iteratoro_category()); + _Less<_ValueType1, _ValueType2>(), + _IIterCategory1(), + _IIterCategory2(), + _OIterCategory()); + } + + template + inline _OutputIterator + set_intersection(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, _Predicate __pred) + { + typedef std::iterator_traits<_IIter1> _IIterTraits1; + typedef std::iterator_traits<_IIter2> _IIterTraits2; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits1::iterator_category + _IIterCategory1; + typedef typename _IIterTraits2::iterator_category + _IIterCategory2; + typedef typename _OIterTraits::iterator_category _OIterCategory; + + return __set_intersection_switch(__begin1, __end1, __begin2, __end2, __out, __pred, + _IIterCategory1(), + _IIterCategory2(), + _OIterCategory()); } // Sequential fallback - template - inline OutputIterator - set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, + template + inline _OutputIterator + set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::set_symmetric_difference(begin1,end1, - begin2, end2, out); } + { return _GLIBCXX_STD_P::set_symmetric_difference(__begin1,__end1, + __begin2, __end2, __out); } // Sequential fallback - template - inline OutputIterator - set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, Predicate pred, + template + inline _OutputIterator + set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, _Predicate __pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1, begin2, - end2, out, pred); } + { return _GLIBCXX_STD_P::set_symmetric_difference(__begin1, __end1, __begin2, + __end2, __out, __pred); } // Sequential fallback for input iterator case - template - inline OutputIterator - set_symmetric_difference_switch(InputIterator1 begin1, - InputIterator1 end1, - InputIterator2 begin2, - InputIterator2 end2, - OutputIterator result, Predicate pred, - IteratorTag1, IteratorTag2, IteratorTag3) - { return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1, - begin2, end2, - result, pred); } + template + inline _OutputIterator + __set_symmetric_difference_switch(_IIter1 __begin1, + _IIter1 __end1, + _IIter2 __begin2, + _IIter2 __end2, + _OutputIterator __result, _Predicate __pred, + _IteratorTag1, _IteratorTag2, _IteratorTag3) + { return _GLIBCXX_STD_P::set_symmetric_difference(__begin1, __end1, + __begin2, __end2, + __result, __pred); } // Parallel set_symmetric_difference for random access iterators - template - OutputRandomAccessIterator - set_symmetric_difference_switch(RandomAccessIterator1 begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, - RandomAccessIterator2 end2, - OutputRandomAccessIterator result, - Predicate pred, + template + _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::sequence_index_t>(end1 - begin1) + static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) >= __gnu_parallel::_Settings::get().set_symmetric_difference_minimal_n - || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) + || 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); + return __gnu_parallel::__parallel_set_symmetric_difference(__begin1, __end1, + __begin2, __end2, + __result, __pred); else - return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1, - begin2, end2, - result, pred); + return _GLIBCXX_STD_P::set_symmetric_difference(__begin1, __end1, + __begin2, __end2, + __result, __pred); } // Public interface. - template - inline OutputIterator - set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out) - { - typedef std::iterator_traits iteratori1_traits; - typedef std::iterator_traits iteratori2_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori1_traits::iterator_category - iteratori1_category; - typedef typename iteratori2_traits::iterator_category - iteratori2_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; - typedef typename iteratori1_traits::value_type value1_type; - typedef typename iteratori2_traits::value_type value2_type; - - return set_symmetric_difference_switch(begin1, end1, begin2, end2, out, + template + inline _OutputIterator + set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out) + { + typedef std::iterator_traits<_IIter1> _IIterTraits1; + typedef std::iterator_traits<_IIter2> _IIterTraits2; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits1::iterator_category + _IIterCategory1; + typedef typename _IIterTraits2::iterator_category + _IIterCategory2; + typedef typename _OIterTraits::iterator_category _OIterCategory; + typedef typename _IIterTraits1::value_type _ValueType1; + typedef typename _IIterTraits2::value_type _ValueType2; + + return __set_symmetric_difference_switch(__begin1, __end1, __begin2, __end2, __out, __gnu_parallel:: - less(), - iteratori1_category(), - iteratori2_category(), - iteratoro_category()); + _Less<_ValueType1, _ValueType2>(), + _IIterCategory1(), + _IIterCategory2(), + _OIterCategory()); } // Public interface. - template - inline OutputIterator - set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, Predicate pred) - { - typedef std::iterator_traits iteratori1_traits; - typedef std::iterator_traits iteratori2_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori1_traits::iterator_category - iteratori1_category; - typedef typename iteratori2_traits::iterator_category - iteratori2_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; - - return set_symmetric_difference_switch(begin1, end1, begin2, end2, out, - pred, iteratori1_category(), - iteratori2_category(), - iteratoro_category()); + template + inline _OutputIterator + set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, _Predicate __pred) + { + typedef std::iterator_traits<_IIter1> _IIterTraits1; + typedef std::iterator_traits<_IIter2> _IIterTraits2; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits1::iterator_category + _IIterCategory1; + typedef typename _IIterTraits2::iterator_category + _IIterCategory2; + typedef typename _OIterTraits::iterator_category _OIterCategory; + + return __set_symmetric_difference_switch(__begin1, __end1, __begin2, __end2, __out, + __pred, _IIterCategory1(), + _IIterCategory2(), + _OIterCategory()); } // Sequential fallback. - template - inline OutputIterator - set_difference(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::set_difference(begin1,end1, begin2, end2, out); } + template + inline _OutputIterator + set_difference(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::set_difference(__begin1,__end1, __begin2, __end2, __out); } // Sequential fallback. - template - inline OutputIterator - set_difference(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, Predicate pred, + template + inline _OutputIterator + set_difference(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, _Predicate __pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::set_difference(begin1, end1, - begin2, end2, out, pred); } + { return _GLIBCXX_STD_P::set_difference(__begin1, __end1, + __begin2, __end2, __out, __pred); } // Sequential fallback for input iterator case. - template - inline OutputIterator - set_difference_switch(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator result, Predicate pred, - IteratorTag1, IteratorTag2, IteratorTag3) - { return _GLIBCXX_STD_P::set_difference(begin1, end1, - begin2, end2, result, pred); } + template + inline _OutputIterator + __set_difference_switch(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __result, _Predicate __pred, + _IteratorTag1, _IteratorTag2, _IteratorTag3) + { return _GLIBCXX_STD_P::set_difference(__begin1, __end1, + __begin2, __end2, __result, __pred); } // Parallel set_difference for random access iterators - template - OutputRandomAccessIterator - set_difference_switch(RandomAccessIterator1 begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, - RandomAccessIterator2 end2, - OutputRandomAccessIterator result, Predicate pred, + template + _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::sequence_index_t>(end1 - begin1) + static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) >= __gnu_parallel::_Settings::get().set_difference_minimal_n - || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) + || 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); + return __gnu_parallel::__parallel_set_difference(__begin1, __end1, + __begin2, __end2, + __result, __pred); else - return _GLIBCXX_STD_P::set_difference(begin1, end1, - begin2, end2, result, pred); + return _GLIBCXX_STD_P::set_difference(__begin1, __end1, + __begin2, __end2, __result, __pred); } // Public interface - template - inline OutputIterator - set_difference(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out) - { - typedef std::iterator_traits iteratori1_traits; - typedef std::iterator_traits iteratori2_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori1_traits::iterator_category - iteratori1_category; - typedef typename iteratori2_traits::iterator_category - iteratori2_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; - typedef typename iteratori1_traits::value_type value1_type; - typedef typename iteratori2_traits::value_type value2_type; - - return set_difference_switch(begin1, end1, begin2, end2, out, + template + inline _OutputIterator + set_difference(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out) + { + typedef std::iterator_traits<_IIter1> _IIterTraits1; + typedef std::iterator_traits<_IIter2> _IIterTraits2; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits1::iterator_category + _IIterCategory1; + typedef typename _IIterTraits2::iterator_category + _IIterCategory2; + typedef typename _OIterTraits::iterator_category _OIterCategory; + typedef typename _IIterTraits1::value_type _ValueType1; + typedef typename _IIterTraits2::value_type _ValueType2; + + return __set_difference_switch(__begin1, __end1, __begin2, __end2, __out, __gnu_parallel:: - less(), - iteratori1_category(), - iteratori2_category(), - iteratoro_category()); + _Less<_ValueType1, _ValueType2>(), + _IIterCategory1(), + _IIterCategory2(), + _OIterCategory()); } // Public interface - template - inline OutputIterator - set_difference(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator out, Predicate pred) - { - typedef std::iterator_traits iteratori1_traits; - typedef std::iterator_traits iteratori2_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori1_traits::iterator_category - iteratori1_category; - typedef typename iteratori2_traits::iterator_category - iteratori2_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; - - return set_difference_switch(begin1, end1, begin2, end2, out, pred, - iteratori1_category(), - iteratori2_category(), - iteratoro_category()); + template + inline _OutputIterator + set_difference(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __out, _Predicate __pred) + { + typedef std::iterator_traits<_IIter1> _IIterTraits1; + typedef std::iterator_traits<_IIter2> _IIterTraits2; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits1::iterator_category + _IIterCategory1; + typedef typename _IIterTraits2::iterator_category + _IIterCategory2; + typedef typename _OIterTraits::iterator_category _OIterCategory; + + return __set_difference_switch(__begin1, __end1, __begin2, __end2, __out, __pred, + _IIterCategory1(), + _IIterCategory2(), + _OIterCategory()); } // Sequential fallback - template - inline ForwardIterator - adjacent_find(ForwardIterator begin, ForwardIterator end, + template + inline _ForwardIterator + adjacent_find(_ForwardIterator __begin, _ForwardIterator __end, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::adjacent_find(begin, end); } + { return _GLIBCXX_STD_P::adjacent_find(__begin, __end); } // Sequential fallback - template - inline ForwardIterator - adjacent_find(ForwardIterator begin, ForwardIterator end, - BinaryPredicate binary_pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::adjacent_find(begin, end, binary_pred); } + template + inline _ForwardIterator + adjacent_find(_ForwardIterator __begin, _ForwardIterator __end, + _BinaryPredicate __binary_pred, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::adjacent_find(__begin, __end, __binary_pred); } // Parallel algorithm for random access iterators - template - RandomAccessIterator - adjacent_find_switch(RandomAccessIterator begin, RandomAccessIterator end, + template + _RAIter + __adjacent_find_switch(_RAIter __begin, _RAIter __end, random_access_iterator_tag) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; if (_GLIBCXX_PARALLEL_CONDITION(true)) { - RandomAccessIterator spot = __gnu_parallel:: - find_template(begin, end - 1, begin, equal_to(), - __gnu_parallel::adjacent_find_selector()).first; - if (spot == (end - 1)) - return end; + _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()); + return adjacent_find(__begin, __end, __gnu_parallel::sequential_tag()); } // Sequential fallback for input iterator case - template - inline ForwardIterator - adjacent_find_switch(ForwardIterator begin, ForwardIterator end, - IteratorTag) - { return adjacent_find(begin, end, __gnu_parallel::sequential_tag()); } + template + inline _ForwardIterator + __adjacent_find_switch(_ForwardIterator __begin, _ForwardIterator __end, + _IteratorTag) + { return adjacent_find(__begin, __end, __gnu_parallel::sequential_tag()); } // Public interface - template - inline ForwardIterator - adjacent_find(ForwardIterator begin, ForwardIterator end) + template + inline _ForwardIterator + adjacent_find(_ForwardIterator __begin, _ForwardIterator __end) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - return adjacent_find_switch(begin, end, iterator_category()); + typedef iterator_traits<_ForwardIterator> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + return __adjacent_find_switch(__begin, __end, _IteratorCategory()); } // Sequential fallback for input iterator case - template - inline ForwardIterator - adjacent_find_switch(ForwardIterator begin, ForwardIterator end, - BinaryPredicate pred, IteratorTag) - { return adjacent_find(begin, end, pred, + template + inline _ForwardIterator + __adjacent_find_switch(_ForwardIterator __begin, _ForwardIterator __end, + _BinaryPredicate __pred, _IteratorTag) + { return adjacent_find(__begin, __end, __pred, __gnu_parallel::sequential_tag()); } // Parallel algorithm for random access iterators - template - RandomAccessIterator - adjacent_find_switch(RandomAccessIterator begin, RandomAccessIterator end, - BinaryPredicate pred, random_access_iterator_tag) + template + _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, + return __gnu_parallel::__find_template(__begin, __end, __begin, __pred, __gnu_parallel:: - adjacent_find_selector()).first; + __adjacent_find_selector()).first; else - return adjacent_find(begin, end, pred, + return adjacent_find(__begin, __end, __pred, __gnu_parallel::sequential_tag()); } // Public interface - template - inline ForwardIterator - adjacent_find(ForwardIterator begin, ForwardIterator end, - BinaryPredicate pred) + template + inline _ForwardIterator + adjacent_find(_ForwardIterator __begin, _ForwardIterator __end, + _BinaryPredicate __pred) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - return adjacent_find_switch(begin, end, pred, iterator_category()); + typedef iterator_traits<_ForwardIterator> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + return __adjacent_find_switch(__begin, __end, __pred, _IteratorCategory()); } // Sequential fallback - template - inline typename iterator_traits::difference_type - count(InputIterator begin, InputIterator end, const T& value, + template + inline typename iterator_traits<_IIter>::difference_type + count(_IIter __begin, _IIter __end, const _Tp& __value, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::count(begin, end, value); } + { return _GLIBCXX_STD_P::count(__begin, __end, __value); } // Parallel code for random access iterators - template - typename iterator_traits::difference_type - count_switch(RandomAccessIterator begin, RandomAccessIterator end, - const T& value, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + template + typename iterator_traits<_RAIter>::difference_type + __count_switch(_RAIter __begin, _RAIter __end, + const _Tp& __value, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_unbalanced) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; - typedef __gnu_parallel::sequence_index_t sequence_index_t; + 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(end - begin) + static_cast<_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().count_minimal_n - && __gnu_parallel::is_parallel(parallelism_tag))) + && __gnu_parallel::__is_parallel(__parallelism_tag))) { - __gnu_parallel::count_selector - functionality; - difference_type res = 0; + __gnu_parallel::__count_selector<_RAIter, _DifferenceType> + __functionality; + _DifferenceType __res = 0; __gnu_parallel:: - for_each_template_random_access(begin, end, value, - functionality, - std::plus(), - res, res, -1, parallelism_tag); - return res; + __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()); + return count(__begin, __end, __value, __gnu_parallel::sequential_tag()); } // Sequential fallback for input iterator case. - template - inline typename iterator_traits::difference_type - count_switch(InputIterator begin, InputIterator end, const T& value, - IteratorTag) - { return count(begin, end, value, __gnu_parallel::sequential_tag()); } + template + 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 - inline typename iterator_traits::difference_type - count(InputIterator begin, InputIterator end, const T& value, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline typename iterator_traits<_IIter>::difference_type + count(_IIter __begin, _IIter __end, const _Tp& __value, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - return count_switch(begin, end, value, iterator_category(), - parallelism_tag); + typedef iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + return __count_switch(__begin, __end, __value, _IteratorCategory(), + __parallelism_tag); } - template - inline typename iterator_traits::difference_type - count(InputIterator begin, InputIterator end, const T& value) + template + inline typename iterator_traits<_IIter>::difference_type + count(_IIter __begin, _IIter __end, const _Tp& __value) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - return count_switch(begin, end, value, iterator_category()); + typedef iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + return __count_switch(__begin, __end, __value, _IteratorCategory()); } // Sequential fallback. - template - inline typename iterator_traits::difference_type - count_if(InputIterator begin, InputIterator end, Predicate pred, + template + inline typename iterator_traits<_IIter>::difference_type + count_if(_IIter __begin, _IIter __end, _Predicate __pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::count_if(begin, end, pred); } + { return _GLIBCXX_STD_P::count_if(__begin, __end, __pred); } // Parallel count_if for random access iterators - template - typename iterator_traits::difference_type - count_if_switch(RandomAccessIterator begin, RandomAccessIterator end, - Predicate pred, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + template + typename iterator_traits<_RAIter>::difference_type + __count_if_switch(_RAIter __begin, _RAIter __end, + _Predicate __pred, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_unbalanced) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; - typedef __gnu_parallel::sequence_index_t sequence_index_t; + 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(end - begin) + static_cast<_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().count_minimal_n - && __gnu_parallel::is_parallel(parallelism_tag))) + && __gnu_parallel::__is_parallel(__parallelism_tag))) { - difference_type res = 0; + _DifferenceType __res = 0; __gnu_parallel:: - count_if_selector - functionality; + __count_if_selector<_RAIter, _DifferenceType> + __functionality; __gnu_parallel:: - for_each_template_random_access(begin, end, pred, - functionality, - std::plus(), - res, res, -1, parallelism_tag); - return res; + __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()); + return count_if(__begin, __end, __pred, __gnu_parallel::sequential_tag()); } // Sequential fallback for input iterator case. - template - inline typename iterator_traits::difference_type - count_if_switch(InputIterator begin, InputIterator end, Predicate pred, - IteratorTag) - { return count_if(begin, end, pred, __gnu_parallel::sequential_tag()); } + template + 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 - inline typename iterator_traits::difference_type - count_if(InputIterator begin, InputIterator end, Predicate pred, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline typename iterator_traits<_IIter>::difference_type + count_if(_IIter __begin, _IIter __end, _Predicate __pred, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - return count_if_switch(begin, end, pred, iterator_category(), - parallelism_tag); + typedef iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + return __count_if_switch(__begin, __end, __pred, _IteratorCategory(), + __parallelism_tag); } - template - inline typename iterator_traits::difference_type - count_if(InputIterator begin, InputIterator end, Predicate pred) + template + inline typename iterator_traits<_IIter>::difference_type + count_if(_IIter __begin, _IIter __end, _Predicate __pred) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - return count_if_switch(begin, end, pred, iterator_category()); + typedef iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + return __count_if_switch(__begin, __end, __pred, _IteratorCategory()); } // Sequential fallback. template inline ForwardIterator1 - search(ForwardIterator1 begin1, ForwardIterator1 end1, - ForwardIterator2 begin2, ForwardIterator2 end2, + search(ForwardIterator1 __begin1, ForwardIterator1 __end1, + ForwardIterator2 __begin2, ForwardIterator2 __end2, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::search(begin1, end1, begin2, end2); } + { return _GLIBCXX_STD_P::search(__begin1, __end1, __begin2, __end2); } // Parallel algorithm for random access iterator - template - RandomAccessIterator1 - search_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, RandomAccessIterator2 end2, + template + _RAIter1 + __search_switch(_RAIter1 __begin1, _RAIter1 __end1, + _RAIter2 __begin2, _RAIter2 __end2, random_access_iterator_tag, random_access_iterator_tag) { - typedef std::iterator_traits iterator1_traits; - typedef typename iterator1_traits::value_type value1_type; - typedef std::iterator_traits iterator2_traits; - typedef typename iterator2_traits::value_type value2_type; + typedef std::iterator_traits<_RAIter1> iterator1_traits; + typedef typename iterator1_traits::value_type _ValueType1; + typedef std::iterator_traits<_RAIter2> iterator2_traits; + typedef typename iterator2_traits::value_type _ValueType2; if (_GLIBCXX_PARALLEL_CONDITION(true)) return __gnu_parallel:: - search_template(begin1, end1, begin2, end2, __gnu_parallel:: - equal_to()); + __search_template(__begin1, __end1, __begin2, __end2, __gnu_parallel:: + equal_to<_ValueType1, _ValueType2>()); else - return search(begin1, end1, begin2, end2, + return search(__begin1, __end1, __begin2, __end2, __gnu_parallel::sequential_tag()); } // Sequential fallback for input iterator case template + typename _IteratorTag1, typename _IteratorTag2> inline ForwardIterator1 - search_switch(ForwardIterator1 begin1, ForwardIterator1 end1, - ForwardIterator2 begin2, ForwardIterator2 end2, - IteratorTag1, IteratorTag2) - { return search(begin1, end1, begin2, end2, + __search_switch(ForwardIterator1 __begin1, ForwardIterator1 __end1, + ForwardIterator2 __begin2, ForwardIterator2 __end2, + _IteratorTag1, _IteratorTag2) + { return search(__begin1, __end1, __begin2, __end2, __gnu_parallel::sequential_tag()); } // Public interface. template inline ForwardIterator1 - search(ForwardIterator1 begin1, ForwardIterator1 end1, - ForwardIterator2 begin2, ForwardIterator2 end2) + search(ForwardIterator1 __begin1, ForwardIterator1 __end1, + ForwardIterator2 __begin2, ForwardIterator2 __end2) { typedef std::iterator_traits iterator1_traits; - typedef typename iterator1_traits::iterator_category iterator1_category; + typedef typename iterator1_traits::iterator_category _IteratorCategory1; typedef std::iterator_traits iterator2_traits; - typedef typename iterator2_traits::iterator_category iterator2_category; + typedef typename iterator2_traits::iterator_category _IteratorCategory2; - return search_switch(begin1, end1, begin2, end2, - iterator1_category(), iterator2_category()); + return __search_switch(__begin1, __end1, __begin2, __end2, + _IteratorCategory1(), _IteratorCategory2()); } // Public interface. template + typename _BinaryPredicate> inline ForwardIterator1 - search(ForwardIterator1 begin1, ForwardIterator1 end1, - ForwardIterator2 begin2, ForwardIterator2 end2, - BinaryPredicate pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::search(begin1, end1, begin2, end2, pred); } + search(ForwardIterator1 __begin1, ForwardIterator1 __end1, + ForwardIterator2 __begin2, ForwardIterator2 __end2, + _BinaryPredicate __pred, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::search(__begin1, __end1, __begin2, __end2, __pred); } // Parallel algorithm for random access iterator. - template - RandomAccessIterator1 - search_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, RandomAccessIterator2 end2, - BinaryPredicate pred, + template + _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(true)) - return __gnu_parallel::search_template(begin1, end1, - begin2, end2, pred); + return __gnu_parallel::__search_template(__begin1, __end1, + __begin2, __end2, __pred); else - return search(begin1, end1, begin2, end2, pred, + return search(__begin1, __end1, __begin2, __end2, __pred, __gnu_parallel::sequential_tag()); } // Sequential fallback for input iterator case template + typename _BinaryPredicate, typename _IteratorTag1, + typename _IteratorTag2> inline ForwardIterator1 - search_switch(ForwardIterator1 begin1, ForwardIterator1 end1, - ForwardIterator2 begin2, ForwardIterator2 end2, - BinaryPredicate pred, IteratorTag1, IteratorTag2) - { return search(begin1, end1, begin2, end2, pred, + __search_switch(ForwardIterator1 __begin1, ForwardIterator1 __end1, + ForwardIterator2 __begin2, ForwardIterator2 __end2, + _BinaryPredicate __pred, _IteratorTag1, _IteratorTag2) + { return search(__begin1, __end1, __begin2, __end2, __pred, __gnu_parallel::sequential_tag()); } // Public interface template + typename _BinaryPredicate> inline ForwardIterator1 - search(ForwardIterator1 begin1, ForwardIterator1 end1, - ForwardIterator2 begin2, ForwardIterator2 end2, - BinaryPredicate pred) + search(ForwardIterator1 __begin1, ForwardIterator1 __end1, + ForwardIterator2 __begin2, ForwardIterator2 __end2, + _BinaryPredicate __pred) { typedef std::iterator_traits iterator1_traits; - typedef typename iterator1_traits::iterator_category iterator1_category; + typedef typename iterator1_traits::iterator_category _IteratorCategory1; typedef std::iterator_traits iterator2_traits; - typedef typename iterator2_traits::iterator_category iterator2_category; - return search_switch(begin1, end1, begin2, end2, pred, - iterator1_category(), iterator2_category()); + typedef typename iterator2_traits::iterator_category _IteratorCategory2; + return __search_switch(__begin1, __end1, __begin2, __end2, __pred, + _IteratorCategory1(), _IteratorCategory2()); } // Sequential fallback - template - inline ForwardIterator - search_n(ForwardIterator begin, ForwardIterator end, Integer count, - const T& val, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::search_n(begin, end, count, val); } + template + inline _ForwardIterator + search_n(_ForwardIterator __begin, _ForwardIterator __end, _Integer count, + const _Tp& __val, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::search_n(__begin, __end, count, __val); } // Sequential fallback - template - inline ForwardIterator - search_n(ForwardIterator begin, ForwardIterator end, Integer count, - const T& val, BinaryPredicate binary_pred, + template + inline _ForwardIterator + search_n(_ForwardIterator __begin, _ForwardIterator __end, _Integer count, + const _Tp& __val, _BinaryPredicate __binary_pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::search_n(begin, end, count, val, binary_pred); } + { return _GLIBCXX_STD_P::search_n(__begin, __end, count, __val, __binary_pred); } // Public interface. - template - inline ForwardIterator - search_n(ForwardIterator begin, ForwardIterator end, Integer count, - const T& val) + template + inline _ForwardIterator + search_n(_ForwardIterator __begin, _ForwardIterator __end, _Integer count, + const _Tp& __val) { - typedef typename iterator_traits::value_type value_type; - return search_n(begin, end, count, val, - __gnu_parallel::equal_to()); + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + return search_n(__begin, __end, count, __val, + __gnu_parallel::equal_to<_ValueType, _Tp>()); } // Parallel algorithm for random access iterators. - template - RandomAccessIterator - search_n_switch(RandomAccessIterator begin, RandomAccessIterator end, - Integer count, const T& val, BinaryPredicate binary_pred, + template + _RAIter + __search_n_switch(_RAIter __begin, _RAIter __end, + _Integer count, const _Tp& __val, _BinaryPredicate __binary_pred, random_access_iterator_tag) { if (_GLIBCXX_PARALLEL_CONDITION(true)) { - __gnu_parallel::pseudo_sequence ps(val, count); - return __gnu_parallel::search_template(begin, end, ps.begin(), - ps.end(), binary_pred); + __gnu_parallel::_PseudoSequence<_Tp, _Integer> __ps(__val, count); + return __gnu_parallel::__search_template(__begin, __end, __ps.begin(), + __ps.end(), __binary_pred); } else - return std::__search_n(begin, end, count, val, - binary_pred, random_access_iterator_tag()); + return std::__search_n(__begin, __end, count, __val, + __binary_pred, random_access_iterator_tag()); } // Sequential fallback for input iterator case. - template - inline ForwardIterator - search_n_switch(ForwardIterator begin, ForwardIterator end, Integer count, - const T& val, BinaryPredicate binary_pred, IteratorTag) - { return __search_n(begin, end, count, val, binary_pred, IteratorTag()); } + template + inline _ForwardIterator + __search_n_switch(_ForwardIterator __begin, _ForwardIterator __end, _Integer count, + const _Tp& __val, _BinaryPredicate __binary_pred, _IteratorTag) + { return __search_n(__begin, __end, count, __val, __binary_pred, _IteratorTag()); } // Public interface. - template - inline ForwardIterator - search_n(ForwardIterator begin, ForwardIterator end, Integer count, - const T& val, BinaryPredicate binary_pred) - { - return search_n_switch(begin, end, count, val, binary_pred, - typename std::iterator_traits:: + template + inline _ForwardIterator + search_n(_ForwardIterator __begin, _ForwardIterator __end, _Integer count, + const _Tp& __val, _BinaryPredicate __binary_pred) + { + return __search_n_switch(__begin, __end, count, __val, __binary_pred, + typename std::iterator_traits<_ForwardIterator>:: iterator_category()); } // Sequential fallback. - template - inline OutputIterator - transform(InputIterator begin, InputIterator end, OutputIterator result, - UnaryOperation unary_op, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::transform(begin, end, result, unary_op); } + template + inline _OutputIterator + transform(_IIter __begin, _IIter __end, _OutputIterator __result, + _UnaryOperation unary_op, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::transform(__begin, __end, __result, unary_op); } // Parallel unary transform for random access iterators. - template - RandomAccessIterator2 - transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end, - RandomAccessIterator2 result, UnaryOperation unary_op, + template + _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 + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_balanced) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().transform_minimal_n - && __gnu_parallel::is_parallel(parallelism_tag))) + && __gnu_parallel::__is_parallel(__parallelism_tag))) { - bool dummy = true; - typedef __gnu_parallel::iterator_pair ip; - ip begin_pair(begin, result), end_pair(end, result + (end - begin)); - __gnu_parallel::transform1_selector functionality; + 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::dummy_reduct(), - dummy, dummy, -1, parallelism_tag); - return functionality.finish_iterator; + __for_each_template_random_access(begin_pair, end_pair, + unary_op, __functionality, + __gnu_parallel::_DummyReduct(), + __dummy, __dummy, -1, __parallelism_tag); + return __functionality.finish_iterator; } else - return transform(begin, end, result, unary_op, + return transform(__begin, __end, __result, unary_op, __gnu_parallel::sequential_tag()); } // Sequential fallback for input iterator case. - template - inline RandomAccessIterator2 - transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end, - RandomAccessIterator2 result, UnaryOperation unary_op, - IteratorTag1, IteratorTag2) - { return transform(begin, end, result, unary_op, + template + 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 - inline OutputIterator - transform(InputIterator begin, InputIterator end, OutputIterator result, - UnaryOperation unary_op, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _OutputIterator + transform(_IIter __begin, _IIter __end, _OutputIterator __result, + _UnaryOperation unary_op, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef std::iterator_traits iteratori_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori_traits::iterator_category iteratori_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; + typedef std::iterator_traits<_IIter> _IIterTraits; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits::iterator_category _IIteratorCategory; + typedef typename _OIterTraits::iterator_category _OIterCategory; - return transform1_switch(begin, end, result, unary_op, - iteratori_category(), iteratoro_category(), - parallelism_tag); + return __transform1_switch(__begin, __end, __result, unary_op, + _IIteratorCategory(), _OIterCategory(), + __parallelism_tag); } - template - inline OutputIterator - transform(InputIterator begin, InputIterator end, OutputIterator result, - UnaryOperation unary_op) + template + inline _OutputIterator + transform(_IIter __begin, _IIter __end, _OutputIterator __result, + _UnaryOperation unary_op) { - typedef std::iterator_traits iteratori_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori_traits::iterator_category iteratori_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; + typedef std::iterator_traits<_IIter> _IIterTraits; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits::iterator_category _IIteratorCategory; + typedef typename _OIterTraits::iterator_category _OIterCategory; - return transform1_switch(begin, end, result, unary_op, - iteratori_category(), iteratoro_category()); + return __transform1_switch(__begin, __end, __result, unary_op, + _IIteratorCategory(), _OIterCategory()); } // Sequential fallback - template - inline OutputIterator - transform(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, OutputIterator result, - BinaryOperation binary_op, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::transform(begin1, end1, - begin2, result, binary_op); } + template + inline _OutputIterator + transform(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _OutputIterator __result, + _BinaryOperation __binary_op, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::transform(__begin1, __end1, + __begin2, __result, __binary_op); } // Parallel binary transform for random access iterators. - template - RandomAccessIterator3 - transform2_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, - RandomAccessIterator3 result, BinaryOperation binary_op, + template + _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 + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_balanced) { if (_GLIBCXX_PARALLEL_CONDITION( - (end1 - begin1) >= + (__end1 - __begin1) >= __gnu_parallel::_Settings::get().transform_minimal_n - && __gnu_parallel::is_parallel(parallelism_tag))) + && __gnu_parallel::__is_parallel(__parallelism_tag))) { - bool dummy = true; - typedef __gnu_parallel::iterator_triple ip; - ip begin_triple(begin1, begin2, result), - end_triple(end1, begin2 + (end1 - begin1), - result + (end1 - begin1)); - __gnu_parallel::transform2_selector functionality; + 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::dummy_reduct(), - dummy, dummy, -1, - parallelism_tag); - return functionality.finish_iterator; + __for_each_template_random_access(__begin_triple, __end_triple, + __binary_op, __functionality, + __gnu_parallel::_DummyReduct(), + __dummy, __dummy, -1, + __parallelism_tag); + return __functionality.finish_iterator; } else - return transform(begin1, end1, begin2, result, binary_op, + return transform(__begin1, __end1, __begin2, __result, __binary_op, __gnu_parallel::sequential_tag()); } // Sequential fallback for input iterator case. - template - inline OutputIterator - transform2_switch(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, OutputIterator result, - BinaryOperation binary_op, tag1, tag2, tag3) - { return transform(begin1, end1, begin2, result, binary_op, + template + 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 - inline OutputIterator - transform(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, OutputIterator result, - BinaryOperation binary_op, - __gnu_parallel::_Parallelism parallelism_tag) - { - typedef std::iterator_traits iteratori1_traits; - typedef typename iteratori1_traits::iterator_category - iteratori1_category; - typedef std::iterator_traits iteratori2_traits; - typedef typename iteratori2_traits::iterator_category - iteratori2_category; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratoro_traits::iterator_category iteratoro_category; - - return transform2_switch(begin1, end1, begin2, result, binary_op, - iteratori1_category(), iteratori2_category(), - iteratoro_category(), parallelism_tag); - } - - template - inline OutputIterator - transform(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, OutputIterator result, - BinaryOperation binary_op) - { - typedef std::iterator_traits iteratori1_traits; - typedef typename iteratori1_traits::iterator_category - iteratori1_category; - typedef std::iterator_traits iteratori2_traits; - typedef typename iteratori2_traits::iterator_category - iteratori2_category; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratoro_traits::iterator_category iteratoro_category; - - return transform2_switch(begin1, end1, begin2, result, binary_op, - iteratori1_category(), iteratori2_category(), - iteratoro_category()); + template + inline _OutputIterator + transform(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _OutputIterator __result, + _BinaryOperation __binary_op, + __gnu_parallel::_Parallelism __parallelism_tag) + { + typedef std::iterator_traits<_IIter1> _IIterTraits1; + typedef typename _IIterTraits1::iterator_category + _IIterCategory1; + typedef std::iterator_traits<_IIter2> _IIterTraits2; + typedef typename _IIterTraits2::iterator_category + _IIterCategory2; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _OIterTraits::iterator_category _OIterCategory; + + return __transform2_switch(__begin1, __end1, __begin2, __result, __binary_op, + _IIterCategory1(), _IIterCategory2(), + _OIterCategory(), __parallelism_tag); + } + + template + inline _OutputIterator + transform(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _OutputIterator __result, + _BinaryOperation __binary_op) + { + typedef std::iterator_traits<_IIter1> _IIterTraits1; + typedef typename _IIterTraits1::iterator_category + _IIterCategory1; + typedef std::iterator_traits<_IIter2> _IIterTraits2; + typedef typename _IIterTraits2::iterator_category + _IIterCategory2; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _OIterTraits::iterator_category _OIterCategory; + + return __transform2_switch(__begin1, __end1, __begin2, __result, __binary_op, + _IIterCategory1(), _IIterCategory2(), + _OIterCategory()); } // Sequential fallback - template + template inline void - replace(ForwardIterator begin, ForwardIterator end, const T& old_value, - const T& new_value, __gnu_parallel::sequential_tag) - { _GLIBCXX_STD_P::replace(begin, end, old_value, new_value); } + replace(_ForwardIterator __begin, _ForwardIterator __end, const _Tp& __old_value, + const _Tp& __new_value, __gnu_parallel::sequential_tag) + { _GLIBCXX_STD_P::replace(__begin, __end, __old_value, __new_value); } // Sequential fallback for input iterator case - template + template inline void - replace_switch(ForwardIterator begin, ForwardIterator end, - const T& old_value, const T& new_value, IteratorTag) - { replace(begin, end, old_value, new_value, + __replace_switch(_ForwardIterator __begin, _ForwardIterator __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 + template inline void - replace_switch(RandomAccessIterator begin, RandomAccessIterator end, - const T& old_value, const T& new_value, + __replace_switch(_RAIter __begin, _RAIter __end, + const _Tp& __old_value, const _Tp& __new_value, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_balanced) { // XXX parallel version is where? - replace(begin, end, old_value, new_value, + replace(__begin, __end, __old_value, __new_value, __gnu_parallel::sequential_tag()); } // Public interface - template + template inline void - replace(ForwardIterator begin, ForwardIterator end, const T& old_value, - const T& new_value, __gnu_parallel::_Parallelism parallelism_tag) + replace(_ForwardIterator __begin, _ForwardIterator __end, const _Tp& __old_value, + const _Tp& __new_value, __gnu_parallel::_Parallelism __parallelism_tag) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - replace_switch(begin, end, old_value, new_value, iterator_category(), - parallelism_tag); + typedef iterator_traits<_ForwardIterator> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + __replace_switch(__begin, __end, __old_value, __new_value, _IteratorCategory(), + __parallelism_tag); } - template + template inline void - replace(ForwardIterator begin, ForwardIterator end, const T& old_value, - const T& new_value) + replace(_ForwardIterator __begin, _ForwardIterator __end, const _Tp& __old_value, + const _Tp& __new_value) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - replace_switch(begin, end, old_value, new_value, iterator_category()); + typedef iterator_traits<_ForwardIterator> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + __replace_switch(__begin, __end, __old_value, __new_value, _IteratorCategory()); } // Sequential fallback - template + template inline void - replace_if(ForwardIterator begin, ForwardIterator end, Predicate pred, - const T& new_value, __gnu_parallel::sequential_tag) - { _GLIBCXX_STD_P::replace_if(begin, end, pred, new_value); } + replace_if(_ForwardIterator __begin, _ForwardIterator __end, _Predicate __pred, + const _Tp& __new_value, __gnu_parallel::sequential_tag) + { _GLIBCXX_STD_P::replace_if(__begin, __end, __pred, __new_value); } // Sequential fallback for input iterator case - template + template inline void - replace_if_switch(ForwardIterator begin, ForwardIterator end, - Predicate pred, const T& new_value, IteratorTag) - { replace_if(begin, end, pred, new_value, + __replace_if_switch(_ForwardIterator __begin, _ForwardIterator __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 + template void - replace_if_switch(RandomAccessIterator begin, RandomAccessIterator end, - Predicate pred, const T& new_value, + __replace_if_switch(_RAIter __begin, _RAIter __end, + _Predicate __pred, const _Tp& __new_value, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_balanced) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().replace_minimal_n - && __gnu_parallel::is_parallel(parallelism_tag))) + && __gnu_parallel::__is_parallel(__parallelism_tag))) { - bool dummy; + bool __dummy; __gnu_parallel:: - replace_if_selector - functionality(new_value); + __replace_if_selector<_RAIter, _Predicate, _Tp> + __functionality(__new_value); __gnu_parallel:: - for_each_template_random_access(begin, end, pred, - functionality, - __gnu_parallel::dummy_reduct(), - true, dummy, -1, parallelism_tag); + __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, + replace_if(__begin, __end, __pred, __new_value, __gnu_parallel::sequential_tag()); } // Public interface. - template + template inline void - replace_if(ForwardIterator begin, ForwardIterator end, - Predicate pred, const T& new_value, - __gnu_parallel::_Parallelism parallelism_tag) + replace_if(_ForwardIterator __begin, _ForwardIterator __end, + _Predicate __pred, const _Tp& __new_value, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - replace_if_switch(begin, end, pred, new_value, iterator_category(), - parallelism_tag); + typedef std::iterator_traits<_ForwardIterator> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + __replace_if_switch(__begin, __end, __pred, __new_value, _IteratorCategory(), + __parallelism_tag); } - template + template inline void - replace_if(ForwardIterator begin, ForwardIterator end, - Predicate pred, const T& new_value) + replace_if(_ForwardIterator __begin, _ForwardIterator __end, + _Predicate __pred, const _Tp& __new_value) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - replace_if_switch(begin, end, pred, new_value, iterator_category()); + typedef std::iterator_traits<_ForwardIterator> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + __replace_if_switch(__begin, __end, __pred, __new_value, _IteratorCategory()); } // Sequential fallback - template + template inline void - generate(ForwardIterator begin, ForwardIterator end, Generator gen, + generate(_ForwardIterator __begin, _ForwardIterator __end, Generator __gen, __gnu_parallel::sequential_tag) - { _GLIBCXX_STD_P::generate(begin, end, gen); } + { _GLIBCXX_STD_P::generate(__begin, __end, __gen); } // Sequential fallback for input iterator case. - template + template inline void - generate_switch(ForwardIterator begin, ForwardIterator end, Generator gen, - IteratorTag) - { generate(begin, end, gen, __gnu_parallel::sequential_tag()); } + __generate_switch(_ForwardIterator __begin, _ForwardIterator __end, Generator __gen, + _IteratorTag) + { generate(__begin, __end, __gen, __gnu_parallel::sequential_tag()); } // Parallel algorithm for random access iterators. - template + template void - generate_switch(RandomAccessIterator begin, RandomAccessIterator end, - Generator gen, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + __generate_switch(_RAIter __begin, _RAIter __end, + Generator __gen, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_balanced) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().generate_minimal_n - && __gnu_parallel::is_parallel(parallelism_tag))) + && __gnu_parallel::__is_parallel(__parallelism_tag))) { - bool dummy; - __gnu_parallel::generate_selector - functionality; + bool __dummy; + __gnu_parallel::__generate_selector<_RAIter> + __functionality; __gnu_parallel:: - for_each_template_random_access(begin, end, gen, functionality, - __gnu_parallel::dummy_reduct(), - true, dummy, -1, parallelism_tag); + __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()); + generate(__begin, __end, __gen, __gnu_parallel::sequential_tag()); } // Public interface. - template + template inline void - generate(ForwardIterator begin, ForwardIterator end, - Generator gen, __gnu_parallel::_Parallelism parallelism_tag) + generate(_ForwardIterator __begin, _ForwardIterator __end, + Generator __gen, __gnu_parallel::_Parallelism __parallelism_tag) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - generate_switch(begin, end, gen, iterator_category(), parallelism_tag); + typedef std::iterator_traits<_ForwardIterator> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + __generate_switch(__begin, __end, __gen, _IteratorCategory(), __parallelism_tag); } - template + template inline void - generate(ForwardIterator begin, ForwardIterator end, Generator gen) + generate(_ForwardIterator __begin, _ForwardIterator __end, Generator __gen) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - generate_switch(begin, end, gen, iterator_category()); + typedef std::iterator_traits<_ForwardIterator> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + __generate_switch(__begin, __end, __gen, _IteratorCategory()); } // Sequential fallback. - template - inline OutputIterator - generate_n(OutputIterator begin, Size n, Generator gen, + template + inline _OutputIterator + generate_n(_OutputIterator __begin, _Size __n, Generator __gen, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::generate_n(begin, n, gen); } + { return _GLIBCXX_STD_P::generate_n(__begin, __n, __gen); } // Sequential fallback for input iterator case. - template - inline OutputIterator - generate_n_switch(OutputIterator begin, Size n, Generator gen, IteratorTag) - { return generate_n(begin, n, gen, __gnu_parallel::sequential_tag()); } + template + 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 - inline RandomAccessIterator - generate_n_switch(RandomAccessIterator begin, Size n, Generator gen, + template + inline _RAIter + __generate_n_switch(_RAIter __begin, _Size __n, Generator __gen, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_balanced) { // XXX parallel version is where? - return generate_n(begin, n, gen, __gnu_parallel::sequential_tag()); + return generate_n(__begin, __n, __gen, __gnu_parallel::sequential_tag()); } // Public interface. - template - inline OutputIterator - generate_n(OutputIterator begin, Size n, Generator gen, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _OutputIterator + generate_n(_OutputIterator __begin, _Size __n, Generator __gen, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - return generate_n_switch(begin, n, gen, iterator_category(), - parallelism_tag); + typedef std::iterator_traits<_OutputIterator> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + return __generate_n_switch(__begin, __n, __gen, _IteratorCategory(), + __parallelism_tag); } - template - inline OutputIterator - generate_n(OutputIterator begin, Size n, Generator gen) + template + inline _OutputIterator + generate_n(_OutputIterator __begin, _Size __n, Generator __gen) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - return generate_n_switch(begin, n, gen, iterator_category()); + typedef std::iterator_traits<_OutputIterator> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + return __generate_n_switch(__begin, __n, __gen, _IteratorCategory()); } // Sequential fallback. - template + template inline void - random_shuffle(RandomAccessIterator begin, RandomAccessIterator end, + random_shuffle(_RAIter __begin, _RAIter __end, __gnu_parallel::sequential_tag) - { _GLIBCXX_STD_P::random_shuffle(begin, end); } + { _GLIBCXX_STD_P::random_shuffle(__begin, __end); } // Sequential fallback. - template + template inline void - random_shuffle(RandomAccessIterator begin, RandomAccessIterator end, - RandomNumberGenerator& rand, __gnu_parallel::sequential_tag) - { _GLIBCXX_STD_P::random_shuffle(begin, end, rand); } + random_shuffle(_RAIter __begin, _RAIter __end, + RandomNumberGenerator& __rand, __gnu_parallel::sequential_tag) + { _GLIBCXX_STD_P::random_shuffle(__begin, __end, __rand); } /** @brief Functor wrapper for std::rand(). */ - template + template struct c_rand_number { int - operator()(int limit) - { return rand() % limit; } + operator()(int __limit) + { return rand() % __limit; } }; // Fill in random number generator. - template + template inline void - random_shuffle(RandomAccessIterator begin, RandomAccessIterator end) + random_shuffle(_RAIter __begin, _RAIter __end) { - c_rand_number<> r; + c_rand_number<> __r; // Parallelization still possible. - __gnu_parallel::random_shuffle(begin, end, r); + __gnu_parallel::random_shuffle(__begin, __end, __r); } // Parallel algorithm for random access iterators. - template + template void - random_shuffle(RandomAccessIterator begin, RandomAccessIterator end, - RandomNumberGenerator& rand) + random_shuffle(_RAIter __begin, _RAIter __end, + RandomNumberGenerator& __rand) { - if (begin == end) + if (__begin == __end) return; if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().random_shuffle_minimal_n)) - __gnu_parallel::parallel_random_shuffle(begin, end, rand); + __gnu_parallel::__parallel_random_shuffle(__begin, __end, __rand); else - __gnu_parallel::sequential_random_shuffle(begin, end, rand); + __gnu_parallel::__sequential_random_shuffle(__begin, __end, __rand); } // Sequential fallback. - template - inline ForwardIterator - partition(ForwardIterator begin, ForwardIterator end, - Predicate pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::partition(begin, end, pred); } + template + inline _ForwardIterator + partition(_ForwardIterator __begin, _ForwardIterator __end, + _Predicate __pred, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::partition(__begin, __end, __pred); } // Sequential fallback for input iterator case. - template - inline ForwardIterator - partition_switch(ForwardIterator begin, ForwardIterator end, - Predicate pred, IteratorTag) - { return partition(begin, end, pred, __gnu_parallel::sequential_tag()); } + template + inline _ForwardIterator + __partition_switch(_ForwardIterator __begin, _ForwardIterator __end, + _Predicate __pred, _IteratorTag) + { return partition(__begin, __end, __pred, __gnu_parallel::sequential_tag()); } // Parallel algorithm for random access iterators. - template - RandomAccessIterator - partition_switch(RandomAccessIterator begin, RandomAccessIterator end, - Predicate pred, random_access_iterator_tag) + template + _RAIter + __partition_switch(_RAIter __begin, _RAIter __end, + _Predicate __pred, random_access_iterator_tag) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().partition_minimal_n)) { - typedef typename std::iterator_traits:: - difference_type difference_type; - difference_type middle = __gnu_parallel:: - parallel_partition(begin, end, pred, - __gnu_parallel::get_max_threads()); - return begin + middle; + 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()); + return partition(__begin, __end, __pred, __gnu_parallel::sequential_tag()); } // Public interface. - template - inline ForwardIterator - partition(ForwardIterator begin, ForwardIterator end, Predicate pred) + template + inline _ForwardIterator + partition(_ForwardIterator __begin, _ForwardIterator __end, _Predicate __pred) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - return partition_switch(begin, end, pred, iterator_category()); + typedef iterator_traits<_ForwardIterator> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + return __partition_switch(__begin, __end, __pred, _IteratorCategory()); } // sort interface // Sequential fallback - template + template inline void - sort(RandomAccessIterator begin, RandomAccessIterator end, + sort(_RAIter __begin, _RAIter __end, __gnu_parallel::sequential_tag) - { _GLIBCXX_STD_P::sort(begin, end); } + { _GLIBCXX_STD_P::sort(__begin, __end); } // Sequential fallback - template + template inline void - sort(RandomAccessIterator begin, RandomAccessIterator end, Comparator comp, + sort(_RAIter __begin, _RAIter __end, _Compare __comp, __gnu_parallel::sequential_tag) - { _GLIBCXX_STD_P::sort(begin, end, - comp); } + { _GLIBCXX_STD_P::sort<_RAIter, _Compare>(__begin, __end, + __comp); } // Public interface - template + template void - sort(RandomAccessIterator begin, RandomAccessIterator end, Comparator comp, - Parallelism parallelism) + sort(_RAIter __begin, _RAIter __end, _Compare __comp, + _Parallelism __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; - if (begin != end) + if (__begin != __end) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().sort_minimal_n)) - __gnu_parallel::parallel_sort(begin, end, comp, parallelism); + __gnu_parallel::parallel_sort(__begin, __end, __comp, __parallelism); else - sort(begin, end, comp, __gnu_parallel::sequential_tag()); + sort(__begin, __end, __comp, __gnu_parallel::sequential_tag()); } } // Public interface, insert default comparator - template + template inline void - sort(RandomAccessIterator begin, RandomAccessIterator end) + sort(_RAIter __begin, _RAIter __end) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - sort(begin, end, std::less(), + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + sort(__begin, __end, std::less<_ValueType>(), __gnu_parallel::default_parallel_tag()); } // Public interface, insert default comparator - template + template inline void - sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::default_parallel_tag parallelism) + sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::default_parallel_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface, insert default comparator - template + template inline void - sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::parallel_tag parallelism) + sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::parallel_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface, insert default comparator - template + template inline void - sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::multiway_mergesort_tag parallelism) + sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::multiway_mergesort_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface, insert default comparator - template + template inline void - sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::multiway_mergesort_sampling_tag parallelism) + sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::multiway_mergesort_sampling_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface, insert default comparator - template + template inline void - sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::multiway_mergesort_exact_tag parallelism) + sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::multiway_mergesort_exact_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface, insert default comparator - template + template inline void - sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::quicksort_tag parallelism) + sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::quicksort_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface, insert default comparator - template + template inline void - sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::balanced_quicksort_tag parallelism) + sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::balanced_quicksort_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface - template + template void - sort(RandomAccessIterator begin, RandomAccessIterator end, Comparator comp) + sort(_RAIter __begin, _RAIter __end, _Compare __comp) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - sort(begin, end, comp, __gnu_parallel::default_parallel_tag()); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + sort(__begin, __end, __comp, __gnu_parallel::default_parallel_tag()); } @@ -1848,515 +1848,515 @@ namespace __parallel // Sequential fallback - template + template inline void - stable_sort(RandomAccessIterator begin, RandomAccessIterator end, + stable_sort(_RAIter __begin, _RAIter __end, __gnu_parallel::sequential_tag) - { _GLIBCXX_STD_P::stable_sort(begin, end); } + { _GLIBCXX_STD_P::stable_sort(__begin, __end); } // Sequential fallback - template + template inline void - stable_sort(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, __gnu_parallel::sequential_tag) - { _GLIBCXX_STD_P::stable_sort( - begin, end, comp); } + stable_sort(_RAIter __begin, _RAIter __end, + _Compare __comp, __gnu_parallel::sequential_tag) + { _GLIBCXX_STD_P::stable_sort<_RAIter, _Compare>( + __begin, __end, __comp); } // Public interface - template + template void - stable_sort(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, Parallelism parallelism) + stable_sort(_RAIter __begin, _RAIter __end, + _Compare __comp, _Parallelism __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; - if (begin != end) + if (__begin != __end) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().sort_minimal_n)) - __gnu_parallel::parallel_sort(begin, end, comp, parallelism); + __gnu_parallel::parallel_sort(__begin, __end, __comp, __parallelism); else - stable_sort(begin, end, comp, __gnu_parallel::sequential_tag()); + stable_sort(__begin, __end, __comp, __gnu_parallel::sequential_tag()); } } // Public interface, insert default comparator - template + template inline void - stable_sort(RandomAccessIterator begin, RandomAccessIterator end) + stable_sort(_RAIter __begin, _RAIter __end) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - stable_sort(begin, end, std::less(), + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + stable_sort(__begin, __end, std::less<_ValueType>(), __gnu_parallel::default_parallel_tag()); } // Public interface, insert default comparator - template + template inline void - stable_sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::default_parallel_tag parallelism) + stable_sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::default_parallel_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - stable_sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface, insert default comparator - template + template inline void - stable_sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::parallel_tag parallelism) + stable_sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::parallel_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - stable_sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface, insert default comparator - template + template inline void - stable_sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::multiway_mergesort_tag parallelism) + stable_sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::multiway_mergesort_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - stable_sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface, insert default comparator - template + template inline void - stable_sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::quicksort_tag parallelism) + stable_sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::quicksort_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - stable_sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface, insert default comparator - template + template inline void - stable_sort(RandomAccessIterator begin, RandomAccessIterator end, - __gnu_parallel::balanced_quicksort_tag parallelism) + stable_sort(_RAIter __begin, _RAIter __end, + __gnu_parallel::balanced_quicksort_tag __parallelism) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - stable_sort(begin, end, std::less(), parallelism); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + stable_sort(__begin, __end, std::less<_ValueType>(), __parallelism); } // Public interface - template + template void - stable_sort(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp) + stable_sort(_RAIter __begin, _RAIter __end, + _Compare __comp) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - stable_sort(begin, end, comp, __gnu_parallel::default_parallel_tag()); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + stable_sort(__begin, __end, __comp, __gnu_parallel::default_parallel_tag()); } // // Sequential fallback -// template +// template // inline void -// stable_sort(RandomAccessIterator begin, RandomAccessIterator end, +// stable_sort(_RAIter __begin, _RAIter __end, // __gnu_parallel::sequential_tag) -// { return _GLIBCXX_STD_P::stable_sort(begin, end); } +// { return _GLIBCXX_STD_P::stable_sort(__begin, __end); } // // // Sequential fallback -// template +// template // inline void -// stable_sort(RandomAccessIterator begin, RandomAccessIterator end, -// Comparator comp, __gnu_parallel::sequential_tag) -// { return _GLIBCXX_STD_P::stable_sort(begin, end, comp); } +// stable_sort(_RAIter __begin, _RAIter __end, +// _Compare __comp, __gnu_parallel::sequential_tag) +// { return _GLIBCXX_STD_P::stable_sort(__begin, __end, __comp); } // -// template +// template // void -// stable_sort(RandomAccessIterator begin, RandomAccessIterator end) +// stable_sort(_RAIter __begin, _RAIter __end) // { -// typedef iterator_traits traits_type; -// typedef typename traits_type::value_type value_type; -// stable_sort(begin, end, std::less()); +// typedef iterator_traits<_RAIter> _TraitsType; +// typedef typename _TraitsType::value_type _ValueType; +// stable_sort(__begin, __end, std::less<_ValueType>()); // } // // // Parallel algorithm for random access iterators -// template +// template // void -// stable_sort(RandomAccessIterator begin, RandomAccessIterator end, -// Comparator comp) +// stable_sort(_RAIter __begin, _RAIter __end, +// _Compare __comp) // { -// if (begin != end) +// if (__begin != __end) // { // if (_GLIBCXX_PARALLEL_CONDITION( -// static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= +// static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= // __gnu_parallel::_Settings::get().sort_minimal_n)) -// __gnu_parallel::parallel_sort(begin, end, comp, +// __gnu_parallel::parallel_sort(__begin, __end, __comp, // __gnu_parallel::parallel_tag()); // else -// stable_sort(begin, end, comp, __gnu_parallel::sequential_tag()); +// stable_sort(__begin, __end, __comp, __gnu_parallel::sequential_tag()); // } // } // Sequential fallback - template - inline OutputIterator - merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, - InputIterator2 end2, OutputIterator result, + template + inline _OutputIterator + merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, + _IIter2 __end2, _OutputIterator __result, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2, result); } + { return _GLIBCXX_STD_P::merge(__begin1, __end1, __begin2, __end2, __result); } // Sequential fallback - template - inline OutputIterator - merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, - InputIterator2 end2, OutputIterator result, Comparator comp, + template + inline _OutputIterator + merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, + _IIter2 __end2, _OutputIterator __result, _Compare __comp, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2, result, comp); } + { return _GLIBCXX_STD_P::merge(__begin1, __end1, __begin2, __end2, __result, __comp); } // Sequential fallback for input iterator case - template - inline OutputIterator - merge_switch(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator result, Comparator comp, - IteratorTag1, IteratorTag2, IteratorTag3) - { return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2, - result, comp); } + template + inline _OutputIterator + __merge_switch(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _OutputIterator __result, _Compare __comp, + _IteratorTag1, _IteratorTag2, _IteratorTag3) + { return _GLIBCXX_STD_P::merge(__begin1, __end1, __begin2, __end2, + __result, __comp); } // Parallel algorithm for random access iterators - template - OutputIterator - merge_switch(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - OutputIterator result, Comparator comp, + template + _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::sequence_index_t>(end1 - begin1) + (static_cast<__gnu_parallel::_SequenceIndex>(__end1 - __begin1) >= __gnu_parallel::_Settings::get().merge_minimal_n - || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) + || 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); + 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); + return __gnu_parallel::__merge_advance(__begin1, __end1, __begin2, __end2, + __result, (__end1 - __begin1) + + (__end2 - __begin2), __comp); } // Public interface - template - inline OutputIterator - merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, - InputIterator2 end2, OutputIterator result, Comparator comp) - { - typedef typename iterator_traits::value_type value_type; - - typedef std::iterator_traits iteratori1_traits; - typedef std::iterator_traits iteratori2_traits; - typedef std::iterator_traits iteratoro_traits; - typedef typename iteratori1_traits::iterator_category - iteratori1_category; - typedef typename iteratori2_traits::iterator_category - iteratori2_category; - typedef typename iteratoro_traits::iterator_category iteratoro_category; - - return merge_switch(begin1, end1, begin2, end2, result, comp, - iteratori1_category(), iteratori2_category(), - iteratoro_category()); + template + inline _OutputIterator + merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, + _IIter2 __end2, _OutputIterator __result, _Compare __comp) + { + typedef typename iterator_traits<_IIter1>::value_type _ValueType; + + typedef std::iterator_traits<_IIter1> _IIterTraits1; + typedef std::iterator_traits<_IIter2> _IIterTraits2; + typedef std::iterator_traits<_OutputIterator> _OIterTraits; + typedef typename _IIterTraits1::iterator_category + _IIterCategory1; + typedef typename _IIterTraits2::iterator_category + _IIterCategory2; + typedef typename _OIterTraits::iterator_category _OIterCategory; + + return __merge_switch(__begin1, __end1, __begin2, __end2, __result, __comp, + _IIterCategory1(), _IIterCategory2(), + _OIterCategory()); } // Public interface, insert default comparator - template - inline OutputIterator - merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, - InputIterator2 end2, OutputIterator result) + template + inline _OutputIterator + merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, + _IIter2 __end2, _OutputIterator __result) { - typedef std::iterator_traits iterator1_traits; - typedef std::iterator_traits iterator2_traits; - typedef typename iterator1_traits::value_type value1_type; - typedef typename iterator2_traits::value_type value2_type; + typedef std::iterator_traits<_IIter1> iterator1_traits; + typedef std::iterator_traits<_IIter2> iterator2_traits; + typedef typename iterator1_traits::value_type _ValueType1; + typedef typename iterator2_traits::value_type _ValueType2; - return merge(begin1, end1, begin2, end2, result, - __gnu_parallel::less()); + return merge(__begin1, __end1, __begin2, __end2, __result, + __gnu_parallel::_Less<_ValueType1, _ValueType2>()); } // Sequential fallback - template + template inline void - nth_element(RandomAccessIterator begin, RandomAccessIterator nth, - RandomAccessIterator end, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::nth_element(begin, nth, end); } + nth_element(_RAIter __begin, _RAIter __nth, + _RAIter __end, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::nth_element(__begin, __nth, __end); } // Sequential fallback - template + template inline void - nth_element(RandomAccessIterator begin, RandomAccessIterator nth, - RandomAccessIterator end, Comparator comp, + nth_element(_RAIter __begin, _RAIter __nth, + _RAIter __end, _Compare __comp, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::nth_element(begin, nth, end, comp); } + { return _GLIBCXX_STD_P::nth_element(__begin, __nth, __end, __comp); } // Public interface - template + template inline void - nth_element(RandomAccessIterator begin, RandomAccessIterator nth, - RandomAccessIterator end, Comparator comp) + nth_element(_RAIter __begin, _RAIter __nth, + _RAIter __end, _Compare __comp) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().nth_element_minimal_n)) - __gnu_parallel::parallel_nth_element(begin, nth, end, comp); + __gnu_parallel::parallel_nth_element(__begin, __nth, __end, __comp); else - nth_element(begin, nth, end, comp, __gnu_parallel::sequential_tag()); + nth_element(__begin, __nth, __end, __comp, __gnu_parallel::sequential_tag()); } // Public interface, insert default comparator - template + template inline void - nth_element(RandomAccessIterator begin, RandomAccessIterator nth, - RandomAccessIterator end) + nth_element(_RAIter __begin, _RAIter __nth, + _RAIter __end) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - nth_element(begin, nth, end, std::less()); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + nth_element(__begin, __nth, __end, std::less<_ValueType>()); } // Sequential fallback - template + template inline void - partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, - RandomAccessIterator end, _Compare comp, + partial_sort(_RAIter __begin, _RAIter __middle, + _RAIter __end, _Compare __comp, __gnu_parallel::sequential_tag) - { _GLIBCXX_STD_P::partial_sort(begin, middle, end, comp); } + { _GLIBCXX_STD_P::partial_sort(__begin, __middle, __end, __comp); } // Sequential fallback - template + template inline void - partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, - RandomAccessIterator end, __gnu_parallel::sequential_tag) - { _GLIBCXX_STD_P::partial_sort(begin, middle, end); } + partial_sort(_RAIter __begin, _RAIter __middle, + _RAIter __end, __gnu_parallel::sequential_tag) + { _GLIBCXX_STD_P::partial_sort(__begin, __middle, __end); } // Public interface, parallel algorithm for random access iterators - template + template void - partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, - RandomAccessIterator end, _Compare comp) + partial_sort(_RAIter __begin, _RAIter __middle, + _RAIter __end, _Compare __comp) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().partial_sort_minimal_n)) - __gnu_parallel::parallel_partial_sort(begin, middle, end, comp); + __gnu_parallel::parallel_partial_sort(__begin, __middle, __end, __comp); else - partial_sort(begin, middle, end, comp, + partial_sort(__begin, __middle, __end, __comp, __gnu_parallel::sequential_tag()); } // Public interface, insert default comparator - template + template inline void - partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, - RandomAccessIterator end) + partial_sort(_RAIter __begin, _RAIter __middle, + _RAIter __end) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - partial_sort(begin, middle, end, std::less()); + typedef iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + partial_sort(__begin, __middle, __end, std::less<_ValueType>()); } // Sequential fallback - template - inline ForwardIterator - max_element(ForwardIterator begin, ForwardIterator end, + template + inline _ForwardIterator + max_element(_ForwardIterator __begin, _ForwardIterator __end, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::max_element(begin, end); } + { return _GLIBCXX_STD_P::max_element(__begin, __end); } // Sequential fallback - template - inline ForwardIterator - max_element(ForwardIterator begin, ForwardIterator end, Comparator comp, + template + inline _ForwardIterator + max_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::max_element(begin, end, comp); } + { return _GLIBCXX_STD_P::max_element(__begin, __end, __comp); } // Sequential fallback for input iterator case - template - inline ForwardIterator - max_element_switch(ForwardIterator begin, ForwardIterator end, - Comparator comp, IteratorTag) - { return max_element(begin, end, comp, __gnu_parallel::sequential_tag()); } + template + inline _ForwardIterator + __max_element_switch(_ForwardIterator __begin, _ForwardIterator __end, + _Compare __comp, _IteratorTag) + { return max_element(__begin, __end, __comp, __gnu_parallel::sequential_tag()); } // Parallel algorithm for random access iterators - template - RandomAccessIterator - max_element_switch(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + template + _RAIter + __max_element_switch(_RAIter __begin, _RAIter __end, + _Compare __comp, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_balanced) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().max_element_minimal_n - && __gnu_parallel::is_parallel(parallelism_tag))) + && __gnu_parallel::__is_parallel(__parallelism_tag))) { - RandomAccessIterator res(begin); - __gnu_parallel::identity_selector - functionality; + _RAIter __res(__begin); + __gnu_parallel::__identity_selector<_RAIter> + __functionality; __gnu_parallel:: - for_each_template_random_access(begin, end, - __gnu_parallel::nothing(), - functionality, + __for_each_template_random_access(__begin, __end, + __gnu_parallel::_Nothing(), + __functionality, __gnu_parallel:: - max_element_reduct(comp), - res, res, -1, parallelism_tag); - return res; + __max_element_reduct<_Compare, + _RAIter>(__comp), + __res, __res, -1, __parallelism_tag); + return __res; } else - return max_element(begin, end, comp, __gnu_parallel::sequential_tag()); + return max_element(__begin, __end, __comp, __gnu_parallel::sequential_tag()); } // Public interface, insert default comparator - template - inline ForwardIterator - max_element(ForwardIterator begin, ForwardIterator end, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _ForwardIterator + max_element(_ForwardIterator __begin, _ForwardIterator __end, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef typename iterator_traits::value_type value_type; - return max_element(begin, end, std::less(), parallelism_tag); + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + return max_element(__begin, __end, std::less<_ValueType>(), __parallelism_tag); } - template - inline ForwardIterator - max_element(ForwardIterator begin, ForwardIterator end) + template + inline _ForwardIterator + max_element(_ForwardIterator __begin, _ForwardIterator __end) { - typedef typename iterator_traits::value_type value_type; - return max_element(begin, end, std::less()); + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + return max_element(__begin, __end, std::less<_ValueType>()); } // Public interface - template - inline ForwardIterator - max_element(ForwardIterator begin, ForwardIterator end, Comparator comp, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _ForwardIterator + max_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - return max_element_switch(begin, end, comp, iterator_category(), - parallelism_tag); + typedef iterator_traits<_ForwardIterator> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + return __max_element_switch(__begin, __end, __comp, _IteratorCategory(), + __parallelism_tag); } - template - inline ForwardIterator - max_element(ForwardIterator begin, ForwardIterator end, Comparator comp) + template + inline _ForwardIterator + max_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - return max_element_switch(begin, end, comp, iterator_category()); + typedef iterator_traits<_ForwardIterator> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + return __max_element_switch(__begin, __end, __comp, _IteratorCategory()); } // Sequential fallback - template - inline ForwardIterator - min_element(ForwardIterator begin, ForwardIterator end, + template + inline _ForwardIterator + min_element(_ForwardIterator __begin, _ForwardIterator __end, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::min_element(begin, end); } + { return _GLIBCXX_STD_P::min_element(__begin, __end); } // Sequential fallback - template - inline ForwardIterator - min_element(ForwardIterator begin, ForwardIterator end, Comparator comp, + template + inline _ForwardIterator + min_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::min_element(begin, end, comp); } + { return _GLIBCXX_STD_P::min_element(__begin, __end, __comp); } // Sequential fallback for input iterator case - template - inline ForwardIterator - min_element_switch(ForwardIterator begin, ForwardIterator end, - Comparator comp, IteratorTag) - { return min_element(begin, end, comp, __gnu_parallel::sequential_tag()); } + template + inline _ForwardIterator + __min_element_switch(_ForwardIterator __begin, _ForwardIterator __end, + _Compare __comp, _IteratorTag) + { return min_element(__begin, __end, __comp, __gnu_parallel::sequential_tag()); } // Parallel algorithm for random access iterators - template - RandomAccessIterator - min_element_switch(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + template + _RAIter + __min_element_switch(_RAIter __begin, _RAIter __end, + _Compare __comp, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_balanced) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().min_element_minimal_n - && __gnu_parallel::is_parallel(parallelism_tag))) + && __gnu_parallel::__is_parallel(__parallelism_tag))) { - RandomAccessIterator res(begin); - __gnu_parallel::identity_selector - functionality; + _RAIter __res(__begin); + __gnu_parallel::__identity_selector<_RAIter> + __functionality; __gnu_parallel:: - for_each_template_random_access(begin, end, - __gnu_parallel::nothing(), - functionality, + __for_each_template_random_access(__begin, __end, + __gnu_parallel::_Nothing(), + __functionality, __gnu_parallel:: - min_element_reduct(comp), - res, res, -1, parallelism_tag); - return res; + __min_element_reduct<_Compare, + _RAIter>(__comp), + __res, __res, -1, __parallelism_tag); + return __res; } else - return min_element(begin, end, comp, __gnu_parallel::sequential_tag()); + return min_element(__begin, __end, __comp, __gnu_parallel::sequential_tag()); } // Public interface, insert default comparator - template - inline ForwardIterator - min_element(ForwardIterator begin, ForwardIterator end, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _ForwardIterator + min_element(_ForwardIterator __begin, _ForwardIterator __end, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef typename iterator_traits::value_type value_type; - return min_element(begin, end, std::less(), parallelism_tag); + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + return min_element(__begin, __end, std::less<_ValueType>(), __parallelism_tag); } - template - inline ForwardIterator - min_element(ForwardIterator begin, ForwardIterator end) + template + inline _ForwardIterator + min_element(_ForwardIterator __begin, _ForwardIterator __end) { - typedef typename iterator_traits::value_type value_type; - return min_element(begin, end, std::less()); + typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; + return min_element(__begin, __end, std::less<_ValueType>()); } // Public interface - template - inline ForwardIterator - min_element(ForwardIterator begin, ForwardIterator end, Comparator comp, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _ForwardIterator + min_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - return min_element_switch(begin, end, comp, iterator_category(), - parallelism_tag); + typedef iterator_traits<_ForwardIterator> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + return __min_element_switch(__begin, __end, __comp, _IteratorCategory(), + __parallelism_tag); } - template - inline ForwardIterator - min_element(ForwardIterator begin, ForwardIterator end, Comparator comp) + template + inline _ForwardIterator + min_element(_ForwardIterator __begin, _ForwardIterator __end, _Compare __comp) { - typedef iterator_traits traits_type; - typedef typename traits_type::iterator_category iterator_category; - return min_element_switch(begin, end, comp, iterator_category()); + typedef iterator_traits<_ForwardIterator> _TraitsType; + typedef typename _TraitsType::iterator_category _IteratorCategory; + return __min_element_switch(__begin, __end, __comp, _IteratorCategory()); } } // end namespace } // end namespace diff --git a/libstdc++-v3/include/parallel/algobase.h b/libstdc++-v3/include/parallel/algobase.h index aaffb3e5f3b3..b50068d29674 100644 --- a/libstdc++-v3/include/parallel/algobase.h +++ b/libstdc++-v3/include/parallel/algobase.h @@ -50,230 +50,230 @@ namespace __parallel // NB: equal and lexicographical_compare require mismatch. // Sequential fallback - template - inline pair - mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, + template + inline pair<_IIter1, _IIter2> + mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2); } + { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2); } // Sequential fallback - template - inline pair - mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, - Predicate pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); } + template + inline pair<_IIter1, _IIter2> + mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, + _Predicate __pred, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred); } // Sequential fallback for input iterator case - template - inline pair - mismatch_switch(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, Predicate pred, IteratorTag1, - IteratorTag2) - { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); } + template + inline pair<_IIter1, _IIter2> + __mismatch_switch(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _Predicate __pred, _IteratorTag1, + _IteratorTag2) + { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred); } // Parallel mismatch for random access iterators - template - pair - mismatch_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, Predicate pred, + template + pair<_RAIter1, _RAIter2> + __mismatch_switch(_RAIter1 __begin1, _RAIter1 __end1, + _RAIter2 __begin2, _Predicate __pred, random_access_iterator_tag, random_access_iterator_tag) { if (_GLIBCXX_PARALLEL_CONDITION(true)) { - RandomAccessIterator1 res = - __gnu_parallel::find_template(begin1, end1, begin2, pred, + _RAIter1 __res = + __gnu_parallel::__find_template(__begin1, __end1, __begin2, __pred, __gnu_parallel:: - mismatch_selector()).first; - return make_pair(res , begin2 + (res - begin1)); + __mismatch_selector()).first; + return make_pair(__res , __begin2 + (__res - __begin1)); } else - return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); + return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred); } // Public interface - template - inline pair - mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2) + template + inline pair<_IIter1, _IIter2> + mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2) { - typedef std::iterator_traits iterator1_traits; - typedef std::iterator_traits iterator2_traits; - typedef typename iterator1_traits::value_type value1_type; - typedef typename iterator2_traits::value_type value2_type; - typedef typename iterator1_traits::iterator_category iterator1_category; - typedef typename iterator2_traits::iterator_category iterator2_category; + typedef std::iterator_traits<_IIter1> iterator1_traits; + typedef std::iterator_traits<_IIter2> iterator2_traits; + typedef typename iterator1_traits::value_type _ValueType1; + typedef typename iterator2_traits::value_type _ValueType2; + typedef typename iterator1_traits::iterator_category _IteratorCategory1; + typedef typename iterator2_traits::iterator_category _IteratorCategory2; - typedef __gnu_parallel::equal_to equal_to_type; + typedef __gnu_parallel::equal_to<_ValueType1, _ValueType2> equal_to_type; - return mismatch_switch(begin1, end1, begin2, equal_to_type(), - iterator1_category(), iterator2_category()); + return __mismatch_switch(__begin1, __end1, __begin2, equal_to_type(), + _IteratorCategory1(), _IteratorCategory2()); } // Public interface - template - inline pair - mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, - Predicate pred) + template + inline pair<_IIter1, _IIter2> + mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, + _Predicate __pred) { - typedef std::iterator_traits iterator1_traits; - typedef std::iterator_traits iterator2_traits; - typedef typename iterator1_traits::iterator_category iterator1_category; - typedef typename iterator2_traits::iterator_category iterator2_category; + typedef std::iterator_traits<_IIter1> iterator1_traits; + typedef std::iterator_traits<_IIter2> iterator2_traits; + typedef typename iterator1_traits::iterator_category _IteratorCategory1; + typedef typename iterator2_traits::iterator_category _IteratorCategory2; - return mismatch_switch(begin1, end1, begin2, pred, iterator1_category(), - iterator2_category()); + return __mismatch_switch(__begin1, __end1, __begin2, __pred, _IteratorCategory1(), + _IteratorCategory2()); } // Sequential fallback - template + template inline bool - equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, + equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::equal(begin1, end1, begin2); } + { return _GLIBCXX_STD_P::equal(__begin1, __end1, __begin2); } // Sequential fallback - template + template inline bool - equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, - Predicate pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::equal(begin1, end1, begin2, pred); } + equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, + _Predicate __pred, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::equal(__begin1, __end1, __begin2, __pred); } // Public interface - template + template inline bool - equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2) - { return mismatch(begin1, end1, begin2).first == end1; } + equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2) + { return mismatch(__begin1, __end1, __begin2).first == __end1; } // Public interface - template + template inline bool - equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, - Predicate pred) - { return mismatch(begin1, end1, begin2, pred).first == end1; } + equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, + _Predicate __pred) + { return mismatch(__begin1, __end1, __begin2, __pred).first == __end1; } // Sequential fallback - template + template inline bool - lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, + lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, - begin2, end2); } + { return _GLIBCXX_STD_P::lexicographical_compare(__begin1, __end1, + __begin2, __end2); } // Sequential fallback - template + template inline bool - lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - Predicate pred, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, - begin2, end2, pred); } + lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _Predicate __pred, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::lexicographical_compare(__begin1, __end1, + __begin2, __end2, __pred); } // Sequential fallback for input iterator case - template + template inline bool - lexicographical_compare_switch(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - Predicate pred, IteratorTag1, IteratorTag2) - { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, - begin2, end2, pred); } + __lexicographical_compare_switch(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _Predicate __pred, _IteratorTag1, _IteratorTag2) + { return _GLIBCXX_STD_P::lexicographical_compare(__begin1, __end1, + __begin2, __end2, __pred); } // Parallel lexicographical_compare for random access iterators // Limitation: Both valuetypes must be the same - template + template bool - lexicographical_compare_switch(RandomAccessIterator1 begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, - RandomAccessIterator2 end2, Predicate pred, + __lexicographical_compare_switch(_RAIter1 __begin1, + _RAIter1 __end1, + _RAIter2 __begin2, + _RAIter2 __end2, _Predicate __pred, random_access_iterator_tag, random_access_iterator_tag) { if (_GLIBCXX_PARALLEL_CONDITION(true)) { - typedef iterator_traits traits1_type; - typedef typename traits1_type::value_type value1_type; + typedef iterator_traits<_RAIter1> _TraitsType1; + typedef typename _TraitsType1::value_type _ValueType1; - typedef iterator_traits traits2_type; - typedef typename traits2_type::value_type value2_type; + typedef iterator_traits<_RAIter2> _TraitsType2; + typedef typename _TraitsType2::value_type _ValueType2; - typedef __gnu_parallel::equal_from_less equal_type; + typedef __gnu_parallel::_EqualFromLess<_Predicate, _ValueType1, + _ValueType2> _EqualFromLessCompare; // Longer sequence in first place. - if ((end1 - begin1) < (end2 - begin2)) + if ((__end1 - __begin1) < (__end2 - __begin2)) { - typedef pair - pair_type; - pair_type mm = mismatch_switch(begin1, end1, begin2, - equal_type(pred), + typedef pair<_RAIter1, _RAIter2> + _SpotType; + _SpotType __mm = __mismatch_switch(__begin1, __end1, __begin2, + _EqualFromLessCompare(__pred), random_access_iterator_tag(), random_access_iterator_tag()); - return (mm.first == end1) || bool(pred(*mm.first, *mm.second)); + return (__mm.first == __end1) || bool(__pred(*__mm.first, *__mm.second)); } else { - typedef pair - pair_type; - pair_type mm = mismatch_switch(begin2, end2, begin1, - equal_type(pred), + typedef pair<_RAIter2, _RAIter1> + _SpotType; + _SpotType __mm = __mismatch_switch(__begin2, __end2, __begin1, + _EqualFromLessCompare(__pred), random_access_iterator_tag(), random_access_iterator_tag()); - return (mm.first != end2) && bool(pred(*mm.second, *mm.first)); + return (__mm.first != __end2) && bool(__pred(*__mm.second, *__mm.first)); } } else - return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, - begin2, end2, pred); + return _GLIBCXX_STD_P::lexicographical_compare(__begin1, __end1, + __begin2, __end2, __pred); } // Public interface - template + template inline bool - lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2) + lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2) { - typedef iterator_traits traits1_type; - typedef typename traits1_type::value_type value1_type; - typedef typename traits1_type::iterator_category iterator1_category; - - typedef iterator_traits traits2_type; - typedef typename traits2_type::value_type value2_type; - typedef typename traits2_type::iterator_category iterator2_category; - typedef __gnu_parallel::less less_type; - - return lexicographical_compare_switch(begin1, end1, begin2, end2, - less_type(), iterator1_category(), - iterator2_category()); + typedef iterator_traits<_IIter1> _TraitsType1; + typedef typename _TraitsType1::value_type _ValueType1; + typedef typename _TraitsType1::iterator_category _IteratorCategory1; + + typedef iterator_traits<_IIter2> _TraitsType2; + typedef typename _TraitsType2::value_type _ValueType2; + typedef typename _TraitsType2::iterator_category _IteratorCategory2; + typedef __gnu_parallel::_Less<_ValueType1, _ValueType2> _LessType; + + return __lexicographical_compare_switch(__begin1, __end1, __begin2, __end2, + _LessType(), _IteratorCategory1(), + _IteratorCategory2()); } // Public interface - template + template inline bool - lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, - InputIterator2 begin2, InputIterator2 end2, - Predicate pred) + lexicographical_compare(_IIter1 __begin1, _IIter1 __end1, + _IIter2 __begin2, _IIter2 __end2, + _Predicate __pred) { - typedef iterator_traits traits1_type; - typedef typename traits1_type::iterator_category iterator1_category; + typedef iterator_traits<_IIter1> _TraitsType1; + typedef typename _TraitsType1::iterator_category _IteratorCategory1; - typedef iterator_traits traits2_type; - typedef typename traits2_type::iterator_category iterator2_category; + typedef iterator_traits<_IIter2> _TraitsType2; + typedef typename _TraitsType2::iterator_category _IteratorCategory2; - return lexicographical_compare_switch(begin1, end1, begin2, end2, pred, - iterator1_category(), - iterator2_category()); + return __lexicographical_compare_switch(__begin1, __end1, __begin2, __end2, __pred, + _IteratorCategory1(), + _IteratorCategory2()); } } // end namespace } // end namespace diff --git a/libstdc++-v3/include/parallel/algorithmfwd.h b/libstdc++-v3/include/parallel/algorithmfwd.h index 7c3b3f23ff28..c85959ecf643 100644 --- a/libstdc++-v3/include/parallel/algorithmfwd.h +++ b/libstdc++-v3/include/parallel/algorithmfwd.h @@ -48,11 +48,11 @@ namespace __parallel template _FIter - adjacent_find_switch(_FIter, _FIter, _IterTag); + __adjacent_find_switch(_FIter, _FIter, _IterTag); template _RAIter - adjacent_find_switch(_RAIter, _RAIter, random_access_iterator_tag); + __adjacent_find_switch(_RAIter, _RAIter, random_access_iterator_tag); template @@ -66,11 +66,11 @@ namespace __parallel template _FIter - adjacent_find_switch(_FIter, _FIter, _BiPredicate, _IterTag); + __adjacent_find_switch(_FIter, _FIter, _BiPredicate, _IterTag); template _RAIter - adjacent_find_switch(_RAIter, _RAIter, _BiPredicate, + __adjacent_find_switch(_RAIter, _RAIter, _BiPredicate, random_access_iterator_tag); @@ -88,12 +88,12 @@ namespace __parallel template typename iterator_traits<_IIter>::difference_type - count_switch(_IIter, _IIter, const _Tp&, _IterTag); + __count_switch(_IIter, _IIter, const _Tp&, _IterTag); template typename iterator_traits<_RAIter>::difference_type - count_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism + __count_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism = __gnu_parallel::parallel_unbalanced); @@ -111,12 +111,12 @@ namespace __parallel template typename iterator_traits<_IIter>::difference_type - count_if_switch(_IIter, _IIter, _Predicate, _IterTag); + __count_if_switch(_IIter, _IIter, _Predicate, _IterTag); template typename iterator_traits<_RAIter>::difference_type - count_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism + __count_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism = __gnu_parallel::parallel_unbalanced); // algobase.h @@ -124,18 +124,18 @@ namespace __parallel bool equal(_IIter1, _IIter1, _IIter2, __gnu_parallel::sequential_tag); - template + template bool - equal(_IIter1, _IIter1, _IIter2, Predicate, + equal(_IIter1, _IIter1, _IIter2, _Predicate, __gnu_parallel::sequential_tag); template bool equal(_IIter1, _IIter1, _IIter2); - template + template bool - equal(_IIter1, _IIter1, _IIter2, Predicate); + equal(_IIter1, _IIter1, _IIter2, _Predicate); template _IIter @@ -143,15 +143,15 @@ namespace __parallel template _IIter - find(_IIter, _IIter, const _Tp& val); + find(_IIter, _IIter, const _Tp& __val); template _IIter - find_switch(_IIter, _IIter, const _Tp&, _IterTag); + __find_switch(_IIter, _IIter, const _Tp&, _IterTag); template _RAIter - find_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag); + __find_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag); template _IIter @@ -163,11 +163,11 @@ namespace __parallel template _IIter - find_if_switch(_IIter, _IIter, _Predicate, _IterTag); + __find_if_switch(_IIter, _IIter, _Predicate, _IterTag); template _RAIter - find_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag); + __find_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag); template _IIter @@ -190,18 +190,18 @@ namespace __parallel template _IIter - find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _IterTag1, _IterTag2); + __find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _IterTag1, _IterTag2); template _RAIter - find_first_of_switch(_RAIter, _RAIter, _FIter, _FIter, _BiPredicate, + __find_first_of_switch(_RAIter, _RAIter, _FIter, _FIter, _BiPredicate, random_access_iterator_tag, _IterTag); template _IIter - find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _BiPredicate, + __find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _BiPredicate, _IterTag1, _IterTag2); @@ -219,12 +219,12 @@ namespace __parallel template _Function - for_each_switch(_IIter, _IIter, _Function, _IterTag); + __for_each_switch(_IIter, _IIter, _Function, _IterTag); template _Function - for_each_switch(_RAIter, _RAIter, _Function, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism + __for_each_switch(_RAIter, _RAIter, _Function, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism = __gnu_parallel::parallel_balanced); @@ -242,12 +242,12 @@ namespace __parallel template void - generate_switch(_FIter, _FIter, _Generator, _IterTag); + __generate_switch(_FIter, _FIter, _Generator, _IterTag); template void - generate_switch(_RAIter, _RAIter, _Generator, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism + __generate_switch(_RAIter, _RAIter, _Generator, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism = __gnu_parallel::parallel_balanced); template @@ -265,12 +265,12 @@ namespace __parallel template _OIter - generate_n_switch(_OIter, _Size, _Generator, _IterTag); + __generate_n_switch(_OIter, _Size, _Generator, _IterTag); template _RAIter - generate_n_switch(_RAIter, _Size, _Generator, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism + __generate_n_switch(_RAIter, _Size, _Generator, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism = __gnu_parallel::parallel_balanced); template @@ -294,12 +294,12 @@ namespace __parallel template bool - lexicographical_compare_switch(_IIter1, _IIter1, _IIter2, _IIter2, + __lexicographical_compare_switch(_IIter1, _IIter1, _IIter2, _IIter2, _Predicate, _IterTag1, _IterTag2); template bool - lexicographical_compare_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, + __lexicographical_compare_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Predicate, random_access_iterator_tag, random_access_iterator_tag); @@ -324,12 +324,12 @@ namespace __parallel template pair<_IIter1, _IIter2> - mismatch_switch(_IIter1, _IIter1, _IIter2, _Predicate, + __mismatch_switch(_IIter1, _IIter1, _IIter2, _Predicate, _IterTag1, _IterTag2); template pair<_RAIter1, _RAIter2> - mismatch_switch(_RAIter1, _RAIter1, _RAIter2, _Predicate, + __mismatch_switch(_RAIter1, _RAIter1, _RAIter2, _Predicate, random_access_iterator_tag, random_access_iterator_tag); template @@ -351,23 +351,23 @@ namespace __parallel template _RAIter1 - search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, + __search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, random_access_iterator_tag, random_access_iterator_tag); template _FIter1 - search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _IterTag1, _IterTag2); + __search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _IterTag1, _IterTag2); template _RAIter1 - search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _BiPredicate, + __search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _BiPredicate, random_access_iterator_tag, random_access_iterator_tag); template _FIter1 - search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate, + __search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate, _IterTag1, _IterTag2); template @@ -393,42 +393,42 @@ namespace __parallel template _RAIter - search_n_switch(_RAIter, _RAIter, _Integer, const _Tp&, + __search_n_switch(_RAIter, _RAIter, _Integer, const _Tp&, _BiPredicate, random_access_iterator_tag); template _FIter - search_n_switch(_FIter, _FIter, _Integer, const _Tp&, + __search_n_switch(_FIter, _FIter, _Integer, const _Tp&, _BiPredicate, _IterTag); - template + template _OIter - transform(_IIter, _IIter, _OIter, UnaryOperation); + transform(_IIter, _IIter, _OIter, _UnaryOperation); - template + template _OIter - transform(_IIter, _IIter, _OIter, UnaryOperation, + transform(_IIter, _IIter, _OIter, _UnaryOperation, __gnu_parallel::sequential_tag); - template + template _OIter - transform(_IIter, _IIter, _OIter, UnaryOperation, + transform(_IIter, _IIter, _OIter, _UnaryOperation, __gnu_parallel::_Parallelism); - template _OIter - transform1_switch(_IIter, _IIter, _OIter, UnaryOperation, + __transform1_switch(_IIter, _IIter, _OIter, _UnaryOperation, _IterTag1, _IterTag2); - template + template _RAOIter - transform1_switch(_RAIIter, _RAIIter, _RAOIter, UnaryOperation, + __transform1_switch(_RAIIter, _RAIIter, _RAOIter, _UnaryOperation, random_access_iterator_tag, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism + __gnu_parallel::_Parallelism __parallelism = __gnu_parallel::parallel_balanced); @@ -452,17 +452,17 @@ namespace __parallel template _RAIter3 - transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation, + __transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism + __gnu_parallel::_Parallelism __parallelism = __gnu_parallel::parallel_balanced); template _OIter - transform2_switch(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, + __transform2_switch(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation, _Tag1, _Tag2, _Tag3); @@ -482,11 +482,11 @@ namespace __parallel template void - replace_switch(_FIter, _FIter, const _Tp&, const _Tp&, _IterTag); + __replace_switch(_FIter, _FIter, const _Tp&, const _Tp&, _IterTag); template void - replace_switch(_RAIter, _RAIter, const _Tp&, const _Tp&, + __replace_switch(_RAIter, _RAIter, const _Tp&, const _Tp&, random_access_iterator_tag, __gnu_parallel::_Parallelism); @@ -507,11 +507,11 @@ namespace __parallel template void - replace_if_switch(_FIter, _FIter, _Predicate, const _Tp&, _IterTag); + __replace_if_switch(_FIter, _FIter, _Predicate, const _Tp&, _IterTag); template void - replace_if_switch(_RAIter, _RAIter, _Predicate, const _Tp&, + __replace_if_switch(_RAIter, _RAIter, _Predicate, const _Tp&, random_access_iterator_tag, __gnu_parallel::_Parallelism); @@ -542,12 +542,12 @@ namespace __parallel template _FIter - max_element_switch(_FIter, _FIter, _Compare, _IterTag); + __max_element_switch(_FIter, _FIter, _Compare, _IterTag); template _RAIter - max_element_switch(_RAIter, _RAIter, _Compare, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism + __max_element_switch(_RAIter, _RAIter, _Compare, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism = __gnu_parallel::parallel_balanced); @@ -575,13 +575,13 @@ namespace __parallel typename _Compare, typename _IterTag1, typename _IterTag2, typename _IterTag3> _OIter - merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, + __merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, _IterTag1, _IterTag2, _IterTag3); template _OIter - merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, + __merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag); @@ -596,7 +596,7 @@ namespace __parallel template _FIter - min_element(_FIter, _FIter, __gnu_parallel::_Parallelism parallelism_tag); + min_element(_FIter, _FIter, __gnu_parallel::_Parallelism __parallelism_tag); template _FIter @@ -612,12 +612,12 @@ namespace __parallel template _FIter - min_element_switch(_FIter, _FIter, _Compare, _IterTag); + __min_element_switch(_FIter, _FIter, _Compare, _IterTag); template _RAIter - min_element_switch(_RAIter, _RAIter, _Compare, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism + __min_element_switch(_RAIter, _RAIter, _Compare, random_access_iterator_tag, + __gnu_parallel::_Parallelism __parallelism = __gnu_parallel::parallel_balanced); template @@ -654,21 +654,21 @@ namespace __parallel void partial_sort(_RAIter, _RAIter, _RAIter); - template + template _FIter - partition(_FIter, _FIter, Predicate, __gnu_parallel::sequential_tag); + partition(_FIter, _FIter, _Predicate, __gnu_parallel::sequential_tag); - template + template _FIter - partition(_FIter, _FIter, Predicate); + partition(_FIter, _FIter, _Predicate); - template + template _FIter - partition_switch(_FIter, _FIter, Predicate, _IterTag); + __partition_switch(_FIter, _FIter, _Predicate, _IterTag); - template + template _RAIter - partition_switch(_RAIter, _RAIter, Predicate, random_access_iterator_tag); + __partition_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag); template void @@ -693,9 +693,9 @@ namespace __parallel __gnu_parallel::sequential_tag); template + typename _Predicate> _OIter - set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate, __gnu_parallel::sequential_tag); template @@ -711,13 +711,13 @@ namespace __parallel typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3> _OIter - set_union_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, + __set_union_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate, _IterTag1, _IterTag2, _IterTag3); template _Output_RAIter - set_union_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Output_RAIter, + __set_union_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Output_RAIter, _Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag); @@ -745,13 +745,13 @@ namespace __parallel typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3> _OIter - set_intersection_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, + __set_intersection_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate, _IterTag1, _IterTag2, _IterTag3); template _Output_RAIter - set_intersection_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, + __set_intersection_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Output_RAIter, _Predicate, random_access_iterator_tag, random_access_iterator_tag, @@ -782,14 +782,14 @@ namespace __parallel typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3> _OIter - set_symmetric_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, + __set_symmetric_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate, _IterTag1, _IterTag2, _IterTag3); template _Output_RAIter - set_symmetric_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, + __set_symmetric_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Output_RAIter, _Predicate, random_access_iterator_tag, random_access_iterator_tag, @@ -820,13 +820,13 @@ namespace __parallel typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3> _OIter - set_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, + __set_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate, _IterTag1, _IterTag2, _IterTag3); template _Output_RAIter - set_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, + __set_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Output_RAIter, _Predicate, random_access_iterator_tag, random_access_iterator_tag, @@ -885,12 +885,12 @@ namespace __parallel template _OIter - unique_copy_switch(_IIter, _IIter, _OIter, _Predicate, + __unique_copy_switch(_IIter, _IIter, _OIter, _Predicate, _IterTag1, _IterTag2); template _RandomAccess_OIter - unique_copy_switch(_RAIter, _RAIter, _RandomAccess_OIter, _Predicate, + __unique_copy_switch(_RAIter, _RAIter, _RandomAccess_OIter, _Predicate, random_access_iterator_tag, random_access_iterator_tag); } // end namespace __parallel } // end namespace std diff --git a/libstdc++-v3/include/parallel/balanced_quicksort.h b/libstdc++-v3/include/parallel/balanced_quicksort.h index 2310110bb62d..2e939143e3d5 100644 --- a/libstdc++-v3/include/parallel/balanced_quicksort.h +++ b/libstdc++-v3/include/parallel/balanced_quicksort.h @@ -58,171 +58,171 @@ namespace __gnu_parallel { /** @brief Information local to one thread in the parallel quicksort run. */ -template - struct QSBThreadLocal +template + struct _QSBThreadLocal { - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; /** @brief Continuous part of the sequence, described by an iterator pair. */ - typedef std::pair Piece; + typedef std::pair<_RAIter, _RAIter> _Piece; /** @brief Initial piece to work on. */ - Piece initial; + _Piece _M_initial; /** @brief Work-stealing queue. */ - RestrictedBoundedConcurrentQueue leftover_parts; + _RestrictedBoundedConcurrentQueue<_Piece> _M_leftover_parts; /** @brief Number of threads involved in this algorithm. */ - thread_index_t num_threads; + _ThreadIndex __num_threads; /** @brief Pointer to a counter of elements left over to sort. */ - volatile difference_type* elements_leftover; + volatile _DifferenceType* _M_elements_leftover; /** @brief The complete sequence to sort. */ - Piece global; + _Piece _M_global; /** @brief Constructor. - * @param queue_size Size of the work-stealing queue. */ - QSBThreadLocal(int queue_size) : leftover_parts(queue_size) { } + * @param __queue_size size of the work-stealing queue. */ + _QSBThreadLocal(int __queue_size) : _M_leftover_parts(__queue_size) { } }; /** @brief Balanced quicksort divide step. - * @param begin Begin iterator of subsequence. - * @param end End iterator of subsequence. - * @param comp Comparator. - * @param num_threads Number of threads that are allowed to work on + * @param __begin Begin iterator of subsequence. + * @param __end End iterator of subsequence. + * @param __comp Comparator. + * @param __num_threads Number of threads that are allowed to work on * this part. - * @pre @c (end-begin)>=1 */ -template - typename std::iterator_traits::difference_type - qsb_divide(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, thread_index_t num_threads) + * @pre @__c (__end-__begin)>=1 */ +template + typename std::iterator_traits<_RAIter>::difference_type + __qsb_divide(_RAIter __begin, _RAIter __end, + _Compare __comp, _ThreadIndex __num_threads) { - _GLIBCXX_PARALLEL_ASSERT(num_threads > 0); + _GLIBCXX_PARALLEL_ASSERT(__num_threads > 0); - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - RandomAccessIterator pivot_pos = - median_of_three_iterators(begin, begin + (end - begin) / 2, - end - 1, comp); + _RAIter __pivot_pos = + __median_of_three_iterators(__begin, __begin + (__end - __begin) / 2, + __end - 1, __comp); #if defined(_GLIBCXX_ASSERTIONS) // Must be in between somewhere. - difference_type n = end - begin; + _DifferenceType __n = __end - __begin; _GLIBCXX_PARALLEL_ASSERT( - (!comp(*pivot_pos, *begin) && !comp(*(begin + n / 2), *pivot_pos)) - || (!comp(*pivot_pos, *begin) && !comp(*(end - 1), *pivot_pos)) - || (!comp(*pivot_pos, *(begin + n / 2)) && !comp(*begin, *pivot_pos)) - || (!comp(*pivot_pos, *(begin + n / 2)) && !comp(*(end - 1), *pivot_pos)) - || (!comp(*pivot_pos, *(end - 1)) && !comp(*begin, *pivot_pos)) - || (!comp(*pivot_pos, *(end - 1)) && !comp(*(begin + n / 2), *pivot_pos))); + (!__comp(*__pivot_pos, *__begin) && !__comp(*(__begin + __n / 2), *__pivot_pos)) + || (!__comp(*__pivot_pos, *__begin) && !__comp(*(__end - 1), *__pivot_pos)) + || (!__comp(*__pivot_pos, *(__begin + __n / 2)) && !__comp(*__begin, *__pivot_pos)) + || (!__comp(*__pivot_pos, *(__begin + __n / 2)) && !__comp(*(__end - 1), *__pivot_pos)) + || (!__comp(*__pivot_pos, *(__end - 1)) && !__comp(*__begin, *__pivot_pos)) + || (!__comp(*__pivot_pos, *(__end - 1)) && !__comp(*(__begin + __n / 2), *__pivot_pos))); #endif // Swap pivot value to end. - if (pivot_pos != (end - 1)) - std::swap(*pivot_pos, *(end - 1)); - pivot_pos = end - 1; + if (__pivot_pos != (__end - 1)) + std::swap(*__pivot_pos, *(__end - 1)); + __pivot_pos = __end - 1; - __gnu_parallel::binder2nd - pred(comp, *pivot_pos); + __gnu_parallel::binder2nd<_Compare, _ValueType, _ValueType, bool> + __pred(__comp, *__pivot_pos); - // Divide, returning end - begin - 1 in the worst case. - difference_type split_pos = parallel_partition( - begin, end - 1, pred, num_threads); + // Divide, returning __end - __begin - 1 in the worst case. + _DifferenceType __split_pos = __parallel_partition( + __begin, __end - 1, __pred, __num_threads); // Swap back pivot to middle. - std::swap(*(begin + split_pos), *pivot_pos); - pivot_pos = begin + split_pos; + std::swap(*(__begin + __split_pos), *__pivot_pos); + __pivot_pos = __begin + __split_pos; #if _GLIBCXX_ASSERTIONS - RandomAccessIterator r; - for (r = begin; r != pivot_pos; ++r) - _GLIBCXX_PARALLEL_ASSERT(comp(*r, *pivot_pos)); - for (; r != end; ++r) - _GLIBCXX_PARALLEL_ASSERT(!comp(*r, *pivot_pos)); + _RAIter __r; + for (__r = __begin; __r != __pivot_pos; ++__r) + _GLIBCXX_PARALLEL_ASSERT(__comp(*__r, *__pivot_pos)); + for (; __r != __end; ++__r) + _GLIBCXX_PARALLEL_ASSERT(!__comp(*__r, *__pivot_pos)); #endif - return split_pos; + return __split_pos; } /** @brief Quicksort conquer step. - * @param tls Array of thread-local storages. - * @param begin Begin iterator of subsequence. - * @param end End iterator of subsequence. - * @param comp Comparator. - * @param iam Number of the thread processing this function. - * @param num_threads + * @param __tls Array of thread-local storages. + * @param __begin Begin iterator of subsequence. + * @param __end End iterator of subsequence. + * @param __comp Comparator. + * @param __iam Number of the thread processing this function. + * @param __num_threads * Number of threads that are allowed to work on this part. */ -template +template void - qsb_conquer(QSBThreadLocal** tls, - RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, - thread_index_t iam, thread_index_t num_threads, - bool parent_wait) + __qsb_conquer(_QSBThreadLocal<_RAIter>** __tls, + _RAIter __begin, _RAIter __end, + _Compare __comp, + _ThreadIndex __iam, _ThreadIndex __num_threads, + bool __parent_wait) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - difference_type n = end - begin; + _DifferenceType __n = __end - __begin; - if (num_threads <= 1 || n <= 1) + if (__num_threads <= 1 || __n <= 1) { - tls[iam]->initial.first = begin; - tls[iam]->initial.second = end; + __tls[__iam]->_M_initial.first = __begin; + __tls[__iam]->_M_initial.second = __end; - qsb_local_sort_with_helping(tls, comp, iam, parent_wait); + __qsb_local_sort_with_helping(__tls, __comp, __iam, __parent_wait); return; } // Divide step. - difference_type split_pos = qsb_divide(begin, end, comp, num_threads); + _DifferenceType __split_pos = __qsb_divide(__begin, __end, __comp, __num_threads); #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(0 <= split_pos && split_pos < (end - begin)); + _GLIBCXX_PARALLEL_ASSERT(0 <= __split_pos && __split_pos < (__end - __begin)); #endif - thread_index_t num_threads_leftside = - std::max(1, std::min( - num_threads - 1, split_pos * num_threads / n)); + _ThreadIndex __num_threads_leftside = + std::max<_ThreadIndex>(1, std::min<_ThreadIndex>( + __num_threads - 1, __split_pos * __num_threads / __n)); # pragma omp atomic - *tls[iam]->elements_leftover -= (difference_type)1; + *__tls[__iam]->_M_elements_leftover -= (_DifferenceType)1; // Conquer step. # pragma omp parallel num_threads(2) { - bool wait; + bool __wait; if(omp_get_num_threads() < 2) - wait = false; + __wait = false; else - wait = parent_wait; + __wait = __parent_wait; # pragma omp sections { # pragma omp section { - qsb_conquer(tls, begin, begin + split_pos, comp, - iam, - num_threads_leftside, - wait); - wait = parent_wait; + __qsb_conquer(__tls, __begin, __begin + __split_pos, __comp, + __iam, + __num_threads_leftside, + __wait); + __wait = __parent_wait; } // The pivot_pos is left in place, to ensure termination. # pragma omp section { - qsb_conquer(tls, begin + split_pos + 1, end, comp, - iam + num_threads_leftside, - num_threads - num_threads_leftside, - wait); - wait = parent_wait; + __qsb_conquer(__tls, __begin + __split_pos + 1, __end, __comp, + __iam + __num_threads_leftside, + __num_threads - __num_threads_leftside, + __wait); + __wait = __parent_wait; } } } @@ -230,175 +230,175 @@ template /** * @brief Quicksort step doing load-balanced local sort. - * @param tls Array of thread-local storages. - * @param comp Comparator. - * @param iam Number of the thread processing this function. + * @param __tls Array of thread-local storages. + * @param __comp Comparator. + * @param __iam Number of the thread processing this function. */ -template +template void - qsb_local_sort_with_helping(QSBThreadLocal** tls, - Comparator& comp, int iam, bool wait) + __qsb_local_sort_with_helping(_QSBThreadLocal<_RAIter>** __tls, + _Compare& __comp, int __iam, bool __wait) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; - typedef std::pair Piece; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; + typedef std::pair<_RAIter, _RAIter> _Piece; - QSBThreadLocal& tl = *tls[iam]; + _QSBThreadLocal<_RAIter>& __tl = *__tls[__iam]; - difference_type base_case_n = + _DifferenceType __base_case_n = _Settings::get().sort_qsb_base_case_maximal_n; - if (base_case_n < 2) - base_case_n = 2; - thread_index_t num_threads = tl.num_threads; + if (__base_case_n < 2) + __base_case_n = 2; + _ThreadIndex __num_threads = __tl.__num_threads; // Every thread has its own random number generator. - random_number rng(iam + 1); + _RandomNumber __rng(__iam + 1); - Piece current = tl.initial; + _Piece __current = __tl._M_initial; - difference_type elements_done = 0; + _DifferenceType __elements_done = 0; #if _GLIBCXX_ASSERTIONS - difference_type total_elements_done = 0; + _DifferenceType __total_elements_done = 0; #endif for (;;) { - // Invariant: current must be a valid (maybe empty) range. - RandomAccessIterator begin = current.first, end = current.second; - difference_type n = end - begin; + // Invariant: __current must be a valid (maybe empty) range. + _RAIter __begin = __current.first, __end = __current.second; + _DifferenceType __n = __end - __begin; - if (n > base_case_n) + if (__n > __base_case_n) { // Divide. - RandomAccessIterator pivot_pos = begin + rng(n); + _RAIter __pivot_pos = __begin + __rng(__n); - // Swap pivot_pos value to end. - if (pivot_pos != (end - 1)) - std::swap(*pivot_pos, *(end - 1)); - pivot_pos = end - 1; + // Swap __pivot_pos value to end. + if (__pivot_pos != (__end - 1)) + std::swap(*__pivot_pos, *(__end - 1)); + __pivot_pos = __end - 1; __gnu_parallel::binder2nd - - pred(comp, *pivot_pos); + <_Compare, _ValueType, _ValueType, bool> + __pred(__comp, *__pivot_pos); // Divide, leave pivot unchanged in last place. - RandomAccessIterator split_pos1, split_pos2; - split_pos1 = __gnu_sequential::partition(begin, end - 1, pred); + _RAIter __split_pos1, __split_pos2; + __split_pos1 = __gnu_sequential::partition(__begin, __end - 1, __pred); - // Left side: < pivot_pos; right side: >= pivot_pos. + // Left side: < __pivot_pos; __right side: >= __pivot_pos. #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(begin <= split_pos1 && split_pos1 < end); + _GLIBCXX_PARALLEL_ASSERT(__begin <= __split_pos1 && __split_pos1 < __end); #endif // Swap pivot back to middle. - if (split_pos1 != pivot_pos) - std::swap(*split_pos1, *pivot_pos); - pivot_pos = split_pos1; + if (__split_pos1 != __pivot_pos) + std::swap(*__split_pos1, *__pivot_pos); + __pivot_pos = __split_pos1; - // In case all elements are equal, split_pos1 == 0. - if ((split_pos1 + 1 - begin) < (n >> 7) - || (end - split_pos1) < (n >> 7)) + // In case all elements are equal, __split_pos1 == 0. + if ((__split_pos1 + 1 - __begin) < (__n >> 7) + || (__end - __split_pos1) < (__n >> 7)) { // Very unequal split, one part smaller than one 128th // elements not strictly larger than the pivot. - __gnu_parallel::unary_negate<__gnu_parallel::binder1st - , value_type> - pred(__gnu_parallel::binder1st - (comp, - *pivot_pos)); + __gnu_parallel::__unary_negate<__gnu_parallel::__binder1st + <_Compare, _ValueType, _ValueType, bool>, _ValueType> + __pred(__gnu_parallel::__binder1st + <_Compare, _ValueType, _ValueType, bool>(__comp, + *__pivot_pos)); // Find other end of pivot-equal range. - split_pos2 = __gnu_sequential::partition(split_pos1 + 1, - end, pred); + __split_pos2 = __gnu_sequential::partition(__split_pos1 + 1, + __end, __pred); } else // Only skip the pivot. - split_pos2 = split_pos1 + 1; + __split_pos2 = __split_pos1 + 1; // Elements equal to pivot are done. - elements_done += (split_pos2 - split_pos1); + __elements_done += (__split_pos2 - __split_pos1); #if _GLIBCXX_ASSERTIONS - total_elements_done += (split_pos2 - split_pos1); + __total_elements_done += (__split_pos2 - __split_pos1); #endif // Always push larger part onto stack. - if (((split_pos1 + 1) - begin) < (end - (split_pos2))) + if (((__split_pos1 + 1) - __begin) < (__end - (__split_pos2))) { // Right side larger. - if ((split_pos2) != end) - tl.leftover_parts.push_front(std::make_pair(split_pos2, - end)); + if ((__split_pos2) != __end) + __tl._M_leftover_parts.push_front(std::make_pair(__split_pos2, + __end)); - //current.first = begin; //already set anyway - current.second = split_pos1; + //__current.first = __begin; //already set anyway + __current.second = __split_pos1; continue; } else { // Left side larger. - if (begin != split_pos1) - tl.leftover_parts.push_front(std::make_pair(begin, - split_pos1)); + if (__begin != __split_pos1) + __tl._M_leftover_parts.push_front(std::make_pair(__begin, + __split_pos1)); - current.first = split_pos2; - //current.second = end; //already set anyway + __current.first = __split_pos2; + //__current.second = __end; //already set anyway continue; } } else { - __gnu_sequential::sort(begin, end, comp); - elements_done += n; + __gnu_sequential::sort(__begin, __end, __comp); + __elements_done += __n; #if _GLIBCXX_ASSERTIONS - total_elements_done += n; + __total_elements_done += __n; #endif // Prefer own stack, small pieces. - if (tl.leftover_parts.pop_front(current)) + if (__tl._M_leftover_parts.pop_front(__current)) continue; # pragma omp atomic - *tl.elements_leftover -= elements_done; + *__tl._M_elements_leftover -= __elements_done; - elements_done = 0; + __elements_done = 0; #if _GLIBCXX_ASSERTIONS - double search_start = omp_get_wtime(); + double __search_start = omp_get_wtime(); #endif // Look for new work. - bool successfully_stolen = false; - while (wait && *tl.elements_leftover > 0 && !successfully_stolen + bool __successfully_stolen = false; + while (__wait && *__tl._M_elements_leftover > 0 && !__successfully_stolen #if _GLIBCXX_ASSERTIONS // Possible dead-lock. - && (omp_get_wtime() < (search_start + 1.0)) + && (omp_get_wtime() < (__search_start + 1.0)) #endif ) { - thread_index_t victim; - victim = rng(num_threads); + _ThreadIndex __victim; + __victim = __rng(__num_threads); // Large pieces. - successfully_stolen = (victim != iam) - && tls[victim]->leftover_parts.pop_back(current); - if (!successfully_stolen) - yield(); + __successfully_stolen = (__victim != __iam) + && __tls[__victim]->_M_leftover_parts.pop_back(__current); + if (!__successfully_stolen) + __yield(); #if !defined(__ICC) && !defined(__ECC) # pragma omp flush #endif } #if _GLIBCXX_ASSERTIONS - if (omp_get_wtime() >= (search_start + 1.0)) + if (omp_get_wtime() >= (__search_start + 1.0)) { sleep(1); _GLIBCXX_PARALLEL_ASSERT(omp_get_wtime() - < (search_start + 1.0)); + < (__search_start + 1.0)); } #endif - if (!successfully_stolen) + if (!__successfully_stolen) { #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(*tl.elements_leftover == 0); + _GLIBCXX_PARALLEL_ASSERT(*__tl._M_elements_leftover == 0); #endif return; } @@ -407,70 +407,70 @@ template } /** @brief Top-level quicksort routine. - * @param begin Begin iterator of sequence. - * @param end End iterator of sequence. - * @param comp Comparator. - * @param num_threads Number of threads that are allowed to work on + * @param __begin Begin iterator of sequence. + * @param __end End iterator of sequence. + * @param __comp Comparator. + * @param __num_threads Number of threads that are allowed to work on * this part. */ -template +template void - parallel_sort_qsb(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, - thread_index_t num_threads) + __parallel_sort_qsb(_RAIter __begin, _RAIter __end, + _Compare __comp, + _ThreadIndex __num_threads) { - _GLIBCXX_CALL(end - begin) + _GLIBCXX_CALL(__end - __begin) - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; - typedef std::pair Piece; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; + typedef std::pair<_RAIter, _RAIter> _Piece; - typedef QSBThreadLocal tls_type; + typedef _QSBThreadLocal<_RAIter> _TLSType; - difference_type n = end - begin; + _DifferenceType __n = __end - __begin; - if (n <= 1) + if (__n <= 1) return; // At least one element per processor. - if (num_threads > n) - num_threads = static_cast(n); + if (__num_threads > __n) + __num_threads = static_cast<_ThreadIndex>(__n); // Initialize thread local storage - tls_type** tls = new tls_type*[num_threads]; - difference_type queue_size = num_threads * (thread_index_t)(log2(n) + 1); - for (thread_index_t t = 0; t < num_threads; ++t) - tls[t] = new QSBThreadLocal(queue_size); + _TLSType** __tls = new _TLSType*[__num_threads]; + _DifferenceType __queue_size = __num_threads * (_ThreadIndex)(log2(__n) + 1); + for (_ThreadIndex __t = 0; __t < __num_threads; ++__t) + __tls[__t] = new _QSBThreadLocal<_RAIter>(__queue_size); - // There can never be more than ceil(log2(n)) ranges on the stack, because + // There can never be more than ceil(log2(__n)) ranges on the stack, because // 1. Only one processor pushes onto the stack - // 2. The largest range has at most length n + // 2. The largest range has at most length __n // 3. Each range is larger than half of the range remaining - volatile difference_type elements_leftover = n; - for (int i = 0; i < num_threads; ++i) + volatile _DifferenceType _M_elements_leftover = __n; + for (int __i = 0; __i < __num_threads; ++__i) { - tls[i]->elements_leftover = &elements_leftover; - tls[i]->num_threads = num_threads; - tls[i]->global = std::make_pair(begin, end); + __tls[__i]->_M_elements_leftover = &_M_elements_leftover; + __tls[__i]->__num_threads = __num_threads; + __tls[__i]->_M_global = std::make_pair(__begin, __end); // Just in case nothing is left to assign. - tls[i]->initial = std::make_pair(end, end); + __tls[__i]->_M_initial = std::make_pair(__end, __end); } // Main recursion call. - qsb_conquer(tls, begin, begin + n, comp, 0, num_threads, true); + __qsb_conquer(__tls, __begin, __begin + __n, __comp, 0, __num_threads, true); #if _GLIBCXX_ASSERTIONS // All stack must be empty. - Piece dummy; - for (int i = 1; i < num_threads; ++i) - _GLIBCXX_PARALLEL_ASSERT(!tls[i]->leftover_parts.pop_back(dummy)); + _Piece __dummy; + for (int __i = 1; __i < __num_threads; ++__i) + _GLIBCXX_PARALLEL_ASSERT(!__tls[__i]->_M_leftover_parts.pop_back(__dummy)); #endif - for (int i = 0; i < num_threads; ++i) - delete tls[i]; - delete[] tls; + for (int __i = 0; __i < __num_threads; ++__i) + delete __tls[__i]; + delete[] __tls; } } // namespace __gnu_parallel diff --git a/libstdc++-v3/include/parallel/base.h b/libstdc++-v3/include/parallel/base.h index 7f855dfca5ce..e09f05c76f8a 100644 --- a/libstdc++-v3/include/parallel/base.h +++ b/libstdc++-v3/include/parallel/base.h @@ -82,7 +82,7 @@ namespace __gnu_parallel // and active, which imples that the OpenMP runtime is actually // going to be linked in. inline int - get_max_threads() + __get_max_threads() { int __i = omp_get_max_threads(); return __i > 1 ? __i : 1; @@ -90,91 +90,91 @@ namespace __gnu_parallel inline bool - is_parallel(const _Parallelism __p) { return __p != sequential; } + __is_parallel(const _Parallelism __p) { return __p != sequential; } // XXX remove std::duplicates from here if possible, // XXX but keep minimal dependencies. -/** @brief Calculates the rounded-down logarithm of @c n for base 2. - * @param n Argument. +/** @brief Calculates the rounded-down logarithm of @__c __n for base 2. + * @param __n Argument. * @return Returns 0 for any argument <1. */ -template - inline Size - __log2(Size n) +template + inline _Size + __log2(_Size __n) { - Size k; - for (k = 0; n > 1; n >>= 1) - ++k; - return k; + _Size __k; + for (__k = 0; __n > 1; __n >>= 1) + ++__k; + return __k; } -/** @brief Encode two integers into one __gnu_parallel::lcas_t. - * @param a First integer, to be encoded in the most-significant @c - * lcas_t_bits/2 bits. - * @param b Second integer, to be encoded in the least-significant - * @c lcas_t_bits/2 bits. - * @return __gnu_parallel::lcas_t value encoding @c a and @c b. +/** @brief Encode two integers into one __gnu_parallel::_CASable. + * @param __a First integer, to be encoded in the most-significant @__c + * _CASable_bits/2 bits. + * @param __b Second integer, to be encoded in the least-significant + * @__c _CASable_bits/2 bits. + * @return __gnu_parallel::_CASable _M_value encoding @__c __a and @__c __b. * @see decode2 */ -inline lcas_t -encode2(int a, int b) //must all be non-negative, actually +inline _CASable +__encode2(int __a, int __b) //must all be non-negative, actually { - return (((lcas_t)a) << (lcas_t_bits / 2)) | (((lcas_t)b) << 0); + return (((_CASable)__a) << (_CASable_bits / 2)) | (((_CASable)__b) << 0); } -/** @brief Decode two integers from one __gnu_parallel::lcas_t. - * @param x __gnu_parallel::lcas_t to decode integers from. - * @param a First integer, to be decoded from the most-significant - * @c lcas_t_bits/2 bits of @c x. - * @param b Second integer, to be encoded in the least-significant - * @c lcas_t_bits/2 bits of @c x. - * @see encode2 +/** @brief Decode two integers from one __gnu_parallel::_CASable. + * @param __x __gnu_parallel::_CASable to decode integers from. + * @param __a First integer, to be decoded from the most-significant + * @__c _CASable_bits/2 bits of @__c __x. + * @param __b Second integer, to be encoded in the least-significant + * @__c _CASable_bits/2 bits of @__c __x. + * @see __encode2 */ inline void -decode2(lcas_t x, int& a, int& b) +decode2(_CASable __x, int& __a, int& __b) { - a = (int)((x >> (lcas_t_bits / 2)) & lcas_t_mask); - b = (int)((x >> 0 ) & lcas_t_mask); + __a = (int)((__x >> (_CASable_bits / 2)) & _CASable_mask); + __b = (int)((__x >> 0 ) & _CASable_mask); } /** @brief Equivalent to std::min. */ -template - const T& - min(const T& a, const T& b) - { return (a < b) ? a : b; } +template + const _Tp& + min(const _Tp& __a, const _Tp& __b) + { return (__a < __b) ? __a : __b; } /** @brief Equivalent to std::max. */ -template - const T& - max(const T& a, const T& b) - { return (a > b) ? a : b; } +template + const _Tp& + max(const _Tp& __a, const _Tp& __b) + { return (__a > __b) ? __a : __b; } /** @brief Constructs predicate for equality from strict weak * ordering predicate */ // XXX comparator at the end, as per others -template - class equal_from_less : public std::binary_function +template + class _EqualFromLess : public std::binary_function<_T1, _T2, bool> { private: - Comparator& comp; + _Compare& __comp; public: - equal_from_less(Comparator& _comp) : comp(_comp) { } + _EqualFromLess(_Compare& _comp) : __comp(_comp) { } - bool operator()(const T1& a, const T2& b) + bool operator()(const _T1& __a, const _T2& __b) { - return !comp(a, b) && !comp(b, a); + return !__comp(__a, __b) && !__comp(__b, __a); } }; -/** @brief Similar to std::binder1st, +/** @brief Similar to std::__binder1st, * but giving the argument types explicitly. */ template - class unary_negate + class __unary_negate : public std::unary_function { protected: @@ -182,93 +182,93 @@ template public: explicit - unary_negate(const _Predicate& __x) : _M_pred(__x) { } + __unary_negate(const _Predicate& __x) : _M_pred(__x) { } bool operator()(const argument_type& __x) { return !_M_pred(__x); } }; -/** @brief Similar to std::binder1st, +/** @brief Similar to std::__binder1st, * but giving the argument types explicitly. */ -template - class binder1st - : public std::unary_function +template + class __binder1st + : public std::unary_function<_SecondArgumentType, _ResultType> { protected: - _Operation op; - first_argument_type value; + _Operation _M_op; + _FirstArgumentType _M_value; public: - binder1st(const _Operation& __x, - const first_argument_type& __y) - : op(__x), value(__y) { } + __binder1st(const _Operation& __x, + const _FirstArgumentType& __y) + : _M_op(__x), _M_value(__y) { } - result_type - operator()(const second_argument_type& __x) - { return op(value, __x); } + _ResultType + operator()(const _SecondArgumentType& __x) + { return _M_op(_M_value, __x); } // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 109. Missing binders for non-const sequence elements - result_type - operator()(second_argument_type& __x) const - { return op(value, __x); } + // 109. Missing binders for non-const __sequence __elements + _ResultType + operator()(_SecondArgumentType& __x) const + { return _M_op(_M_value, __x); } }; /** * @brief Similar to std::binder2nd, but giving the argument types * explicitly. */ -template +template class binder2nd - : public std::unary_function + : public std::unary_function<_FirstArgumentType, _ResultType> { protected: - _Operation op; - second_argument_type value; + _Operation _M_op; + _SecondArgumentType _M_value; public: binder2nd(const _Operation& __x, - const second_argument_type& __y) - : op(__x), value(__y) { } + const _SecondArgumentType& __y) + : _M_op(__x), _M_value(__y) { } - result_type - operator()(const first_argument_type& __x) const - { return op(__x, value); } + _ResultType + operator()(const _FirstArgumentType& __x) const + { return _M_op(__x, _M_value); } // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 109. Missing binders for non-const sequence elements - result_type - operator()(first_argument_type& __x) - { return op(__x, value); } + // 109. Missing binders for non-const __sequence __elements + _ResultType + operator()(_FirstArgumentType& __x) + { return _M_op(__x, _M_value); } }; /** @brief Similar to std::equal_to, but allows two different types. */ -template - struct equal_to : std::binary_function +template + struct equal_to : std::binary_function<_T1, _T2, bool> { - bool operator()(const T1& t1, const T2& t2) const - { return t1 == t2; } + bool operator()(const _T1& __t1, const _T2& __t2) const + { return __t1 == __t2; } }; /** @brief Similar to std::less, but allows two different types. */ -template - struct less : std::binary_function +template + struct _Less : std::binary_function<_T1, _T2, bool> { bool - operator()(const T1& t1, const T2& t2) const - { return t1 < t2; } + operator()(const _T1& __t1, const _T2& __t2) const + { return __t1 < __t2; } bool - operator()(const T2& t2, const T1& t1) const - { return t2 < t1; } + operator()(const _T2& __t2, const _T1& __t1) const + { return __t2 < __t1; } }; // Partial specialization for one type. Same as std::less. template -struct less<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, bool> +struct _Less<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __x, const _Tp& __y) const @@ -278,24 +278,24 @@ struct less<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, bool> /** @brief Similar to std::plus, but allows two different types. */ template - struct plus : public std::binary_function<_Tp1, _Tp2, _Tp1> + struct _Plus : public std::binary_function<_Tp1, _Tp2, _Tp1> { typedef __typeof__(*static_cast<_Tp1*>(NULL) - + *static_cast<_Tp2*>(NULL)) result; + + *static_cast<_Tp2*>(NULL)) __result; - result + __result operator()(const _Tp1& __x, const _Tp2& __y) const { return __x + __y; } }; // Partial specialization for one type. Same as std::plus. template - struct plus<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, _Tp> + struct _Plus<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, _Tp> { typedef __typeof__(*static_cast<_Tp*>(NULL) - + *static_cast<_Tp*>(NULL)) result; + + *static_cast<_Tp*>(NULL)) __result; - result + __result operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; } }; @@ -303,164 +303,164 @@ template /** @brief Similar to std::multiplies, but allows two different types. */ template - struct multiplies : public std::binary_function<_Tp1, _Tp2, _Tp1> + struct _Multiplies : public std::binary_function<_Tp1, _Tp2, _Tp1> { typedef __typeof__(*static_cast<_Tp1*>(NULL) - * *static_cast<_Tp2*>(NULL)) result; + * *static_cast<_Tp2*>(NULL)) __result; - result + __result operator()(const _Tp1& __x, const _Tp2& __y) const { return __x * __y; } }; // Partial specialization for one type. Same as std::multiplies. template - struct multiplies<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, _Tp> + struct _Multiplies<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, _Tp> { typedef __typeof__(*static_cast<_Tp*>(NULL) - * *static_cast<_Tp*>(NULL)) result; + * *static_cast<_Tp*>(NULL)) __result; - result + __result operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; } }; -template - class pseudo_sequence; +template + class _PseudoSequence; -/** @brief Iterator associated with __gnu_parallel::pseudo_sequence. +/** @brief _Iterator associated with __gnu_parallel::_PseudoSequence. * If features the usual random-access iterator functionality. - * @param T Sequence value type. - * @param difference_type Sequence difference type. + * @param _Tp Sequence _M_value type. + * @param _DifferenceType Sequence difference type. */ -template - class pseudo_sequence_iterator +template + class _PseudoSequenceIterator { public: - typedef _DifferenceTp difference_type; + typedef _DifferenceTp _DifferenceType; private: - typedef pseudo_sequence_iterator type; + typedef _PseudoSequenceIterator<_Tp, _DifferenceTp> _Self; - const T& val; - difference_type pos; + const _Tp& _M_val; + _DifferenceType _M_pos; public: - pseudo_sequence_iterator(const T& val, difference_type pos) - : val(val), pos(pos) { } + _PseudoSequenceIterator(const _Tp& _M_val, _DifferenceType _M_pos) + : _M_val(_M_val), _M_pos(_M_pos) { } // Pre-increment operator. - type& + _Self& operator++() { - ++pos; + ++_M_pos; return *this; } // Post-increment operator. - const type + const _Self operator++(int) - { return type(pos++); } + { return _Self(_M_pos++); } - const T& + const _Tp& operator*() const - { return val; } + { return _M_val; } - const T& - operator[](difference_type) const - { return val; } + const _Tp& + operator[](_DifferenceType) const + { return _M_val; } bool - operator==(const type& i2) - { return pos == i2.pos; } + operator==(const _Self& __i2) + { return _M_pos == __i2._M_pos; } - difference_type - operator!=(const type& i2) - { return pos != i2.pos; } + _DifferenceType + operator!=(const _Self& __i2) + { return _M_pos != __i2._M_pos; } - difference_type - operator-(const type& i2) - { return pos - i2.pos; } + _DifferenceType + operator-(const _Self& __i2) + { return _M_pos - __i2._M_pos; } }; /** @brief Sequence that conceptually consists of multiple copies of the same element. * The copies are not stored explicitly, of course. - * @param T Sequence value type. - * @param difference_type Sequence difference type. + * @param _Tp Sequence _M_value type. + * @param _DifferenceType Sequence difference type. */ -template - class pseudo_sequence +template + class _PseudoSequence { - typedef pseudo_sequence type; + typedef _PseudoSequence<_Tp, _DifferenceTp> _Self; public: - typedef _DifferenceTp difference_type; + typedef _DifferenceTp _DifferenceType; // Better case down to uint64, than up to _DifferenceTp. - typedef pseudo_sequence_iterator iterator; + typedef _PseudoSequenceIterator<_Tp, uint64> iterator; /** @brief Constructor. - * @param val Element of the sequence. - * @param count Number of (virtual) copies. + * @param _M_val Element of the sequence. + * @param __count Number of (virtual) copies. */ - pseudo_sequence(const T& val, difference_type count) - : val(val), count(count) { } + _PseudoSequence(const _Tp& _M_val, _DifferenceType __count) + : _M_val(_M_val), __count(__count) { } /** @brief Begin iterator. */ iterator begin() const - { return iterator(val, 0); } + { return iterator(_M_val, 0); } /** @brief End iterator. */ iterator end() const - { return iterator(val, count); } + { return iterator(_M_val, __count); } private: - const T& val; - difference_type count; + const _Tp& _M_val; + _DifferenceType __count; }; /** @brief Functor that does nothing */ template - class void_functor + class _VoidFunctor { inline void - operator()(const _ValueTp& v) const { } + operator()(const _ValueTp& __v) const { } }; /** @brief Compute the median of three referenced elements, - according to @c comp. - * @param a First iterator. - * @param b Second iterator. - * @param c Third iterator. - * @param comp Comparator. + according to @__c __comp. + * @param __a First iterator. + * @param __b Second iterator. + * @param __c Third iterator. + * @param __comp Comparator. */ -template - RandomAccessIterator - median_of_three_iterators(RandomAccessIterator a, RandomAccessIterator b, - RandomAccessIterator c, Comparator& comp) +template + _RAIter + __median_of_three_iterators(_RAIter __a, _RAIter __b, + _RAIter __c, _Compare& __comp) { - if (comp(*a, *b)) - if (comp(*b, *c)) - return b; + if (__comp(*__a, *__b)) + if (__comp(*__b, *__c)) + return __b; else - if (comp(*a, *c)) - return c; + if (__comp(*__a, *__c)) + return __c; else - return a; + return __a; else { - // Just swap a and b. - if (comp(*a, *c)) - return a; + // Just swap __a and __b. + if (__comp(*__a, *__c)) + return __a; else - if (comp(*b, *c)) - return c; + if (__comp(*__b, *__c)) + return __c; else - return b; + return __b; } } diff --git a/libstdc++-v3/include/parallel/checkers.h b/libstdc++-v3/include/parallel/checkers.h index 819e8ad26d41..47d21749a867 100644 --- a/libstdc++-v3/include/parallel/checkers.h +++ b/libstdc++-v3/include/parallel/checkers.h @@ -39,115 +39,115 @@ namespace __gnu_parallel { /** - * @brief Check whether @c [begin, @c end) is sorted according to @c comp. - * @param begin Begin iterator of sequence. - * @param end End iterator of sequence. - * @param comp Comparator. - * @return @c true if sorted, @c false otherwise. + * @brief Check whether @__c [__begin, @__c __end) is sorted according to @__c __comp. + * @param __begin Begin iterator of sequence. + * @param __end End iterator of sequence. + * @param __comp Comparator. + * @return @__c true if sorted, @__c false otherwise. */ - // XXX Comparator default template argument - template + // XXX Compare default template argument + template bool - is_sorted(InputIterator begin, InputIterator end, - Comparator comp - = std::less:: - value_type>()) + __is_sorted(_IIter __begin, _IIter __end, + _Compare __comp + = std::less:: + _ValueType>()) { - if (begin == end) + if (__begin == __end) return true; - InputIterator current(begin), recent(begin); + _IIter __current(__begin), __recent(__begin); - unsigned long long position = 1; - for (current++; current != end; current++) + unsigned long long __position = 1; + for (__current++; __current != __end; __current++) { - if (comp(*current, *recent)) + if (__comp(*__current, *__recent)) { - printf("is_sorted: check failed before position %i.\n", - position); + printf("__is_sorted: check failed before position %__i.\n", + __position); return false; } - recent = current; - position++; + __recent = __current; + __position++; } return true; } /** - * @brief Check whether @c [begin, @c end) is sorted according to @c comp. + * @brief Check whether @__c [__begin, @__c __end) is sorted according to @__c __comp. * Prints the position in case an unordered pair is found. - * @param begin Begin iterator of sequence. - * @param end End iterator of sequence. - * @param first_failure The first failure is returned in this variable. - * @param comp Comparator. - * @return @c true if sorted, @c false otherwise. + * @param __begin Begin iterator of sequence. + * @param __end End iterator of sequence. + * @param __first_failure The first failure is returned in this variable. + * @param __comp Comparator. + * @return @__c true if sorted, @__c false otherwise. */ - // XXX Comparator default template argument - template + // XXX Compare default template argument + template bool - is_sorted_failure(InputIterator begin, InputIterator end, - InputIterator& first_failure, - Comparator comp - = std::less:: - value_type>()) + is_sorted_failure(_IIter __begin, _IIter __end, + _IIter& __first_failure, + _Compare __comp + = std::less:: + _ValueType>()) { - if (begin == end) + if (__begin == __end) return true; - InputIterator current(begin), recent(begin); + _IIter __current(__begin), __recent(__begin); - unsigned long long position = 1; - for (current++; current != end; current++) + unsigned long long __position = 1; + for (__current++; __current != __end; __current++) { - if (comp(*current, *recent)) + if (__comp(*__current, *__recent)) { - first_failure = current; - printf("is_sorted: check failed before position %lld.\n", - position); + __first_failure = __current; + printf("__is_sorted: check failed before position %lld.\n", + __position); return false; } - recent = current; - position++; + __recent = __current; + __position++; } - first_failure = end; + __first_failure = __end; return true; } /** - * @brief Check whether @c [begin, @c end) is sorted according to @c comp. + * @brief Check whether @__c [__begin, @__c __end) is sorted according to @__c __comp. * Prints all unordered pair, including the surrounding two elements. - * @param begin Begin iterator of sequence. - * @param end End iterator of sequence. - * @param comp Comparator. - * @return @c true if sorted, @c false otherwise. + * @param __begin Begin iterator of sequence. + * @param __end End iterator of sequence. + * @param __comp Comparator. + * @return @__c true if sorted, @__c false otherwise. */ - template + template bool - // XXX Comparator default template argument - is_sorted_print_failures(InputIterator begin, InputIterator end, - Comparator comp + // XXX Compare default template argument + is_sorted_print_failures(_IIter __begin, _IIter __end, + _Compare __comp = std::less::value_type>()) + <_IIter>::value_type>()) { - if (begin == end) + if (__begin == __end) return true; - InputIterator recent(begin); - bool ok = true; + _IIter __recent(__begin); + bool __ok = true; - for (InputIterator pos(begin + 1); pos != end; pos++) + for (_IIter __pos(__begin + 1); __pos != __end; __pos++) { - if (comp(*pos, *recent)) + if (__comp(*__pos, *__recent)) { - printf("%ld: %d %d %d %d\n", pos - begin, *(pos - 2), - *(pos- 1), *pos, *(pos + 1)); - ok = false; + printf("%ld: %d %d %d %d\n", __pos - __begin, *(__pos - 2), + *(__pos- 1), *__pos, *(__pos + 1)); + __ok = false; } - recent = pos; + __recent = __pos; } - return ok; + return __ok; } } diff --git a/libstdc++-v3/include/parallel/compatibility.h b/libstdc++-v3/include/parallel/compatibility.h index a5726dd35b32..2dc02a8898c7 100644 --- a/libstdc++-v3/include/parallel/compatibility.h +++ b/libstdc++-v3/include/parallel/compatibility.h @@ -61,24 +61,24 @@ __attribute((dllimport)) void __attribute__((stdcall)) Sleep (unsigned long); namespace __gnu_parallel { #if defined(__ICC) - template - int32 faa32(int32* x, int32 inc) + template + int32 __faa32(int32* __x, int32 __inc) { asm volatile("lock xadd %0,%1" - : "=r" (inc), "=m" (*x) - : "0" (inc) + : "=__r" (__inc), "=__m" (*__x) + : "0" (__inc) : "memory"); - return inc; + return __inc; } #if defined(__x86_64) - template - int64 faa64(int64* x, int64 inc) + template + int64 __faa64(int64* __x, int64 __inc) { asm volatile("lock xadd %0,%1" - : "=r" (inc), "=m" (*x) - : "0" (inc) + : "=__r" (__inc), "=__m" (*__x) + : "0" (__inc) : "memory"); - return inc; + return __inc; } #endif #endif @@ -88,106 +88,106 @@ namespace __gnu_parallel /** @brief Add a value to a variable, atomically. * * Implementation is heavily platform-dependent. - * @param ptr Pointer to a 32-bit signed integer. - * @param addend Value to add. + * @param __ptr Pointer to a 32-bit signed integer. + * @param __addend Value to add. */ inline int32 - fetch_and_add_32(volatile int32* ptr, int32 addend) + __fetch_and_add_32(volatile int32* __ptr, int32 __addend) { #if defined(__ICC) //x86 version - return _InterlockedExchangeAdd((void*)ptr, addend); + return _InterlockedExchangeAdd((void*)__ptr, __addend); #elif defined(__ECC) //IA-64 version - return _InterlockedExchangeAdd((void*)ptr, addend); + return _InterlockedExchangeAdd((void*)__ptr, __addend); #elif defined(__ICL) || defined(_MSC_VER) - return _InterlockedExchangeAdd(reinterpret_cast(ptr), - addend); + return _InterlockedExchangeAdd(reinterpret_cast(__ptr), + __addend); #elif defined(__GNUC__) - return __sync_fetch_and_add(ptr, addend); + return __sync_fetch_and_add(__ptr, __addend); #elif defined(__SUNPRO_CC) && defined(__sparc) - volatile int32 before, after; + volatile int32 __before, __after; do { - before = *ptr; - after = before + addend; - } while (atomic_cas_32((volatile unsigned int*)ptr, before, - after) != before); - return before; + __before = *__ptr; + __after = __before + __addend; + } while (atomic_cas_32((volatile unsigned int*)__ptr, __before, + __after) != __before); + return __before; #else //fallback, slow -#pragma message("slow fetch_and_add_32") - int32 res; +#pragma message("slow __fetch_and_add_32") + int32 __res; #pragma omp critical { - res = *ptr; - *(ptr) += addend; + __res = *__ptr; + *(__ptr) += __addend; } - return res; + return __res; #endif } /** @brief Add a value to a variable, atomically. * * Implementation is heavily platform-dependent. - * @param ptr Pointer to a 64-bit signed integer. - * @param addend Value to add. + * @param __ptr Pointer to a 64-bit signed integer. + * @param __addend Value to add. */ inline int64 - fetch_and_add_64(volatile int64* ptr, int64 addend) + __fetch_and_add_64(volatile int64* __ptr, int64 __addend) { #if defined(__ICC) && defined(__x86_64) //x86 version - return faa64((int64*)ptr, addend); + return __faa64((int64*)__ptr, __addend); #elif defined(__ECC) //IA-64 version - return _InterlockedExchangeAdd64((void*)ptr, addend); + return _InterlockedExchangeAdd64((void*)__ptr, __addend); #elif defined(__ICL) || defined(_MSC_VER) #ifndef _WIN64 _GLIBCXX_PARALLEL_ASSERT(false); //not available in this case return 0; #else - return _InterlockedExchangeAdd64(ptr, addend); + return _InterlockedExchangeAdd64(__ptr, __addend); #endif #elif defined(__GNUC__) && defined(__x86_64) - return __sync_fetch_and_add(ptr, addend); + return __sync_fetch_and_add(__ptr, __addend); #elif defined(__GNUC__) && defined(__i386) && \ (defined(__i686) || defined(__pentium4) || defined(__athlon)) - return __sync_fetch_and_add(ptr, addend); + return __sync_fetch_and_add(__ptr, __addend); #elif defined(__SUNPRO_CC) && defined(__sparc) - volatile int64 before, after; + volatile int64 __before, __after; do { - before = *ptr; - after = before + addend; - } while (atomic_cas_64((volatile unsigned long long*)ptr, before, - after) != before); - return before; + __before = *__ptr; + __after = __before + __addend; + } while (atomic_cas_64((volatile unsigned long long*)__ptr, __before, + __after) != __before); + return __before; #else //fallback, slow #if defined(__GNUC__) && defined(__i386) - // XXX doesn't work with -march=native + // XXX doesn'__t work with -march=native //#warning "please compile with -march=i686 or better" #endif -#pragma message("slow fetch_and_add_64") - int64 res; +#pragma message("slow __fetch_and_add_64") + int64 __res; #pragma omp critical { - res = *ptr; - *(ptr) += addend; + __res = *__ptr; + *(__ptr) += __addend; } - return res; + return __res; #endif } /** @brief Add a value to a variable, atomically. * * Implementation is heavily platform-dependent. - * @param ptr Pointer to a signed integer. - * @param addend Value to add. + * @param __ptr Pointer to a signed integer. + * @param __addend Value to add. */ - template - inline T - fetch_and_add(volatile T* ptr, T addend) + template + inline _Tp + __fetch_and_add(volatile _Tp* __ptr, _Tp __addend) { - if (sizeof(T) == sizeof(int32)) - return (T)fetch_and_add_32((volatile int32*) ptr, (int32)addend); - else if (sizeof(T) == sizeof(int64)) - return (T)fetch_and_add_64((volatile int64*) ptr, (int64)addend); + if (sizeof(_Tp) == sizeof(int32)) + return (_Tp)__fetch_and_add_32((volatile int32*) __ptr, (int32)__addend); + else if (sizeof(_Tp) == sizeof(int64)) + return (_Tp)__fetch_and_add_64((volatile int64*) __ptr, (int64)__addend); else _GLIBCXX_PARALLEL_ASSERT(false); } @@ -195,141 +195,141 @@ namespace __gnu_parallel #if defined(__ICC) - template + template inline int32 - cas32(volatile int32* ptr, int32 old, int32 nw) + __cas32(volatile int32* __ptr, int32 __old, int32 __nw) { - int32 before; + int32 __before; __asm__ __volatile__("lock; cmpxchgl %1,%2" - : "=a"(before) - : "q"(nw), "m"(*(volatile long long*)(ptr)), "0"(old) + : "=a"(__before) + : "q"(__nw), "__m"(*(volatile long long*)(__ptr)), "0"(__old) : "memory"); - return before; + return __before; } #if defined(__x86_64) - template + template inline int64 - cas64(volatile int64 *ptr, int64 old, int64 nw) + __cas64(volatile int64 *__ptr, int64 __old, int64 __nw) { - int64 before; + int64 __before; __asm__ __volatile__("lock; cmpxchgq %1,%2" - : "=a"(before) - : "q"(nw), "m"(*(volatile long long*)(ptr)), "0"(old) + : "=a"(__before) + : "q"(__nw), "__m"(*(volatile long long*)(__ptr)), "0"(__old) : "memory"); - return before; + return __before; } #endif #endif - /** @brief Compare @c *ptr and @c comparand. If equal, let @c - * *ptr=replacement and return @c true, return @c false otherwise. + /** @brief Compare @__c *__ptr and @__c __comparand. If equal, let @__c + * *__ptr=__replacement and return @__c true, return @__c false otherwise. * * Implementation is heavily platform-dependent. - * @param ptr Pointer to 32-bit signed integer. - * @param comparand Compare value. - * @param replacement Replacement value. + * @param __ptr Pointer to 32-bit signed integer. + * @param __comparand Compare value. + * @param __replacement Replacement value. */ inline bool - compare_and_swap_32(volatile int32* ptr, int32 comparand, int32 replacement) + __compare_and_swap_32(volatile int32* __ptr, int32 __comparand, int32 __replacement) { #if defined(__ICC) //x86 version - return _InterlockedCompareExchange((void*)ptr, replacement, - comparand) == comparand; + return _InterlockedCompareExchange((void*)__ptr, __replacement, + __comparand) == __comparand; #elif defined(__ECC) //IA-64 version - return _InterlockedCompareExchange((void*)ptr, replacement, - comparand) == comparand; + return _InterlockedCompareExchange((void*)__ptr, __replacement, + __comparand) == __comparand; #elif defined(__ICL) || defined(_MSC_VER) - return _InterlockedCompareExchange(reinterpret_cast(ptr), - replacement, comparand) == comparand; + return _InterlockedCompareExchange(reinterpret_cast(__ptr), + __replacement, __comparand) == __comparand; #elif defined(__GNUC__) - return __sync_bool_compare_and_swap(ptr, comparand, replacement); + return __sync_bool_compare_and_swap(__ptr, __comparand, __replacement); #elif defined(__SUNPRO_CC) && defined(__sparc) - return atomic_cas_32((volatile unsigned int*)ptr, comparand, - replacement) == comparand; + return atomic_cas_32((volatile unsigned int*)__ptr, __comparand, + __replacement) == __comparand; #else -#pragma message("slow compare_and_swap_32") - bool res = false; +#pragma message("slow __compare_and_swap_32") + bool __res = false; #pragma omp critical { - if (*ptr == comparand) + if (*__ptr == __comparand) { - *ptr = replacement; - res = true; + *__ptr = __replacement; + __res = true; } } - return res; + return __res; #endif } - /** @brief Compare @c *ptr and @c comparand. If equal, let @c - * *ptr=replacement and return @c true, return @c false otherwise. + /** @brief Compare @__c *__ptr and @__c __comparand. If equal, let @__c + * *__ptr=__replacement and return @__c true, return @__c false otherwise. * * Implementation is heavily platform-dependent. - * @param ptr Pointer to 64-bit signed integer. - * @param comparand Compare value. - * @param replacement Replacement value. + * @param __ptr Pointer to 64-bit signed integer. + * @param __comparand Compare value. + * @param __replacement Replacement value. */ inline bool - compare_and_swap_64(volatile int64* ptr, int64 comparand, int64 replacement) + __compare_and_swap_64(volatile int64* __ptr, int64 __comparand, int64 __replacement) { #if defined(__ICC) && defined(__x86_64) //x86 version - return cas64(ptr, comparand, replacement) == comparand; + return __cas64(__ptr, __comparand, __replacement) == __comparand; #elif defined(__ECC) //IA-64 version - return _InterlockedCompareExchange64((void*)ptr, replacement, - comparand) == comparand; + return _InterlockedCompareExchange64((void*)__ptr, __replacement, + __comparand) == __comparand; #elif defined(__ICL) || defined(_MSC_VER) #ifndef _WIN64 _GLIBCXX_PARALLEL_ASSERT(false); //not available in this case return 0; #else - return _InterlockedCompareExchange64(ptr, replacement, - comparand) == comparand; + return _InterlockedCompareExchange64(__ptr, __replacement, + __comparand) == __comparand; #endif #elif defined(__GNUC__) && defined(__x86_64) - return __sync_bool_compare_and_swap(ptr, comparand, replacement); + return __sync_bool_compare_and_swap(__ptr, __comparand, __replacement); #elif defined(__GNUC__) && defined(__i386) && \ (defined(__i686) || defined(__pentium4) || defined(__athlon)) - return __sync_bool_compare_and_swap(ptr, comparand, replacement); + return __sync_bool_compare_and_swap(__ptr, __comparand, __replacement); #elif defined(__SUNPRO_CC) && defined(__sparc) - return atomic_cas_64((volatile unsigned long long*)ptr, - comparand, replacement) == comparand; + return atomic_cas_64((volatile unsigned long long*)__ptr, + __comparand, __replacement) == __comparand; #else #if defined(__GNUC__) && defined(__i386) // XXX -march=native //#warning "please compile with -march=i686 or better" #endif -#pragma message("slow compare_and_swap_64") - bool res = false; +#pragma message("slow __compare_and_swap_64") + bool __res = false; #pragma omp critical { - if (*ptr == comparand) + if (*__ptr == __comparand) { - *ptr = replacement; - res = true; + *__ptr = __replacement; + __res = true; } } - return res; + return __res; #endif } - /** @brief Compare @c *ptr and @c comparand. If equal, let @c - * *ptr=replacement and return @c true, return @c false otherwise. + /** @brief Compare @__c *__ptr and @__c __comparand. If equal, let @__c + * *__ptr=__replacement and return @__c true, return @__c false otherwise. * * Implementation is heavily platform-dependent. - * @param ptr Pointer to signed integer. - * @param comparand Compare value. - * @param replacement Replacement value. */ - template + * @param __ptr Pointer to signed integer. + * @param __comparand Compare value. + * @param __replacement Replacement value. */ + template inline bool - compare_and_swap(volatile T* ptr, T comparand, T replacement) + __compare_and_swap(volatile _Tp* __ptr, _Tp __comparand, _Tp __replacement) { - if (sizeof(T) == sizeof(int32)) - return compare_and_swap_32((volatile int32*) ptr, (int32)comparand, (int32)replacement); - else if (sizeof(T) == sizeof(int64)) - return compare_and_swap_64((volatile int64*) ptr, (int64)comparand, (int64)replacement); + if (sizeof(_Tp) == sizeof(int32)) + return __compare_and_swap_32((volatile int32*) __ptr, (int32)__comparand, (int32)__replacement); + else if (sizeof(_Tp) == sizeof(int64)) + return __compare_and_swap_64((volatile int64*) __ptr, (int64)__comparand, (int64)__replacement); else _GLIBCXX_PARALLEL_ASSERT(false); } @@ -337,7 +337,7 @@ namespace __gnu_parallel /** @brief Yield the control to another thread, without waiting for the end to the time slice. */ inline void - yield() + __yield() { #if defined (_WIN32) && !defined (__CYGWIN__) Sleep(0); diff --git a/libstdc++-v3/include/parallel/compiletime_settings.h b/libstdc++-v3/include/parallel/compiletime_settings.h index e7e31d068cb2..e375a94a9da9 100644 --- a/libstdc++-v3/include/parallel/compiletime_settings.h +++ b/libstdc++-v3/include/parallel/compiletime_settings.h @@ -38,15 +38,15 @@ /** @def _GLIBCXX_CALL * @brief Macro to produce log message when entering a function. - * @param n Input size. + * @param __n Input size. * @see _GLIBCXX_VERBOSE_LEVEL */ #if (_GLIBCXX_VERBOSE_LEVEL == 0) -#define _GLIBCXX_CALL(n) +#define _GLIBCXX_CALL(__n) #endif #if (_GLIBCXX_VERBOSE_LEVEL == 1) -#define _GLIBCXX_CALL(n) \ - printf(" %s:\niam = %d, n = %ld, num_threads = %d\n", \ - __PRETTY_FUNCTION__, omp_get_thread_num(), (n), get_max_threads()); +#define _GLIBCXX_CALL(__n) \ + printf(" %__s:\niam = %d, __n = %ld, __num_threads = %d\n", \ + __PRETTY_FUNCTION__, omp_get_thread_num(), (__n), __get_max_threads()); #endif #ifndef _GLIBCXX_SCALE_DOWN_FPU @@ -64,12 +64,12 @@ #ifndef _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1 /** @brief Switch on many _GLIBCXX_PARALLEL_ASSERTions in parallel code. * Consider the size of the L1 cache for - * __gnu_parallel::parallel_random_shuffle(). */ +* gnu_parallel::__parallel_random_shuffle(). */ #define _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1 0 #endif #ifndef _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB /** @brief Switch on many _GLIBCXX_PARALLEL_ASSERTions in parallel code. * Consider the size of the TLB for - * __gnu_parallel::parallel_random_shuffle(). */ +* gnu_parallel::__parallel_random_shuffle(). */ #define _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB 0 #endif diff --git a/libstdc++-v3/include/parallel/equally_split.h b/libstdc++-v3/include/parallel/equally_split.h index ee4bfeeeb0ee..11672c4579ac 100644 --- a/libstdc++-v3/include/parallel/equally_split.h +++ b/libstdc++-v3/include/parallel/equally_split.h @@ -33,54 +33,54 @@ namespace __gnu_parallel { -/** @brief Function to split a sequence into parts of almost equal size. +/** @brief function to split a sequence into parts of almost equal size. * - * The resulting sequence s of length num_threads+1 contains the splitting - * positions when splitting the range [0,n) into parts of almost + * The resulting sequence __s of length __num_threads+1 contains the splitting + * positions when splitting the range [0,__n) into parts of almost * equal size (plus minus 1). The first entry is 0, the last one - * n. There may result empty parts. - * @param n Number of elements - * @param num_threads Number of parts - * @param s Splitters - * @returns End of splitter sequence, i. e. @c s+num_threads+1 */ -template - OutputIterator - equally_split(difference_type n, thread_index_t num_threads, OutputIterator s) +* n. There may result empty parts. + * @param __n Number of elements + * @param __num_threads Number of parts + * @param __s Splitters + * @returns End of splitter sequence, i.e. @__c __s+__num_threads+1 */ +template + _OutputIterator + equally_split(_DifferenceType __n, _ThreadIndex __num_threads, _OutputIterator __s) { - difference_type chunk_length = n / num_threads; - difference_type num_longer_chunks = n % num_threads; - difference_type pos = 0; - for (thread_index_t i = 0; i < num_threads; ++i) + _DifferenceType __chunk_length = __n / __num_threads; + _DifferenceType __num_longer_chunks = __n % __num_threads; + _DifferenceType __pos = 0; + for (_ThreadIndex __i = 0; __i < __num_threads; ++__i) { - *s++ = pos; - pos += (i < num_longer_chunks) ? (chunk_length + 1) : chunk_length; + *__s++ = __pos; + __pos += (__i < __num_longer_chunks) ? (__chunk_length + 1) : __chunk_length; } - *s++ = n; - return s; + *__s++ = __n; + return __s; } -/** @brief Function to split a sequence into parts of almost equal size. +/** @brief function to split a sequence into parts of almost equal size. * * Returns the position of the splitting point between - * thread number thread_no (included) and - * thread number thread_no+1 (excluded). - * @param n Number of elements - * @param num_threads Number of parts - * @returns _SplittingAlgorithm point */ -template - difference_type - equally_split_point(difference_type n, - thread_index_t num_threads, - thread_index_t thread_no) + * thread number __thread_no (included) and + * thread number __thread_no+1 (excluded). + * @param __n Number of elements + * @param __num_threads Number of parts + * @returns splitting point */ +template + _DifferenceType + equally_split_point(_DifferenceType __n, + _ThreadIndex __num_threads, + _ThreadIndex __thread_no) { - difference_type chunk_length = n / num_threads; - difference_type num_longer_chunks = n % num_threads; - if (thread_no < num_longer_chunks) - return thread_no * (chunk_length + 1); + _DifferenceType __chunk_length = __n / __num_threads; + _DifferenceType __num_longer_chunks = __n % __num_threads; + if (__thread_no < __num_longer_chunks) + return __thread_no * (__chunk_length + 1); else - return num_longer_chunks * (chunk_length + 1) - + (thread_no - num_longer_chunks) * chunk_length; + return __num_longer_chunks * (__chunk_length + 1) + + (__thread_no - __num_longer_chunks) * __chunk_length; } } diff --git a/libstdc++-v3/include/parallel/features.h b/libstdc++-v3/include/parallel/features.h index 417606ea7ac3..077429f1688f 100644 --- a/libstdc++-v3/include/parallel/features.h +++ b/libstdc++-v3/include/parallel/features.h @@ -78,7 +78,7 @@ #ifndef _GLIBCXX_TREE_INITIAL_SPLITTING /** @def _GLIBCXX_TREE_INITIAL_SPLITTING * @brief Include the initial splitting variant for - * _Rb_tree::insert_unique(InputIterator beg, InputIterator end). + * _Rb_tree::insert_unique(_IIter beg, _IIter __end). * @see __gnu_parallel::_Rb_tree */ #define _GLIBCXX_TREE_INITIAL_SPLITTING 1 #endif @@ -86,7 +86,7 @@ #ifndef _GLIBCXX_TREE_DYNAMIC_BALANCING /** @def _GLIBCXX_TREE_DYNAMIC_BALANCING * @brief Include the dynamic balancing variant for - * _Rb_tree::insert_unique(InputIterator beg, InputIterator end). + * _Rb_tree::insert_unique(_IIter beg, _IIter __end). * @see __gnu_parallel::_Rb_tree */ #define _GLIBCXX_TREE_DYNAMIC_BALANCING 1 #endif @@ -94,7 +94,7 @@ #ifndef _GLIBCXX_TREE_FULL_COPY /** @def _GLIBCXX_TREE_FULL_COPY * @brief In order to sort the input sequence of - * _Rb_tree::insert_unique(InputIterator beg, InputIterator end) a + * _Rb_tree::insert_unique(_IIter beg, _IIter __end) a * full copy of the input elements is done. * @see __gnu_parallel::_Rb_tree */ #define _GLIBCXX_TREE_FULL_COPY 1 diff --git a/libstdc++-v3/include/parallel/find.h b/libstdc++-v3/include/parallel/find.h index 0597cc58ec6e..da442f90e0a5 100644 --- a/libstdc++-v3/include/parallel/find.h +++ b/libstdc++-v3/include/parallel/find.h @@ -23,7 +23,7 @@ // . /** @file parallel/find.h - * @brief Parallel implementation base for std::find(), std::equal() + * @brief Parallel implementation __base for std::find(), std::equal() * and related functions. * This file is a GNU parallel extension to the Standard C++ Library. */ @@ -44,36 +44,36 @@ namespace __gnu_parallel { /** * @brief Parallel std::find, switch for different algorithms. - * @param begin1 Begin iterator of first sequence. - * @param end1 End iterator of first sequence. - * @param begin2 Begin iterator of second sequence. Must have same + * @param __begin1 Begin iterator of first sequence. + * @param __end1 End iterator of first sequence. + * @param __begin2 Begin iterator of second sequence. Must have same * length as first sequence. - * @param pred Find predicate. - * @param selector Functionality (e. g. std::find_if (), std::equal(),...) + * @param __pred Find predicate. + * @param __selector _Functionality (e. g. std::find_if (), std::equal(),...) * @return Place of finding in both sequences. */ -template - inline std::pair - find_template(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, Pred pred, Selector selector) +template + inline std::pair<_RAIter1, _RAIter2> + __find_template(_RAIter1 __begin1, _RAIter1 __end1, + _RAIter2 __begin2, _Pred __pred, _Selector __selector) { switch (_Settings::get().find_algorithm) { case GROWING_BLOCKS: - return find_template(begin1, end1, begin2, pred, selector, + return __find_template(__begin1, __end1, __begin2, __pred, __selector, growing_blocks_tag()); case CONSTANT_SIZE_BLOCKS: - return find_template(begin1, end1, begin2, pred, selector, + return __find_template(__begin1, __end1, __begin2, __pred, __selector, constant_size_blocks_tag()); case EQUAL_SPLIT: - return find_template(begin1, end1, begin2, pred, selector, + return __find_template(__begin1, __end1, __begin2, __pred, __selector, equal_split_tag()); default: _GLIBCXX_PARALLEL_ASSERT(false); - return std::make_pair(begin1, begin2); + return std::make_pair(__begin1, __begin2); } } @@ -81,80 +81,80 @@ template - std::pair - find_template(RandomAccessIterator1 begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, - Pred pred, - Selector selector, +template + std::pair<_RAIter1, _RAIter2> + __find_template(_RAIter1 __begin1, + _RAIter1 __end1, + _RAIter2 __begin2, + _Pred __pred, + _Selector __selector, equal_split_tag) { - _GLIBCXX_CALL(end1 - begin1) + _GLIBCXX_CALL(__end1 - __begin1) - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; - typedef typename traits_type::value_type value_type; + typedef std::iterator_traits<_RAIter1> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; + typedef typename _TraitsType::value_type _ValueType; - difference_type length = end1 - begin1; - difference_type result = length; - difference_type* borders; + _DifferenceType __length = __end1 - __begin1; + _DifferenceType __result = __length; + _DifferenceType* __borders; - omp_lock_t result_lock; - omp_init_lock(&result_lock); + omp_lock_t __result_lock; + omp_init_lock(&__result_lock); - thread_index_t num_threads = get_max_threads(); -# pragma omp parallel num_threads(num_threads) + _ThreadIndex __num_threads = __get_max_threads(); +# pragma omp parallel num_threads(__num_threads) { # pragma omp single { - num_threads = omp_get_num_threads(); - borders = new difference_type[num_threads + 1]; - equally_split(length, num_threads, borders); + __num_threads = omp_get_num_threads(); + __borders = new _DifferenceType[__num_threads + 1]; + equally_split(__length, __num_threads, __borders); } //single - thread_index_t iam = omp_get_thread_num(); - difference_type start = borders[iam], stop = borders[iam + 1]; + _ThreadIndex __iam = omp_get_thread_num(); + _DifferenceType __start = __borders[__iam], __stop = __borders[__iam + 1]; - RandomAccessIterator1 i1 = begin1 + start; - RandomAccessIterator2 i2 = begin2 + start; - for (difference_type pos = start; pos < stop; ++pos) + _RAIter1 __i1 = __begin1 + __start; + _RAIter2 __i2 = __begin2 + __start; + for (_DifferenceType __pos = __start; __pos < __stop; ++__pos) { - #pragma omp flush(result) + #pragma omp flush(__result) // Result has been set to something lower. - if (result < pos) + if (__result < __pos) break; - if (selector(i1, i2, pred)) + if (__selector(__i1, __i2, __pred)) { - omp_set_lock(&result_lock); - if (pos < result) - result = pos; - omp_unset_lock(&result_lock); + omp_set_lock(&__result_lock); + if (__pos < __result) + __result = __pos; + omp_unset_lock(&__result_lock); break; } - ++i1; - ++i2; + ++__i1; + ++__i2; } } //parallel - omp_destroy_lock(&result_lock); - delete[] borders; + omp_destroy_lock(&__result_lock); + delete[] __borders; return - std::pair(begin1 + result, - begin2 + result); + std::pair<_RAIter1, _RAIter2>(__begin1 + __result, + __begin2 + __result); } #endif @@ -163,12 +163,12 @@ template - std::pair - find_template(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, Pred pred, Selector selector, +template + std::pair<_RAIter1, _RAIter2> + __find_template(_RAIter1 __begin1, _RAIter1 __end1, + _RAIter2 __begin2, _Pred __pred, _Selector __selector, growing_blocks_tag) { - _GLIBCXX_CALL(end1 - begin1) + _GLIBCXX_CALL(__end1 - __begin1) - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; - typedef typename traits_type::value_type value_type; + typedef std::iterator_traits<_RAIter1> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; + typedef typename _TraitsType::value_type _ValueType; const _Settings& __s = _Settings::get(); - difference_type length = end1 - begin1; + _DifferenceType __length = __end1 - __begin1; - difference_type sequential_search_size = - std::min(length, __s.find_sequential_search_size); + _DifferenceType __sequential_search_size = + std::min<_DifferenceType>(__length, __s.find_sequential_search_size); // Try it sequentially first. - std::pair find_seq_result = - selector.sequential_algorithm( - begin1, begin1 + sequential_search_size, begin2, pred); + std::pair<_RAIter1, _RAIter2> __find_seq_result = + __selector._M_sequential_algorithm( + __begin1, __begin1 + __sequential_search_size, __begin2, __pred); - if (find_seq_result.first != (begin1 + sequential_search_size)) - return find_seq_result; + if (__find_seq_result.first != (__begin1 + __sequential_search_size)) + return __find_seq_result; // Index of beginning of next free block (after sequential find). - difference_type next_block_start = sequential_search_size; - difference_type result = length; + _DifferenceType __next_block_start = __sequential_search_size; + _DifferenceType __result = __length; - omp_lock_t result_lock; - omp_init_lock(&result_lock); + omp_lock_t __result_lock; + omp_init_lock(&__result_lock); - thread_index_t num_threads = get_max_threads(); -# pragma omp parallel shared(result) num_threads(num_threads) + _ThreadIndex __num_threads = __get_max_threads(); +# pragma omp parallel shared(__result) num_threads(__num_threads) { # pragma omp single - num_threads = omp_get_num_threads(); + __num_threads = omp_get_num_threads(); - // Not within first k elements -> start parallel. - thread_index_t iam = omp_get_thread_num(); + // Not within first __k __elements -> start parallel. + _ThreadIndex __iam = omp_get_thread_num(); - difference_type block_size = __s.find_initial_block_size; - difference_type start = - fetch_and_add(&next_block_start, block_size); + _DifferenceType __block_size = __s.find_initial_block_size; + _DifferenceType __start = + __fetch_and_add<_DifferenceType>(&__next_block_start, __block_size); // Get new block, update pointer to next block. - difference_type stop = - std::min(length, start + block_size); + _DifferenceType __stop = + std::min<_DifferenceType>(__length, __start + __block_size); - std::pair local_result; + std::pair<_RAIter1, _RAIter2> __local_result; - while (start < length) + while (__start < __length) { -# pragma omp flush(result) +# pragma omp flush(__result) // Get new value of result. - if (result < start) + if (__result < __start) { // No chance to find first element. break; } - local_result = selector.sequential_algorithm( - begin1 + start, begin1 + stop, begin2 + start, pred); - if (local_result.first != (begin1 + stop)) + __local_result = __selector._M_sequential_algorithm( + __begin1 + __start, __begin1 + __stop, __begin2 + __start, __pred); + if (__local_result.first != (__begin1 + __stop)) { - omp_set_lock(&result_lock); - if ((local_result.first - begin1) < result) + omp_set_lock(&__result_lock); + if ((__local_result.first - __begin1) < __result) { - result = local_result.first - begin1; + __result = __local_result.first - __begin1; // Result cannot be in future blocks, stop algorithm. - fetch_and_add(&next_block_start, length); + __fetch_and_add<_DifferenceType>(&__next_block_start, __length); } - omp_unset_lock(&result_lock); + omp_unset_lock(&__result_lock); } - block_size = - std::min(block_size * __s.find_increasing_factor, + __block_size = + std::min<_DifferenceType>(__block_size * __s.find_increasing_factor, __s.find_maximum_block_size); // Get new block, update pointer to next block. - start = - fetch_and_add(&next_block_start, block_size); - stop = ((length < (start + block_size)) - ? length : (start + block_size)); + __start = + __fetch_and_add<_DifferenceType>(&__next_block_start, __block_size); + __stop = ((__length < (__start + __block_size)) + ? __length : (__start + __block_size)); } } //parallel - omp_destroy_lock(&result_lock); + omp_destroy_lock(&__result_lock); // Return iterator on found element. return - std::pair(begin1 + result, - begin2 + result); + std::pair<_RAIter1, _RAIter2>(__begin1 + __result, + __begin2 + __result); } #endif @@ -290,12 +290,12 @@ template - std::pair - find_template(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, Pred pred, Selector selector, +template + std::pair<_RAIter1, _RAIter2> + __find_template(_RAIter1 __begin1, _RAIter1 __end1, + _RAIter2 __begin2, _Pred __pred, _Selector __selector, constant_size_blocks_tag) { - _GLIBCXX_CALL(end1 - begin1) - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; - typedef typename traits_type::value_type value_type; + _GLIBCXX_CALL(__end1 - __begin1) + typedef std::iterator_traits<_RAIter1> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; + typedef typename _TraitsType::value_type _ValueType; const _Settings& __s = _Settings::get(); - difference_type length = end1 - begin1; + _DifferenceType __length = __end1 - __begin1; - difference_type sequential_search_size = std::min( - length, __s.find_sequential_search_size); + _DifferenceType __sequential_search_size = std::min<_DifferenceType>( + __length, __s.find_sequential_search_size); // Try it sequentially first. - std::pair find_seq_result = - selector.sequential_algorithm(begin1, begin1 + sequential_search_size, - begin2, pred); + std::pair<_RAIter1, _RAIter2> __find_seq_result = + __selector._M_sequential_algorithm(__begin1, __begin1 + __sequential_search_size, + __begin2, __pred); - if (find_seq_result.first != (begin1 + sequential_search_size)) - return find_seq_result; + if (__find_seq_result.first != (__begin1 + __sequential_search_size)) + return __find_seq_result; - difference_type result = length; - omp_lock_t result_lock; - omp_init_lock(&result_lock); + _DifferenceType __result = __length; + omp_lock_t __result_lock; + omp_init_lock(&__result_lock); - // Not within first sequential_search_size elements -> start parallel. + // Not within first __sequential_search_size elements -> start parallel. - thread_index_t num_threads = get_max_threads(); -# pragma omp parallel shared(result) num_threads(num_threads) + _ThreadIndex __num_threads = __get_max_threads(); +# pragma omp parallel shared(__result) num_threads(__num_threads) { # pragma omp single - num_threads = omp_get_num_threads(); + __num_threads = omp_get_num_threads(); - thread_index_t iam = omp_get_thread_num(); - difference_type block_size = __s.find_initial_block_size; + _ThreadIndex __iam = omp_get_thread_num(); + _DifferenceType __block_size = __s.find_initial_block_size; // First element of thread's current iteration. - difference_type iteration_start = sequential_search_size; + _DifferenceType __iteration_start = __sequential_search_size; // Where to work (initialization). - difference_type start = iteration_start + iam * block_size; - difference_type stop = - std::min(length, start + block_size); + _DifferenceType __start = __iteration_start + __iam * __block_size; + _DifferenceType __stop = + std::min<_DifferenceType>(__length, __start + __block_size); - std::pair local_result; + std::pair<_RAIter1, _RAIter2> __local_result; - while (start < length) + while (__start < __length) { // Get new value of result. -# pragma omp flush(result) +# pragma omp flush(__result) // No chance to find first element. - if (result < start) + if (__result < __start) break; - local_result = selector.sequential_algorithm( - begin1 + start, begin1 + stop, - begin2 + start, pred); - if (local_result.first != (begin1 + stop)) + __local_result = __selector._M_sequential_algorithm( + __begin1 + __start, __begin1 + __stop, + __begin2 + __start, __pred); + if (__local_result.first != (__begin1 + __stop)) { - omp_set_lock(&result_lock); - if ((local_result.first - begin1) < result) - result = local_result.first - begin1; - omp_unset_lock(&result_lock); + omp_set_lock(&__result_lock); + if ((__local_result.first - __begin1) < __result) + __result = __local_result.first - __begin1; + omp_unset_lock(&__result_lock); // Will not find better value in its interval. break; } - iteration_start += num_threads * block_size; + __iteration_start += __num_threads * __block_size; // Where to work. - start = iteration_start + iam * block_size; - stop = std::min(length, start + block_size); + __start = __iteration_start + __iam * __block_size; + __stop = std::min<_DifferenceType>(__length, __start + __block_size); } } //parallel - omp_destroy_lock(&result_lock); + omp_destroy_lock(&__result_lock); // Return iterator on found element. return - std::pair(begin1 + result, - begin2 + result); + std::pair<_RAIter1, _RAIter2>(__begin1 + __result, + __begin2 + __result); } #endif } // end namespace diff --git a/libstdc++-v3/include/parallel/find_selectors.h b/libstdc++-v3/include/parallel/find_selectors.h index 3cbc1b80ef8c..8f6db75cb6c9 100644 --- a/libstdc++-v3/include/parallel/find_selectors.h +++ b/libstdc++-v3/include/parallel/find_selectors.h @@ -23,7 +23,7 @@ // . /** @file parallel/find_selectors.h - * @brief Function objects representing different tasks to be plugged + * @brief _Function objects representing different tasks to be plugged * into the parallel find algorithm. * This file is a GNU parallel extension to the Standard C++ Library. */ @@ -39,153 +39,153 @@ namespace __gnu_parallel { - /** @brief Base class of all __gnu_parallel::find_template selectors. */ - struct generic_find_selector + /** @brief Base class of all __gnu_parallel::__find_template selectors. */ + struct __generic_find_selector { }; /** * @brief Test predicate on a single element, used for std::find() * and std::find_if (). */ - struct find_if_selector : public generic_find_selector + struct __find_if_selector : public __generic_find_selector { - /** @brief Test on one position. - * @param i1 Iterator on first sequence. - * @param i2 Iterator on second sequence (unused). - * @param pred Find predicate. + /** @brief Test on one __position. + * @param __i1 _Iterator on first sequence. + * @param __i2 _Iterator on second sequence (unused). + * @param __pred Find predicate. */ - template + template bool - operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred) - { return pred(*i1); } + operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred) + { return __pred(*__i1); } /** @brief Corresponding sequential algorithm on a sequence. - * @param begin1 Begin iterator of first sequence. - * @param end1 End iterator of first sequence. - * @param begin2 Begin iterator of second sequence. - * @param pred Find predicate. + * @param __begin1 Begin iterator of first sequence. + * @param __end1 End iterator of first sequence. + * @param __begin2 Begin iterator of second sequence. + * @param __pred Find predicate. */ - template - std::pair - sequential_algorithm(RandomAccessIterator1 begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, Pred pred) - { return std::make_pair(find_if(begin1, end1, pred, - sequential_tag()), begin2); } + template + std::pair<_RAIter1, _RAIter2> + _M_sequential_algorithm(_RAIter1 __begin1, + _RAIter1 __end1, + _RAIter2 __begin2, _Pred __pred) + { return std::make_pair(find_if(__begin1, __end1, __pred, + sequential_tag()), __begin2); } }; - /** @brief Test predicate on two adjacent elements. */ - struct adjacent_find_selector : public generic_find_selector + /** @brief Test predicate on two adjacent __elements. */ + struct __adjacent_find_selector : public __generic_find_selector { - /** @brief Test on one position. - * @param i1 Iterator on first sequence. - * @param i2 Iterator on second sequence (unused). - * @param pred Find predicate. + /** @brief Test on one __position. + * @param __i1 _Iterator on first sequence. + * @param __i2 _Iterator on second sequence (unused). + * @param __pred Find predicate. */ - template + template bool - operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred) + operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred) { // Passed end iterator is one short. - return pred(*i1, *(i1 + 1)); + return __pred(*__i1, *(__i1 + 1)); } /** @brief Corresponding sequential algorithm on a sequence. - * @param begin1 Begin iterator of first sequence. - * @param end1 End iterator of first sequence. - * @param begin2 Begin iterator of second sequence. - * @param pred Find predicate. + * @param __begin1 Begin iterator of first sequence. + * @param __end1 End iterator of first sequence. + * @param __begin2 Begin iterator of second sequence. + * @param __pred Find predicate. */ - template - std::pair - sequential_algorithm(RandomAccessIterator1 begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, Pred pred) + template + std::pair<_RAIter1, _RAIter2> + _M_sequential_algorithm(_RAIter1 __begin1, + _RAIter1 __end1, + _RAIter2 __begin2, _Pred __pred) { // Passed end iterator is one short. - RandomAccessIterator1 spot = adjacent_find(begin1, end1 + 1, - pred, sequential_tag()); - if (spot == (end1 + 1)) - spot = end1; - return std::make_pair(spot, begin2); + _RAIter1 spot = adjacent_find(__begin1, __end1 + 1, + __pred, sequential_tag()); + if (spot == (__end1 + 1)) + spot = __end1; + return std::make_pair(spot, __begin2); } }; /** @brief Test inverted predicate on a single element. */ - struct mismatch_selector : public generic_find_selector + struct __mismatch_selector : public __generic_find_selector { /** - * @brief Test on one position. - * @param i1 Iterator on first sequence. - * @param i2 Iterator on second sequence (unused). - * @param pred Find predicate. + * @brief Test on one __position. + * @param __i1 _Iterator on first sequence. + * @param __i2 _Iterator on second sequence (unused). + * @param __pred Find predicate. */ - template + template bool - operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred) - { return !pred(*i1, *i2); } + operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred) + { return !__pred(*__i1, *__i2); } /** * @brief Corresponding sequential algorithm on a sequence. - * @param begin1 Begin iterator of first sequence. - * @param end1 End iterator of first sequence. - * @param begin2 Begin iterator of second sequence. - * @param pred Find predicate. + * @param __begin1 Begin iterator of first sequence. + * @param __end1 End iterator of first sequence. + * @param __begin2 Begin iterator of second sequence. + * @param __pred Find predicate. */ - template - std::pair - sequential_algorithm(RandomAccessIterator1 begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, Pred pred) - { return mismatch(begin1, end1, begin2, pred, sequential_tag()); } + template + std::pair<_RAIter1, _RAIter2> + _M_sequential_algorithm(_RAIter1 __begin1, + _RAIter1 __end1, + _RAIter2 __begin2, _Pred __pred) + { return mismatch(__begin1, __end1, __begin2, __pred, sequential_tag()); } }; - /** @brief Test predicate on several elements. */ - template - struct find_first_of_selector : public generic_find_selector + /** @brief Test predicate on several __elements. */ + template + struct __find_first_of_selector : public __generic_find_selector { - ForwardIterator begin; - ForwardIterator end; - - explicit find_first_of_selector(ForwardIterator begin, ForwardIterator end) - : begin(begin), end(end) { } - - /** @brief Test on one position. - * @param i1 Iterator on first sequence. - * @param i2 Iterator on second sequence (unused). - * @param pred Find predicate. */ - template + _ForwardIterator __begin; + _ForwardIterator __end; + + explicit __find_first_of_selector(_ForwardIterator __begin, _ForwardIterator __end) + : __begin(__begin), __end(__end) { } + + /** @brief Test on one __position. + * @param __i1 _Iterator on first sequence. + * @param __i2 _Iterator on second sequence (unused). + * @param __pred Find predicate. */ + template bool - operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred) + operator()(_RAIter1 __i1, _RAIter2 __i2, _Pred __pred) { - for (ForwardIterator pos_in_candidates = begin; - pos_in_candidates != end; ++pos_in_candidates) - if (pred(*i1, *pos_in_candidates)) + for (_ForwardIterator __pos_in_candidates = __begin; + __pos_in_candidates != __end; ++__pos_in_candidates) + if (__pred(*__i1, *__pos_in_candidates)) return true; return false; } /** @brief Corresponding sequential algorithm on a sequence. - * @param begin1 Begin iterator of first sequence. - * @param end1 End iterator of first sequence. - * @param begin2 Begin iterator of second sequence. - * @param pred Find predicate. */ - template - std::pair - sequential_algorithm(RandomAccessIterator1 begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2 begin2, Pred pred) - { return std::make_pair(find_first_of(begin1, end1, begin, end, pred, - sequential_tag()), begin2); } + * @param __begin1 Begin iterator of first sequence. + * @param __end1 End iterator of first sequence. + * @param __begin2 Begin iterator of second sequence. + * @param __pred Find predicate. */ + template + std::pair<_RAIter1, _RAIter2> + _M_sequential_algorithm(_RAIter1 __begin1, + _RAIter1 __end1, + _RAIter2 __begin2, _Pred __pred) + { return std::make_pair(find_first_of(__begin1, __end1, __begin, __end, __pred, + sequential_tag()), __begin2); } }; } diff --git a/libstdc++-v3/include/parallel/for_each.h b/libstdc++-v3/include/parallel/for_each.h index 61158f86582e..77162ed07c63 100644 --- a/libstdc++-v3/include/parallel/for_each.h +++ b/libstdc++-v3/include/parallel/for_each.h @@ -42,55 +42,55 @@ namespace __gnu_parallel { - /** @brief Chose the desired algorithm by evaluating @c parallelism_tag. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param user_op A user-specified functor (comparator, predicate, + /** @brief Chose the desired algorithm by evaluating @__c __parallelism_tag. + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __user_op A user-specified functor (comparator, predicate, * associative operator,...) - * @param functionality functor to "process" an element with - * user_op (depends on desired functionality, e. g. accumulate, + * @param __functionality functor to "process" an element with + * __user_op (depends on desired functionality, e. g. accumulate, * for_each,... - * @param reduction Reduction functor. - * @param reduction_start Initial value for reduction. - * @param output Output iterator. - * @param bound Maximum number of elements processed. - * @param parallelism_tag Parallelization method */ - template - UserOp - for_each_template_random_access(InputIterator begin, InputIterator end, - UserOp user_op, - Functionality& functionality, - Red reduction, Result reduction_start, - Result& output, typename - std::iterator_traits:: - difference_type bound, - _Parallelism parallelism_tag) + * @param __reduction Reduction functor. + * @param __reduction_start Initial value for reduction. + * @param __output Output iterator. + * @param __bound Maximum number of elements processed. + * @param __parallelism_tag Parallelization method */ + template + _UserOp + __for_each_template_random_access(_IIter __begin, _IIter __end, + _UserOp __user_op, + _Functionality& __functionality, + _Red __reduction, _Result __reduction_start, + _Result& __output, typename + std::iterator_traits<_IIter>:: + difference_type __bound, + _Parallelism __parallelism_tag) { - if (parallelism_tag == parallel_unbalanced) - return for_each_template_random_access_ed(begin, end, user_op, - functionality, reduction, - reduction_start, - output, bound); - else if (parallelism_tag == parallel_omp_loop) - return for_each_template_random_access_omp_loop(begin, end, user_op, - functionality, - reduction, - reduction_start, - output, bound); - else if (parallelism_tag == parallel_omp_loop_static) - return for_each_template_random_access_omp_loop(begin, end, user_op, - functionality, - reduction, - reduction_start, - output, bound); + if (__parallelism_tag == parallel_unbalanced) + return for_each_template_random_access_ed(__begin, __end, __user_op, + __functionality, __reduction, + __reduction_start, + __output, __bound); + else if (__parallelism_tag == parallel_omp_loop) + return for_each_template_random_access_omp_loop(__begin, __end, __user_op, + __functionality, + __reduction, + __reduction_start, + __output, __bound); + else if (__parallelism_tag == parallel_omp_loop_static) + return for_each_template_random_access_omp_loop(__begin, __end, __user_op, + __functionality, + __reduction, + __reduction_start, + __output, __bound); else //e. g. parallel_balanced - return for_each_template_random_access_workstealing(begin, end, - user_op, - functionality, - reduction, - reduction_start, - output, bound); + return for_each_template_random_access_workstealing(__begin, __end, + __user_op, + __functionality, + __reduction, + __reduction_start, + __output, __bound); } } diff --git a/libstdc++-v3/include/parallel/for_each_selectors.h b/libstdc++-v3/include/parallel/for_each_selectors.h index b46d30f51f23..ed8728dc340f 100644 --- a/libstdc++-v3/include/parallel/for_each_selectors.h +++ b/libstdc++-v3/include/parallel/for_each_selectors.h @@ -38,192 +38,192 @@ namespace __gnu_parallel { - /** @brief Generic selector for embarrassingly parallel functions. */ - template - struct generic_for_each_selector + /** @brief Generic __selector for embarrassingly parallel functions. */ + template + struct __generic_for_each_selector { - /** @brief Iterator on last element processed; needed for some + /** @brief _Iterator on last element processed; needed for some * algorithms (e. g. std::transform()). */ - It finish_iterator; + _It finish_iterator; }; /** @brief std::for_each() selector. */ - template - struct for_each_selector : public generic_for_each_selector + template + struct __for_each_selector : public __generic_for_each_selector<_It> { /** @brief Functor execution. - * @param o Operator. - * @param i Iterator referencing object. */ - template + * @param __o Operator. + * @param __i iterator referencing object. */ + template bool - operator()(Op& o, It i) + operator()(_Op& __o, _It __i) { - o(*i); + __o(*__i); return true; } }; /** @brief std::generate() selector. */ - template - struct generate_selector : public generic_for_each_selector + template + struct __generate_selector : public __generic_for_each_selector<_It> { /** @brief Functor execution. - * @param o Operator. - * @param i Iterator referencing object. */ - template + * @param __o Operator. + * @param __i iterator referencing object. */ + template bool - operator()(Op& o, It i) + operator()(_Op& __o, _It __i) { - *i = o(); + *__i = __o(); return true; } }; /** @brief std::fill() selector. */ - template - struct fill_selector : public generic_for_each_selector + template + struct __fill_selector : public __generic_for_each_selector<_It> { /** @brief Functor execution. - * @param v Current value. - * @param i Iterator referencing object. */ + * @param __v Current value. + * @param __i iterator referencing object. */ template bool - operator()(Val& v, It i) + operator()(Val& __v, _It __i) { - *i = v; + *__i = __v; return true; } }; - /** @brief std::transform() selector, one input sequence variant. */ - template - struct transform1_selector : public generic_for_each_selector + /** @brief std::transform() __selector, one input sequence variant. */ + template + struct __transform1_selector : public __generic_for_each_selector<_It> { /** @brief Functor execution. - * @param o Operator. - * @param i Iterator referencing object. */ - template + * @param __o Operator. + * @param __i iterator referencing object. */ + template bool - operator()(Op& o, It i) + operator()(_Op& __o, _It __i) { - *i.second = o(*i.first); + *__i.second = __o(*__i.first); return true; } }; - /** @brief std::transform() selector, two input sequences variant. */ - template - struct transform2_selector : public generic_for_each_selector + /** @brief std::transform() __selector, two input sequences variant. */ + template + struct __transform2_selector : public __generic_for_each_selector<_It> { /** @brief Functor execution. - * @param o Operator. - * @param i Iterator referencing object. */ - template + * @param __o Operator. + * @param __i iterator referencing object. */ + template bool - operator()(Op& o, It i) + operator()(_Op& __o, _It __i) { - *i.third = o(*i.first, *i.second); + *__i.__third = __o(*__i.__first, *__i.__second); return true; } }; /** @brief std::replace() selector. */ - template - struct replace_selector : public generic_for_each_selector + template + struct __replace_selector : public __generic_for_each_selector<_It> { /** @brief Value to replace with. */ - const T& new_val; + const _Tp& __new_val; /** @brief Constructor - * @param new_val Value to replace with. */ + * @param __new_val Value to replace with. */ explicit - replace_selector(const T &new_val) : new_val(new_val) {} + __replace_selector(const _Tp &__new_val) : __new_val(__new_val) {} /** @brief Functor execution. - * @param v Current value. - * @param i Iterator referencing object. */ + * @param __v Current value. + * @param __i iterator referencing object. */ bool - operator()(T& v, It i) + operator()(_Tp& __v, _It __i) { - if (*i == v) - *i = new_val; + if (*__i == __v) + *__i = __new_val; return true; } }; /** @brief std::replace() selector. */ - template - struct replace_if_selector : public generic_for_each_selector + template + struct __replace_if_selector : public __generic_for_each_selector<_It> { /** @brief Value to replace with. */ - const T& new_val; + const _Tp& __new_val; /** @brief Constructor. - * @param new_val Value to replace with. */ + * @param __new_val Value to replace with. */ explicit - replace_if_selector(const T &new_val) : new_val(new_val) { } + __replace_if_selector(const _Tp &__new_val) : __new_val(__new_val) { } /** @brief Functor execution. - * @param o Operator. - * @param i Iterator referencing object. */ + * @param __o Operator. + * @param __i iterator referencing object. */ bool - operator()(Op& o, It i) + operator()(_Op& __o, _It __i) { - if (o(*i)) - *i = new_val; + if (__o(*__i)) + *__i = __new_val; return true; } }; /** @brief std::count() selector. */ - template - struct count_selector : public generic_for_each_selector + template + struct __count_selector : public __generic_for_each_selector<_It> { /** @brief Functor execution. - * @param v Current value. - * @param i Iterator referencing object. + * @param __v Current value. + * @param __i iterator referencing object. * @return 1 if count, 0 if does not count. */ template - Diff - operator()(Val& v, It i) - { return (v == *i) ? 1 : 0; } + _Diff + operator()(Val& __v, _It __i) + { return (__v == *__i) ? 1 : 0; } }; /** @brief std::count_if () selector. */ - template - struct count_if_selector : public generic_for_each_selector + template + struct __count_if_selector : public __generic_for_each_selector<_It> { /** @brief Functor execution. - * @param o Operator. - * @param i Iterator referencing object. + * @param __o Operator. + * @param __i iterator referencing object. * @return 1 if count, 0 if does not count. */ - template - Diff - operator()(Op& o, It i) - { return (o(*i)) ? 1 : 0; } + template + _Diff + operator()(_Op& __o, _It __i) + { return (__o(*__i)) ? 1 : 0; } }; /** @brief std::accumulate() selector. */ - template - struct accumulate_selector : public generic_for_each_selector + template + struct __accumulate_selector : public __generic_for_each_selector<_It> { /** @brief Functor execution. - * @param o Operator (unused). - * @param i Iterator referencing object. + * @param __o Operator (unused). + * @param __i iterator referencing object. * @return The current value. */ - template - typename std::iterator_traits::value_type operator()(Op o, It i) - { return *i; } + template + typename std::iterator_traits<_It>::value_type operator()(_Op __o, _It __i) + { return *__i; } }; /** @brief std::inner_product() selector. */ - template - struct inner_product_selector : public generic_for_each_selector + template + struct __inner_product_selector : public __generic_for_each_selector<_It> { /** @brief Begin iterator of first sequence. */ - It begin1_iterator; + _It __begin1_iterator; /** @brief Begin iterator of second sequence. */ It2 begin2_iterator; @@ -232,50 +232,50 @@ namespace __gnu_parallel * @param b1 Begin iterator of first sequence. * @param b2 Begin iterator of second sequence. */ explicit - inner_product_selector(It b1, It2 b2) - : begin1_iterator(b1), begin2_iterator(b2) { } + __inner_product_selector(_It b1, It2 b2) + : __begin1_iterator(b1), begin2_iterator(b2) { } /** @brief Functor execution. - * @param mult Multiplication functor. - * @param current Iterator referencing object. - * @return Inner product elemental result. */ - template - T - operator()(Op mult, It current) + * @param __mult Multiplication functor. + * @param __current iterator referencing object. + * @return Inner product elemental __result. */ + template + _Tp + operator()(_Op __mult, _It __current) { - typename std::iterator_traits::difference_type position - = current - begin1_iterator; - return mult(*current, *(begin2_iterator + position)); + typename std::iterator_traits<_It>::difference_type __position + = __current - __begin1_iterator; + return __mult(*__current, *(begin2_iterator + __position)); } }; /** @brief Selector that just returns the passed iterator. */ - template - struct identity_selector : public generic_for_each_selector + template + struct __identity_selector : public __generic_for_each_selector<_It> { /** @brief Functor execution. - * @param o Operator (unused). - * @param i Iterator referencing object. + * @param __o Operator (unused). + * @param __i iterator referencing object. * @return Passed iterator. */ - template - It - operator()(Op o, It i) - { return i; } + template + _It + operator()(_Op __o, _It __i) + { return __i; } }; /** @brief Selector that returns the difference between two adjacent - * elements. + * __elements. */ - template - struct adjacent_difference_selector : public generic_for_each_selector + template + struct __adjacent_difference_selector : public __generic_for_each_selector<_It> { - template + template bool - operator()(Op& o, It i) + operator()(_Op& __o, _It __i) { - typename It::first_type go_back_one = i.first; - --go_back_one; - *i.second = o(*i.first, *go_back_one); + typename _It::first_type __go_back_one = __i.first; + --__go_back_one; + *__i.__second = __o(*__i.__first, *__go_back_one); return true; } }; @@ -283,77 +283,77 @@ namespace __gnu_parallel // XXX move into type_traits? /** @brief Functor doing nothing * - * For some reduction tasks (this is not a function object, but is - * passed as selector dummy parameter. + * For some __reduction tasks (this is not a function object, but is + * passed as __selector __dummy parameter. */ - struct nothing + struct _Nothing { /** @brief Functor execution. - * @param i Iterator referencing object. */ - template + * @param __i iterator referencing object. */ + template void - operator()(It i) { } + operator()(_It __i) { } }; /** @brief Reduction function doing nothing. */ - struct dummy_reduct + struct _DummyReduct { bool - operator()(bool /*x*/, bool /*y*/) const + operator()(bool /*__x*/, bool /*__y*/) const { return true; } }; /** @brief Reduction for finding the maximum element, using a comparator. */ - template - struct min_element_reduct + template + struct __min_element_reduct { - Comp& comp; + _Compare& __comp; explicit - min_element_reduct(Comp &c) : comp(c) { } + __min_element_reduct(_Compare &__c) : __comp(__c) { } - It - operator()(It x, It y) + _It + operator()(_It __x, _It __y) { - if (comp(*x, *y)) - return x; + if (__comp(*__x, *__y)) + return __x; else - return y; + return __y; } }; /** @brief Reduction for finding the maximum element, using a comparator. */ - template - struct max_element_reduct + template + struct __max_element_reduct { - Comp& comp; + _Compare& __comp; explicit - max_element_reduct(Comp& c) : comp(c) { } + __max_element_reduct(_Compare& __c) : __comp(__c) { } - It - operator()(It x, It y) + _It + operator()(_It __x, _It __y) { - if (comp(*x, *y)) - return y; + if (__comp(*__x, *__y)) + return __y; else - return x; + return __x; } }; /** @brief General reduction, using a binary operator. */ - template - struct accumulate_binop_reduct + template + struct __accumulate_binop_reduct { - BinOp& binop; + _BinOp& __binop; explicit - accumulate_binop_reduct(BinOp& b) : binop(b) { } + __accumulate_binop_reduct(_BinOp& __b) : __binop(__b) { } - template - Result - operator()(const Result& x, const Addend& y) - { return binop(x, y); } + template + _Result + operator()(const _Result& __x, const _Addend& __y) + { return __binop(__x, __y); } }; } diff --git a/libstdc++-v3/include/parallel/iterator.h b/libstdc++-v3/include/parallel/iterator.h index c9bfd5a2fdbf..1baade860c93 100644 --- a/libstdc++-v3/include/parallel/iterator.h +++ b/libstdc++-v3/include/parallel/iterator.h @@ -40,160 +40,160 @@ namespace __gnu_parallel /** @brief A pair of iterators. The usual iterator operations are * applied to both child iterators. */ - template - class iterator_pair : public std::pair + template + class _IteratorPair : public std::pair<_Iterator1, _Iterator2> { private: - typedef iterator_pair type; - typedef std::pair base_type; + typedef _IteratorPair<_Iterator1, _Iterator2, _IteratorCategory> _Self; + typedef std::pair<_Iterator1, _Iterator2> _Base; public: - typedef IteratorCategory iterator_category; + typedef _IteratorCategory iterator_category; typedef void value_type; - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; - typedef type* pointer; - typedef type& reference; + typedef std::iterator_traits<_Iterator1> _TraitsType; + typedef typename _TraitsType::difference_type difference_type; + typedef _Self* pointer; + typedef _Self& reference; - iterator_pair() { } + _IteratorPair() { } - iterator_pair(const Iterator1& first, const Iterator2& second) - : base_type(first, second) { } + _IteratorPair(const _Iterator1& __first, const _Iterator2& __second) + : _Base(__first, __second) { } // Pre-increment operator. - type& + _Self& operator++() { - ++base_type::first; - ++base_type::second; + ++_Base::first; + ++_Base::second; return *this; } // Post-increment operator. - const type + const _Self operator++(int) - { return type(base_type::first++, base_type::second++); } + { return _Self(_Base::first++, _Base::second++); } // Pre-decrement operator. - type& + _Self& operator--() { - --base_type::first; - --base_type::second; + --_Base::first; + --_Base::second; return *this; } // Post-decrement operator. - const type + const _Self operator--(int) - { return type(base_type::first--, base_type::second--); } + { return _Self(_Base::first--, _Base::second--); } // Type conversion. - operator Iterator2() const - { return base_type::second; } + operator _Iterator2() const + { return _Base::second; } - type& - operator=(const type& other) + _Self& + operator=(const _Self& __other) { - base_type::first = other.first; - base_type::second = other.second; + _Base::first = __other.first; + _Base::second = __other.second; return *this; } - type - operator+(difference_type delta) const - { return type(base_type::first + delta, base_type::second + delta); } + _Self + operator+(difference_type __delta) const + { return _Self(_Base::first + __delta, _Base::second + __delta); } difference_type - operator-(const type& other) const - { return base_type::first - other.first; } + operator-(const _Self& __other) const + { return _Base::first - __other.first; } }; /** @brief A triple of iterators. The usual iterator operations are applied to all three child iterators. */ - template - class iterator_triple + template + class _IteratorTriple { private: - typedef iterator_triple type; + typedef _IteratorTriple<_Iterator1, _Iterator2, _Iterator3, + _IteratorCategory> _Self; public: - typedef IteratorCategory iterator_category; + typedef _IteratorCategory iterator_category; typedef void value_type; - typedef typename std::iterator_traits::difference_type + typedef typename std::iterator_traits<_Iterator1>::difference_type difference_type; - typedef type* pointer; - typedef type& reference; + typedef _Self* pointer; + typedef _Self& reference; - Iterator1 first; - Iterator2 second; - Iterator3 third; + _Iterator1 __first; + _Iterator2 __second; + _Iterator3 __third; - iterator_triple() { } + _IteratorTriple() { } - iterator_triple(const Iterator1& _first, const Iterator2& _second, - const Iterator3& _third) + _IteratorTriple(const _Iterator1& _first, const _Iterator2& _second, + const _Iterator3& _third) { - first = _first; - second = _second; - third = _third; + __first = _first; + __second = _second; + __third = _third; } // Pre-increment operator. - type& + _Self& operator++() { - ++first; - ++second; - ++third; + ++__first; + ++__second; + ++__third; return *this; } // Post-increment operator. - const type + const _Self operator++(int) - { return type(first++, second++, third++); } + { return _Self(__first++, __second++, __third++); } // Pre-decrement operator. - type& + _Self& operator--() { - --first; - --second; - --third; + --__first; + --__second; + --__third; return *this; } // Post-decrement operator. - const type + const _Self operator--(int) - { return type(first--, second--, third--); } + { return _Self(__first--, __second--, __third--); } // Type conversion. - operator Iterator3() const - { return third; } + operator _Iterator3() const + { return __third; } - type& - operator=(const type& other) + _Self& + operator=(const _Self& __other) { - first = other.first; - second = other.second; - third = other.third; + __first = __other.__first; + __second = __other.__second; + __third = __other.__third; return *this; } - type - operator+(difference_type delta) const - { return type(first + delta, second + delta, third + delta); } + _Self + operator+(difference_type __delta) const + { return _Self(__first + __delta, __second + __delta, __third + __delta); } difference_type - operator-(const type& other) const - { return first - other.first; } + operator-(const _Self& __other) const + { return __first - __other.__first; } }; } diff --git a/libstdc++-v3/include/parallel/list_partition.h b/libstdc++-v3/include/parallel/list_partition.h index a359a3f3a406..5065a86f9a0a 100644 --- a/libstdc++-v3/include/parallel/list_partition.h +++ b/libstdc++-v3/include/parallel/list_partition.h @@ -3,12 +3,12 @@ // Copyright (C) 2007, 2008, 2009 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 +// 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 +// 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. @@ -23,7 +23,7 @@ // . /** @file parallel/list_partition.h - * @brief Functionality to split sequence referenced by only input + * @brief _Functionality to split __sequence referenced by only input * iterators. * This file is a GNU parallel extension to the Standard C++ Library. */ @@ -39,137 +39,137 @@ namespace __gnu_parallel { /** @brief Shrinks and doubles the ranges. - * @param os_starts Start positions worked on (oversampled). - * @param count_to_two Counts up to 2. - * @param range_length Current length of a chunk. - * @param make_twice Whether the @c os_starts is allowed to be + * @param __os_starts Start positions worked on (oversampled). + * @param __count_to_two Counts up to 2. + * @param __range_length Current length of a chunk. + * @param __make_twice Whether the @__c __os_starts is allowed to be * grown or not */ - template + template void - shrink_and_double(std::vector& os_starts, - size_t& count_to_two, size_t& range_length, - const bool make_twice) + __shrink_and_double(std::vector<_IIter>& __os_starts, + size_t& __count_to_two, size_t& __range_length, + const bool __make_twice) { - ++count_to_two; - if (not make_twice or count_to_two < 2) - shrink(os_starts, count_to_two, range_length); + ++__count_to_two; + if (not __make_twice or __count_to_two < 2) + __shrink(__os_starts, __count_to_two, __range_length); else { - os_starts.resize((os_starts.size() - 1) * 2 + 1); - count_to_two = 0; + __os_starts.resize((__os_starts.size() - 1) * 2 + 1); + __count_to_two = 0; } } /** @brief Combines two ranges into one and thus halves the number of ranges. - * @param os_starts Start positions worked on (oversampled). - * @param count_to_two Counts up to 2. - * @param range_length Current length of a chunk. */ - template + * @param __os_starts Start positions worked on (oversampled). + * @param __count_to_two Counts up to 2. + * @param __range_length Current length of a chunk. */ + template void - shrink(std::vector& os_starts, size_t& count_to_two, - size_t& range_length) + __shrink(std::vector<_IIter>& __os_starts, size_t& __count_to_two, + size_t& __range_length) { - for (typename std::vector::size_type i = 0; - i <= (os_starts.size() / 2); ++i) - os_starts[i] = os_starts[i * 2]; - range_length *= 2; + for (typename std::vector<_IIter>::size_type __i = 0; + __i <= (__os_starts.size() / 2); ++__i) + __os_starts[__i] = __os_starts[__i * 2]; + __range_length *= 2; } /** @brief Splits a sequence given by input iterators into parts of * almost equal size * * The function needs only one pass over the sequence. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param starts Start iterators for the resulting parts, dimension - * @c num_parts+1. For convenience, @c starts @c [num_parts] + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __starts Start iterators for the resulting parts, dimension + * @__c __num_parts+1. For convenience, @__c __starts @__c [__num_parts] * contains the end iterator of the sequence. - * @param lengths Length of the resulting parts. - * @param num_parts Number of parts to split the sequence into. - * @param f Functor to be applied to each element by traversing it - * @param oversampling Oversampling factor. If 0, then the - * partitions will differ in at most @f$ \sqrt{\mathrm{end} - - * \mathrm{begin}} @f$ elements. Otherwise, the ratio between the - * longest and the shortest part is bounded by @f$ - * 1/(\mathrm{oversampling} \cdot \mathrm{num\_parts}) @f$. + * @param __lengths Length of the resulting parts. + * @param __num_parts Number of parts to split the sequence into. + * @param __f Functor to be applied to each element by traversing __it + * @param __oversampling Oversampling factor. If 0, then the + * partitions will differ in at most @__f$ \sqrt{\mathrm{__end} - + * \mathrm{__begin}} @__f$ __elements. Otherwise, the ratio between the + * longest and the shortest part is bounded by @__f$ + * 1/(\mathrm{__oversampling} \cdot \mathrm{num\_parts}) @__f$. * @return Length of the whole sequence. */ - template + template size_t - list_partition(const InputIterator begin, const InputIterator end, - InputIterator* starts, size_t* lengths, const int num_parts, - FunctorType& f, int oversampling = 0) + list_partition(const _IIter __begin, const _IIter __end, + _IIter* __starts, size_t* __lengths, const int __num_parts, + _FunctorType& __f, int __oversampling = 0) { - bool make_twice = false; + bool __make_twice = false; // The resizing algorithm is chosen according to the oversampling factor. - if (oversampling == 0) + if (__oversampling == 0) { - make_twice = true; - oversampling = 1; + __make_twice = true; + __oversampling = 1; } - std::vector os_starts(2 * oversampling * num_parts + 1); + std::vector<_IIter> __os_starts(2 * __oversampling * __num_parts + 1); - os_starts[0]= begin; - InputIterator prev = begin, it = begin; - size_t dist_limit = 0, dist = 0; - size_t cur = 1, next = 1; - size_t range_length = 1; - size_t count_to_two = 0; - while (it != end) + __os_starts[0]= __begin; + _IIter __prev = __begin, __it = __begin; + size_t __dist_limit = 0, __dist = 0; + size_t __cur = 1, __next = 1; + size_t __range_length = 1; + size_t __count_to_two = 0; + while (__it != __end) { - cur = next; - for (; cur < os_starts.size() and it != end; ++cur) + __cur = __next; + for (; __cur < __os_starts.size() and __it != __end; ++__cur) { - for (dist_limit += range_length; - dist < dist_limit and it != end; ++dist) + for (__dist_limit += __range_length; + __dist < __dist_limit and __it != __end; ++__dist) { - f(it); - ++it; + __f(__it); + ++__it; } - os_starts[cur] = it; + __os_starts[__cur] = __it; } - // Must compare for end and not cur < os_starts.size() , because - // cur could be == os_starts.size() as well - if (it == end) + // Must compare for end and not __cur < __os_starts.size() , because + // __cur could be == __os_starts.size() as well + if (__it == __end) break; - shrink_and_double(os_starts, count_to_two, range_length, make_twice); - next = os_starts.size() / 2 + 1; + __shrink_and_double(__os_starts, __count_to_two, __range_length, __make_twice); + __next = __os_starts.size() / 2 + 1; } - // Calculation of the parts (one must be extracted from current - // because the partition beginning at end, consists only of + // Calculation of the parts (one must be extracted from __current + // because the partition beginning at __end, consists only of // itself). - size_t size_part = (cur - 1) / num_parts; - int size_greater = static_cast((cur - 1) % num_parts); - starts[0] = os_starts[0]; + size_t __size_part = (__cur - 1) / __num_parts; + int __size_greater = static_cast((__cur - 1) % __num_parts); + __starts[0] = __os_starts[0]; - size_t index = 0; + size_t __index = 0; // Smallest partitions. - for (int i = 1; i < (num_parts + 1 - size_greater); ++i) + for (int __i = 1; __i < (__num_parts + 1 - __size_greater); ++__i) { - lengths[i - 1] = size_part * range_length; - index += size_part; - starts[i] = os_starts[index]; + __lengths[__i - 1] = __size_part * __range_length; + __index += __size_part; + __starts[__i] = __os_starts[__index]; } // Biggest partitions. - for (int i = num_parts + 1 - size_greater; i <= num_parts; ++i) + for (int __i = __num_parts + 1 - __size_greater; __i <= __num_parts; ++__i) { - lengths[i - 1] = (size_part+1) * range_length; - index += (size_part+1); - starts[i] = os_starts[index]; + __lengths[__i - 1] = (__size_part+1) * __range_length; + __index += (__size_part+1); + __starts[__i] = __os_starts[__index]; } // Correction of the end size (the end iteration has not finished). - lengths[num_parts - 1] -= (dist_limit - dist); + __lengths[__num_parts - 1] -= (__dist_limit - __dist); - return dist; + return __dist; } } diff --git a/libstdc++-v3/include/parallel/losertree.h b/libstdc++-v3/include/parallel/losertree.h index 6dbd59288641..b98102572328 100644 --- a/libstdc++-v3/include/parallel/losertree.h +++ b/libstdc++-v3/include/parallel/losertree.h @@ -46,45 +46,45 @@ namespace __gnu_parallel * * The smallest element is at the top. * - * Guarding is done explicitly through one flag sup per element, + * Guarding is done explicitly through one flag _M_sup per element, * inf is not needed due to a better initialization routine. This * is a well-performing variant. * - * @param T the element type - * @param Comparator the comparator to use, defaults to std::less + * @param _Tp the element _Self + * @param _Compare the comparator to use, defaults to std::less<_Tp> */ -template +template class LoserTreeBase { protected: /** @brief Internal representation of a LoserTree element. */ - struct Loser - { - /** @brief flag, true iff this is a "maximum" sentinel. */ - bool sup; - /** @brief index of the source sequence. */ - int source; - /** @brief key of the element in the LoserTree. */ - T key; + struct _Loser + { + /** @brief flag, true iff this is a "maximum" __sentinel. */ + bool _M_sup; + /** @brief __index of the _M_source __sequence. */ + int _M_source; + /** @brief _M_key of the element in the LoserTree. */ + _Tp _M_key; }; - unsigned int ik, k, offset; + unsigned int __ik, __k, __offset; - /** log_2{k} */ + /** log_2{__k} */ unsigned int _M_log_k; - /** @brief LoserTree elements. */ - Loser* losers; + /** @brief LoserTree __elements. */ + _Loser* __losers; - /** @brief Comparator to use. */ - Comparator comp; + /** @brief _Compare to use. */ + _Compare __comp; /** * @brief State flag that determines whether the LoserTree is empty. * * Only used for building the LoserTree. */ - bool first_insert; + bool __first_insert; public: /** @@ -93,117 +93,117 @@ public: * @param _k The number of sequences to merge. * @param _comp The comparator to use. */ - LoserTreeBase(unsigned int _k, Comparator _comp) - : comp(_comp) + LoserTreeBase(unsigned int _k, _Compare _comp) + : __comp(_comp) { - ik = _k; + __ik = _k; - // Compute log_2{k} for the Loser Tree - _M_log_k = __log2(ik - 1) + 1; + // Compute log_2{__k} for the _Loser Tree + _M_log_k = __log2(__ik - 1) + 1; // Next greater power of 2. - k = 1 << _M_log_k; - offset = k; + __k = 1 << _M_log_k; + __offset = __k; - // Avoid default-constructing losers[].key - losers = static_cast(::operator new(2 * k * sizeof(Loser))); - for (unsigned int i = ik - 1; i < k; ++i) - losers[i + k].sup = true; + // Avoid default-constructing __losers[]._M_key + __losers = static_cast<_Loser*>(::operator new(2 * __k * sizeof(_Loser))); + for (unsigned int __i = __ik - 1; __i < __k; ++__i) + __losers[__i + __k]._M_sup = true; - first_insert = true; + __first_insert = true; } /** * @brief The destructor. */ ~LoserTreeBase() - { ::operator delete(losers); } + { ::operator delete(__losers); } /** - * @brief Initializes the sequence "source" with the element "key". + * @brief Initializes the sequence "_M_source" with the element "_M_key". * - * @param key the element to insert - * @param source index of the source sequence - * @param sup flag that determines whether the value to insert is an - * explicit supremum. + * @param _M_key the element to insert + * @param _M_source __index of the _M_source __sequence + * @param _M_sup flag that determines whether the value to insert is an + * explicit __supremum. */ inline void - insert_start(const T& key, int source, bool sup) + __insert_start(const _Tp& _M_key, int _M_source, bool _M_sup) { - unsigned int pos = k + source; + unsigned int __pos = __k + _M_source; - if(first_insert) + if(__first_insert) { // Construct all keys, so we can easily deconstruct them. - for (unsigned int i = 0; i < (2 * k); ++i) - new(&(losers[i].key)) T(key); - first_insert = false; + for (unsigned int __i = 0; __i < (2 * __k); ++__i) + new(&(__losers[__i]._M_key)) _Tp(_M_key); + __first_insert = false; } else - new(&(losers[pos].key)) T(key); + new(&(__losers[__pos]._M_key)) _Tp(_M_key); - losers[pos].sup = sup; - losers[pos].source = source; + __losers[__pos]._M_sup = _M_sup; + __losers[__pos]._M_source = _M_source; } /** * @return the index of the sequence with the smallest element. */ - int get_min_source() - { return losers[0].source; } + int __get_min_source() + { return __losers[0]._M_source; } }; /** * @brief Stable LoserTree variant. * - * Provides the stable implementations of insert_start, init_winner, - * init and delete_min_insert. + * Provides the stable implementations of insert_start, __init_winner, + * __init and __delete_min_insert. * * Unstable variant is done using partial specialisation below. */ -template -class LoserTree : public LoserTreeBase +template +class LoserTree : public LoserTreeBase<_Tp, _Compare> { - typedef LoserTreeBase Base; - using Base::k; - using Base::losers; - using Base::first_insert; + typedef LoserTreeBase<_Tp, _Compare> Base; + using Base::__k; + using Base::__losers; + using Base::__first_insert; public: - LoserTree(unsigned int _k, Comparator _comp) + LoserTree(unsigned int _k, _Compare _comp) : Base::LoserTreeBase(_k, _comp) {} unsigned int - init_winner(unsigned int root) + __init_winner(unsigned int __root) { - if (root >= k) + if (__root >= __k) { - return root; + return __root; } else { - unsigned int left = init_winner (2 * root); - unsigned int right = init_winner (2 * root + 1); - if (losers[right].sup - || (!losers[left].sup - && !comp(losers[right].key, losers[left].key))) + unsigned int __left = __init_winner (2 * __root); + unsigned int __right = __init_winner (2 * __root + 1); + if (__losers[__right]._M_sup + || (!__losers[__left]._M_sup + && !__comp(__losers[__right]._M_key, __losers[__left]._M_key))) { // Left one is less or equal. - losers[root] = losers[right]; - return left; + __losers[__root] = __losers[__right]; + return __left; } else { // Right one is less. - losers[root] = losers[left]; - return right; + __losers[__root] = __losers[__left]; + return __right; } } } - void init() - { losers[0] = losers[init_winner(1)]; } + void __init() + { __losers[0] = __losers[__init_winner(1)]; } /** * @brief Delete the smallest element and insert a new element from @@ -211,34 +211,34 @@ public: * * This implementation is stable. */ - // Do not pass a const reference since key will be used as local variable. - void delete_min_insert(T key, bool sup) + // Do not pass a const reference since _M_key will be used as local variable. + void __delete_min_insert(_Tp _M_key, bool _M_sup) { #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top! - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif - int source = losers[0].source; - for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2) + int _M_source = __losers[0]._M_source; + for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2) { - // The smaller one gets promoted, ties are broken by source. - if ((sup && (!losers[pos].sup || losers[pos].source < source)) - || (!sup && !losers[pos].sup - && ((comp(losers[pos].key, key)) - || (!comp(key, losers[pos].key) - && losers[pos].source < source)))) + // The smaller one gets promoted, ties are broken by _M_source. + if ((_M_sup && (!__losers[__pos]._M_sup || __losers[__pos]._M_source < _M_source)) + || (!_M_sup && !__losers[__pos]._M_sup + && ((__comp(__losers[__pos]._M_key, _M_key)) + || (!__comp(_M_key, __losers[__pos]._M_key) + && __losers[__pos]._M_source < _M_source)))) { // The other one is smaller. - std::swap(losers[pos].sup, sup); - std::swap(losers[pos].source, source); - std::swap(losers[pos].key, key); + std::swap(__losers[__pos]._M_sup, _M_sup); + std::swap(__losers[__pos]._M_source, _M_source); + std::swap(__losers[__pos]._M_key, _M_key); } } - losers[0].sup = sup; - losers[0].source = source; - losers[0].key = key; + __losers[0]._M_sup = _M_sup; + __losers[0]._M_source = _M_source; + __losers[0]._M_key = _M_key; } }; @@ -247,141 +247,141 @@ public: * * Stability (non-stable here) is selected with partial specialization. */ -template -class LoserTree : - public LoserTreeBase +template +class LoserTree : + public LoserTreeBase<_Tp, _Compare> { - typedef LoserTreeBase Base; + typedef LoserTreeBase<_Tp, _Compare> Base; using Base::_M_log_k; - using Base::k; - using Base::losers; - using Base::first_insert; + using Base::__k; + using Base::__losers; + using Base::__first_insert; public: - LoserTree(unsigned int _k, Comparator _comp) + LoserTree(unsigned int _k, _Compare _comp) : Base::LoserTreeBase(_k, _comp) {} /** - * Computes the winner of the competition at position "root". + * Computes the winner of the competition at __position "__root". * * Called recursively (starting at 0) to build the initial tree. * - * @param root index of the "game" to start. + * @param __root __index of the "game" to start. */ unsigned int - init_winner (unsigned int root) + __init_winner (unsigned int __root) { - if (root >= k) + if (__root >= __k) { - return root; + return __root; } else { - unsigned int left = init_winner (2 * root); - unsigned int right = init_winner (2 * root + 1); - if (losers[right].sup || - (!losers[left].sup - && !comp(losers[right].key, losers[left].key))) + unsigned int __left = __init_winner (2 * __root); + unsigned int __right = __init_winner (2 * __root + 1); + if (__losers[__right]._M_sup || + (!__losers[__left]._M_sup + && !__comp(__losers[__right]._M_key, __losers[__left]._M_key))) { // Left one is less or equal. - losers[root] = losers[right]; - return left; + __losers[__root] = __losers[__right]; + return __left; } else { // Right one is less. - losers[root] = losers[left]; - return right; + __losers[__root] = __losers[__left]; + return __right; } } } inline void - init() - { losers[0] = losers[init_winner(1)]; } + __init() + { __losers[0] = __losers[__init_winner(1)]; } /** - * Delete the key smallest element and insert the element key instead. + * Delete the _M_key smallest element and insert the element _M_key instead. * - * @param key the key to insert - * @param sup true iff key is an explicitly marked supremum + * @param _M_key the _M_key to insert + * @param _M_sup true iff _M_key is an explicitly marked supremum */ - // Do not pass a const reference since key will be used as local variable. + // Do not pass a const reference since _M_key will be used as local variable. inline void - delete_min_insert(T key, bool sup) + __delete_min_insert(_Tp _M_key, bool _M_sup) { #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top! - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif - int source = losers[0].source; - for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2) + int _M_source = __losers[0]._M_source; + for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2) { // The smaller one gets promoted. - if (sup || (!losers[pos].sup && comp(losers[pos].key, key))) + if (_M_sup || (!__losers[__pos]._M_sup && __comp(__losers[__pos]._M_key, _M_key))) { // The other one is smaller. - std::swap(losers[pos].sup, sup); - std::swap(losers[pos].source, source); - std::swap(losers[pos].key, key); + std::swap(__losers[__pos]._M_sup, _M_sup); + std::swap(__losers[__pos]._M_source, _M_source); + std::swap(__losers[__pos]._M_key, _M_key); } } - losers[0].sup = sup; - losers[0].source = source; - losers[0].key = key; + __losers[0]._M_sup = _M_sup; + __losers[0]._M_source = _M_source; + __losers[0]._M_key = _M_key; } }; /** - * @brief Base class of Loser Tree implementation using pointers. + * @brief Base class of _Loser Tree implementation using pointers. */ -template -class LoserTreePointerBase +template +class _LoserTreePointerBase { protected: - /** @brief Internal representation of LoserTree elements. */ - struct Loser + /** @brief Internal representation of LoserTree __elements. */ + struct _Loser { - bool sup; - int source; - const T* keyp; + bool _M_sup; + int _M_source; + const _Tp* _M_keyp; }; - unsigned int ik, k, offset; - Loser* losers; - Comparator comp; + unsigned int __ik, __k, __offset; + _Loser* __losers; + _Compare __comp; public: - LoserTreePointerBase(unsigned int _k, Comparator _comp = std::less()) - : comp(_comp) + _LoserTreePointerBase(unsigned int _k, _Compare _comp = std::less<_Tp>()) + : __comp(_comp) { - ik = _k; + __ik = _k; // Next greater power of 2. - k = 1 << (__log2(ik - 1) + 1); - offset = k; - losers = new Loser[k * 2]; - for (unsigned int i = ik - 1; i < k; i++) - losers[i + k].sup = true; + __k = 1 << (__log2(__ik - 1) + 1); + __offset = __k; + __losers = new _Loser[__k * 2]; + for (unsigned int __i = __ik - 1; __i < __k; __i++) + __losers[__i + __k]._M_sup = true; } - ~LoserTreePointerBase() - { ::operator delete[](losers); } + ~_LoserTreePointerBase() + { ::operator delete[](__losers); } - int get_min_source() - { return losers[0].source; } + int __get_min_source() + { return __losers[0]._M_source; } - void insert_start(const T& key, int source, bool sup) + void __insert_start(const _Tp& _M_key, int _M_source, bool _M_sup) { - unsigned int pos = k + source; + unsigned int __pos = __k + _M_source; - losers[pos].sup = sup; - losers[pos].source = source; - losers[pos].keyp = &key; + __losers[__pos]._M_sup = _M_sup; + __losers[__pos]._M_source = _M_source; + __losers[__pos]._M_keyp = &_M_key; } }; @@ -390,77 +390,77 @@ public: * * The unstable variant is implemented using partial instantiation below. */ -template -class LoserTreePointer : public LoserTreePointerBase +template +class _LoserTreePointer : public _LoserTreePointerBase<_Tp, _Compare> { - typedef LoserTreePointerBase Base; - using Base::k; - using Base::losers; + typedef _LoserTreePointerBase<_Tp, _Compare> Base; + using Base::__k; + using Base::__losers; public: - LoserTreePointer(unsigned int _k, Comparator _comp = std::less()) - : Base::LoserTreePointerBase(_k, _comp) + _LoserTreePointer(unsigned int _k, _Compare _comp = std::less<_Tp>()) + : Base::_LoserTreePointerBase(_k, _comp) {} unsigned int - init_winner(unsigned int root) + __init_winner(unsigned int __root) { - if (root >= k) + if (__root >= __k) { - return root; + return __root; } else { - unsigned int left = init_winner (2 * root); - unsigned int right = init_winner (2 * root + 1); - if (losers[right].sup - || (!losers[left].sup && !comp(*losers[right].keyp, - *losers[left].keyp))) + unsigned int __left = __init_winner (2 * __root); + unsigned int __right = __init_winner (2 * __root + 1); + if (__losers[__right]._M_sup + || (!__losers[__left]._M_sup && !__comp(*__losers[__right]._M_keyp, + *__losers[__left]._M_keyp))) { // Left one is less or equal. - losers[root] = losers[right]; - return left; + __losers[__root] = __losers[__right]; + return __left; } else { // Right one is less. - losers[root] = losers[left]; - return right; + __losers[__root] = __losers[__left]; + return __right; } } } - void init() - { losers[0] = losers[init_winner(1)]; } + void __init() + { __losers[0] = __losers[__init_winner(1)]; } - void delete_min_insert(const T& key, bool sup) + void __delete_min_insert(const _Tp& _M_key, bool _M_sup) { #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top! - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif - const T* keyp = &key; - int source = losers[0].source; - for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2) + const _Tp* _M_keyp = &_M_key; + int _M_source = __losers[0]._M_source; + for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2) { - // The smaller one gets promoted, ties are broken by source. - if ((sup && (!losers[pos].sup || losers[pos].source < source)) || - (!sup && !losers[pos].sup && - ((comp(*losers[pos].keyp, *keyp)) || - (!comp(*keyp, *losers[pos].keyp) - && losers[pos].source < source)))) + // The smaller one gets promoted, ties are broken by _M_source. + if ((_M_sup && (!__losers[__pos]._M_sup || __losers[__pos]._M_source < _M_source)) || + (!_M_sup && !__losers[__pos]._M_sup && + ((__comp(*__losers[__pos]._M_keyp, *_M_keyp)) || + (!__comp(*_M_keyp, *__losers[__pos]._M_keyp) + && __losers[__pos]._M_source < _M_source)))) { // The other one is smaller. - std::swap(losers[pos].sup, sup); - std::swap(losers[pos].source, source); - std::swap(losers[pos].keyp, keyp); + std::swap(__losers[__pos]._M_sup, _M_sup); + std::swap(__losers[__pos]._M_source, _M_source); + std::swap(__losers[__pos]._M_keyp, _M_keyp); } } - losers[0].sup = sup; - losers[0].source = source; - losers[0].keyp = keyp; + __losers[0]._M_sup = _M_sup; + __losers[0]._M_source = _M_source; + __losers[0]._M_keyp = _M_keyp; } }; @@ -469,74 +469,74 @@ public: * * The stable variant is above. */ -template -class LoserTreePointer : - public LoserTreePointerBase +template +class _LoserTreePointer : + public _LoserTreePointerBase<_Tp, _Compare> { - typedef LoserTreePointerBase Base; - using Base::k; - using Base::losers; + typedef _LoserTreePointerBase<_Tp, _Compare> Base; + using Base::__k; + using Base::__losers; public: - LoserTreePointer(unsigned int _k, Comparator _comp = std::less()) - : Base::LoserTreePointerBase(_k, _comp) + _LoserTreePointer(unsigned int _k, _Compare _comp = std::less<_Tp>()) + : Base::_LoserTreePointerBase(_k, _comp) {} unsigned int - init_winner(unsigned int root) + __init_winner(unsigned int __root) { - if (root >= k) + if (__root >= __k) { - return root; + return __root; } else { - unsigned int left = init_winner (2 * root); - unsigned int right = init_winner (2 * root + 1); - if (losers[right].sup - || (!losers[left].sup - && !comp(*losers[right].keyp, *losers[left].keyp))) + unsigned int __left = __init_winner (2 * __root); + unsigned int __right = __init_winner (2 * __root + 1); + if (__losers[__right]._M_sup + || (!__losers[__left]._M_sup + && !__comp(*__losers[__right]._M_keyp, *__losers[__left]._M_keyp))) { // Left one is less or equal. - losers[root] = losers[right]; - return left; + __losers[__root] = __losers[__right]; + return __left; } else { // Right one is less. - losers[root] = losers[left]; - return right; + __losers[__root] = __losers[__left]; + return __right; } } } - void init() - { losers[0] = losers[init_winner(1)]; } + void __init() + { __losers[0] = __losers[__init_winner(1)]; } - void delete_min_insert(const T& key, bool sup) + void __delete_min_insert(const _Tp& _M_key, bool _M_sup) { #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top! - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif - const T* keyp = &key; - int source = losers[0].source; - for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2) + const _Tp* _M_keyp = &_M_key; + int _M_source = __losers[0]._M_source; + for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2) { // The smaller one gets promoted. - if (sup || (!losers[pos].sup && comp(*losers[pos].keyp, *keyp))) + if (_M_sup || (!__losers[__pos]._M_sup && __comp(*__losers[__pos]._M_keyp, *_M_keyp))) { // The other one is smaller. - std::swap(losers[pos].sup, sup); - std::swap(losers[pos].source, source); - std::swap(losers[pos].keyp, keyp); + std::swap(__losers[__pos]._M_sup, _M_sup); + std::swap(__losers[__pos]._M_source, _M_source); + std::swap(__losers[__pos]._M_keyp, _M_keyp); } } - losers[0].sup = sup; - losers[0].source = source; - losers[0].keyp = keyp; + __losers[0]._M_sup = _M_sup; + __losers[0]._M_source = _M_source; + __losers[0]._M_keyp = _M_keyp; } }; @@ -545,66 +545,66 @@ public: * The whole element is copied into the tree structure. * * No guarding is done, therefore not a single input sequence must - * run empty. Unused sequence heads are marked with a sentinel which + * run empty. Unused __sequence heads are marked with a sentinel which * is > all elements that are to be merged. * * This is a very fast variant. */ -template -class LoserTreeUnguardedBase +template +class _LoserTreeUnguardedBase { protected: - struct Loser + struct _Loser { - int source; - T key; + int _M_source; + _Tp _M_key; }; - unsigned int ik, k, offset; - Loser* losers; - Comparator comp; + unsigned int __ik, __k, __offset; + _Loser* __losers; + _Compare __comp; public: inline - LoserTreeUnguardedBase(unsigned int _k, const T _sentinel, - Comparator _comp = std::less()) - : comp(_comp) + _LoserTreeUnguardedBase(unsigned int _k, const _Tp _sentinel, + _Compare _comp = std::less<_Tp>()) + : __comp(_comp) { - ik = _k; + __ik = _k; // Next greater power of 2. - k = 1 << (__log2(ik - 1) + 1); - offset = k; - // Avoid default-constructing losers[].key - losers = static_cast(::operator new(2 * k * sizeof(Loser))); + __k = 1 << (__log2(__ik - 1) + 1); + __offset = __k; + // Avoid default-constructing __losers[]._M_key + __losers = static_cast<_Loser*>(::operator new(2 * __k * sizeof(_Loser))); - for (unsigned int i = k + ik - 1; i < (2 * k); ++i) + for (unsigned int __i = __k + __ik - 1; __i < (2 * __k); ++__i) { - losers[i].key = _sentinel; - losers[i].source = -1; + __losers[__i]._M_key = _sentinel; + __losers[__i]._M_source = -1; } } - inline ~LoserTreeUnguardedBase() - { ::operator delete(losers); } + inline ~_LoserTreeUnguardedBase() + { ::operator delete(__losers); } inline int - get_min_source() + __get_min_source() { #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top! - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif - return losers[0].source; + return __losers[0]._M_source; } inline void - insert_start(const T& key, int source, bool) + __insert_start(const _Tp& _M_key, int _M_source, bool) { - unsigned int pos = k + source; + unsigned int __pos = __k + _M_source; - new(&(losers[pos].key)) T(key); - losers[pos].source = source; + new(&(__losers[__pos]._M_key)) _Tp(_M_key); + __losers[__pos]._M_source = _M_source; } }; @@ -613,80 +613,80 @@ public: * * Unstable variant is selected below with partial specialization. */ -template -class LoserTreeUnguarded : public LoserTreeUnguardedBase +template +class _LoserTreeUnguarded : public _LoserTreeUnguardedBase<_Tp, _Compare> { - typedef LoserTreeUnguardedBase Base; - using Base::k; - using Base::losers; + typedef _LoserTreeUnguardedBase<_Tp, _Compare> Base; + using Base::__k; + using Base::__losers; public: - LoserTreeUnguarded(unsigned int _k, const T _sentinel, - Comparator _comp = std::less()) - : Base::LoserTreeUnguardedBase(_k, _sentinel, _comp) + _LoserTreeUnguarded(unsigned int _k, const _Tp _sentinel, + _Compare _comp = std::less<_Tp>()) + : Base::_LoserTreeUnguardedBase(_k, _sentinel, _comp) {} unsigned int - init_winner(unsigned int root) + __init_winner(unsigned int __root) { - if (root >= k) + if (__root >= __k) { - return root; + return __root; } else { - unsigned int left = init_winner (2 * root); - unsigned int right = init_winner (2 * root + 1); - if (!comp(losers[right].key, losers[left].key)) + unsigned int __left = __init_winner (2 * __root); + unsigned int __right = __init_winner (2 * __root + 1); + if (!__comp(__losers[__right]._M_key, __losers[__left]._M_key)) { // Left one is less or equal. - losers[root] = losers[right]; - return left; + __losers[__root] = __losers[__right]; + return __left; } else { // Right one is less. - losers[root] = losers[left]; - return right; + __losers[__root] = __losers[__left]; + return __right; } } } inline void - init() + __init() { - losers[0] = losers[init_winner(1)]; + __losers[0] = __losers[__init_winner(1)]; #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top at the beginning (0 sequences!) - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif } - // Do not pass a const reference since key will be used as local variable. + // Do not pass a const reference since _M_key will be used as local variable. inline void - delete_min_insert(T key, bool) + __delete_min_insert(_Tp _M_key, bool) { #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top! - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif - int source = losers[0].source; - for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2) + int _M_source = __losers[0]._M_source; + for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2) { - // The smaller one gets promoted, ties are broken by source. - if (comp(losers[pos].key, key) - || (!comp(key, losers[pos].key) && losers[pos].source < source)) + // The smaller one gets promoted, ties are broken by _M_source. + if (__comp(__losers[__pos]._M_key, _M_key) + || (!__comp(_M_key, __losers[__pos]._M_key) && __losers[__pos]._M_source < _M_source)) { // The other one is smaller. - std::swap(losers[pos].source, source); - std::swap(losers[pos].key, key); + std::swap(__losers[__pos]._M_source, _M_source); + std::swap(__losers[__pos]._M_key, _M_key); } } - losers[0].source = source; - losers[0].key = key; + __losers[0]._M_source = _M_source; + __losers[0]._M_key = _M_key; } }; @@ -695,152 +695,152 @@ public: * * Stable implementation is above. */ -template -class LoserTreeUnguarded : - public LoserTreeUnguardedBase +template +class _LoserTreeUnguarded : + public _LoserTreeUnguardedBase<_Tp, _Compare> { - typedef LoserTreeUnguardedBase Base; - using Base::k; - using Base::losers; + typedef _LoserTreeUnguardedBase<_Tp, _Compare> Base; + using Base::__k; + using Base::__losers; public: - LoserTreeUnguarded(unsigned int _k, const T _sentinel, - Comparator _comp = std::less()) - : Base::LoserTreeUnguardedBase(_k, _sentinel, _comp) + _LoserTreeUnguarded(unsigned int _k, const _Tp _sentinel, + _Compare _comp = std::less<_Tp>()) + : Base::_LoserTreeUnguardedBase(_k, _sentinel, _comp) {} unsigned int - init_winner (unsigned int root) + __init_winner (unsigned int __root) { - if (root >= k) + if (__root >= __k) { - return root; + return __root; } else { - unsigned int left = init_winner (2 * root); - unsigned int right = init_winner (2 * root + 1); + unsigned int __left = __init_winner (2 * __root); + unsigned int __right = __init_winner (2 * __root + 1); #if _GLIBCXX_ASSERTIONS - // If left one is sentinel then right one must be, too. - if (losers[left].source == -1) - _GLIBCXX_PARALLEL_ASSERT(losers[right].source == -1); + // If __left one is sentinel then __right one must be, too. + if (__losers[__left]._M_source == -1) + _GLIBCXX_PARALLEL_ASSERT(__losers[__right]._M_source == -1); #endif - if (!comp(losers[right].key, losers[left].key)) + if (!__comp(__losers[__right]._M_key, __losers[__left]._M_key)) { // Left one is less or equal. - losers[root] = losers[right]; - return left; + __losers[__root] = __losers[__right]; + return __left; } else { // Right one is less. - losers[root] = losers[left]; - return right; + __losers[__root] = __losers[__left]; + return __right; } } } inline void - init() + __init() { - losers[0] = losers[init_winner(1)]; + __losers[0] = __losers[__init_winner(1)]; #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top at the beginning (0 sequences!) - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif } - // Do not pass a const reference since key will be used as local variable. + // Do not pass a const reference since _M_key will be used as local variable. inline void - delete_min_insert(T key, bool) + __delete_min_insert(_Tp _M_key, bool) { #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top! - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif - int source = losers[0].source; - for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2) + int _M_source = __losers[0]._M_source; + for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2) { // The smaller one gets promoted. - if (comp(losers[pos].key, key)) + if (__comp(__losers[__pos]._M_key, _M_key)) { // The other one is smaller. - std::swap(losers[pos].source, source); - std::swap(losers[pos].key, key); + std::swap(__losers[__pos]._M_source, _M_source); + std::swap(__losers[__pos]._M_key, _M_key); } } - losers[0].source = source; - losers[0].key = key; + __losers[0]._M_source = _M_source; + __losers[0]._M_key = _M_key; } }; /** @brief Unguarded loser tree, keeping only pointers to the -* elements in the tree structure. +* __elements in the tree structure. * * No guarding is done, therefore not a single input sequence must * run empty. This is a very fast variant. */ -template +template class LoserTreePointerUnguardedBase { protected: - struct Loser + struct _Loser { - int source; - const T* keyp; + int _M_source; + const _Tp* _M_keyp; }; - unsigned int ik, k, offset; - Loser* losers; - Comparator comp; + unsigned int __ik, __k, __offset; + _Loser* __losers; + _Compare __comp; public: inline - LoserTreePointerUnguardedBase(unsigned int _k, const T& _sentinel, - Comparator _comp = std::less()) - : comp(_comp) + LoserTreePointerUnguardedBase(unsigned int _k, const _Tp& _sentinel, + _Compare _comp = std::less<_Tp>()) + : __comp(_comp) { - ik = _k; + __ik = _k; // Next greater power of 2. - k = 1 << (__log2(ik - 1) + 1); - offset = k; - // Avoid default-constructing losers[].key - losers = new Loser[2 * k]; + __k = 1 << (__log2(__ik - 1) + 1); + __offset = __k; + // Avoid default-constructing __losers[]._M_key + __losers = new _Loser[2 * __k]; - for (unsigned int i = k + ik - 1; i < (2 * k); ++i) + for (unsigned int __i = __k + __ik - 1; __i < (2 * __k); ++__i) { - losers[i].keyp = &_sentinel; - losers[i].source = -1; + __losers[__i]._M_keyp = &_sentinel; + __losers[__i]._M_source = -1; } } inline ~LoserTreePointerUnguardedBase() - { delete[] losers; } + { delete[] __losers; } inline int - get_min_source() + __get_min_source() { #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top! - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif - return losers[0].source; + return __losers[0]._M_source; } inline void - insert_start(const T& key, int source, bool) + __insert_start(const _Tp& _M_key, int _M_source, bool) { - unsigned int pos = k + source; + unsigned int __pos = __k + _M_source; - losers[pos].keyp = &key; - losers[pos].source = source; + __losers[__pos]._M_keyp = &_M_key; + __losers[__pos]._M_source = _M_source; } }; @@ -849,81 +849,81 @@ public: * * Unstable variant is implemented below using partial specialization. */ -template +template class LoserTreePointerUnguarded : - public LoserTreePointerUnguardedBase + public LoserTreePointerUnguardedBase<_Tp, _Compare> { - typedef LoserTreePointerUnguardedBase Base; - using Base::k; - using Base::losers; + typedef LoserTreePointerUnguardedBase<_Tp, _Compare> Base; + using Base::__k; + using Base::__losers; public: - LoserTreePointerUnguarded(unsigned int _k, const T& _sentinel, - Comparator _comp = std::less()) + LoserTreePointerUnguarded(unsigned int _k, const _Tp& _sentinel, + _Compare _comp = std::less<_Tp>()) : Base::LoserTreePointerUnguardedBase(_k, _sentinel, _comp) {} unsigned int - init_winner(unsigned int root) + __init_winner(unsigned int __root) { - if (root >= k) + if (__root >= __k) { - return root; + return __root; } else { - unsigned int left = init_winner (2 * root); - unsigned int right = init_winner (2 * root + 1); - if (!comp(*losers[right].keyp, *losers[left].keyp)) + unsigned int __left = __init_winner (2 * __root); + unsigned int __right = __init_winner (2 * __root + 1); + if (!__comp(*__losers[__right]._M_keyp, *__losers[__left]._M_keyp)) { // Left one is less or equal. - losers[root] = losers[right]; - return left; + __losers[__root] = __losers[__right]; + return __left; } else { // Right one is less. - losers[root] = losers[left]; - return right; + __losers[__root] = __losers[__left]; + return __right; } } } inline void - init() + __init() { - losers[0] = losers[init_winner(1)]; + __losers[0] = __losers[__init_winner(1)]; #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top at the beginning (0 sequences!) - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif } inline void - delete_min_insert(const T& key, bool sup) + __delete_min_insert(const _Tp& _M_key, bool _M_sup) { #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top! - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif - const T* keyp = &key; - int source = losers[0].source; - for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2) + const _Tp* _M_keyp = &_M_key; + int _M_source = __losers[0]._M_source; + for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2) { - // The smaller one gets promoted, ties are broken by source. - if (comp(*losers[pos].keyp, *keyp) - || (!comp(*keyp, *losers[pos].keyp) && losers[pos].source < source)) + // The smaller one gets promoted, ties are broken by _M_source. + if (__comp(*__losers[__pos]._M_keyp, *_M_keyp) + || (!__comp(*_M_keyp, *__losers[__pos]._M_keyp) && __losers[__pos]._M_source < _M_source)) { // The other one is smaller. - std::swap(losers[pos].source, source); - std::swap(losers[pos].keyp, keyp); + std::swap(__losers[__pos]._M_source, _M_source); + std::swap(__losers[__pos]._M_keyp, _M_keyp); } } - losers[0].source = source; - losers[0].keyp = keyp; + __losers[0]._M_source = _M_source; + __losers[0]._M_keyp = _M_keyp; } }; @@ -932,87 +932,87 @@ public: * * Stable variant is above. */ -template -class LoserTreePointerUnguarded : - public LoserTreePointerUnguardedBase +template +class LoserTreePointerUnguarded : + public LoserTreePointerUnguardedBase<_Tp, _Compare> { - typedef LoserTreePointerUnguardedBase Base; - using Base::k; - using Base::losers; + typedef LoserTreePointerUnguardedBase<_Tp, _Compare> Base; + using Base::__k; + using Base::__losers; public: - LoserTreePointerUnguarded(unsigned int _k, const T& _sentinel, - Comparator _comp = std::less()) + LoserTreePointerUnguarded(unsigned int _k, const _Tp& _sentinel, + _Compare _comp = std::less<_Tp>()) : Base::LoserTreePointerUnguardedBase(_k, _sentinel, _comp) {} unsigned int - init_winner(unsigned int root) + __init_winner(unsigned int __root) { - if (root >= k) + if (__root >= __k) { - return root; + return __root; } else { - unsigned int left = init_winner (2 * root); - unsigned int right = init_winner (2 * root + 1); + unsigned int __left = __init_winner (2 * __root); + unsigned int __right = __init_winner (2 * __root + 1); #if _GLIBCXX_ASSERTIONS - // If left one is sentinel then right one must be, too. - if (losers[left].source == -1) - _GLIBCXX_PARALLEL_ASSERT(losers[right].source == -1); + // If __left one is sentinel then __right one must be, too. + if (__losers[__left]._M_source == -1) + _GLIBCXX_PARALLEL_ASSERT(__losers[__right]._M_source == -1); #endif - if (!comp(*losers[right].keyp, *losers[left].keyp)) + if (!__comp(*__losers[__right]._M_keyp, *__losers[__left]._M_keyp)) { // Left one is less or equal. - losers[root] = losers[right]; - return left; + __losers[__root] = __losers[__right]; + return __left; } else { // Right one is less. - losers[root] = losers[left]; - return right; + __losers[__root] = __losers[__left]; + return __right; } } } inline void - init() + __init() { - losers[0] = losers[init_winner(1)]; + __losers[0] = __losers[__init_winner(1)]; #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top at the beginning (0 sequences!) - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif } inline void - delete_min_insert(const T& key, bool sup) + __delete_min_insert(const _Tp& _M_key, bool _M_sup) { #if _GLIBCXX_ASSERTIONS // no dummy sequence can ever be at the top! - _GLIBCXX_PARALLEL_ASSERT(losers[0].source != -1); + _GLIBCXX_PARALLEL_ASSERT(__losers[0]._M_source != -1); #endif - const T* keyp = &key; - int source = losers[0].source; - for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2) + const _Tp* _M_keyp = &_M_key; + int _M_source = __losers[0]._M_source; + for (unsigned int __pos = (__k + _M_source) / 2; __pos > 0; __pos /= 2) { // The smaller one gets promoted. - if (comp(*(losers[pos].keyp), *keyp)) + if (__comp(*(__losers[__pos]._M_keyp), *_M_keyp)) { // The other one is smaller. - std::swap(losers[pos].source, source); - std::swap(losers[pos].keyp, keyp); + std::swap(__losers[__pos]._M_source, _M_source); + std::swap(__losers[__pos]._M_keyp, _M_keyp); } } - losers[0].source = source; - losers[0].keyp = keyp; + __losers[0]._M_source = _M_source; + __losers[0]._M_keyp = _M_keyp; } }; diff --git a/libstdc++-v3/include/parallel/merge.h b/libstdc++-v3/include/parallel/merge.h index d947e258aa82..7b61ca692e8e 100644 --- a/libstdc++-v3/include/parallel/merge.h +++ b/libstdc++-v3/include/parallel/merge.h @@ -37,224 +37,224 @@ namespace __gnu_parallel { - /** @brief Merge routine being able to merge only the @c max_length + /** @brief Merge routine being able to merge only the @__c __max_length * smallest elements. * - * The @c begin iterators are advanced accordingly, they might not - * reach @c end, in contrast to the usual variant. - * @param begin1 Begin iterator of first sequence. - * @param end1 End iterator of first sequence. - * @param begin2 Begin iterator of second sequence. - * @param end2 End iterator of second sequence. - * @param target Target begin iterator. - * @param max_length Maximum number of elements to merge. - * @param comp Comparator. + * The @__c __begin iterators are advanced accordingly, they might not + * reach @__c __end, in contrast to the usual variant. + * @param __begin1 Begin iterator of first sequence. + * @param __end1 End iterator of first sequence. + * @param __begin2 Begin iterator of second sequence. + * @param __end2 End iterator of second sequence. + * @param __target Target begin iterator. + * @param __max_length Maximum number of elements to merge. + * @param __comp Comparator. * @return Output end iterator. */ - template - OutputIterator - merge_advance_usual(RandomAccessIterator1& begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2& begin2, - RandomAccessIterator2 end2, OutputIterator target, - _DifferenceTp max_length, Comparator comp) + template + _OutputIterator + __merge_advance_usual(_RAIter1& __begin1, + _RAIter1 __end1, + _RAIter2& __begin2, + _RAIter2 __end2, _OutputIterator __target, + _DifferenceTp __max_length, _Compare __comp) { - typedef _DifferenceTp difference_type; - while (begin1 != end1 && begin2 != end2 && max_length > 0) + typedef _DifferenceTp _DifferenceType; + while (__begin1 != __end1 && __begin2 != __end2 && __max_length > 0) { - // array1[i1] < array0[i0] - if (comp(*begin2, *begin1)) - *target++ = *begin2++; + // array1[__i1] < array0[i0] + if (__comp(*__begin2, *__begin1)) + *__target++ = *__begin2++; else - *target++ = *begin1++; - --max_length; + *__target++ = *__begin1++; + --__max_length; } - if (begin1 != end1) + if (__begin1 != __end1) { - target = std::copy(begin1, begin1 + max_length, target); - begin1 += max_length; + __target = std::copy(__begin1, __begin1 + __max_length, __target); + __begin1 += __max_length; } else { - target = std::copy(begin2, begin2 + max_length, target); - begin2 += max_length; + __target = std::copy(__begin2, __begin2 + __max_length, __target); + __begin2 += __max_length; } - return target; + return __target; } - /** @brief Merge routine being able to merge only the @c max_length + /** @brief Merge routine being able to merge only the @__c __max_length * smallest elements. * - * The @c begin iterators are advanced accordingly, they might not - * reach @c end, in contrast to the usual variant. + * The @__c __begin iterators are advanced accordingly, they might not + * reach @__c __end, in contrast to the usual variant. * Specially designed code should allow the compiler to generate * conditional moves instead of branches. - * @param begin1 Begin iterator of first sequence. - * @param end1 End iterator of first sequence. - * @param begin2 Begin iterator of second sequence. - * @param end2 End iterator of second sequence. - * @param target Target begin iterator. - * @param max_length Maximum number of elements to merge. - * @param comp Comparator. + * @param __begin1 Begin iterator of first sequence. + * @param __end1 End iterator of first sequence. + * @param __begin2 Begin iterator of second sequence. + * @param __end2 End iterator of second sequence. + * @param __target Target begin iterator. + * @param __max_length Maximum number of elements to merge. + * @param __comp Comparator. * @return Output end iterator. */ - template - OutputIterator - merge_advance_movc(RandomAccessIterator1& begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2& begin2, - RandomAccessIterator2 end2, - OutputIterator target, - _DifferenceTp max_length, Comparator comp) + template + _OutputIterator + __merge_advance_movc(_RAIter1& __begin1, + _RAIter1 __end1, + _RAIter2& __begin2, + _RAIter2 __end2, + _OutputIterator __target, + _DifferenceTp __max_length, _Compare __comp) { - typedef _DifferenceTp difference_type; - typedef typename std::iterator_traits::value_type + typedef _DifferenceTp _DifferenceType; + typedef typename std::iterator_traits<_RAIter1>::value_type value_type1; - typedef typename std::iterator_traits::value_type + typedef typename std::iterator_traits<_RAIter2>::value_type value_type2; #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(max_length >= 0); + _GLIBCXX_PARALLEL_ASSERT(__max_length >= 0); #endif - while (begin1 != end1 && begin2 != end2 && max_length > 0) + while (__begin1 != __end1 && __begin2 != __end2 && __max_length > 0) { - RandomAccessIterator1 next1 = begin1 + 1; - RandomAccessIterator2 next2 = begin2 + 1; - value_type1 element1 = *begin1; - value_type2 element2 = *begin2; + _RAIter1 __next1 = __begin1 + 1; + _RAIter2 __next2 = __begin2 + 1; + value_type1 __element1 = *__begin1; + value_type2 __element2 = *__begin2; - if (comp(element2, element1)) + if (__comp(__element2, __element1)) { - element1 = element2; - begin2 = next2; + __element1 = __element2; + __begin2 = __next2; } else - begin1 = next1; + __begin1 = __next1; - *target = element1; + *__target = __element1; - ++target; - --max_length; + ++__target; + --__max_length; } - if (begin1 != end1) + if (__begin1 != __end1) { - target = std::copy(begin1, begin1 + max_length, target); - begin1 += max_length; + __target = std::copy(__begin1, __begin1 + __max_length, __target); + __begin1 += __max_length; } else { - target = std::copy(begin2, begin2 + max_length, target); - begin2 += max_length; + __target = std::copy(__begin2, __begin2 + __max_length, __target); + __begin2 += __max_length; } - return target; + return __target; } - /** @brief Merge routine being able to merge only the @c max_length + /** @brief Merge routine being able to merge only the @__c __max_length * smallest elements. * - * The @c begin iterators are advanced accordingly, they might not - * reach @c end, in contrast to the usual variant. + * The @__c __begin iterators are advanced accordingly, they might not + * reach @__c __end, in contrast to the usual variant. * Static switch on whether to use the conditional-move variant. - * @param begin1 Begin iterator of first sequence. - * @param end1 End iterator of first sequence. - * @param begin2 Begin iterator of second sequence. - * @param end2 End iterator of second sequence. - * @param target Target begin iterator. - * @param max_length Maximum number of elements to merge. - * @param comp Comparator. + * @param __begin1 Begin iterator of first sequence. + * @param __end1 End iterator of first sequence. + * @param __begin2 Begin iterator of second sequence. + * @param __end2 End iterator of second sequence. + * @param __target Target begin iterator. + * @param __max_length Maximum number of elements to merge. + * @param __comp Comparator. * @return Output end iterator. */ - template - inline OutputIterator - merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, - RandomAccessIterator2& begin2, RandomAccessIterator2 end2, - OutputIterator target, _DifferenceTp max_length, - Comparator comp) + template + inline _OutputIterator + __merge_advance(_RAIter1& __begin1, _RAIter1 __end1, + _RAIter2& __begin2, _RAIter2 __end2, + _OutputIterator __target, _DifferenceTp __max_length, + _Compare __comp) { - _GLIBCXX_CALL(max_length) + _GLIBCXX_CALL(__max_length) - return merge_advance_movc(begin1, end1, begin2, end2, target, - max_length, comp); + return __merge_advance_movc(__begin1, __end1, __begin2, __end2, __target, + __max_length, __comp); } /** @brief Merge routine fallback to sequential in case the iterators of the two input sequences are of different type. - * @param begin1 Begin iterator of first sequence. - * @param end1 End iterator of first sequence. - * @param begin2 Begin iterator of second sequence. - * @param end2 End iterator of second sequence. - * @param target Target begin iterator. - * @param max_length Maximum number of elements to merge. - * @param comp Comparator. + * @param __begin1 Begin iterator of first sequence. + * @param __end1 End iterator of first sequence. + * @param __begin2 Begin iterator of second sequence. + * @param __end2 End iterator of second sequence. + * @param __target Target begin iterator. + * @param __max_length Maximum number of elements to merge. + * @param __comp Comparator. * @return Output end iterator. */ - template - inline RandomAccessIterator3 - parallel_merge_advance(RandomAccessIterator1& begin1, - RandomAccessIterator1 end1, - RandomAccessIterator2& begin2, + template + inline _RAIter3 + __parallel_merge_advance(_RAIter1& __begin1, + _RAIter1 __end1, + _RAIter2& __begin2, // different iterators, parallel implementation // not available - RandomAccessIterator2 end2, - RandomAccessIterator3 target, typename - std::iterator_traits:: - difference_type max_length, Comparator comp) - { return merge_advance(begin1, end1, begin2, end2, target, - max_length, comp); } + _RAIter2 __end2, + _RAIter3 __target, typename + std::iterator_traits<_RAIter1>:: + difference_type __max_length, _Compare __comp) + { return __merge_advance(__begin1, __end1, __begin2, __end2, __target, + __max_length, __comp); } - /** @brief Parallel merge routine being able to merge only the @c - * max_length smallest elements. + /** @brief Parallel merge routine being able to merge only the @__c + * __max_length smallest elements. * - * The @c begin iterators are advanced accordingly, they might not - * reach @c end, in contrast to the usual variant. + * The @__c __begin iterators are advanced accordingly, they might not + * reach @__c __end, in contrast to the usual variant. * The functionality is projected onto parallel_multiway_merge. - * @param begin1 Begin iterator of first sequence. - * @param end1 End iterator of first sequence. - * @param begin2 Begin iterator of second sequence. - * @param end2 End iterator of second sequence. - * @param target Target begin iterator. - * @param max_length Maximum number of elements to merge. - * @param comp Comparator. + * @param __begin1 Begin iterator of first sequence. + * @param __end1 End iterator of first sequence. + * @param __begin2 Begin iterator of second sequence. + * @param __end2 End iterator of second sequence. + * @param __target Target begin iterator. + * @param __max_length Maximum number of elements to merge. + * @param __comp Comparator. * @return Output end iterator. */ - template - inline RandomAccessIterator3 - parallel_merge_advance(RandomAccessIterator1& begin1, - RandomAccessIterator1 end1, - RandomAccessIterator1& begin2, - RandomAccessIterator1 end2, - RandomAccessIterator3 target, typename - std::iterator_traits:: - difference_type max_length, Comparator comp) + template + inline _RAIter3 + __parallel_merge_advance(_RAIter1& __begin1, + _RAIter1 __end1, + _RAIter1& __begin2, + _RAIter1 __end2, + _RAIter3 __target, typename + std::iterator_traits<_RAIter1>:: + difference_type __max_length, _Compare __comp) { typedef typename - std::iterator_traits::value_type value_type; - typedef typename std::iterator_traits:: - difference_type difference_type1 /* == difference_type2 */; - typedef typename std::iterator_traits:: - difference_type difference_type3; - typedef typename std::pair - iterator_pair; + std::iterator_traits<_RAIter1>::value_type _ValueType; + typedef typename std::iterator_traits<_RAIter1>:: + difference_type _DifferenceType1 /* == difference_type2 */; + typedef typename std::iterator_traits<_RAIter3>:: + difference_type _DifferenceType3; + typedef typename std::pair<_RAIter1, _RAIter1> + _IteratorPair; - iterator_pair - seqs[2] = { std::make_pair(begin1, end1), - std::make_pair(begin2, end2) }; - RandomAccessIterator3 - target_end = parallel_multiway_merge - < /* stable = */ true, /* sentinels = */ false>( - seqs, seqs + 2, target, + _IteratorPair + seqs[2] = { std::make_pair(__begin1, __end1), + std::make_pair(__begin2, __end2) }; + _RAIter3 + __target_end = parallel_multiway_merge + < /* __stable = */ true, /* __sentinels = */ false>( + seqs, seqs + 2, __target, multiway_merge_exact_splitting - < /* stable = */ true, iterator_pair*, - Comparator, difference_type1>, - max_length, comp, omp_get_max_threads()); + < /* __stable = */ true, _IteratorPair*, + _Compare, _DifferenceType1>, + __max_length, __comp, omp_get_max_threads()); - return target_end; + return __target_end; } } //namespace __gnu_parallel diff --git a/libstdc++-v3/include/parallel/multiseq_selection.h b/libstdc++-v3/include/parallel/multiseq_selection.h index 6ef3d22b15c3..353330e3f5ae 100644 --- a/libstdc++-v3/include/parallel/multiseq_selection.h +++ b/libstdc++-v3/include/parallel/multiseq_selection.h @@ -23,7 +23,7 @@ // . /** @file parallel/multiseq_selection.h - * @brief Functions to find elements of a certain global rank in + * @brief Functions to find elements of a certain global __rank in * multiple sorted sequences. Also serves for splitting such * sequence sets. * @@ -50,275 +50,275 @@ namespace __gnu_parallel { - /** @brief Compare a pair of types lexicographically, ascending. */ - template - class lexicographic - : public std::binary_function, std::pair, bool> + /** @brief Compare __a pair of types lexicographically, ascending. */ + template + class _Lexicographic + : public std::binary_function, std::pair<_T1, _T2>, bool> { private: - Comparator& comp; + _Compare& __comp; public: - lexicographic(Comparator& _comp) : comp(_comp) { } + _Lexicographic(_Compare& _comp) : __comp(_comp) { } bool - operator()(const std::pair& p1, - const std::pair& p2) const + operator()(const std::pair<_T1, _T2>& __p1, + const std::pair<_T1, _T2>& __p2) const { - if (comp(p1.first, p2.first)) + if (__comp(__p1.first, __p2.first)) return true; - if (comp(p2.first, p1.first)) + if (__comp(__p2.first, __p1.first)) return false; // Firsts are equal. - return p1.second < p2.second; + return __p1.second < __p2.second; } }; - /** @brief Compare a pair of types lexicographically, descending. */ - template - class lexicographic_reverse : public std::binary_function + /** @brief Compare __a pair of types lexicographically, descending. */ + template + class _LexicographicReverse : public std::binary_function<_T1, _T2, bool> { private: - Comparator& comp; + _Compare& __comp; public: - lexicographic_reverse(Comparator& _comp) : comp(_comp) { } + _LexicographicReverse(_Compare& _comp) : __comp(_comp) { } bool - operator()(const std::pair& p1, - const std::pair& p2) const + operator()(const std::pair<_T1, _T2>& __p1, + const std::pair<_T1, _T2>& __p2) const { - if (comp(p2.first, p1.first)) + if (__comp(__p2.first, __p1.first)) return true; - if (comp(p1.first, p2.first)) + if (__comp(__p1.first, __p2.first)) return false; // Firsts are equal. - return p2.second < p1.second; + return __p2.second < __p1.second; } }; /** - * @brief Splits several sorted sequences at a certain global rank, + * @brief Splits several sorted sequences at __a certain global __rank, * resulting in a splitting point for each sequence. - * The sequences are passed via a sequence of random-access + * The sequences are passed via __a __sequence of random-access * iterator pairs, none of the sequences may be empty. If there * are several equal elements across the split, the ones on the - * left side will be chosen from sequences with smaller number. - * @param begin_seqs Begin of the sequence of iterator pairs. - * @param end_seqs End of the sequence of iterator pairs. - * @param rank The global rank to partition at. - * @param begin_offsets A random-access sequence begin where the - * result will be stored in. Each element of the sequence is an + * __left side will be chosen from sequences with smaller number. + * @param __begin_seqs Begin of the sequence of iterator pairs. + * @param __end_seqs End of the sequence of iterator pairs. + * @param __rank The global __rank to partition at. + * @param __begin_offsets A random-access __sequence __begin where the + * __result will be stored in. Each element of the sequence is an * iterator that points to the first element on the greater part of - * the respective sequence. - * @param comp The ordering functor, defaults to std::less. + * the respective __sequence. + * @param __comp The ordering functor, defaults to std::less<_Tp>. */ - template + template void - multiseq_partition(RanSeqs begin_seqs, RanSeqs end_seqs, - RankType rank, - RankIterator begin_offsets, - Comparator comp = std::less< + multiseq_partition(_RanSeqs __begin_seqs, _RanSeqs __end_seqs, + _RankType __rank, + _RankIterator __begin_offsets, + _Compare __comp = std::less< typename std::iterator_traits::value_type:: - first_type>::value_type>()) // std::less + std::iterator_traits<_RanSeqs>::value_type:: + first_type>::value_type>()) // std::less<_Tp> { - _GLIBCXX_CALL(end_seqs - begin_seqs) + _GLIBCXX_CALL(__end_seqs - __begin_seqs) - typedef typename std::iterator_traits::value_type::first_type - It; - typedef typename std::iterator_traits::difference_type - difference_type; - typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits<_RanSeqs>::value_type::first_type + _It; + typedef typename std::iterator_traits<_It>::difference_type + _DifferenceType; + typedef typename std::iterator_traits<_It>::value_type _ValueType; - lexicographic lcomp(comp); - lexicographic_reverse lrcomp(comp); + _Lexicographic<_ValueType, int, _Compare> __lcomp(__comp); + _LexicographicReverse<_ValueType, int, _Compare> __lrcomp(__comp); // Number of sequences, number of elements in total (possibly // including padding). - difference_type m = std::distance(begin_seqs, end_seqs), N = 0, - nmax, n, r; + _DifferenceType __m = std::distance(__begin_seqs, __end_seqs), __N = 0, + __nmax, __n, __r; - for (int i = 0; i < m; i++) + for (int __i = 0; __i < __m; __i++) { - N += std::distance(begin_seqs[i].first, begin_seqs[i].second); + __N += std::distance(__begin_seqs[__i].first, __begin_seqs[__i].second); _GLIBCXX_PARALLEL_ASSERT( - std::distance(begin_seqs[i].first, begin_seqs[i].second) > 0); + std::distance(__begin_seqs[__i].first, __begin_seqs[__i].second) > 0); } - if (rank == N) + if (__rank == __N) { - for (int i = 0; i < m; i++) - begin_offsets[i] = begin_seqs[i].second; // Very end. - // Return m - 1; + for (int __i = 0; __i < __m; __i++) + __begin_offsets[__i] = __begin_seqs[__i].second; // Very end. + // Return __m - 1; return; } - _GLIBCXX_PARALLEL_ASSERT(m != 0); - _GLIBCXX_PARALLEL_ASSERT(N != 0); - _GLIBCXX_PARALLEL_ASSERT(rank >= 0); - _GLIBCXX_PARALLEL_ASSERT(rank < N); + _GLIBCXX_PARALLEL_ASSERT(__m != 0); + _GLIBCXX_PARALLEL_ASSERT(__N != 0); + _GLIBCXX_PARALLEL_ASSERT(__rank >= 0); + _GLIBCXX_PARALLEL_ASSERT(__rank < __N); - difference_type* ns = new difference_type[m]; - difference_type* a = new difference_type[m]; - difference_type* b = new difference_type[m]; - difference_type l; + _DifferenceType* __ns = new _DifferenceType[__m]; + _DifferenceType* __a = new _DifferenceType[__m]; + _DifferenceType* __b = new _DifferenceType[__m]; + _DifferenceType __l; - ns[0] = std::distance(begin_seqs[0].first, begin_seqs[0].second); - nmax = ns[0]; - for (int i = 0; i < m; i++) + __ns[0] = std::distance(__begin_seqs[0].first, __begin_seqs[0].second); + __nmax = __ns[0]; + for (int __i = 0; __i < __m; __i++) { - ns[i] = std::distance(begin_seqs[i].first, begin_seqs[i].second); - nmax = std::max(nmax, ns[i]); + __ns[__i] = std::distance(__begin_seqs[__i].first, __begin_seqs[__i].second); + __nmax = std::max(__nmax, __ns[__i]); } - r = __log2(nmax) + 1; + __r = __log2(__nmax) + 1; - // Pad all lists to this length, at least as long as any ns[i], - // equality iff nmax = 2^k - 1. - l = (1ULL << r) - 1; + // Pad all lists to this length, at least as long as any ns[__i], + // equality iff __nmax = 2^__k - 1. + __l = (1ULL << __r) - 1; // From now on, including padding. - N = l * m; + __N = __l * __m; - for (int i = 0; i < m; i++) + for (int __i = 0; __i < __m; __i++) { - a[i] = 0; - b[i] = l; + __a[__i] = 0; + __b[__i] = __l; } - n = l / 2; + __n = __l / 2; // Invariants: - // 0 <= a[i] <= ns[i], 0 <= b[i] <= l + // 0 <= __a[__i] <= __ns[__i], 0 <= __b[__i] <= __l -#define S(i) (begin_seqs[i].first) +#define __S(__i) (__begin_seqs[__i].first) // Initial partition. - std::vector > sample; + std::vector > __sample; - for (int i = 0; i < m; i++) - if (n < ns[i]) //sequence long enough - sample.push_back(std::make_pair(S(i)[n], i)); - __gnu_sequential::sort(sample.begin(), sample.end(), lcomp); + for (int __i = 0; __i < __m; __i++) + if (__n < __ns[__i]) //__sequence long enough + __sample.push_back(std::make_pair(__S(__i)[__n], __i)); + __gnu_sequential::sort(__sample.begin(), __sample.end(), __lcomp); - for (int i = 0; i < m; i++) //conceptual infinity - if (n >= ns[i]) //sequence too short, conceptual infinity - sample.push_back(std::make_pair(S(i)[0] /*dummy element*/, i)); + for (int __i = 0; __i < __m; __i++) //conceptual infinity + if (__n >= __ns[__i]) //__sequence too short, conceptual infinity + __sample.push_back(std::make_pair(__S(__i)[0] /*__dummy element*/, __i)); - difference_type localrank = rank * m / N ; + _DifferenceType localrank = __rank * __m / __N ; - int j; - for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); ++j) - a[sample[j].second] += n + 1; - for (; j < m; j++) - b[sample[j].second] -= n + 1; + int __j; + for (__j = 0; __j < localrank && ((__n + 1) <= __ns[__sample[__j].second]); ++__j) + __a[__sample[__j].second] += __n + 1; + for (; __j < __m; __j++) + __b[__sample[__j].second] -= __n + 1; // Further refinement. - while (n > 0) + while (__n > 0) { - n /= 2; + __n /= 2; - int lmax_seq = -1; // to avoid warning - const value_type* lmax = NULL; // impossible to avoid the warning? - for (int i = 0; i < m; i++) + int __lmax_seq = -1; // to avoid warning + const _ValueType* __lmax = NULL; // impossible to avoid the warning? + for (int __i = 0; __i < __m; __i++) { - if (a[i] > 0) + if (__a[__i] > 0) { - if (!lmax) + if (!__lmax) { - lmax = &(S(i)[a[i] - 1]); - lmax_seq = i; + __lmax = &(__S(__i)[__a[__i] - 1]); + __lmax_seq = __i; } else { // Max, favor rear sequences. - if (!comp(S(i)[a[i] - 1], *lmax)) + if (!__comp(__S(__i)[__a[__i] - 1], *__lmax)) { - lmax = &(S(i)[a[i] - 1]); - lmax_seq = i; + __lmax = &(__S(__i)[__a[__i] - 1]); + __lmax_seq = __i; } } } } - int i; - for (i = 0; i < m; i++) + int __i; + for (__i = 0; __i < __m; __i++) { - difference_type middle = (b[i] + a[i]) / 2; - if (lmax && middle < ns[i] && - lcomp(std::make_pair(S(i)[middle], i), - std::make_pair(*lmax, lmax_seq))) - a[i] = std::min(a[i] + n + 1, ns[i]); + _DifferenceType __middle = (__b[__i] + __a[__i]) / 2; + if (__lmax && __middle < __ns[__i] && + __lcomp(std::make_pair(__S(__i)[__middle], __i), + std::make_pair(*__lmax, __lmax_seq))) + __a[__i] = std::min(__a[__i] + __n + 1, __ns[__i]); else - b[i] -= n + 1; + __b[__i] -= __n + 1; } - difference_type leftsize = 0, total = 0; - for (int i = 0; i < m; i++) + _DifferenceType __leftsize = 0, __total = 0; + for (int __i = 0; __i < __m; __i++) { - leftsize += a[i] / (n + 1); - total += l / (n + 1); + __leftsize += __a[__i] / (__n + 1); + __total += __l / (__n + 1); } - difference_type skew = static_cast - (static_cast(total) * rank / N - leftsize); + _DifferenceType __skew = static_cast<_DifferenceType> + (static_cast(__total) * __rank / __N - __leftsize); - if (skew > 0) + if (__skew > 0) { // Move to the left, find smallest. - std::priority_queue, - std::vector >, - lexicographic_reverse > - pq(lrcomp); + std::priority_queue, + std::vector >, + _LexicographicReverse<_ValueType, int, _Compare> > + __pq(__lrcomp); - for (int i = 0; i < m; i++) - if (b[i] < ns[i]) - pq.push(std::make_pair(S(i)[b[i]], i)); + for (int __i = 0; __i < __m; __i++) + if (__b[__i] < __ns[__i]) + __pq.push(std::make_pair(__S(__i)[__b[__i]], __i)); - for (; skew != 0 && !pq.empty(); --skew) + for (; __skew != 0 && !__pq.empty(); --__skew) { - int source = pq.top().second; - pq.pop(); + int source = __pq.top().second; + __pq.pop(); - a[source] = std::min(a[source] + n + 1, ns[source]); - b[source] += n + 1; + __a[source] = std::min(__a[source] + __n + 1, __ns[source]); + __b[source] += __n + 1; - if (b[source] < ns[source]) - pq.push(std::make_pair(S(source)[b[source]], source)); + if (__b[source] < __ns[source]) + __pq.push(std::make_pair(__S(source)[__b[source]], source)); } } - else if (skew < 0) + else if (__skew < 0) { // Move to the right, find greatest. - std::priority_queue, - std::vector >, - lexicographic > pq(lcomp); + std::priority_queue, + std::vector >, + _Lexicographic<_ValueType, int, _Compare> > __pq(__lcomp); - for (int i = 0; i < m; i++) - if (a[i] > 0) - pq.push(std::make_pair(S(i)[a[i] - 1], i)); + for (int __i = 0; __i < __m; __i++) + if (__a[__i] > 0) + __pq.push(std::make_pair(__S(__i)[__a[__i] - 1], __i)); - for (; skew != 0; ++skew) + for (; __skew != 0; ++__skew) { - int source = pq.top().second; - pq.pop(); + int source = __pq.top().second; + __pq.pop(); - a[source] -= n + 1; - b[source] -= n + 1; + __a[source] -= __n + 1; + __b[source] -= __n + 1; - if (a[source] > 0) - pq.push(std::make_pair(S(source)[a[source] - 1], source)); + if (__a[source] > 0) + __pq.push(std::make_pair(__S(source)[__a[source] - 1], source)); } } } // Postconditions: - // a[i] == b[i] in most cases, except when a[i] has been clamped + // __a[__i] == __b[__i] in most cases, except when __a[__i] has been clamped // because of having reached the boundary // Now return the result, calculate the offset. @@ -326,236 +326,236 @@ namespace __gnu_parallel // Compare the keys on both edges of the border. // Maximum of left edge, minimum of right edge. - value_type* maxleft = NULL; - value_type* minright = NULL; - for (int i = 0; i < m; i++) + _ValueType* __maxleft = NULL; + _ValueType* __minright = NULL; + for (int __i = 0; __i < __m; __i++) { - if (a[i] > 0) + if (__a[__i] > 0) { - if (!maxleft) - maxleft = &(S(i)[a[i] - 1]); + if (!__maxleft) + __maxleft = &(__S(__i)[__a[__i] - 1]); else { // Max, favor rear sequences. - if (!comp(S(i)[a[i] - 1], *maxleft)) - maxleft = &(S(i)[a[i] - 1]); + if (!__comp(__S(__i)[__a[__i] - 1], *__maxleft)) + __maxleft = &(__S(__i)[__a[__i] - 1]); } } - if (b[i] < ns[i]) + if (__b[__i] < __ns[__i]) { - if (!minright) - minright = &(S(i)[b[i]]); + if (!__minright) + __minright = &(__S(__i)[__b[__i]]); else { // Min, favor fore sequences. - if (comp(S(i)[b[i]], *minright)) - minright = &(S(i)[b[i]]); + if (__comp(__S(__i)[__b[__i]], *__minright)) + __minright = &(__S(__i)[__b[__i]]); } } } - int seq = 0; - for (int i = 0; i < m; i++) - begin_offsets[i] = S(i) + a[i]; + int __seq = 0; + for (int __i = 0; __i < __m; __i++) + __begin_offsets[__i] = __S(__i) + __a[__i]; - delete[] ns; - delete[] a; - delete[] b; + delete[] __ns; + delete[] __a; + delete[] __b; } /** - * @brief Selects the element at a certain global rank from several + * @brief Selects the element at __a certain global __rank from several * sorted sequences. * - * The sequences are passed via a sequence of random-access + * The sequences are passed via __a __sequence of random-access * iterator pairs, none of the sequences may be empty. - * @param begin_seqs Begin of the sequence of iterator pairs. - * @param end_seqs End of the sequence of iterator pairs. - * @param rank The global rank to partition at. - * @param offset The rank of the selected element in the global + * @param __begin_seqs Begin of the sequence of iterator pairs. + * @param __end_seqs End of the sequence of iterator pairs. + * @param __rank The global __rank to partition at. + * @param __offset The rank of the selected element in the global * subsequence of elements equal to the selected element. If the * selected element is unique, this number is 0. - * @param comp The ordering functor, defaults to std::less. + * @param __comp The ordering functor, defaults to std::less. */ - template - T - multiseq_selection(RanSeqs begin_seqs, RanSeqs end_seqs, RankType rank, - RankType& offset, Comparator comp = std::less()) + template + _Tp + multiseq_selection(_RanSeqs __begin_seqs, _RanSeqs __end_seqs, _RankType __rank, + _RankType& __offset, _Compare __comp = std::less<_Tp>()) { - _GLIBCXX_CALL(end_seqs - begin_seqs) + _GLIBCXX_CALL(__end_seqs - __begin_seqs) - typedef typename std::iterator_traits::value_type::first_type - It; - typedef typename std::iterator_traits::difference_type - difference_type; + typedef typename std::iterator_traits<_RanSeqs>::value_type::first_type + _It; + typedef typename std::iterator_traits<_It>::difference_type + _DifferenceType; - lexicographic lcomp(comp); - lexicographic_reverse lrcomp(comp); + _Lexicographic<_Tp, int, _Compare> __lcomp(__comp); + _LexicographicReverse<_Tp, int, _Compare> __lrcomp(__comp); // Number of sequences, number of elements in total (possibly // including padding). - difference_type m = std::distance(begin_seqs, end_seqs); - difference_type N = 0; - difference_type nmax, n, r; + _DifferenceType __m = std::distance(__begin_seqs, __end_seqs); + _DifferenceType __N = 0; + _DifferenceType __nmax, __n, __r; - for (int i = 0; i < m; i++) - N += std::distance(begin_seqs[i].first, begin_seqs[i].second); + for (int __i = 0; __i < __m; __i++) + __N += std::distance(__begin_seqs[__i].first, __begin_seqs[__i].second); - if (m == 0 || N == 0 || rank < 0 || rank >= N) + if (__m == 0 || __N == 0 || __rank < 0 || __rank >= __N) { - // Result undefined when there is no data or rank is outside bounds. + // _Result undefined when there is no data or __rank is outside bounds. throw std::exception(); } - difference_type* ns = new difference_type[m]; - difference_type* a = new difference_type[m]; - difference_type* b = new difference_type[m]; - difference_type l; + _DifferenceType* __ns = new _DifferenceType[__m]; + _DifferenceType* __a = new _DifferenceType[__m]; + _DifferenceType* __b = new _DifferenceType[__m]; + _DifferenceType __l; - ns[0] = std::distance(begin_seqs[0].first, begin_seqs[0].second); - nmax = ns[0]; - for (int i = 0; i < m; ++i) + __ns[0] = std::distance(__begin_seqs[0].first, __begin_seqs[0].second); + __nmax = __ns[0]; + for (int __i = 0; __i < __m; ++__i) { - ns[i] = std::distance(begin_seqs[i].first, begin_seqs[i].second); - nmax = std::max(nmax, ns[i]); + __ns[__i] = std::distance(__begin_seqs[__i].first, __begin_seqs[__i].second); + __nmax = std::max(__nmax, __ns[__i]); } - r = __log2(nmax) + 1; + __r = __log2(__nmax) + 1; - // Pad all lists to this length, at least as long as any ns[i], - // equality iff nmax = 2^k - 1 - l = pow2(r) - 1; + // Pad all lists to this length, at least as long as any ns[__i], + // equality iff __nmax = 2^__k - 1 + __l = pow2(__r) - 1; // From now on, including padding. - N = l * m; + __N = __l * __m; - for (int i = 0; i < m; ++i) + for (int __i = 0; __i < __m; ++__i) { - a[i] = 0; - b[i] = l; + __a[__i] = 0; + __b[__i] = __l; } - n = l / 2; + __n = __l / 2; // Invariants: - // 0 <= a[i] <= ns[i], 0 <= b[i] <= l + // 0 <= __a[__i] <= __ns[__i], 0 <= __b[__i] <= __l -#define S(i) (begin_seqs[i].first) +#define __S(__i) (__begin_seqs[__i].first) // Initial partition. - std::vector > sample; + std::vector > __sample; - for (int i = 0; i < m; i++) - if (n < ns[i]) - sample.push_back(std::make_pair(S(i)[n], i)); - __gnu_sequential::sort(sample.begin(), sample.end(), - lcomp, sequential_tag()); + for (int __i = 0; __i < __m; __i++) + if (__n < __ns[__i]) + __sample.push_back(std::make_pair(__S(__i)[__n], __i)); + __gnu_sequential::sort(__sample.begin(), __sample.end(), + __lcomp, sequential_tag()); // Conceptual infinity. - for (int i = 0; i < m; i++) - if (n >= ns[i]) - sample.push_back(std::make_pair(S(i)[0] /*dummy element*/, i)); + for (int __i = 0; __i < __m; __i++) + if (__n >= __ns[__i]) + __sample.push_back(std::make_pair(__S(__i)[0] /*__dummy element*/, __i)); - difference_type localrank = rank * m / N ; + _DifferenceType localrank = __rank * __m / __N ; - int j; - for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); ++j) - a[sample[j].second] += n + 1; - for (; j < m; ++j) - b[sample[j].second] -= n + 1; + int __j; + for (__j = 0; __j < localrank && ((__n + 1) <= __ns[__sample[__j].second]); ++__j) + __a[__sample[__j].second] += __n + 1; + for (; __j < __m; ++__j) + __b[__sample[__j].second] -= __n + 1; // Further refinement. - while (n > 0) + while (__n > 0) { - n /= 2; + __n /= 2; - const T* lmax = NULL; - for (int i = 0; i < m; ++i) + const _Tp* __lmax = NULL; + for (int __i = 0; __i < __m; ++__i) { - if (a[i] > 0) + if (__a[__i] > 0) { - if (!lmax) - lmax = &(S(i)[a[i] - 1]); + if (!__lmax) + __lmax = &(__S(__i)[__a[__i] - 1]); else { - if (comp(*lmax, S(i)[a[i] - 1])) //max - lmax = &(S(i)[a[i] - 1]); + if (__comp(*__lmax, __S(__i)[__a[__i] - 1])) //max + __lmax = &(__S(__i)[__a[__i] - 1]); } } } - int i; - for (i = 0; i < m; i++) + int __i; + for (__i = 0; __i < __m; __i++) { - difference_type middle = (b[i] + a[i]) / 2; - if (lmax && middle < ns[i] && comp(S(i)[middle], *lmax)) - a[i] = std::min(a[i] + n + 1, ns[i]); + _DifferenceType __middle = (__b[__i] + __a[__i]) / 2; + if (__lmax && __middle < __ns[__i] && __comp(__S(__i)[__middle], *__lmax)) + __a[__i] = std::min(__a[__i] + __n + 1, __ns[__i]); else - b[i] -= n + 1; + __b[__i] -= __n + 1; } - difference_type leftsize = 0, total = 0; - for (int i = 0; i < m; ++i) + _DifferenceType __leftsize = 0, __total = 0; + for (int __i = 0; __i < __m; ++__i) { - leftsize += a[i] / (n + 1); - total += l / (n + 1); + __leftsize += __a[__i] / (__n + 1); + __total += __l / (__n + 1); } - difference_type skew = ((unsigned long long)total * rank / N - - leftsize); + _DifferenceType __skew = ((unsigned long long)__total * __rank / __N + - __leftsize); - if (skew > 0) + if (__skew > 0) { // Move to the left, find smallest. - std::priority_queue, - std::vector >, - lexicographic_reverse > pq(lrcomp); + std::priority_queue, + std::vector >, + _LexicographicReverse<_Tp, int, _Compare> > __pq(__lrcomp); - for (int i = 0; i < m; ++i) - if (b[i] < ns[i]) - pq.push(std::make_pair(S(i)[b[i]], i)); + for (int __i = 0; __i < __m; ++__i) + if (__b[__i] < __ns[__i]) + __pq.push(std::make_pair(__S(__i)[__b[__i]], __i)); - for (; skew != 0 && !pq.empty(); --skew) + for (; __skew != 0 && !__pq.empty(); --__skew) { - int source = pq.top().second; - pq.pop(); + int source = __pq.top().second; + __pq.pop(); - a[source] = std::min(a[source] + n + 1, ns[source]); - b[source] += n + 1; + __a[source] = std::min(__a[source] + __n + 1, __ns[source]); + __b[source] += __n + 1; - if (b[source] < ns[source]) - pq.push(std::make_pair(S(source)[b[source]], source)); + if (__b[source] < __ns[source]) + __pq.push(std::make_pair(__S(source)[__b[source]], source)); } } - else if (skew < 0) + else if (__skew < 0) { // Move to the right, find greatest. - std::priority_queue, - std::vector >, - lexicographic > pq(lcomp); + std::priority_queue, + std::vector >, + _Lexicographic<_Tp, int, _Compare> > __pq(__lcomp); - for (int i = 0; i < m; ++i) - if (a[i] > 0) - pq.push(std::make_pair(S(i)[a[i] - 1], i)); + for (int __i = 0; __i < __m; ++__i) + if (__a[__i] > 0) + __pq.push(std::make_pair(__S(__i)[__a[__i] - 1], __i)); - for (; skew != 0; ++skew) + for (; __skew != 0; ++__skew) { - int source = pq.top().second; - pq.pop(); + int source = __pq.top().second; + __pq.pop(); - a[source] -= n + 1; - b[source] -= n + 1; + __a[source] -= __n + 1; + __b[source] -= __n + 1; - if (a[source] > 0) - pq.push(std::make_pair(S(source)[a[source] - 1], source)); + if (__a[source] > 0) + __pq.push(std::make_pair(__S(source)[__a[source] - 1], source)); } } } // Postconditions: - // a[i] == b[i] in most cases, except when a[i] has been clamped + // __a[__i] == __b[__i] in most cases, except when __a[__i] has been clamped // because of having reached the boundary // Now return the result, calculate the offset. @@ -563,71 +563,71 @@ namespace __gnu_parallel // Compare the keys on both edges of the border. // Maximum of left edge, minimum of right edge. - bool maxleftset = false, minrightset = false; + bool __maxleftset = false, __minrightset = false; // Impossible to avoid the warning? - T maxleft, minright; - for (int i = 0; i < m; ++i) + _Tp __maxleft, __minright; + for (int __i = 0; __i < __m; ++__i) { - if (a[i] > 0) + if (__a[__i] > 0) { - if (!maxleftset) + if (!__maxleftset) { - maxleft = S(i)[a[i] - 1]; - maxleftset = true; + __maxleft = __S(__i)[__a[__i] - 1]; + __maxleftset = true; } else { // Max. - if (comp(maxleft, S(i)[a[i] - 1])) - maxleft = S(i)[a[i] - 1]; + if (__comp(__maxleft, __S(__i)[__a[__i] - 1])) + __maxleft = __S(__i)[__a[__i] - 1]; } } - if (b[i] < ns[i]) + if (__b[__i] < __ns[__i]) { - if (!minrightset) + if (!__minrightset) { - minright = S(i)[b[i]]; - minrightset = true; + __minright = __S(__i)[__b[__i]]; + __minrightset = true; } else { // Min. - if (comp(S(i)[b[i]], minright)) - minright = S(i)[b[i]]; + if (__comp(__S(__i)[__b[__i]], __minright)) + __minright = __S(__i)[__b[__i]]; } } } // Minright is the splitter, in any case. - if (!maxleftset || comp(minright, maxleft)) + if (!__maxleftset || __comp(__minright, __maxleft)) { // Good luck, everything is split unambiguously. - offset = 0; + __offset = 0; } else { // We have to calculate an offset. - offset = 0; + __offset = 0; - for (int i = 0; i < m; ++i) + for (int __i = 0; __i < __m; ++__i) { - difference_type lb = std::lower_bound(S(i), S(i) + ns[i], - minright, - comp) - S(i); - offset += a[i] - lb; + _DifferenceType lb = std::lower_bound(__S(__i), __S(__i) + __ns[__i], + __minright, + __comp) - __S(__i); + __offset += __a[__i] - lb; } } - delete[] ns; - delete[] a; - delete[] b; + delete[] __ns; + delete[] __a; + delete[] __b; - return minright; + return __minright; } } -#undef S +#undef __S #endif /* _GLIBCXX_PARALLEL_MULTISEQ_SELECTION_H */ diff --git a/libstdc++-v3/include/parallel/multiway_merge.h b/libstdc++-v3/include/parallel/multiway_merge.h index fe32053d6c1f..0aa661fe6dad 100644 --- a/libstdc++-v3/include/parallel/multiway_merge.h +++ b/libstdc++-v3/include/parallel/multiway_merge.h @@ -50,303 +50,303 @@ #endif /** @brief Length of a sequence described by a pair of iterators. */ -#define _GLIBCXX_PARALLEL_LENGTH(s) ((s).second - (s).first) +#define _GLIBCXX_PARALLEL_LENGTH(__s) ((__s).second - (__s).first) namespace __gnu_parallel { // Announce guarded and unguarded iterator. -template - class guarded_iterator; +template + class _GuardedIterator; // Making the arguments const references seems to dangerous, // the user-defined comparator might not be const. -template +template inline bool - operator<(guarded_iterator& bi1, - guarded_iterator& bi2); + operator<(_GuardedIterator<_RAIter, _Compare>& __bi1, + _GuardedIterator<_RAIter, _Compare>& __bi2); -template +template inline bool - operator<=(guarded_iterator& bi1, - guarded_iterator& bi2); + operator<=(_GuardedIterator<_RAIter, _Compare>& __bi1, + _GuardedIterator<_RAIter, _Compare>& __bi2); -/** @brief Iterator wrapper supporting an implicit supremum at the end +/** @brief _Iterator wrapper supporting an implicit __supremum at the end * of the sequence, dominating all comparisons. * - * The implicit supremum comes with a performance cost. + * The implicit __supremum comes with __a performance cost. * - * Deriving from RandomAccessIterator is not possible since - * RandomAccessIterator need not be a class. + * Deriving from _RAIter is not possible since + * _RAIter need not be __a class. */ -template - class guarded_iterator +template + class _GuardedIterator { private: - /** @brief Current iterator position. */ - RandomAccessIterator current; + /** @brief Current iterator __position. */ + _RAIter _M_current; /** @brief End iterator of the sequence. */ - RandomAccessIterator end; + _RAIter _M_end; - /** @brief Comparator. */ - Comparator& comp; + /** @brief _Compare. */ + _Compare& __comp; public: /** @brief Constructor. Sets iterator to beginning of sequence. - * @param begin Begin iterator of sequence. - * @param end End iterator of sequence. - * @param comp Comparator provided for associated overloaded + * @param __begin Begin iterator of sequence. + * @param _M_end End iterator of sequence. + * @param __comp Comparator provided for associated overloaded * compare operators. */ - guarded_iterator(RandomAccessIterator begin, - RandomAccessIterator end, Comparator& comp) - : current(begin), end(end), comp(comp) + _GuardedIterator(_RAIter __begin, + _RAIter _M_end, _Compare& __comp) + : _M_current(__begin), _M_end(_M_end), __comp(__comp) { } /** @brief Pre-increment operator. * @return This. */ - guarded_iterator& + _GuardedIterator<_RAIter, _Compare>& operator++() { - ++current; + ++_M_current; return *this; } /** @brief Dereference operator. * @return Referenced element. */ - typename std::iterator_traits::value_type& + typename std::iterator_traits<_RAIter>::value_type& operator*() - { return *current; } + { return *_M_current; } /** @brief Convert to wrapped iterator. * @return Wrapped iterator. */ - operator RandomAccessIterator() - { return current; } + operator _RAIter() + { return _M_current; } friend bool - operator< ( - guarded_iterator& bi1, - guarded_iterator& bi2); + operator< <_RAIter, _Compare>( + _GuardedIterator<_RAIter, _Compare>& __bi1, + _GuardedIterator<_RAIter, _Compare>& __bi2); friend bool - operator<= ( - guarded_iterator& bi1, - guarded_iterator& bi2); + operator<= <_RAIter, _Compare>( + _GuardedIterator<_RAIter, _Compare>& __bi1, + _GuardedIterator<_RAIter, _Compare>& __bi2); }; /** @brief Compare two elements referenced by guarded iterators. - * @param bi1 First iterator. - * @param bi2 Second iterator. - * @return @c True if less. */ -template + * @param __bi1 First iterator. + * @param __bi2 Second iterator. + * @return @__c true if less. */ +template inline bool - operator<(guarded_iterator& bi1, - guarded_iterator& bi2) + operator<(_GuardedIterator<_RAIter, _Compare>& __bi1, + _GuardedIterator<_RAIter, _Compare>& __bi2) { - if (bi1.current == bi1.end) //bi1 is sup - return bi2.current == bi2.end; //bi2 is not sup - if (bi2.current == bi2.end) //bi2 is sup + if (__bi1._M_current == __bi1._M_end) //__bi1 is sup + return __bi2._M_current == __bi2._M_end; //__bi2 is not sup + if (__bi2._M_current == __bi2._M_end) //__bi2 is sup return true; - return (bi1.comp)(*bi1, *bi2); //normal compare + return (__bi1.__comp)(*__bi1, *__bi2); //normal compare } /** @brief Compare two elements referenced by guarded iterators. - * @param bi1 First iterator. - * @param bi2 Second iterator. - * @return @c True if less equal. */ -template + * @param __bi1 First iterator. + * @param __bi2 Second iterator. + * @return @__c True if less equal. */ +template inline bool - operator<=(guarded_iterator& bi1, - guarded_iterator& bi2) + operator<=(_GuardedIterator<_RAIter, _Compare>& __bi1, + _GuardedIterator<_RAIter, _Compare>& __bi2) { - if (bi2.current == bi2.end) //bi1 is sup - return bi1.current != bi1.end; //bi2 is not sup - if (bi1.current == bi1.end) //bi2 is sup + if (__bi2._M_current == __bi2._M_end) //__bi1 is sup + return __bi1._M_current != __bi1._M_end; //__bi2 is not sup + if (__bi1._M_current == __bi1._M_end) //__bi2 is sup return false; - return !(bi1.comp)(*bi2, *bi1); //normal compare + return !(__bi1.__comp)(*__bi2, *__bi1); //normal compare } -template +template class unguarded_iterator; -template +template inline bool - operator<(unguarded_iterator& bi1, - unguarded_iterator& bi2); + operator<(unguarded_iterator<_RAIter, _Compare>& __bi1, + unguarded_iterator<_RAIter, _Compare>& __bi2); -template +template inline bool - operator<=(unguarded_iterator& bi1, - unguarded_iterator& bi2); + operator<=(unguarded_iterator<_RAIter, _Compare>& __bi1, + unguarded_iterator<_RAIter, _Compare>& __bi2); -template +template class unguarded_iterator { private: - /** @brief Current iterator position. */ - RandomAccessIterator current; - /** @brief Comparator. */ - mutable Comparator& comp; + /** @brief Current iterator __position. */ + _RAIter _M_current; + /** @brief _Compare. */ + mutable _Compare& __comp; public: /** @brief Constructor. Sets iterator to beginning of sequence. - * @param begin Begin iterator of sequence. - * @param end Unused, only for compatibility. - * @param comp Unused, only for compatibility. */ - unguarded_iterator(RandomAccessIterator begin, - RandomAccessIterator end, Comparator& comp) - : current(begin), comp(comp) + * @param __begin Begin iterator of sequence. + * @param _M_end Unused, only for compatibility. + * @param __comp Unused, only for compatibility. */ + unguarded_iterator(_RAIter __begin, + _RAIter _M_end, _Compare& __comp) + : _M_current(__begin), __comp(__comp) { } /** @brief Pre-increment operator. * @return This. */ - unguarded_iterator& + unguarded_iterator<_RAIter, _Compare>& operator++() { - ++current; + ++_M_current; return *this; } /** @brief Dereference operator. * @return Referenced element. */ - typename std::iterator_traits::value_type& + typename std::iterator_traits<_RAIter>::value_type& operator*() - { return *current; } + { return *_M_current; } /** @brief Convert to wrapped iterator. * @return Wrapped iterator. */ - operator RandomAccessIterator() - { return current; } + operator _RAIter() + { return _M_current; } friend bool - operator< ( - unguarded_iterator& bi1, - unguarded_iterator& bi2); + operator< <_RAIter, _Compare>( + unguarded_iterator<_RAIter, _Compare>& __bi1, + unguarded_iterator<_RAIter, _Compare>& __bi2); friend bool - operator<= ( - unguarded_iterator& bi1, - unguarded_iterator& bi2); + operator<= <_RAIter, _Compare>( + unguarded_iterator<_RAIter, _Compare>& __bi1, + unguarded_iterator<_RAIter, _Compare>& __bi2); }; /** @brief Compare two elements referenced by unguarded iterators. - * @param bi1 First iterator. - * @param bi2 Second iterator. - * @return @c True if less. */ -template + * @param __bi1 First iterator. + * @param __bi2 Second iterator. + * @return @__c true if less. */ +template inline bool - operator<(unguarded_iterator& bi1, - unguarded_iterator& bi2) + operator<(unguarded_iterator<_RAIter, _Compare>& __bi1, + unguarded_iterator<_RAIter, _Compare>& __bi2) { // Normal compare. - return (bi1.comp)(*bi1, *bi2); + return (__bi1.__comp)(*__bi1, *__bi2); } /** @brief Compare two elements referenced by unguarded iterators. - * @param bi1 First iterator. - * @param bi2 Second iterator. - * @return @c True if less equal. */ -template + * @param __bi1 First iterator. + * @param __bi2 Second iterator. + * @return @__c True if less equal. */ +template inline bool - operator<=(unguarded_iterator& bi1, - unguarded_iterator& bi2) + operator<=(unguarded_iterator<_RAIter, _Compare>& __bi1, + unguarded_iterator<_RAIter, _Compare>& __bi2) { // Normal compare. - return !(bi1.comp)(*bi2, *bi1); + return !(__bi1.__comp)(*__bi2, *__bi1); } /** @brief Highly efficient 3-way merging procedure. * * Merging is done with the algorithm implementation described by Peter * Sanders. Basically, the idea is to minimize the number of necessary - * comparison after merging out an element. The implementation trick + * comparison after merging an element. The implementation trick * that makes this fast is that the order of the sequences is stored * in the instruction pointer (translated into labels in C++). * * This works well for merging up to 4 sequences. * - * Note that making the merging stable does not come at a + * Note that making the merging stable does not come at __a * performance hit. * * Whether the merging is done guarded or unguarded is selected by the * used iterator class. * - * @param seqs_begin Begin iterator of iterator pair input sequence. - * @param seqs_end End iterator of iterator pair input sequence. - * @param target Begin iterator out output sequence. - * @param comp Comparator. - * @param length Maximum length to merge, less equal than the + * @param __seqs_begin Begin iterator of iterator pair input sequence. + * @param __seqs_end End iterator of iterator pair input sequence. + * @param __target Begin iterator of __output sequence. + * @param __comp Comparator. + * @param __length Maximum length to merge, less equal than the * total number of elements available. * * @return End iterator of output sequence. */ template class iterator, - typename RandomAccessIteratorIterator, - typename RandomAccessIterator3, + typename _RAIterIterator, + typename _RAIter3, typename _DifferenceTp, - typename Comparator> - RandomAccessIterator3 + typename _Compare> + _RAIter3 multiway_merge_3_variant( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, - _DifferenceTp length, Comparator comp) + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, + _DifferenceTp __length, _Compare __comp) { - _GLIBCXX_CALL(length); + _GLIBCXX_CALL(__length); - typedef _DifferenceTp difference_type; + typedef _DifferenceTp _DifferenceType; - typedef typename std::iterator_traits + typedef typename std::iterator_traits<_RAIterIterator> ::value_type::first_type - RandomAccessIterator1; - typedef typename std::iterator_traits::value_type - value_type; + _RAIter1; + typedef typename std::iterator_traits<_RAIter1>::value_type + _ValueType; - if (length == 0) - return target; + if (__length == 0) + return __target; #if _GLIBCXX_ASSERTIONS - _DifferenceTp orig_length = length; + _DifferenceTp orig_length = __length; #endif - iterator - seq0(seqs_begin[0].first, seqs_begin[0].second, comp), - seq1(seqs_begin[1].first, seqs_begin[1].second, comp), - seq2(seqs_begin[2].first, seqs_begin[2].second, comp); + iterator<_RAIter1, _Compare> + __seq0(__seqs_begin[0].first, __seqs_begin[0].second, __comp), + __seq1(__seqs_begin[1].first, __seqs_begin[1].second, __comp), + __seq2(__seqs_begin[2].first, __seqs_begin[2].second, __comp); - if (seq0 <= seq1) + if (__seq0 <= __seq1) { - if (seq1 <= seq2) - goto s012; + if (__seq1 <= __seq2) + goto __s012; else - if (seq2 < seq0) - goto s201; + if (__seq2 < __seq0) + goto __s201; else - goto s021; + goto __s021; } else { - if (seq1 <= seq2) + if (__seq1 <= __seq2) { - if (seq0 <= seq2) - goto s102; + if (__seq0 <= __seq2) + goto __s102; else - goto s120; + goto __s120; } else - goto s210; + goto __s210; } -#define _GLIBCXX_PARALLEL_MERGE_3_CASE(a,b,c,c0,c1) \ - s ## a ## b ## c : \ - *target = *seq ## a; \ - ++target; \ - --length; \ - ++seq ## a; \ - if (length == 0) goto finish; \ - if (seq ## a c0 seq ## b) goto s ## a ## b ## c; \ - if (seq ## a c1 seq ## c) goto s ## b ## a ## c; \ - goto s ## b ## c ## a; +#define _GLIBCXX_PARALLEL_MERGE_3_CASE(__a,__b,__c,c0,c1) \ + __s ## __a ## __b ## __c : \ + *__target = *__seq ## __a; \ + ++__target; \ + --__length; \ + ++__seq ## __a; \ + if (__length == 0) goto finish; \ + if (__seq ## __a c0 __seq ## __b) goto __s ## __a ## __b ## __c; \ + if (__seq ## __a c1 __seq ## __c) goto __s ## __b ## __a ## __c; \ + goto __s ## __b ## __c ## __a; _GLIBCXX_PARALLEL_MERGE_3_CASE(0, 1, 2, <=, <=); _GLIBCXX_PARALLEL_MERGE_3_CASE(1, 2, 0, <=, < ); @@ -362,17 +362,17 @@ template class iterator, #if _GLIBCXX_ASSERTIONS _GLIBCXX_PARALLEL_ASSERT( - ((RandomAccessIterator1)seq0 - seqs_begin[0].first) + - ((RandomAccessIterator1)seq1 - seqs_begin[1].first) + - ((RandomAccessIterator1)seq2 - seqs_begin[2].first) + ((_RAIter1)__seq0 - __seqs_begin[0].first) + + ((_RAIter1)__seq1 - __seqs_begin[1].first) + + ((_RAIter1)__seq2 - __seqs_begin[2].first) == orig_length); #endif - seqs_begin[0].first = seq0; - seqs_begin[1].first = seq1; - seqs_begin[2].first = seq2; + __seqs_begin[0].first = __seq0; + __seqs_begin[1].first = __seq1; + __seqs_begin[2].first = __seq2; - return target; + return __target; } /** @@ -380,74 +380,74 @@ template class iterator, * * Merging is done with the algorithm implementation described by Peter * Sanders. Basically, the idea is to minimize the number of necessary - * comparison after merging out an element. The implementation trick + * comparison after merging an element. The implementation trick * that makes this fast is that the order of the sequences is stored * in the instruction pointer (translated into goto labels in C++). * * This works well for merging up to 4 sequences. * - * Note that making the merging stable does not come at a + * Note that making the merging stable does not come at __a * performance hit. * * Whether the merging is done guarded or unguarded is selected by the * used iterator class. * - * @param seqs_begin Begin iterator of iterator pair input sequence. - * @param seqs_end End iterator of iterator pair input sequence. - * @param target Begin iterator out output sequence. - * @param comp Comparator. - * @param length Maximum length to merge, less equal than the + * @param __seqs_begin Begin iterator of iterator pair input sequence. + * @param __seqs_end End iterator of iterator pair input sequence. + * @param __target Begin iterator of __output sequence. + * @param __comp Comparator. + * @param __length Maximum length to merge, less equal than the * total number of elements available. * * @return End iterator of output sequence. */ template class iterator, - typename RandomAccessIteratorIterator, - typename RandomAccessIterator3, + typename _RAIterIterator, + typename _RAIter3, typename _DifferenceTp, - typename Comparator> - RandomAccessIterator3 - multiway_merge_4_variant(RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, - _DifferenceTp length, Comparator comp) + typename _Compare> + _RAIter3 + multiway_merge_4_variant(_RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, + _DifferenceTp __length, _Compare __comp) { - _GLIBCXX_CALL(length); - typedef _DifferenceTp difference_type; + _GLIBCXX_CALL(__length); + typedef _DifferenceTp _DifferenceType; - typedef typename std::iterator_traits + typedef typename std::iterator_traits<_RAIterIterator> ::value_type::first_type - RandomAccessIterator1; - typedef typename std::iterator_traits::value_type - value_type; - - iterator - seq0(seqs_begin[0].first, seqs_begin[0].second, comp), - seq1(seqs_begin[1].first, seqs_begin[1].second, comp), - seq2(seqs_begin[2].first, seqs_begin[2].second, comp), - seq3(seqs_begin[3].first, seqs_begin[3].second, comp); - -#define _GLIBCXX_PARALLEL_DECISION(a,b,c,d) { \ - if (seq ## d < seq ## a) goto s ## d ## a ## b ## c; \ - if (seq ## d < seq ## b) goto s ## a ## d ## b ## c; \ - if (seq ## d < seq ## c) goto s ## a ## b ## d ## c; \ - goto s ## a ## b ## c ## d; } - - if (seq0 <= seq1) + _RAIter1; + typedef typename std::iterator_traits<_RAIter1>::value_type + _ValueType; + + iterator<_RAIter1, _Compare> + __seq0(__seqs_begin[0].first, __seqs_begin[0].second, __comp), + __seq1(__seqs_begin[1].first, __seqs_begin[1].second, __comp), + __seq2(__seqs_begin[2].first, __seqs_begin[2].second, __comp), + __seq3(__seqs_begin[3].first, __seqs_begin[3].second, __comp); + +#define _GLIBCXX_PARALLEL_DECISION(__a,__b,__c,d) { \ + if (__seq ## d < __seq ## __a) goto __s ## d ## __a ## __b ## __c; \ + if (__seq ## d < __seq ## __b) goto __s ## __a ## d ## __b ## __c; \ + if (__seq ## d < __seq ## __c) goto __s ## __a ## __b ## d ## __c; \ + goto __s ## __a ## __b ## __c ## d; } + + if (__seq0 <= __seq1) { - if (seq1 <= seq2) + if (__seq1 <= __seq2) _GLIBCXX_PARALLEL_DECISION(0,1,2,3) else - if (seq2 < seq0) + if (__seq2 < __seq0) _GLIBCXX_PARALLEL_DECISION(2,0,1,3) else _GLIBCXX_PARALLEL_DECISION(0,2,1,3) } else { - if (seq1 <= seq2) + if (__seq1 <= __seq2) { - if (seq0 <= seq2) + if (__seq0 <= __seq2) _GLIBCXX_PARALLEL_DECISION(1,0,2,3) else _GLIBCXX_PARALLEL_DECISION(1,2,0,3) @@ -456,17 +456,17 @@ template class iterator, _GLIBCXX_PARALLEL_DECISION(2,1,0,3) } -#define _GLIBCXX_PARALLEL_MERGE_4_CASE(a,b,c,d,c0,c1,c2) \ - s ## a ## b ## c ## d: \ - if (length == 0) goto finish; \ - *target = *seq ## a; \ - ++target; \ - --length; \ - ++seq ## a; \ - if (seq ## a c0 seq ## b) goto s ## a ## b ## c ## d; \ - if (seq ## a c1 seq ## c) goto s ## b ## a ## c ## d; \ - if (seq ## a c2 seq ## d) goto s ## b ## c ## a ## d; \ - goto s ## b ## c ## d ## a; +#define _GLIBCXX_PARALLEL_MERGE_4_CASE(__a,__b,__c,d,c0,c1,c2) \ + __s ## __a ## __b ## __c ## d: \ + if (__length == 0) goto finish; \ + *__target = *__seq ## __a; \ + ++__target; \ + --__length; \ + ++__seq ## __a; \ + if (__seq ## __a c0 __seq ## __b) goto __s ## __a ## __b ## __c ## d; \ + if (__seq ## __a c1 __seq ## __c) goto __s ## __b ## __a ## __c ## d; \ + if (__seq ## __a c2 __seq ## d) goto __s ## __b ## __c ## __a ## d; \ + goto __s ## __b ## __c ## d ## __a; _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 1, 2, 3, <=, <=, <=); _GLIBCXX_PARALLEL_MERGE_4_CASE(0, 1, 3, 2, <=, <=, <=); @@ -499,94 +499,94 @@ template class iterator, finish: ; - seqs_begin[0].first = seq0; - seqs_begin[1].first = seq1; - seqs_begin[2].first = seq2; - seqs_begin[3].first = seq3; + __seqs_begin[0].first = __seq0; + __seqs_begin[1].first = __seq1; + __seqs_begin[2].first = __seq2; + __seqs_begin[3].first = __seq3; - return target; + return __target; } /** @brief Multi-way merging procedure for a high branching factor, * guarded case. * - * This merging variant uses a LoserTree class as selected by LT. + * This merging variant uses __a LoserTree class as selected by LT. * * Stability is selected through the used LoserTree class LT. * - * At least one non-empty sequence is required. + * At least one non-empty __sequence is required. * - * @param seqs_begin Begin iterator of iterator pair input sequence. - * @param seqs_end End iterator of iterator pair input sequence. - * @param target Begin iterator out output sequence. - * @param comp Comparator. - * @param length Maximum length to merge, less equal than the + * @param __seqs_begin Begin iterator of iterator pair input sequence. + * @param __seqs_end End iterator of iterator pair input sequence. + * @param __target Begin iterator of __output sequence. + * @param __comp Comparator. + * @param __length Maximum length to merge, less equal than the * total number of elements available. * * @return End iterator of output sequence. */ template - RandomAccessIterator3 - multiway_merge_loser_tree(RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, - _DifferenceTp length, Comparator comp) + typename _Compare> + _RAIter3 + multiway_merge_loser_tree(_RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, + _DifferenceTp __length, _Compare __comp) { - _GLIBCXX_CALL(length) + _GLIBCXX_CALL(__length) - typedef _DifferenceTp difference_type; - typedef typename std::iterator_traits + typedef _DifferenceTp _DifferenceType; + typedef typename std::iterator_traits<_RAIterIterator> ::value_type::first_type - RandomAccessIterator1; - typedef typename std::iterator_traits::value_type - value_type; + _RAIter1; + typedef typename std::iterator_traits<_RAIter1>::value_type + _ValueType; - int k = static_cast(seqs_end - seqs_begin); + int __k = static_cast(__seqs_end - __seqs_begin); - LT lt(k, comp); + LT __lt(__k, __comp); // Default value for potentially non-default-constructible types. - value_type* arbitrary_element = NULL; + _ValueType* __arbitrary_element = NULL; - for (int t = 0; t < k; ++t) + for (int __t = 0; __t < __k; ++__t) { - if(arbitrary_element == NULL - && _GLIBCXX_PARALLEL_LENGTH(seqs_begin[t]) > 0) - arbitrary_element = &(*seqs_begin[t].first); + if(__arbitrary_element == NULL + && _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__t]) > 0) + __arbitrary_element = &(*__seqs_begin[__t].first); } - for (int t = 0; t < k; ++t) + for (int __t = 0; __t < __k; ++__t) { - if (seqs_begin[t].first == seqs_begin[t].second) - lt.insert_start(*arbitrary_element, t, true); + if (__seqs_begin[__t].first == __seqs_begin[__t].second) + __lt.__insert_start(*__arbitrary_element, __t, true); else - lt.insert_start(*seqs_begin[t].first, t, false); + __lt.__insert_start(*__seqs_begin[__t].first, __t, false); } - lt.init(); + __lt.__init(); int source; - for (difference_type i = 0; i < length; ++i) + for (_DifferenceType __i = 0; __i < __length; ++__i) { - //take out - source = lt.get_min_source(); + //take __out + source = __lt.__get_min_source(); - *(target++) = *(seqs_begin[source].first++); + *(__target++) = *(__seqs_begin[source].first++); // Feed. - if (seqs_begin[source].first == seqs_begin[source].second) - lt.delete_min_insert(*arbitrary_element, true); + if (__seqs_begin[source].first == __seqs_begin[source].second) + __lt.__delete_min_insert(*__arbitrary_element, true); else // Replace from same source. - lt.delete_min_insert(*seqs_begin[source].first, false); + __lt.__delete_min_insert(*__seqs_begin[source].first, false); } - return target; + return __target; } /** @brief Multi-way merging procedure for a high branching factor, @@ -598,360 +598,360 @@ template - RandomAccessIterator3 + typename _RAIterIterator, + typename _RAIter3, + typename _DifferenceTp, typename _Compare> + _RAIter3 multiway_merge_loser_tree_unguarded( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, const typename std::iterator_traits::value_type::first_type>::value_type& - sentinel, - _DifferenceTp length, - Comparator comp) + _RAIterIterator>::value_type::first_type>::value_type& + __sentinel, + _DifferenceTp __length, + _Compare __comp) { - _GLIBCXX_CALL(length) - typedef _DifferenceTp difference_type; + _GLIBCXX_CALL(__length) + typedef _DifferenceTp _DifferenceType; - typedef typename std::iterator_traits + typedef typename std::iterator_traits<_RAIterIterator> ::value_type::first_type - RandomAccessIterator1; - typedef typename std::iterator_traits::value_type - value_type; + _RAIter1; + typedef typename std::iterator_traits<_RAIter1>::value_type + _ValueType; - int k = seqs_end - seqs_begin; + int __k = __seqs_end - __seqs_begin; - LT lt(k, sentinel, comp); + LT __lt(__k, __sentinel, __comp); - for (int t = 0; t < k; ++t) + for (int __t = 0; __t < __k; ++__t) { #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(seqs_begin[t].first != seqs_begin[t].second); + _GLIBCXX_PARALLEL_ASSERT(__seqs_begin[__t].first != __seqs_begin[__t].second); #endif - lt.insert_start(*seqs_begin[t].first, t, false); + __lt.__insert_start(*__seqs_begin[__t].first, __t, false); } - lt.init(); + __lt.__init(); int source; #if _GLIBCXX_ASSERTIONS - difference_type i = 0; + _DifferenceType __i = 0; #endif - RandomAccessIterator3 target_end = target + length; - while (target < target_end) + _RAIter3 __target_end = __target + __length; + while (__target < __target_end) { // Take out. - source = lt.get_min_source(); + source = __lt.__get_min_source(); #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(0 <= source && source < k); - _GLIBCXX_PARALLEL_ASSERT(i == 0 - || !comp(*(seqs_begin[source].first), *(target - 1))); + _GLIBCXX_PARALLEL_ASSERT(0 <= source && source < __k); + _GLIBCXX_PARALLEL_ASSERT(__i == 0 + || !__comp(*(__seqs_begin[source].first), *(__target - 1))); #endif // Feed. - *(target++) = *(seqs_begin[source].first++); + *(__target++) = *(__seqs_begin[source].first++); #if _GLIBCXX_ASSERTIONS - ++i; + ++__i; #endif // Replace from same source. - lt.delete_min_insert(*seqs_begin[source].first, false); + __lt.__delete_min_insert(*__seqs_begin[source].first, false); } - return target; + return __target; } /** @brief Multi-way merging procedure for a high branching factor, * requiring sentinels to exist. * - * @param stable The value must the same as for the used LoserTrees. - * @param UnguardedLoserTree Loser Tree variant to use for the unguarded + * @param __stable The value must the same as for the used LoserTrees. + * @param UnguardedLoserTree _Loser Tree variant to use for the unguarded * merging. - * @param GuardedLoserTree Loser Tree variant to use for the guarded + * @param GuardedLoserTree _Loser Tree variant to use for the guarded * merging. * - * @param seqs_begin Begin iterator of iterator pair input sequence. - * @param seqs_end End iterator of iterator pair input sequence. - * @param target Begin iterator out output sequence. - * @param comp Comparator. - * @param length Maximum length to merge, less equal than the + * @param __seqs_begin Begin iterator of iterator pair input sequence. + * @param __seqs_end End iterator of iterator pair input sequence. + * @param __target Begin iterator of __output sequence. + * @param __comp Comparator. + * @param __length Maximum length to merge, less equal than the * total number of elements available. * * @return End iterator of output sequence. */ template< typename UnguardedLoserTree, - typename RandomAccessIteratorIterator, - typename RandomAccessIterator3, + typename _RAIterIterator, + typename _RAIter3, typename _DifferenceTp, - typename Comparator> - RandomAccessIterator3 + typename _Compare> + _RAIter3 multiway_merge_loser_tree_sentinel( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, const typename std::iterator_traits::value_type::first_type>::value_type& - sentinel, - _DifferenceTp length, - Comparator comp) + _RAIterIterator>::value_type::first_type>::value_type& + __sentinel, + _DifferenceTp __length, + _Compare __comp) { - _GLIBCXX_CALL(length) + _GLIBCXX_CALL(__length) - typedef _DifferenceTp difference_type; - typedef std::iterator_traits traits_type; - typedef typename std::iterator_traits + typedef _DifferenceTp _DifferenceType; + typedef std::iterator_traits<_RAIterIterator> _TraitsType; + typedef typename std::iterator_traits<_RAIterIterator> ::value_type::first_type - RandomAccessIterator1; - typedef typename std::iterator_traits::value_type - value_type; + _RAIter1; + typedef typename std::iterator_traits<_RAIter1>::value_type + _ValueType; - RandomAccessIterator3 target_end; + _RAIter3 __target_end; - for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s) - // Move the sequends end behind the sentinel spots. This has the + for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s) + // Move the sequends _M_end behind the sentinel spots. This has the // effect that the sentinel appears to be within the sequence. Then, // we can use the unguarded variant if we merge out as many // non-sentinel elements as we have. - ++((*s).second); + ++((*__s).second); - target_end = multiway_merge_loser_tree_unguarded + __target_end = multiway_merge_loser_tree_unguarded - (seqs_begin, seqs_end, target, sentinel, length, comp); + (__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp); #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(target_end == target + length); - _GLIBCXX_PARALLEL_ASSERT(is_sorted(target, target_end, comp)); + _GLIBCXX_PARALLEL_ASSERT(__target_end == __target + __length); + _GLIBCXX_PARALLEL_ASSERT(__is_sorted(__target, __target_end, __comp)); #endif // Restore the sequence ends so the sentinels are not contained in the // sequence any more (see comment in loop above). - for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s) - --((*s).second); + for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s) + --((*__s).second); - return target_end; + return __target_end; } /** * @brief Traits for determining whether the loser tree should * use pointers or copies. * - * The field "use_pointer" is used to determine whether to use pointers in + * The field "_M_use_pointer" is used to determine whether to use pointers in * the loser trees or whether to copy the values into the loser tree. * - * The default behavior is to use pointers if the data type is 4 times as + * The default behavior is to use pointers if the data _Self is 4 times as * big as the pointer to it. * - * Specialize for your data type to customize the behavior. + * Specialize for your data _Self to customize the behavior. * * Example: * * template<> - * struct loser_tree_traits - * { static const bool use_pointer = false; }; + * struct _LoserTreeTraits + * { static const bool _M_use_pointer = false; }; * * template<> - * struct loser_tree_traits - * { static const bool use_pointer = true; }; + * struct _LoserTreeTraits + * { static const bool _M_use_pointer = true; }; * - * @param T type to give the loser tree traits for. + * @param _Tp _Self to give the loser tree traits for. */ -template -struct loser_tree_traits +template +struct _LoserTreeTraits { /** * @brief True iff to use pointers instead of values in loser trees. * - * The default behavior is to use pointers if the data type is four + * The default behavior is to use pointers if the data _Self is four * times as big as the pointer to it. */ - static const bool use_pointer = (sizeof(T) > 4 * sizeof(T*)); + static const bool _M_use_pointer = (sizeof(_Tp) > 4 * sizeof(_Tp*)); }; /** - * @brief Switch for 3-way merging with sentinels turned off. + * @brief Switch for 3-way merging with __sentinels turned __off. * - * Note that 3-way merging is always stable! + * Note that 3-way merging is always __stable! */ template< - bool sentinels /*default == false*/, - typename RandomAccessIteratorIterator, - typename RandomAccessIterator3, + bool __sentinels /*default == false*/, + typename _RAIterIterator, + typename _RAIter3, typename _DifferenceTp, - typename Comparator> -struct multiway_merge_3_variant_sentinel_switch + typename _Compare> +struct __multiway_merge_3_variant_sentinel_switch { - RandomAccessIterator3 operator()( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, - _DifferenceTp length, Comparator comp) + _RAIter3 operator()( + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, + _DifferenceTp __length, _Compare __comp) { - return multiway_merge_3_variant( - seqs_begin, seqs_end, target, length, comp); + return multiway_merge_3_variant<_GuardedIterator>( + __seqs_begin, __seqs_end, __target, __length, __comp); } }; /** - * @brief Switch for 3-way merging with sentinels turned on. + * @brief Switch for 3-way merging with __sentinels turned on. * - * Note that 3-way merging is always stable! + * Note that 3-way merging is always __stable! */ template< - typename RandomAccessIteratorIterator, - typename RandomAccessIterator3, + typename _RAIterIterator, + typename _RAIter3, typename _DifferenceTp, - typename Comparator> -struct multiway_merge_3_variant_sentinel_switch - + typename _Compare> +struct __multiway_merge_3_variant_sentinel_switch + { - RandomAccessIterator3 operator()( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, - _DifferenceTp length, Comparator comp) + _RAIter3 operator()( + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, + _DifferenceTp __length, _Compare __comp) { return multiway_merge_3_variant( - seqs_begin, seqs_end, target, length, comp); + __seqs_begin, __seqs_end, __target, __length, __comp); } }; /** - * @brief Switch for 4-way merging with sentinels turned off. + * @brief Switch for 4-way merging with __sentinels turned __off. * - * Note that 4-way merging is always stable! + * Note that 4-way merging is always __stable! */ template< - bool sentinels /*default == false*/, - typename RandomAccessIteratorIterator, - typename RandomAccessIterator3, + bool __sentinels /*default == false*/, + typename _RAIterIterator, + typename _RAIter3, typename _DifferenceTp, - typename Comparator> -struct multiway_merge_4_variant_sentinel_switch + typename _Compare> +struct __multiway_merge_4_variant_sentinel_switch { - RandomAccessIterator3 operator()( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, - _DifferenceTp length, Comparator comp) + _RAIter3 operator()( + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, + _DifferenceTp __length, _Compare __comp) { - return multiway_merge_4_variant( - seqs_begin, seqs_end, target, length, comp); + return multiway_merge_4_variant<_GuardedIterator>( + __seqs_begin, __seqs_end, __target, __length, __comp); } }; /** - * @brief Switch for 4-way merging with sentinels turned on. + * @brief Switch for 4-way merging with __sentinels turned on. * - * Note that 4-way merging is always stable! + * Note that 4-way merging is always __stable! */ template< - typename RandomAccessIteratorIterator, - typename RandomAccessIterator3, + typename _RAIterIterator, + typename _RAIter3, typename _DifferenceTp, - typename Comparator> -struct multiway_merge_4_variant_sentinel_switch - + typename _Compare> +struct __multiway_merge_4_variant_sentinel_switch + { - RandomAccessIterator3 operator()( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, - _DifferenceTp length, Comparator comp) + _RAIter3 operator()( + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, + _DifferenceTp __length, _Compare __comp) { return multiway_merge_4_variant( - seqs_begin, seqs_end, target, length, comp); + __seqs_begin, __seqs_end, __target, __length, __comp); } }; /** - * @brief Switch for k-way merging with sentinels turned on. + * @brief Switch for k-way merging with __sentinels turned on. */ template< - bool sentinels, - bool stable, - typename RandomAccessIteratorIterator, - typename RandomAccessIterator3, + bool __sentinels, + bool __stable, + typename _RAIterIterator, + typename _RAIter3, typename _DifferenceTp, - typename Comparator> -struct multiway_merge_k_variant_sentinel_switch + typename _Compare> +struct __multiway_merge_k_variant_sentinel_switch { - RandomAccessIterator3 operator()( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, + _RAIter3 operator()( + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, const typename std::iterator_traits::value_type::first_type>::value_type& - sentinel, - _DifferenceTp length, Comparator comp) + _RAIterIterator>::value_type::first_type>::value_type& + __sentinel, + _DifferenceTp __length, _Compare __comp) { - typedef typename std::iterator_traits + typedef typename std::iterator_traits<_RAIterIterator> ::value_type::first_type - RandomAccessIterator1; - typedef typename std::iterator_traits::value_type - value_type; + _RAIter1; + typedef typename std::iterator_traits<_RAIter1>::value_type + _ValueType; return multiway_merge_loser_tree_sentinel< typename __gnu_cxx::__conditional_type< - loser_tree_traits::use_pointer - , LoserTreePointerUnguarded - , LoserTreeUnguarded - >::__type>(seqs_begin, seqs_end, target, sentinel, length, comp); + _LoserTreeTraits<_ValueType>::_M_use_pointer + , LoserTreePointerUnguarded<__stable, _ValueType, _Compare> + , _LoserTreeUnguarded<__stable, _ValueType, _Compare> + >::__type>(__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp); } }; /** - * @brief Switch for k-way merging with sentinels turned off. + * @brief Switch for k-way merging with __sentinels turned __off. */ template< - bool stable, - typename RandomAccessIteratorIterator, - typename RandomAccessIterator3, + bool __stable, + typename _RAIterIterator, + typename _RAIter3, typename _DifferenceTp, - typename Comparator> -struct multiway_merge_k_variant_sentinel_switch - + typename _Compare> +struct __multiway_merge_k_variant_sentinel_switch + { - RandomAccessIterator3 operator()( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, + _RAIter3 operator()( + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, const typename std::iterator_traits::value_type::first_type>::value_type& - sentinel, - _DifferenceTp length, Comparator comp) + _RAIterIterator>::value_type::first_type>::value_type& + __sentinel, + _DifferenceTp __length, _Compare __comp) { - typedef typename std::iterator_traits + typedef typename std::iterator_traits<_RAIterIterator> ::value_type::first_type - RandomAccessIterator1; - typedef typename std::iterator_traits::value_type - value_type; + _RAIter1; + typedef typename std::iterator_traits<_RAIter1>::value_type + _ValueType; return multiway_merge_loser_tree< typename __gnu_cxx::__conditional_type< - loser_tree_traits::use_pointer - , LoserTreePointer - , LoserTree - >::__type >(seqs_begin, seqs_end, target, length, comp); + _LoserTreeTraits<_ValueType>::_M_use_pointer + , _LoserTreePointer<__stable, _ValueType, _Compare> + , LoserTree<__stable, _ValueType, _Compare> + >::__type >(__seqs_begin, __seqs_end, __target, __length, __comp); } }; @@ -959,108 +959,108 @@ struct multiway_merge_k_variant_sentinel_switch * * The _GLIBCXX_PARALLEL_DECISION is based on the branching factor and * runtime settings. - * @param seqs_begin Begin iterator of iterator pair input sequence. - * @param seqs_end End iterator of iterator pair input sequence. - * @param target Begin iterator out output sequence. - * @param comp Comparator. - * @param length Maximum length to merge, possibly larger than the + * @param __seqs_begin Begin iterator of iterator pair input sequence. + * @param __seqs_end End iterator of iterator pair input sequence. + * @param __target Begin iterator of __output sequence. + * @param __comp Comparator. + * @param __length Maximum length to merge, possibly larger than the * number of elements available. - * @param stable Stable merging incurs a performance penalty. - * @param sentinel The sequences have a sentinel element. + * @param __stable Stable merging incurs __a performance penalty. + * @param __sentinel The sequences have __a __sentinel element. * @return End iterator of output sequence. */ template< - bool stable, - bool sentinels, - typename RandomAccessIteratorIterator, - typename RandomAccessIterator3, + bool __stable, + bool __sentinels, + typename _RAIterIterator, + typename _RAIter3, typename _DifferenceTp, - typename Comparator> - RandomAccessIterator3 - sequential_multiway_merge( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, + typename _Compare> + _RAIter3 + __sequential_multiway_merge( + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, const typename std::iterator_traits::value_type::first_type>::value_type& - sentinel, - _DifferenceTp length, Comparator comp) + _RAIterIterator>::value_type::first_type>::value_type& + __sentinel, + _DifferenceTp __length, _Compare __comp) { - _GLIBCXX_CALL(length) + _GLIBCXX_CALL(__length) - typedef _DifferenceTp difference_type; - typedef typename std::iterator_traits + typedef _DifferenceTp _DifferenceType; + typedef typename std::iterator_traits<_RAIterIterator> ::value_type::first_type - RandomAccessIterator1; - typedef typename std::iterator_traits::value_type - value_type; + _RAIter1; + typedef typename std::iterator_traits<_RAIter1>::value_type + _ValueType; #if _GLIBCXX_ASSERTIONS - for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s) + for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s) { - _GLIBCXX_PARALLEL_ASSERT(is_sorted((*s).first, (*s).second, comp)); + _GLIBCXX_PARALLEL_ASSERT(__is_sorted((*__s).first, (*__s).second, __comp)); } #endif - _DifferenceTp total_length = 0; - for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s) - total_length += _GLIBCXX_PARALLEL_LENGTH(*s); + _DifferenceTp __total_length = 0; + for (_RAIterIterator __s = __seqs_begin; __s != __seqs_end; ++__s) + __total_length += _GLIBCXX_PARALLEL_LENGTH(*__s); - length = std::min<_DifferenceTp>(length, total_length); + __length = std::min<_DifferenceTp>(__length, __total_length); - if(length == 0) - return target; + if(__length == 0) + return __target; - RandomAccessIterator3 return_target = target; - int k = static_cast(seqs_end - seqs_begin); + _RAIter3 __return_target = __target; + int __k = static_cast(__seqs_end - __seqs_begin); - switch (k) + switch (__k) { case 0: break; case 1: - return_target = std::copy(seqs_begin[0].first, - seqs_begin[0].first + length, - target); - seqs_begin[0].first += length; + __return_target = std::copy(__seqs_begin[0].first, + __seqs_begin[0].first + __length, + __target); + __seqs_begin[0].first += __length; break; case 2: - return_target = merge_advance(seqs_begin[0].first, - seqs_begin[0].second, - seqs_begin[1].first, - seqs_begin[1].second, - target, length, comp); + __return_target = __merge_advance(__seqs_begin[0].first, + __seqs_begin[0].second, + __seqs_begin[1].first, + __seqs_begin[1].second, + __target, __length, __comp); break; case 3: - return_target = multiway_merge_3_variant_sentinel_switch< - sentinels - , RandomAccessIteratorIterator - , RandomAccessIterator3 + __return_target = __multiway_merge_3_variant_sentinel_switch< + __sentinels + , _RAIterIterator + , _RAIter3 , _DifferenceTp - , Comparator>()(seqs_begin, seqs_end, target, length, comp); + , _Compare>()(__seqs_begin, __seqs_end, __target, __length, __comp); break; case 4: - return_target = multiway_merge_4_variant_sentinel_switch< - sentinels - , RandomAccessIteratorIterator - , RandomAccessIterator3 + __return_target = __multiway_merge_4_variant_sentinel_switch< + __sentinels + , _RAIterIterator + , _RAIter3 , _DifferenceTp - , Comparator>()(seqs_begin, seqs_end, target, length, comp); + , _Compare>()(__seqs_begin, __seqs_end, __target, __length, __comp); break; default: - return_target = multiway_merge_k_variant_sentinel_switch< - sentinels - , stable - , RandomAccessIteratorIterator - , RandomAccessIterator3 + __return_target = __multiway_merge_k_variant_sentinel_switch< + __sentinels + , __stable + , _RAIterIterator + , _RAIter3 , _DifferenceTp - , Comparator>()(seqs_begin, seqs_end, target, sentinel, length, comp); + , _Compare>()(__seqs_begin, __seqs_end, __target, __sentinel, __length, __comp); break; } #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(is_sorted(target, target + length, comp)); + _GLIBCXX_PARALLEL_ASSERT(__is_sorted(__target, __target + __length, __comp)); #endif - return return_target; + return __return_target; } /** @@ -1068,104 +1068,104 @@ template< * * Used to reduce code instanciation in multiway_merge_sampling_splitting. */ -template -struct sampling_sorter +template +struct _SamplingSorter { - void operator()(RandomAccessIterator first, RandomAccessIterator last, - StrictWeakOrdering comp) - { __gnu_sequential::stable_sort(first, last, comp); } + void operator()(_RAIter __first, _RAIter __last, + _StrictWeakOrdering __comp) + { __gnu_sequential::stable_sort(__first, __last, __comp); } }; /** - * @brief Non-stable sorting functor. + * @brief Non-__stable sorting functor. * * Used to reduce code instantiation in multiway_merge_sampling_splitting. */ -template -struct sampling_sorter +template +struct _SamplingSorter { - void operator()(RandomAccessIterator first, RandomAccessIterator last, - StrictWeakOrdering comp) - { __gnu_sequential::sort(first, last, comp); } + void operator()(_RAIter __first, _RAIter __last, + _StrictWeakOrdering __comp) + { __gnu_sequential::sort(__first, __last, __comp); } }; /** * @brief Sampling based splitting for parallel multiway-merge routine. */ template< - bool stable - , typename RandomAccessIteratorIterator - , typename Comparator - , typename difference_type> + bool __stable + , typename _RAIterIterator + , typename _Compare + , typename _DifferenceType> void multiway_merge_sampling_splitting( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - difference_type length, difference_type total_length, Comparator comp, - std::vector > *pieces) + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _DifferenceType __length, _DifferenceType __total_length, _Compare __comp, + std::vector > *__pieces) { - typedef typename std::iterator_traits + typedef typename std::iterator_traits<_RAIterIterator> ::value_type::first_type - RandomAccessIterator1; - typedef typename std::iterator_traits::value_type - value_type; + _RAIter1; + typedef typename std::iterator_traits<_RAIter1>::value_type + _ValueType; - // k sequences. - int k = static_cast(seqs_end - seqs_begin); + // __k sequences. + int __k = static_cast(__seqs_end - __seqs_begin); - int num_threads = omp_get_num_threads(); + int __num_threads = omp_get_num_threads(); - difference_type num_samples = - __gnu_parallel::_Settings::get().merge_oversampling * num_threads; + _DifferenceType __num_samples = + __gnu_parallel::_Settings::get().merge_oversampling * __num_threads; - value_type* samples = static_cast( - ::operator new(sizeof(value_type) * k * num_samples)); + _ValueType* __samples = static_cast<_ValueType*>( + ::operator new(sizeof(_ValueType) * __k * __num_samples)); // Sample. - for (int s = 0; s < k; ++s) - for (difference_type i = 0; i < num_samples; ++i) + for (int __s = 0; __s < __k; ++__s) + for (_DifferenceType __i = 0; __i < __num_samples; ++__i) { - difference_type sample_index = - static_cast( - _GLIBCXX_PARALLEL_LENGTH(seqs_begin[s]) - * (double(i + 1) / (num_samples + 1)) - * (double(length) / total_length)); - new(&(samples[s * num_samples + i])) - value_type(seqs_begin[s].first[sample_index]); + _DifferenceType sample_index = + static_cast<_DifferenceType>( + _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__s]) + * (double(__i + 1) / (__num_samples + 1)) + * (double(__length) / __total_length)); + new(&(__samples[__s * __num_samples + __i])) + _ValueType(__seqs_begin[__s].first[sample_index]); } // Sort stable or non-stable, depending on value of template parameter - // "stable". - sampling_sorter()( - samples, samples + (num_samples * k), comp); + // "__stable". + _SamplingSorter<__stable, _ValueType*, _Compare>()( + __samples, __samples + (__num_samples * __k), __comp); - for (int slab = 0; slab < num_threads; ++slab) + for (int __slab = 0; __slab < __num_threads; ++__slab) // For each slab / processor. - for (int seq = 0; seq < k; ++seq) + for (int __seq = 0; __seq < __k; ++__seq) { // For each sequence. - if (slab > 0) - pieces[slab][seq].first = + if (__slab > 0) + __pieces[__slab][__seq].first = std::upper_bound( - seqs_begin[seq].first, - seqs_begin[seq].second, - samples[num_samples * k * slab / num_threads], - comp) - - seqs_begin[seq].first; + __seqs_begin[__seq].first, + __seqs_begin[__seq].second, + __samples[__num_samples * __k * __slab / __num_threads], + __comp) + - __seqs_begin[__seq].first; else // Absolute beginning. - pieces[slab][seq].first = 0; - if ((slab + 1) < num_threads) - pieces[slab][seq].second = + __pieces[__slab][__seq].first = 0; + if ((__slab + 1) < __num_threads) + __pieces[__slab][__seq].second = std::upper_bound( - seqs_begin[seq].first, - seqs_begin[seq].second, - samples[num_samples * k * (slab + 1) / - num_threads], comp) - - seqs_begin[seq].first; + __seqs_begin[__seq].first, + __seqs_begin[__seq].second, + __samples[__num_samples * __k * (__slab + 1) / + __num_threads], __comp) + - __seqs_begin[__seq].first; else // Absolute end. - pieces[slab][seq].second = _GLIBCXX_PARALLEL_LENGTH(seqs_begin[seq]); + __pieces[__slab][__seq].second = _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__seq]); } - ::operator delete(samples); + ::operator delete(__samples); } /** @@ -1174,84 +1174,84 @@ void multiway_merge_sampling_splitting( * None of the passed sequences may be empty. */ template< - bool stable - , typename RandomAccessIteratorIterator - , typename Comparator - , typename difference_type> + bool __stable + , typename _RAIterIterator + , typename _Compare + , typename _DifferenceType> void multiway_merge_exact_splitting( - RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - difference_type length, difference_type total_length, Comparator comp, - std::vector > *pieces) + _RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _DifferenceType __length, _DifferenceType __total_length, _Compare __comp, + std::vector > *__pieces) { - typedef typename std::iterator_traits + typedef typename std::iterator_traits<_RAIterIterator> ::value_type::first_type - RandomAccessIterator1; + _RAIter1; - const bool tight = (total_length == length); + const bool __tight = (__total_length == __length); - // k sequences. - const int k = static_cast(seqs_end - seqs_begin); + // __k sequences. + const int __k = static_cast(__seqs_end - __seqs_begin); - const int num_threads = omp_get_num_threads(); + const int __num_threads = omp_get_num_threads(); // (Settings::multiway_merge_splitting == __gnu_parallel::_Settings::EXACT). - std::vector* offsets = - new std::vector[num_threads]; + std::vector<_RAIter1>* __offsets = + new std::vector<_RAIter1>[__num_threads]; std::vector< - std::pair - > se(k); + std::pair<_RAIter1, _RAIter1> + > __se(__k); - copy(seqs_begin, seqs_end, se.begin()); + copy(__seqs_begin, __seqs_end, __se.begin()); - difference_type* borders = - new difference_type[num_threads + 1]; - equally_split(length, num_threads, borders); + _DifferenceType* __borders = + new _DifferenceType[__num_threads + 1]; + equally_split(__length, __num_threads, __borders); - for (int s = 0; s < (num_threads - 1); ++s) + for (int __s = 0; __s < (__num_threads - 1); ++__s) { - offsets[s].resize(k); + __offsets[__s].resize(__k); multiseq_partition( - se.begin(), se.end(), borders[s + 1], - offsets[s].begin(), comp); + __se.begin(), __se.end(), __borders[__s + 1], + __offsets[__s].begin(), __comp); // Last one also needed and available. - if (!tight) + if (!__tight) { - offsets[num_threads - 1].resize(k); - multiseq_partition(se.begin(), se.end(), - difference_type(length), - offsets[num_threads - 1].begin(), comp); + __offsets[__num_threads - 1].resize(__k); + multiseq_partition(__se.begin(), __se.end(), + _DifferenceType(__length), + __offsets[__num_threads - 1].begin(), __comp); } } - delete[] borders; + delete[] __borders; - for (int slab = 0; slab < num_threads; ++slab) + for (int __slab = 0; __slab < __num_threads; ++__slab) { // For each slab / processor. - for (int seq = 0; seq < k; ++seq) + for (int __seq = 0; __seq < __k; ++__seq) { // For each sequence. - if (slab == 0) + if (__slab == 0) { // Absolute beginning. - pieces[slab][seq].first = 0; + __pieces[__slab][__seq].first = 0; } else - pieces[slab][seq].first = - pieces[slab - 1][seq].second; - if (!tight || slab < (num_threads - 1)) - pieces[slab][seq].second = - offsets[slab][seq] - seqs_begin[seq].first; + __pieces[__slab][__seq].first = + __pieces[__slab - 1][__seq].second; + if (!__tight || __slab < (__num_threads - 1)) + __pieces[__slab][__seq].second = + __offsets[__slab][__seq] - __seqs_begin[__seq].first; else { - // slab == num_threads - 1 - pieces[slab][seq].second = - _GLIBCXX_PARALLEL_LENGTH(seqs_begin[seq]); + // __slab == __num_threads - 1 + __pieces[__slab][__seq].second = + _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__seq]); } } } - delete[] offsets; + delete[] __offsets; } /** @brief Parallel multi-way merge routine. @@ -1261,150 +1261,150 @@ void multiway_merge_exact_splitting( * * Must not be called if the number of sequences is 1. * - * @param Splitter functor to split input (either exact or sampling based) + * @param Splitter functor to split input (either __exact or sampling based) * - * @param seqs_begin Begin iterator of iterator pair input sequence. - * @param seqs_end End iterator of iterator pair input sequence. - * @param target Begin iterator out output sequence. - * @param comp Comparator. - * @param length Maximum length to merge, possibly larger than the + * @param __seqs_begin Begin iterator of iterator pair input sequence. + * @param __seqs_end End iterator of iterator pair input sequence. + * @param __target Begin iterator of __output sequence. + * @param __comp Comparator. + * @param __length Maximum length to merge, possibly larger than the * number of elements available. - * @param stable Stable merging incurs a performance penalty. - * @param sentinel Ignored. + * @param __stable Stable merging incurs __a performance penalty. + * @param __sentinel Ignored. * @return End iterator of output sequence. */ template< - bool stable, - bool sentinels, - typename RandomAccessIteratorIterator, - typename RandomAccessIterator3, + bool __stable, + bool __sentinels, + typename _RAIterIterator, + typename _RAIter3, typename _DifferenceTp, typename Splitter, - typename Comparator + typename _Compare > - RandomAccessIterator3 - parallel_multiway_merge(RandomAccessIteratorIterator seqs_begin, - RandomAccessIteratorIterator seqs_end, - RandomAccessIterator3 target, + _RAIter3 + parallel_multiway_merge(_RAIterIterator __seqs_begin, + _RAIterIterator __seqs_end, + _RAIter3 __target, Splitter splitter, - _DifferenceTp length, - Comparator comp, - thread_index_t num_threads) + _DifferenceTp __length, + _Compare __comp, + _ThreadIndex __num_threads) { #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(seqs_end - seqs_begin > 1); + _GLIBCXX_PARALLEL_ASSERT(__seqs_end - __seqs_begin > 1); #endif - _GLIBCXX_CALL(length) + _GLIBCXX_CALL(__length) - typedef _DifferenceTp difference_type; - typedef typename std::iterator_traits + typedef _DifferenceTp _DifferenceType; + typedef typename std::iterator_traits<_RAIterIterator> ::value_type::first_type - RandomAccessIterator1; + _RAIter1; typedef typename - std::iterator_traits::value_type value_type; + std::iterator_traits<_RAIter1>::value_type _ValueType; // Leave only non-empty sequences. - typedef std::pair seq_type; - seq_type* ne_seqs = new seq_type[seqs_end - seqs_begin]; - int k = 0; - difference_type total_length = 0; - for (RandomAccessIteratorIterator raii = seqs_begin; - raii != seqs_end; ++raii) + typedef std::pair<_RAIter1, _RAIter1> seq_type; + seq_type* __ne_seqs = new seq_type[__seqs_end - __seqs_begin]; + int __k = 0; + _DifferenceType __total_length = 0; + for (_RAIterIterator __raii = __seqs_begin; + __raii != __seqs_end; ++__raii) { - _DifferenceTp seq_length = _GLIBCXX_PARALLEL_LENGTH(*raii); - if(seq_length > 0) + _DifferenceTp __seq_length = _GLIBCXX_PARALLEL_LENGTH(*__raii); + if(__seq_length > 0) { - total_length += seq_length; - ne_seqs[k++] = *raii; + __total_length += __seq_length; + __ne_seqs[__k++] = *__raii; } } - _GLIBCXX_CALL(total_length) + _GLIBCXX_CALL(__total_length) - length = std::min<_DifferenceTp>(length, total_length); + __length = std::min<_DifferenceTp>(__length, __total_length); - if (total_length == 0 || k == 0) + if (__total_length == 0 || __k == 0) { - delete[] ne_seqs; - return target; + delete[] __ne_seqs; + return __target; } - std::vector >* pieces; + std::vector >* __pieces; - num_threads = static_cast - (std::min(num_threads, total_length)); + __num_threads = static_cast<_ThreadIndex> + (std::min<_DifferenceType>(__num_threads, __total_length)); -# pragma omp parallel num_threads (num_threads) +# pragma omp parallel num_threads (__num_threads) { # pragma omp single { - num_threads = omp_get_num_threads(); - // Thread t will have to merge pieces[iam][0..k - 1] - pieces = new std::vector< - std::pair >[num_threads]; - for (int s = 0; s < num_threads; ++s) - pieces[s].resize(k); - - difference_type num_samples = + __num_threads = omp_get_num_threads(); + // Thread __t will have to merge pieces[__iam][0..__k - 1] + __pieces = new std::vector< + std::pair<_DifferenceType, _DifferenceType> >[__num_threads]; + for (int __s = 0; __s < __num_threads; ++__s) + __pieces[__s].resize(__k); + + _DifferenceType __num_samples = __gnu_parallel::_Settings::get().merge_oversampling * - num_threads; + __num_threads; - splitter(ne_seqs, ne_seqs + k, length, total_length, - comp, pieces); + splitter(__ne_seqs, __ne_seqs + __k, __length, __total_length, + __comp, __pieces); } //single - thread_index_t iam = omp_get_thread_num(); + _ThreadIndex __iam = omp_get_thread_num(); - difference_type target_position = 0; + _DifferenceType __target_position = 0; - for (int c = 0; c < k; ++c) - target_position += pieces[iam][c].first; + for (int __c = 0; __c < __k; ++__c) + __target_position += __pieces[__iam][__c].first; - seq_type* chunks = new seq_type[k]; + seq_type* __chunks = new seq_type[__k]; - for (int s = 0; s < k; ++s) + for (int __s = 0; __s < __k; ++__s) { - chunks[s] = std::make_pair( - ne_seqs[s].first + pieces[iam][s].first, - ne_seqs[s].first + pieces[iam][s].second); + __chunks[__s] = std::make_pair( + __ne_seqs[__s].first + __pieces[__iam][__s].first, + __ne_seqs[__s].first + __pieces[__iam][__s].second); } - if(length > target_position) - sequential_multiway_merge( - chunks, chunks + k, target + target_position, - *(seqs_begin->second), length - target_position, comp); + if(__length > __target_position) + __sequential_multiway_merge<__stable, __sentinels>( + __chunks, __chunks + __k, __target + __target_position, + *(__seqs_begin->second), __length - __target_position, __comp); - delete[] chunks; + delete[] __chunks; } // parallel #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(is_sorted(target, target + length, comp)); + _GLIBCXX_PARALLEL_ASSERT(__is_sorted(__target, __target + __length, __comp)); #endif - k = 0; + __k = 0; // Update ends of sequences. - for (RandomAccessIteratorIterator raii = seqs_begin; - raii != seqs_end; ++raii) + for (_RAIterIterator __raii = __seqs_begin; + __raii != __seqs_end; ++__raii) { - _DifferenceTp length = _GLIBCXX_PARALLEL_LENGTH(*raii); - if(length > 0) - (*raii).first += pieces[num_threads - 1][k++].second; + _DifferenceTp __length = _GLIBCXX_PARALLEL_LENGTH(*__raii); + if(__length > 0) + (*__raii).first += __pieces[__num_threads - 1][__k++].second; } - delete[] pieces; - delete[] ne_seqs; + delete[] __pieces; + delete[] __ne_seqs; - return target + length; + return __target + __length; } /** * @brief Multiway Merge Frontend. * - * Merge the sequences specified by seqs_begin and seqs_end into - * target. seqs_begin and seqs_end must point to a sequence of + * Merge the sequences specified by seqs_begin and __seqs_end into + * __target. __seqs_begin and __seqs_end must point to a sequence of * pairs. These pairs must contain an iterator to the beginning - * of a sequence in their first entry and an iterator the end of + * of a sequence in their first entry and an iterator the _M_end of * the same sequence in their second entry. * * Ties are broken arbitrarily. See stable_multiway_merge for a variant @@ -1427,349 +1427,349 @@ template< * * 
  *   int sequences[10][10];
- *   for (int i = 0; i < 10; ++i)
- *     for (int j = 0; i < 10; ++j)
- *       sequences[i][j] = j;
+ *   for (int __i = 0; __i < 10; ++__i)
+ *     for (int __j = 0; __i < 10; ++__j)
+ *       sequences[__i][__j] = __j;
  *
- *   int out[33];
+ *   int __out[33];
  *   std::vector > seqs;
- *   for (int i = 0; i < 10; ++i)
- *     { seqs.push(std::make_pair(sequences[i], sequences[i] + 10)) }
+ *   for (int __i = 0; __i < 10; ++__i)
+ *     { seqs.push(std::make_pair(sequences[__i], sequences[__i] + 10)) }
  *
- *   multiway_merge(seqs.begin(), seqs.end(), target, std::less(), 33);
+ *   multiway_merge(seqs.begin(), seqs.end(), __target, std::less(), 33);
  *
* * @see stable_multiway_merge * * @pre All input sequences must be sorted. - * @pre Target must provide enough space to merge out length elements or + * @pre Target must provide enough space to merge out __length __elements or * the number of elements in all sequences, whichever is smaller. * - * @post [target, return value) contains merged elements from the + * @post [__target, return __value) contains merged __elements from the * input sequences. - * @post return value - target = min(length, number of elements in all + * @post return __value - __target = min(__length, number of elements in all * sequences). * - * @param RandomAccessIteratorPairIterator iterator over sequence + * @param _RAIterPairIterator iterator over __sequence * of pairs of iterators - * @param RandomAccessIteratorOut iterator over target sequence - * @param _DifferenceTp difference type for the sequence - * @param Comparator strict weak ordering type to compare elements + * @param _RAIterOut iterator over target sequence + * @param _DifferenceTp difference _Self for the sequence + * @param _Compare strict weak ordering _Self to compare __elements * in sequences * - * @param seqs_begin begin of sequence sequence - * @param seqs_end end of sequence sequence - * @param target target sequence to merge to. - * @param comp strict weak ordering to use for element comparison. - * @param length Maximum length to merge, possibly larger than the + * @param __seqs_begin __begin of sequence __sequence + * @param __seqs_end _M_end of sequence __sequence + * @param __target target sequence to merge to. + * @param __comp strict weak ordering to use for element comparison. + * @param __length Maximum length to merge, possibly larger than the * number of elements available. * - * @return end iterator of output sequence + * @return _M_end iterator of output sequence */ // multiway_merge // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -multiway_merge(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp + , typename _Compare> +_RAIterOut +multiway_merge(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp , __gnu_parallel::sequential_tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute multiway merge *sequentially*. - return sequential_multiway_merge - - (seqs_begin, seqs_end, target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge + + (__seqs_begin, __seqs_end, __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -multiway_merge(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , __gnu_parallel::exact_tag tag) + , typename _Compare> +_RAIterOut +multiway_merge(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , __gnu_parallel::exact_tag __tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute merge; maybe parallel, depending on the number of merged // elements and the number of sequences and global thresholds in // Settings. - if ((seqs_end - seqs_begin > 1) && + if ((__seqs_end - __seqs_begin > 1) && _GLIBCXX_PARALLEL_CONDITION( - ((seqs_end - seqs_begin) >= + ((__seqs_end - __seqs_begin) >= __gnu_parallel::_Settings::get().multiway_merge_minimal_k) - && ((sequence_index_t)length >= + && ((_SequenceIndex)__length >= __gnu_parallel::_Settings::get().multiway_merge_minimal_n))) return parallel_multiway_merge - ( - seqs_begin, seqs_end, target, - multiway_merge_exact_splitting - ::value_type*, Comparator, _DifferenceTp>, - static_cast(length), comp, tag.get_num_threads()); + ( + __seqs_begin, __seqs_end, __target, + multiway_merge_exact_splitting + ::value_type*, _Compare, _DifferenceTp>, + static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads()); else - return sequential_multiway_merge - ( - seqs_begin, seqs_end, target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge + ( + __seqs_begin, __seqs_end, __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -multiway_merge(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , __gnu_parallel::sampling_tag tag) + , typename _Compare> +_RAIterOut +multiway_merge(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , __gnu_parallel::sampling_tag __tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute merge; maybe parallel, depending on the number of merged // elements and the number of sequences and global thresholds in // Settings. - if ((seqs_end - seqs_begin > 1) && + if ((__seqs_end - __seqs_begin > 1) && _GLIBCXX_PARALLEL_CONDITION( - ((seqs_end - seqs_begin) >= + ((__seqs_end - __seqs_begin) >= __gnu_parallel::_Settings::get().multiway_merge_minimal_k) - && ((sequence_index_t)length >= + && ((_SequenceIndex)__length >= __gnu_parallel::_Settings::get().multiway_merge_minimal_n))) return parallel_multiway_merge - ( - seqs_begin, seqs_end, - target, - multiway_merge_exact_splitting - ::value_type*, Comparator, _DifferenceTp>, - static_cast(length), comp, tag.get_num_threads()); + ( + __seqs_begin, __seqs_end, + __target, + multiway_merge_exact_splitting + ::value_type*, _Compare, _DifferenceTp>, + static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads()); else - return sequential_multiway_merge - ( - seqs_begin, seqs_end, - target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge + ( + __seqs_begin, __seqs_end, + __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -multiway_merge(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , parallel_tag tag = parallel_tag(0)) + , typename _Compare> +_RAIterOut +multiway_merge(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , parallel_tag __tag = parallel_tag(0)) { - return multiway_merge(seqs_begin, seqs_end, target, length, comp, - exact_tag(tag.get_num_threads())); + return multiway_merge(__seqs_begin, __seqs_end, __target, __length, __comp, + exact_tag(__tag.__get_num_threads())); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -multiway_merge(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , default_parallel_tag tag) + , typename _Compare> +_RAIterOut +multiway_merge(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , default_parallel_tag __tag) { - return multiway_merge(seqs_begin, seqs_end, target, length, comp, - exact_tag(tag.get_num_threads())); + return multiway_merge(__seqs_begin, __seqs_end, __target, __length, __comp, + exact_tag(__tag.__get_num_threads())); } // stable_multiway_merge // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp + , typename _Compare> +_RAIterOut +stable_multiway_merge(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp , __gnu_parallel::sequential_tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute multiway merge *sequentially*. - return sequential_multiway_merge - - (seqs_begin, seqs_end, target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge + + (__seqs_begin, __seqs_end, __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , __gnu_parallel::exact_tag tag) + , typename _Compare> +_RAIterOut +stable_multiway_merge(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , __gnu_parallel::exact_tag __tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute merge; maybe parallel, depending on the number of merged // elements and the number of sequences and global thresholds in // Settings. - if ((seqs_end - seqs_begin > 1) && + if ((__seqs_end - __seqs_begin > 1) && _GLIBCXX_PARALLEL_CONDITION( - ((seqs_end - seqs_begin) >= + ((__seqs_end - __seqs_begin) >= __gnu_parallel::_Settings::get().multiway_merge_minimal_k) - && ((sequence_index_t)length >= + && ((_SequenceIndex)__length >= __gnu_parallel::_Settings::get().multiway_merge_minimal_n))) return parallel_multiway_merge - ( - seqs_begin, seqs_end, - target, - multiway_merge_exact_splitting - ::value_type*, Comparator, _DifferenceTp>, - static_cast(length), comp, tag.get_num_threads()); + ( + __seqs_begin, __seqs_end, + __target, + multiway_merge_exact_splitting + ::value_type*, _Compare, _DifferenceTp>, + static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads()); else - return sequential_multiway_merge( - seqs_begin, seqs_end, - target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge( + __seqs_begin, __seqs_end, + __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , sampling_tag tag) + , typename _Compare> +_RAIterOut +stable_multiway_merge(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , sampling_tag __tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute merge; maybe parallel, depending on the number of merged // elements and the number of sequences and global thresholds in // Settings. - if ((seqs_end - seqs_begin > 1) && + if ((__seqs_end - __seqs_begin > 1) && _GLIBCXX_PARALLEL_CONDITION( - ((seqs_end - seqs_begin) >= + ((__seqs_end - __seqs_begin) >= __gnu_parallel::_Settings::get().multiway_merge_minimal_k) - && ((sequence_index_t)length >= + && ((_SequenceIndex)__length >= __gnu_parallel::_Settings::get().multiway_merge_minimal_n))) return parallel_multiway_merge - ( - seqs_begin, seqs_end, - target, - multiway_merge_sampling_splitting - ::value_type*, Comparator, _DifferenceTp>, - static_cast(length), comp, tag.get_num_threads()); + ( + __seqs_begin, __seqs_end, + __target, + multiway_merge_sampling_splitting + ::value_type*, _Compare, _DifferenceTp>, + static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads()); else - return sequential_multiway_merge - ( - seqs_begin, seqs_end, - target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge + ( + __seqs_begin, __seqs_end, + __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , parallel_tag tag = parallel_tag(0)) + , typename _Compare> +_RAIterOut +stable_multiway_merge(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , parallel_tag __tag = parallel_tag(0)) { - return stable_multiway_merge(seqs_begin, seqs_end, target, length, comp, - exact_tag(tag.get_num_threads())); + return stable_multiway_merge(__seqs_begin, __seqs_end, __target, __length, __comp, + exact_tag(__tag.__get_num_threads())); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , default_parallel_tag tag) + , typename _Compare> +_RAIterOut +stable_multiway_merge(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , default_parallel_tag __tag) { - return stable_multiway_merge(seqs_begin, seqs_end, target, length, comp, - exact_tag(tag.get_num_threads())); + return stable_multiway_merge(__seqs_begin, __seqs_end, __target, __length, __comp, + exact_tag(__tag.__get_num_threads())); } /** * @brief Multiway Merge Frontend. * - * Merge the sequences specified by seqs_begin and seqs_end into - * target. seqs_begin and seqs_end must point to a sequence of + * Merge the sequences specified by seqs_begin and __seqs_end into + * __target. __seqs_begin and __seqs_end must point to a sequence of * pairs. These pairs must contain an iterator to the beginning - * of a sequence in their first entry and an iterator the end of + * of a sequence in their first entry and an iterator the _M_end of * the same sequence in their second entry. * * Ties are broken arbitrarily. See stable_multiway_merge for a variant @@ -1788,7 +1788,7 @@ stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin * - using sampling for splitting * - using sentinels * - * You have to take care that the element the end iterator points to is + * You have to take care that the element the _M_end iterator points to is * readable and contains a value that is greater than any other non-sentinel * value in all sequences. * @@ -1796,343 +1796,343 @@ stable_multiway_merge(RandomAccessIteratorPairIterator seqs_begin * * 
  *   int sequences[10][11];
- *   for (int i = 0; i < 10; ++i)
- *     for (int j = 0; i < 11; ++j)
- *       sequences[i][j] = j; // last one is sentinel!
+ *   for (int __i = 0; __i < 10; ++__i)
+ *     for (int __j = 0; __i < 11; ++__j)
+ *       sequences[__i][__j] = __j; // __last one is sentinel!
  *
- *   int out[33];
+ *   int __out[33];
  *   std::vector > seqs;
- *   for (int i = 0; i < 10; ++i)
- *     { seqs.push(std::make_pair(sequences[i], sequences[i] + 10)) }
+ *   for (int __i = 0; __i < 10; ++__i)
+ *     { seqs.push(std::make_pair(sequences[__i], sequences[__i] + 10)) }
  *
- *   multiway_merge(seqs.begin(), seqs.end(), target, std::less(), 33);
+ *   multiway_merge(seqs.begin(), seqs.end(), __target, std::less(), 33);
  *
* * @pre All input sequences must be sorted. - * @pre Target must provide enough space to merge out length elements or + * @pre Target must provide enough space to merge out __length __elements or * the number of elements in all sequences, whichever is smaller. - * @pre For each @c i, @c seqs_begin[i].second must be the end - * marker of the sequence, but also reference the one more sentinel + * @pre For each @__c __i, @__c __seqs_begin[__i].second must be the end + * marker of the sequence, but also reference the one more __sentinel * element. * - * @post [target, return value) contains merged elements from the + * @post [__target, return __value) contains merged __elements from the * input sequences. - * @post return value - target = min(length, number of elements in all + * @post return __value - __target = min(__length, number of elements in all * sequences). * * @see stable_multiway_merge_sentinels * - * @param RandomAccessIteratorPairIterator iterator over sequence + * @param _RAIterPairIterator iterator over __sequence * of pairs of iterators - * @param RandomAccessIteratorOut iterator over target sequence - * @param _DifferenceTp difference type for the sequence - * @param Comparator strict weak ordering type to compare elements + * @param _RAIterOut iterator over target sequence + * @param _DifferenceTp difference _Self for the sequence + * @param _Compare strict weak ordering _Self to compare __elements * in sequences * - * @param seqs_begin begin of sequence sequence - * @param seqs_end end of sequence sequence - * @param target target sequence to merge to. - * @param comp strict weak ordering to use for element comparison. - * @param length Maximum length to merge, possibly larger than the + * @param __seqs_begin __begin of sequence __sequence + * @param __seqs_end _M_end of sequence __sequence + * @param __target target sequence to merge to. + * @param __comp strict weak ordering to use for element comparison. + * @param __length Maximum length to merge, possibly larger than the * number of elements available. * - * @return end iterator of output sequence + * @return _M_end iterator of output sequence */ // multiway_merge_sentinels // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp + , typename _Compare> +_RAIterOut +multiway_merge_sentinels(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp , __gnu_parallel::sequential_tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute multiway merge *sequentially*. - return sequential_multiway_merge - - (seqs_begin, seqs_end, - target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge + + (__seqs_begin, __seqs_end, + __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , __gnu_parallel::exact_tag tag) + , typename _Compare> +_RAIterOut +multiway_merge_sentinels(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , __gnu_parallel::exact_tag __tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute merge; maybe parallel, depending on the number of merged // elements and the number of sequences and global thresholds in // Settings. - if ((seqs_end - seqs_begin > 1) && + if ((__seqs_end - __seqs_begin > 1) && _GLIBCXX_PARALLEL_CONDITION( - ((seqs_end - seqs_begin) >= + ((__seqs_end - __seqs_begin) >= __gnu_parallel::_Settings::get().multiway_merge_minimal_k) - && ((sequence_index_t)length >= + && ((_SequenceIndex)__length >= __gnu_parallel::_Settings::get().multiway_merge_minimal_n))) return parallel_multiway_merge - ( - seqs_begin, seqs_end, - target, - multiway_merge_exact_splitting - ::value_type*, Comparator, _DifferenceTp>, - static_cast(length), comp, tag.get_num_threads()); + ( + __seqs_begin, __seqs_end, + __target, + multiway_merge_exact_splitting + ::value_type*, _Compare, _DifferenceTp>, + static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads()); else - return sequential_multiway_merge - ( - seqs_begin, seqs_end, - target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge + ( + __seqs_begin, __seqs_end, + __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , sampling_tag tag) + , typename _Compare> +_RAIterOut +multiway_merge_sentinels(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , sampling_tag __tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute merge; maybe parallel, depending on the number of merged // elements and the number of sequences and global thresholds in // Settings. - if ((seqs_end - seqs_begin > 1) && + if ((__seqs_end - __seqs_begin > 1) && _GLIBCXX_PARALLEL_CONDITION( - ((seqs_end - seqs_begin) >= + ((__seqs_end - __seqs_begin) >= __gnu_parallel::_Settings::get().multiway_merge_minimal_k) - && ((sequence_index_t)length >= + && ((_SequenceIndex)__length >= __gnu_parallel::_Settings::get().multiway_merge_minimal_n))) return parallel_multiway_merge - - (seqs_begin, seqs_end, target, - multiway_merge_sampling_splitting - ::value_type*, Comparator, _DifferenceTp>, - static_cast(length), comp, tag.get_num_threads()); + + (__seqs_begin, __seqs_end, __target, + multiway_merge_sampling_splitting + ::value_type*, _Compare, _DifferenceTp>, + static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads()); else - return sequential_multiway_merge - ( - seqs_begin, seqs_end, - target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge + ( + __seqs_begin, __seqs_end, + __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , parallel_tag tag = parallel_tag(0)) + , typename _Compare> +_RAIterOut +multiway_merge_sentinels(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , parallel_tag __tag = parallel_tag(0)) { - return multiway_merge_sentinels(seqs_begin, seqs_end, target, length, comp, - exact_tag(tag.get_num_threads())); + return multiway_merge_sentinels(__seqs_begin, __seqs_end, __target, __length, __comp, + exact_tag(__tag.__get_num_threads())); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , default_parallel_tag tag) + , typename _Compare> +_RAIterOut +multiway_merge_sentinels(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , default_parallel_tag __tag) { - return multiway_merge_sentinels(seqs_begin, seqs_end, target, length, comp, - exact_tag(tag.get_num_threads())); + return multiway_merge_sentinels(__seqs_begin, __seqs_end, __target, __length, __comp, + exact_tag(__tag.__get_num_threads())); } // stable_multiway_merge_sentinels // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -stable_multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp + , typename _Compare> +_RAIterOut +stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp , __gnu_parallel::sequential_tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute multiway merge *sequentially*. - return sequential_multiway_merge - - (seqs_begin, seqs_end, target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge + + (__seqs_begin, __seqs_end, __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -stable_multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , __gnu_parallel::exact_tag tag) + , typename _Compare> +_RAIterOut +stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , __gnu_parallel::exact_tag __tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute merge; maybe parallel, depending on the number of merged // elements and the number of sequences and global thresholds in // Settings. - if ((seqs_end - seqs_begin > 1) && + if ((__seqs_end - __seqs_begin > 1) && _GLIBCXX_PARALLEL_CONDITION( - ((seqs_end - seqs_begin) >= + ((__seqs_end - __seqs_begin) >= __gnu_parallel::_Settings::get().multiway_merge_minimal_k) - && ((sequence_index_t)length >= + && ((_SequenceIndex)__length >= __gnu_parallel::_Settings::get().multiway_merge_minimal_n))) return parallel_multiway_merge - ( - seqs_begin, seqs_end, - target, - multiway_merge_exact_splitting - ::value_type*, Comparator, _DifferenceTp>, - static_cast(length), comp, tag.get_num_threads()); + ( + __seqs_begin, __seqs_end, + __target, + multiway_merge_exact_splitting + ::value_type*, _Compare, _DifferenceTp>, + static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads()); else - return sequential_multiway_merge - ( - seqs_begin, seqs_end, target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge + ( + __seqs_begin, __seqs_end, __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -stable_multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , sampling_tag tag) + , typename _Compare> +_RAIterOut +stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , sampling_tag __tag) { - typedef _DifferenceTp difference_type; - _GLIBCXX_CALL(seqs_end - seqs_begin) + typedef _DifferenceTp _DifferenceType; + _GLIBCXX_CALL(__seqs_end - __seqs_begin) // catch special case: no sequences - if (seqs_begin == seqs_end) - return target; + if (__seqs_begin == __seqs_end) + return __target; // Execute merge; maybe parallel, depending on the number of merged // elements and the number of sequences and global thresholds in // Settings. - if ((seqs_end - seqs_begin > 1) && + if ((__seqs_end - __seqs_begin > 1) && _GLIBCXX_PARALLEL_CONDITION( - ((seqs_end - seqs_begin) >= + ((__seqs_end - __seqs_begin) >= __gnu_parallel::_Settings::get().multiway_merge_minimal_k) - && ((sequence_index_t)length >= + && ((_SequenceIndex)__length >= __gnu_parallel::_Settings::get().multiway_merge_minimal_n))) return parallel_multiway_merge - ( - seqs_begin, seqs_end, - target, - multiway_merge_sampling_splitting - ::value_type*, Comparator, _DifferenceTp>, - static_cast(length), comp, tag.get_num_threads()); + ( + __seqs_begin, __seqs_end, + __target, + multiway_merge_sampling_splitting + ::value_type*, _Compare, _DifferenceTp>, + static_cast<_DifferenceType>(__length), __comp, __tag.__get_num_threads()); else - return sequential_multiway_merge - ( - seqs_begin, seqs_end, - target, *(seqs_begin->second), length, comp); + return __sequential_multiway_merge + ( + __seqs_begin, __seqs_end, + __target, *(__seqs_begin->second), __length, __comp); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -stable_multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , parallel_tag tag = parallel_tag(0)) + , typename _Compare> +_RAIterOut +stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , parallel_tag __tag = parallel_tag(0)) { - return stable_multiway_merge_sentinels(seqs_begin, seqs_end, target, length, comp, - exact_tag(tag.get_num_threads())); + return stable_multiway_merge_sentinels(__seqs_begin, __seqs_end, __target, __length, __comp, + exact_tag(__tag.__get_num_threads())); } // public interface template< - typename RandomAccessIteratorPairIterator - , typename RandomAccessIteratorOut + typename _RAIterPairIterator + , typename _RAIterOut , typename _DifferenceTp - , typename Comparator> -RandomAccessIteratorOut -stable_multiway_merge_sentinels(RandomAccessIteratorPairIterator seqs_begin - , RandomAccessIteratorPairIterator seqs_end - , RandomAccessIteratorOut target - , _DifferenceTp length, Comparator comp - , default_parallel_tag tag) + , typename _Compare> +_RAIterOut +stable_multiway_merge_sentinels(_RAIterPairIterator __seqs_begin + , _RAIterPairIterator __seqs_end + , _RAIterOut __target + , _DifferenceTp __length, _Compare __comp + , default_parallel_tag __tag) { - return stable_multiway_merge_sentinels(seqs_begin, seqs_end, target, length, comp, - exact_tag(tag.get_num_threads())); + return stable_multiway_merge_sentinels(__seqs_begin, __seqs_end, __target, __length, __comp, + exact_tag(__tag.__get_num_threads())); } }; // namespace __gnu_parallel diff --git a/libstdc++-v3/include/parallel/multiway_mergesort.h b/libstdc++-v3/include/parallel/multiway_mergesort.h index 11dd885c8aec..1c2c7e445be5 100644 --- a/libstdc++-v3/include/parallel/multiway_mergesort.h +++ b/libstdc++-v3/include/parallel/multiway_mergesort.h @@ -44,431 +44,431 @@ namespace __gnu_parallel /** @brief Subsequence description. */ template - struct Piece + struct _Piece { - typedef _DifferenceTp difference_type; + typedef _DifferenceTp _DifferenceType; /** @brief Begin of subsequence. */ - difference_type begin; + _DifferenceType __begin; /** @brief End of subsequence. */ - difference_type end; + _DifferenceType __end; }; /** @brief Data accessed by all threads. * * PMWMS = parallel multiway mergesort */ -template - struct PMWMSSortingData +template + struct _PMWMSSortingData { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; /** @brief Number of threads involved. */ - thread_index_t num_threads; + _ThreadIndex __num_threads; - /** @brief Input begin. */ - RandomAccessIterator source; + /** @brief Input __begin. */ + _RAIter _M_source; /** @brief Start indices, per thread. */ - difference_type* starts; + _DifferenceType* _M_starts; /** @brief Storage in which to sort. */ - value_type** temporary; + _ValueType** _M_temporary; /** @brief Samples. */ - value_type* samples; + _ValueType* _M_samples; /** @brief Offsets to add to the found positions. */ - difference_type* offsets; + _DifferenceType* _M_offsets; - /** @brief Pieces of data to merge @c [thread][sequence] */ - std::vector >* pieces; + /** @brief Pieces of data to merge @__c [thread][__sequence] */ + std::vector<_Piece<_DifferenceType> >* _M_pieces; }; /** - * @brief Select samples from a sequence. - * @param sd Pointer to algorithm data. Result will be placed in - * @c sd->samples. - * @param num_samples Number of samples to select. + * @brief Select _M_samples from a sequence. + * @param __sd Pointer to algorithm data. _Result will be placed in + * @__c __sd->_M_samples. + * @param __num_samples Number of _M_samples to select. */ -template +template void - determine_samples(PMWMSSortingData* sd, - _DifferenceTp num_samples) + __determine_samples(_PMWMSSortingData<_RAIter>* __sd, + _DifferenceTp __num_samples) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef _DifferenceTp difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef _DifferenceTp _DifferenceType; - thread_index_t iam = omp_get_thread_num(); + _ThreadIndex __iam = omp_get_thread_num(); - difference_type* es = new difference_type[num_samples + 2]; + _DifferenceType* __es = new _DifferenceType[__num_samples + 2]; - equally_split(sd->starts[iam + 1] - sd->starts[iam], - num_samples + 1, es); + equally_split(__sd->_M_starts[__iam + 1] - __sd->_M_starts[__iam], + __num_samples + 1, __es); - for (difference_type i = 0; i < num_samples; ++i) - ::new(&(sd->samples[iam * num_samples + i])) - value_type(sd->source[sd->starts[iam] + es[i + 1]]); + for (_DifferenceType __i = 0; __i < __num_samples; ++__i) + ::new(&(__sd->_M_samples[__iam * __num_samples + __i])) + _ValueType(__sd->_M_source[__sd->_M_starts[__iam] + __es[__i + 1]]); - delete[] es; + delete[] __es; } /** @brief Split consistently. */ -template - struct split_consistently +template + struct _SplitConsistently { }; /** @brief Split by exact splitting. */ -template - struct split_consistently - +template + struct _SplitConsistently + { void operator()( - const thread_index_t iam, - PMWMSSortingData* sd, - Comparator& comp, + const _ThreadIndex __iam, + _PMWMSSortingData<_RAIter>* __sd, + _Compare& __comp, const typename - std::iterator_traits::difference_type - num_samples) + std::iterator_traits<_RAIter>::difference_type + __num_samples) const { # pragma omp barrier - std::vector > - seqs(sd->num_threads); - for (thread_index_t s = 0; s < sd->num_threads; s++) - seqs[s] = std::make_pair(sd->temporary[s], - sd->temporary[s] - + (sd->starts[s + 1] - sd->starts[s])); + std::vector > + seqs(__sd->__num_threads); + for (_ThreadIndex __s = 0; __s < __sd->__num_threads; __s++) + seqs[__s] = std::make_pair(__sd->_M_temporary[__s], + __sd->_M_temporary[__s] + + (__sd->_M_starts[__s + 1] - __sd->_M_starts[__s])); - std::vector offsets(sd->num_threads); + std::vector<_SortingPlacesIterator> _M_offsets(__sd->__num_threads); // if not last thread - if (iam < sd->num_threads - 1) + if (__iam < __sd->__num_threads - 1) multiseq_partition(seqs.begin(), seqs.end(), - sd->starts[iam + 1], offsets.begin(), comp); + __sd->_M_starts[__iam + 1], _M_offsets.begin(), __comp); - for (int seq = 0; seq < sd->num_threads; seq++) + for (int __seq = 0; __seq < __sd->__num_threads; __seq++) { // for each sequence - if (iam < (sd->num_threads - 1)) - sd->pieces[iam][seq].end = offsets[seq] - seqs[seq].first; + if (__iam < (__sd->__num_threads - 1)) + __sd->_M_pieces[__iam][__seq].__end = _M_offsets[__seq] - seqs[__seq].first; else // very end of this sequence - sd->pieces[iam][seq].end = - sd->starts[seq + 1] - sd->starts[seq]; + __sd->_M_pieces[__iam][__seq].__end = + __sd->_M_starts[__seq + 1] - __sd->_M_starts[__seq]; } # pragma omp barrier - for (thread_index_t seq = 0; seq < sd->num_threads; seq++) + for (_ThreadIndex __seq = 0; __seq < __sd->__num_threads; __seq++) { // For each sequence. - if (iam > 0) - sd->pieces[iam][seq].begin = sd->pieces[iam - 1][seq].end; + if (__iam > 0) + __sd->_M_pieces[__iam][__seq].__begin = __sd->_M_pieces[__iam - 1][__seq].__end; else // Absolute beginning. - sd->pieces[iam][seq].begin = 0; + __sd->_M_pieces[__iam][__seq].__begin = 0; } } }; /** @brief Split by sampling. */ -template - struct split_consistently +template + struct _SplitConsistently { void operator()( - const thread_index_t iam, - PMWMSSortingData* sd, - Comparator& comp, + const _ThreadIndex __iam, + _PMWMSSortingData<_RAIter>* __sd, + _Compare& __comp, const typename - std::iterator_traits::difference_type - num_samples) + std::iterator_traits<_RAIter>::difference_type + __num_samples) const { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - determine_samples(sd, num_samples); + __determine_samples(__sd, __num_samples); # pragma omp barrier # pragma omp single - __gnu_sequential::sort(sd->samples, - sd->samples + (num_samples * sd->num_threads), - comp); + __gnu_sequential::sort(__sd->_M_samples, + __sd->_M_samples + (__num_samples * __sd->__num_threads), + __comp); # pragma omp barrier - for (thread_index_t s = 0; s < sd->num_threads; ++s) + for (_ThreadIndex __s = 0; __s < __sd->__num_threads; ++__s) { // For each sequence. - if (num_samples * iam > 0) - sd->pieces[iam][s].begin = - std::lower_bound(sd->temporary[s], - sd->temporary[s] - + (sd->starts[s + 1] - sd->starts[s]), - sd->samples[num_samples * iam], - comp) - - sd->temporary[s]; + if (__num_samples * __iam > 0) + __sd->_M_pieces[__iam][__s].__begin = + std::lower_bound(__sd->_M_temporary[__s], + __sd->_M_temporary[__s] + + (__sd->_M_starts[__s + 1] - __sd->_M_starts[__s]), + __sd->_M_samples[__num_samples * __iam], + __comp) + - __sd->_M_temporary[__s]; else // Absolute beginning. - sd->pieces[iam][s].begin = 0; - - if ((num_samples * (iam + 1)) < (num_samples * sd->num_threads)) - sd->pieces[iam][s].end = - std::lower_bound(sd->temporary[s], - sd->temporary[s] - + (sd->starts[s + 1] - sd->starts[s]), - sd->samples[num_samples * (iam + 1)], - comp) - - sd->temporary[s]; + __sd->_M_pieces[__iam][__s].__begin = 0; + + if ((__num_samples * (__iam + 1)) < (__num_samples * __sd->__num_threads)) + __sd->_M_pieces[__iam][__s].__end = + std::lower_bound(__sd->_M_temporary[__s], + __sd->_M_temporary[__s] + + (__sd->_M_starts[__s + 1] - __sd->_M_starts[__s]), + __sd->_M_samples[__num_samples * (__iam + 1)], + __comp) + - __sd->_M_temporary[__s]; else - // Absolute end. - sd->pieces[iam][s].end = sd->starts[s + 1] - sd->starts[s]; + // Absolute __end. + __sd->_M_pieces[__iam][__s].__end = __sd->_M_starts[__s + 1] - __sd->_M_starts[__s]; } } }; -template - struct possibly_stable_sort +template + struct __possibly_stable_sort { }; -template - struct possibly_stable_sort +template + struct __possibly_stable_sort { - void operator()(const RandomAccessIterator& begin, - const RandomAccessIterator& end, Comparator& comp) const + void operator()(const _RAIter& __begin, + const _RAIter& __end, _Compare& __comp) const { - __gnu_sequential::stable_sort(begin, end, comp); + __gnu_sequential::stable_sort(__begin, __end, __comp); } }; -template - struct possibly_stable_sort +template + struct __possibly_stable_sort { - void operator()(const RandomAccessIterator begin, - const RandomAccessIterator end, Comparator& comp) const + void operator()(const _RAIter __begin, + const _RAIter __end, _Compare& __comp) const { - __gnu_sequential::sort(begin, end, comp); + __gnu_sequential::sort(__begin, __end, __comp); } }; -template - struct possibly_stable_multiway_merge + struct __possibly_stable_multiway_merge { }; -template - struct possibly_stable_multiway_merge - + struct __possibly_stable_multiway_merge + { - void operator()(const SeqRandomAccessIterator& seqs_begin, - const SeqRandomAccessIterator& seqs_end, - const RandomAccessIterator& target, - Comparator& comp, - DiffType length_am) const + void operator()(const Seq_RAIter& __seqs_begin, + const Seq_RAIter& __seqs_end, + const _RAIter& __target, + _Compare& __comp, + DiffType __length_am) const { - stable_multiway_merge(seqs_begin, seqs_end, target, length_am, comp, + stable_multiway_merge(__seqs_begin, __seqs_end, __target, __length_am, __comp, sequential_tag()); } }; -template - struct possibly_stable_multiway_merge - + struct __possibly_stable_multiway_merge + { - void operator()(const SeqRandomAccessIterator& seqs_begin, - const SeqRandomAccessIterator& seqs_end, - const RandomAccessIterator& target, - Comparator& comp, - DiffType length_am) const + void operator()(const Seq_RAIter& __seqs_begin, + const Seq_RAIter& __seqs_end, + const _RAIter& __target, + _Compare& __comp, + DiffType __length_am) const { - multiway_merge(seqs_begin, seqs_end, target, length_am, comp, + multiway_merge(__seqs_begin, __seqs_end, __target, __length_am, __comp, sequential_tag()); } }; /** @brief PMWMS code executed by each thread. - * @param sd Pointer to algorithm data. - * @param comp Comparator. + * @param __sd Pointer to algorithm data. + * @param __comp Comparator. */ -template +template void - parallel_sort_mwms_pu(PMWMSSortingData* sd, - Comparator& comp) + parallel_sort_mwms_pu(_PMWMSSortingData<_RAIter>* __sd, + _Compare& __comp) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - thread_index_t iam = omp_get_thread_num(); + _ThreadIndex __iam = omp_get_thread_num(); // Length of this thread's chunk, before merging. - difference_type length_local = sd->starts[iam + 1] - sd->starts[iam]; + _DifferenceType __length_local = __sd->_M_starts[__iam + 1] - __sd->_M_starts[__iam]; // Sort in temporary storage, leave space for sentinel. - typedef value_type* SortingPlacesIterator; + typedef _ValueType* _SortingPlacesIterator; - sd->temporary[iam] = - static_cast( - ::operator new(sizeof(value_type) * (length_local + 1))); + __sd->_M_temporary[__iam] = + static_cast<_ValueType*>( + ::operator new(sizeof(_ValueType) * (__length_local + 1))); // Copy there. - std::uninitialized_copy(sd->source + sd->starts[iam], - sd->source + sd->starts[iam] + length_local, - sd->temporary[iam]); + std::uninitialized_copy(__sd->_M_source + __sd->_M_starts[__iam], + __sd->_M_source + __sd->_M_starts[__iam] + __length_local, + __sd->_M_temporary[__iam]); - possibly_stable_sort() - (sd->temporary[iam], sd->temporary[iam] + length_local, comp); + __possibly_stable_sort<__stable, _SortingPlacesIterator, _Compare>() + (__sd->_M_temporary[__iam], __sd->_M_temporary[__iam] + __length_local, __comp); - // Invariant: locally sorted subsequence in sd->temporary[iam], - // sd->temporary[iam] + length_local. + // Invariant: locally sorted subsequence in sd->_M_temporary[__iam], + // __sd->_M_temporary[__iam] + __length_local. // No barrier here: Synchronization is done by the splitting routine. - difference_type num_samples = - _Settings::get().sort_mwms_oversampling * sd->num_threads - 1; - split_consistently - () - (iam, sd, comp, num_samples); + _DifferenceType __num_samples = + _Settings::get().sort_mwms_oversampling * __sd->__num_threads - 1; + _SplitConsistently + <__exact, _RAIter, _Compare, _SortingPlacesIterator>() + (__iam, __sd, __comp, __num_samples); - // Offset from target begin, length after merging. - difference_type offset = 0, length_am = 0; - for (thread_index_t s = 0; s < sd->num_threads; s++) + // Offset from __target __begin, __length after merging. + _DifferenceType __offset = 0, __length_am = 0; + for (_ThreadIndex __s = 0; __s < __sd->__num_threads; __s++) { - length_am += sd->pieces[iam][s].end - sd->pieces[iam][s].begin; - offset += sd->pieces[iam][s].begin; + __length_am += __sd->_M_pieces[__iam][__s].__end - __sd->_M_pieces[__iam][__s].__begin; + __offset += __sd->_M_pieces[__iam][__s].__begin; } typedef std::vector< - std::pair > + std::pair<_SortingPlacesIterator, _SortingPlacesIterator> > seq_vector_type; - seq_vector_type seqs(sd->num_threads); + seq_vector_type seqs(__sd->__num_threads); - for (int s = 0; s < sd->num_threads; ++s) + for (int __s = 0; __s < __sd->__num_threads; ++__s) { - seqs[s] = - std::make_pair(sd->temporary[s] + sd->pieces[iam][s].begin, - sd->temporary[s] + sd->pieces[iam][s].end); + seqs[__s] = + std::make_pair(__sd->_M_temporary[__s] + __sd->_M_pieces[__iam][__s].__begin, + __sd->_M_temporary[__s] + __sd->_M_pieces[__iam][__s].__end); } - possibly_stable_multiway_merge< - stable, + __possibly_stable_multiway_merge< + __stable, typename seq_vector_type::iterator, - RandomAccessIterator, - Comparator, difference_type>() + _RAIter, + _Compare, _DifferenceType>() (seqs.begin(), seqs.end(), - sd->source + offset, comp, - length_am); + __sd->_M_source + __offset, __comp, + __length_am); # pragma omp barrier - ::operator delete(sd->temporary[iam]); + ::operator delete(__sd->_M_temporary[__iam]); } /** @brief PMWMS main call. - * @param begin Begin iterator of sequence. - * @param end End iterator of sequence. - * @param comp Comparator. - * @param n Length of sequence. - * @param num_threads Number of threads to use. + * @param __begin Begin iterator of sequence. + * @param __end End iterator of sequence. + * @param __comp Comparator. + * @param __n Length of sequence. + * @param __num_threads Number of threads to use. */ -template +template void - parallel_sort_mwms(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, - thread_index_t num_threads) + parallel_sort_mwms(_RAIter __begin, _RAIter __end, + _Compare __comp, + _ThreadIndex __num_threads) { - _GLIBCXX_CALL(end - begin) + _GLIBCXX_CALL(__end - __begin) - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - difference_type n = end - begin; + _DifferenceType __n = __end - __begin; - if (n <= 1) + if (__n <= 1) return; // at least one element per thread - if (num_threads > n) - num_threads = static_cast(n); + if (__num_threads > __n) + __num_threads = static_cast<_ThreadIndex>(__n); // shared variables - PMWMSSortingData sd; - difference_type* starts; + _PMWMSSortingData<_RAIter> __sd; + _DifferenceType* _M_starts; -# pragma omp parallel num_threads(num_threads) +# pragma omp parallel num_threads(__num_threads) { - num_threads = omp_get_num_threads(); //no more threads than requested + __num_threads = omp_get_num_threads(); //no more threads than requested # pragma omp single { - sd.num_threads = num_threads; - sd.source = begin; + __sd.__num_threads = __num_threads; + __sd._M_source = __begin; - sd.temporary = new value_type*[num_threads]; + __sd._M_temporary = new _ValueType*[__num_threads]; - if (!exact) + if (!__exact) { - difference_type size = - (_Settings::get().sort_mwms_oversampling * num_threads - 1) - * num_threads; - sd.samples = static_cast( - ::operator new(size * sizeof(value_type))); + _DifferenceType size = + (_Settings::get().sort_mwms_oversampling * __num_threads - 1) + * __num_threads; + __sd._M_samples = static_cast<_ValueType*>( + ::operator new(size * sizeof(_ValueType))); } else - sd.samples = NULL; - - sd.offsets = new difference_type[num_threads - 1]; - sd.pieces = new std::vector >[num_threads]; - for (int s = 0; s < num_threads; ++s) - sd.pieces[s].resize(num_threads); - starts = sd.starts = new difference_type[num_threads + 1]; - - difference_type chunk_length = n / num_threads; - difference_type split = n % num_threads; - difference_type pos = 0; - for (int i = 0; i < num_threads; ++i) + __sd._M_samples = NULL; + + __sd._M_offsets = new _DifferenceType[__num_threads - 1]; + __sd._M_pieces = new std::vector<_Piece<_DifferenceType> >[__num_threads]; + for (int __s = 0; __s < __num_threads; ++__s) + __sd._M_pieces[__s].resize(__num_threads); + _M_starts = __sd._M_starts = new _DifferenceType[__num_threads + 1]; + + _DifferenceType __chunk_length = __n / __num_threads; + _DifferenceType __split = __n % __num_threads; + _DifferenceType __pos = 0; + for (int __i = 0; __i < __num_threads; ++__i) { - starts[i] = pos; - pos += (i < split) ? (chunk_length + 1) : chunk_length; + _M_starts[__i] = __pos; + __pos += (__i < __split) ? (__chunk_length + 1) : __chunk_length; } - starts[num_threads] = pos; + _M_starts[__num_threads] = __pos; } //single // Now sort in parallel. - parallel_sort_mwms_pu(&sd, comp); + parallel_sort_mwms_pu<__stable, __exact>(&__sd, __comp); } //parallel - delete[] starts; - delete[] sd.temporary; + delete[] _M_starts; + delete[] __sd._M_temporary; - if (!exact) - ::operator delete(sd.samples); + if (!__exact) + ::operator delete(__sd._M_samples); - delete[] sd.offsets; - delete[] sd.pieces; + delete[] __sd._M_offsets; + delete[] __sd._M_pieces; } } //namespace __gnu_parallel diff --git a/libstdc++-v3/include/parallel/numeric b/libstdc++-v3/include/parallel/numeric index 33b1411f1b0f..e355097edd67 100644 --- a/libstdc++-v3/include/parallel/numeric +++ b/libstdc++-v3/include/parallel/numeric @@ -51,448 +51,448 @@ namespace std namespace __parallel { // Sequential fallback. - template - inline T - accumulate(InputIterator begin, InputIterator end, T init, + template + inline _Tp + accumulate(_IIter __begin, _IIter __end, _Tp __init, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::accumulate(begin, end, init); } + { return _GLIBCXX_STD_P::accumulate(__begin, __end, __init); } - template - inline T - accumulate(InputIterator begin, InputIterator end, T init, - BinaryOperation binary_op, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::accumulate(begin, end, init, binary_op); } + template + inline _Tp + accumulate(_IIter __begin, _IIter __end, _Tp __init, + _BinaryOperation __binary_op, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::accumulate(__begin, __end, __init, __binary_op); } // Sequential fallback for input iterator case. - template - inline T - accumulate_switch(InputIterator begin, InputIterator end, - T init, IteratorTag) - { return accumulate(begin, end, init, __gnu_parallel::sequential_tag()); } - - template - inline T - accumulate_switch(InputIterator begin, InputIterator end, T init, - BinaryOperation binary_op, IteratorTag) - { return accumulate(begin, end, init, binary_op, + template + inline _Tp + __accumulate_switch(_IIter __begin, _IIter __end, + _Tp __init, _IteratorTag) + { return accumulate(__begin, __end, __init, __gnu_parallel::sequential_tag()); } + + template + inline _Tp + __accumulate_switch(_IIter __begin, _IIter __end, _Tp __init, + _BinaryOperation __binary_op, _IteratorTag) + { return accumulate(__begin, __end, __init, __binary_op, __gnu_parallel::sequential_tag()); } // Parallel algorithm for random access iterators. - template - T - accumulate_switch(_RandomAccessIterator begin, _RandomAccessIterator end, - T init, BinaryOperation binary_op, + template + _Tp + __accumulate_switch(__RAIter __begin, __RAIter __end, + _Tp __init, _BinaryOperation __binary_op, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_unbalanced) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().accumulate_minimal_n - && __gnu_parallel::is_parallel(parallelism_tag))) + && __gnu_parallel::__is_parallel(__parallelism_tag))) { - T res = init; - __gnu_parallel::accumulate_selector<_RandomAccessIterator> - my_selector; + _Tp __res = __init; + __gnu_parallel::__accumulate_selector<__RAIter> + __my_selector; __gnu_parallel:: - for_each_template_random_access_ed(begin, end, - __gnu_parallel::nothing(), - my_selector, + for_each_template_random_access_ed(__begin, __end, + __gnu_parallel::_Nothing(), + __my_selector, __gnu_parallel:: - accumulate_binop_reduct - (binary_op), - res, res, -1); - return res; + __accumulate_binop_reduct + <_BinaryOperation>(__binary_op), + __res, __res, -1); + return __res; } else - return accumulate(begin, end, init, binary_op, + return accumulate(__begin, __end, __init, __binary_op, __gnu_parallel::sequential_tag()); } // Public interface. - template - inline T - accumulate(InputIterator begin, InputIterator end, T init, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _Tp + accumulate(_IIter __begin, _IIter __end, _Tp __init, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::value_type value_type; - typedef typename iterator_traits::iterator_category iterator_category; + typedef std::iterator_traits<_IIter> _IteratorTraits; + typedef typename _IteratorTraits::value_type _ValueType; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; - return accumulate_switch(begin, end, init, - __gnu_parallel::plus(), - iterator_category(), parallelism_tag); + return __accumulate_switch(__begin, __end, __init, + __gnu_parallel::_Plus<_Tp, _ValueType>(), + _IteratorCategory(), __parallelism_tag); } - template - inline T - accumulate(InputIterator begin, InputIterator end, T init) + template + inline _Tp + accumulate(_IIter __begin, _IIter __end, _Tp __init) { - typedef std::iterator_traits iterator_traits; - typedef typename iterator_traits::value_type value_type; - typedef typename iterator_traits::iterator_category iterator_category; + typedef std::iterator_traits<_IIter> _IteratorTraits; + typedef typename _IteratorTraits::value_type _ValueType; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; - return accumulate_switch(begin, end, init, - __gnu_parallel::plus(), - iterator_category()); + return __accumulate_switch(__begin, __end, __init, + __gnu_parallel::_Plus<_Tp, _ValueType>(), + _IteratorCategory()); } - template - inline T - accumulate(InputIterator begin, InputIterator end, T init, - BinaryOperation binary_op, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _Tp + accumulate(_IIter __begin, _IIter __end, _Tp __init, + _BinaryOperation __binary_op, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - return accumulate_switch(begin, end, init, binary_op, - iterator_category(), parallelism_tag); + typedef iterator_traits<_IIter> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + return __accumulate_switch(__begin, __end, __init, __binary_op, + _IteratorCategory(), __parallelism_tag); } - template - inline T - accumulate(InputIterator begin, InputIterator end, T init, - BinaryOperation binary_op) + template + inline _Tp + accumulate(_IIter __begin, _IIter __end, _Tp __init, + _BinaryOperation __binary_op) { - typedef iterator_traits iterator_traits; - typedef typename iterator_traits::iterator_category iterator_category; - return accumulate_switch(begin, end, init, binary_op, - iterator_category()); + typedef iterator_traits<_IIter> _IteratorTraits; + typedef typename _IteratorTraits::iterator_category _IteratorCategory; + return __accumulate_switch(__begin, __end, __init, __binary_op, + _IteratorCategory()); } // Sequential fallback. - template - inline T - inner_product(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, T init, + template + inline _Tp + inner_product(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _Tp __init, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::inner_product(first1, last1, first2, init); } + { return _GLIBCXX_STD_P::inner_product(__first1, __last1, __first2, __init); } - template - inline T - inner_product(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, T init, BinaryFunction1 binary_op1, - BinaryFunction2 binary_op2, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::inner_product(first1, last1, first2, init, - binary_op1, binary_op2); } + inline _Tp + inner_product(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _Tp __init, BinaryFunction1 __binary_op1, + BinaryFunction2 __binary_op2, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::inner_product(__first1, __last1, __first2, __init, + __binary_op1, __binary_op2); } // Parallel algorithm for random access iterators. - template - T - inner_product_switch(RandomAccessIterator1 first1, - RandomAccessIterator1 last1, - RandomAccessIterator2 first2, T init, - BinaryFunction1 binary_op1, - BinaryFunction2 binary_op2, + template + _Tp + __inner_product_switch(_RAIter1 __first1, + _RAIter1 __last1, + _RAIter2 __first2, _Tp __init, + BinaryFunction1 __binary_op1, + BinaryFunction2 __binary_op2, random_access_iterator_tag, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_unbalanced) { - if (_GLIBCXX_PARALLEL_CONDITION((last1 - first1) + if (_GLIBCXX_PARALLEL_CONDITION((__last1 - __first1) >= __gnu_parallel::_Settings::get(). accumulate_minimal_n && __gnu_parallel:: - is_parallel(parallelism_tag))) + __is_parallel(__parallelism_tag))) { - T res = init; + _Tp __res = __init; __gnu_parallel:: - inner_product_selector my_selector(first1, first2); + __inner_product_selector<_RAIter1, + _RAIter2, _Tp> __my_selector(__first1, __first2); __gnu_parallel:: - for_each_template_random_access_ed(first1, last1, binary_op2, - my_selector, binary_op1, - res, res, -1); - return res; + for_each_template_random_access_ed(__first1, __last1, __binary_op2, + __my_selector, __binary_op1, + __res, __res, -1); + return __res; } else - return inner_product(first1, last1, first2, init, + return inner_product(__first1, __last1, __first2, __init, __gnu_parallel::sequential_tag()); } // No parallelism for input iterators. - template - inline T - inner_product_switch(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, T init, - BinaryFunction1 binary_op1, - BinaryFunction2 binary_op2, - IteratorTag1, IteratorTag2) - { return inner_product(first1, last1, first2, init, - binary_op1, binary_op2, + typename _IteratorTag1, typename _IteratorTag2> + inline _Tp + __inner_product_switch(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _Tp __init, + BinaryFunction1 __binary_op1, + BinaryFunction2 __binary_op2, + _IteratorTag1, _IteratorTag2) + { return inner_product(__first1, __last1, __first2, __init, + __binary_op1, __binary_op2, __gnu_parallel::sequential_tag()); } - template - inline T - inner_product(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, T init, BinaryFunction1 binary_op1, - BinaryFunction2 binary_op2, - __gnu_parallel::_Parallelism parallelism_tag) + inline _Tp + inner_product(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _Tp __init, BinaryFunction1 __binary_op1, + BinaryFunction2 __binary_op2, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef iterator_traits traits1_type; - typedef typename traits1_type::iterator_category iterator1_category; + typedef iterator_traits<_IIter1> _TraitsType1; + typedef typename _TraitsType1::iterator_category _IteratorCategory1; - typedef iterator_traits traits2_type; - typedef typename traits2_type::iterator_category iterator2_category; + typedef iterator_traits<_IIter2> _TraitsType2; + typedef typename _TraitsType2::iterator_category _IteratorCategory2; - return inner_product_switch(first1, last1, first2, init, binary_op1, - binary_op2, iterator1_category(), - iterator2_category(), parallelism_tag); + return __inner_product_switch(__first1, __last1, __first2, __init, __binary_op1, + __binary_op2, _IteratorCategory1(), + _IteratorCategory2(), __parallelism_tag); } - template - inline T - inner_product(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, T init, BinaryFunction1 binary_op1, - BinaryFunction2 binary_op2) + inline _Tp + inner_product(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _Tp __init, BinaryFunction1 __binary_op1, + BinaryFunction2 __binary_op2) { - typedef iterator_traits traits1_type; - typedef typename traits1_type::iterator_category iterator1_category; + typedef iterator_traits<_IIter1> _TraitsType1; + typedef typename _TraitsType1::iterator_category _IteratorCategory1; - typedef iterator_traits traits2_type; - typedef typename traits2_type::iterator_category iterator2_category; + typedef iterator_traits<_IIter2> _TraitsType2; + typedef typename _TraitsType2::iterator_category _IteratorCategory2; - return inner_product_switch(first1, last1, first2, init, binary_op1, - binary_op2, iterator1_category(), - iterator2_category()); + return __inner_product_switch(__first1, __last1, __first2, __init, __binary_op1, + __binary_op2, _IteratorCategory1(), + _IteratorCategory2()); } - template - inline T - inner_product(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, T init, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _Tp + inner_product(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _Tp __init, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef iterator_traits traits_type1; + typedef iterator_traits<_IIter1> traits_type1; typedef typename traits_type1::value_type value_type1; - typedef iterator_traits traits_type2; + typedef iterator_traits<_IIter2> traits_type2; typedef typename traits_type2::value_type value_type2; typedef typename - __gnu_parallel::multiplies::result - multiplies_result_type; - return inner_product(first1, last1, first2, init, - __gnu_parallel::plus(), + __gnu_parallel::_Multiplies::__result + _MultipliesResultType; + return inner_product(__first1, __last1, __first2, __init, + __gnu_parallel::_Plus<_Tp, _MultipliesResultType>(), __gnu_parallel:: - multiplies(), - parallelism_tag); + _Multiplies(), + __parallelism_tag); } - template - inline T - inner_product(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, T init) + template + inline _Tp + inner_product(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _Tp __init) { - typedef iterator_traits traits_type1; + typedef iterator_traits<_IIter1> traits_type1; typedef typename traits_type1::value_type value_type1; - typedef iterator_traits traits_type2; + typedef iterator_traits<_IIter2> traits_type2; typedef typename traits_type2::value_type value_type2; typedef typename - __gnu_parallel::multiplies::result - multiplies_result_type; - return inner_product(first1, last1, first2, init, - __gnu_parallel::plus(), + __gnu_parallel::_Multiplies::__result + _MultipliesResultType; + return inner_product(__first1, __last1, __first2, __init, + __gnu_parallel::_Plus<_Tp, _MultipliesResultType>(), __gnu_parallel:: - multiplies()); + _Multiplies()); } // Sequential fallback. - template - inline OutputIterator - partial_sum(InputIterator begin, InputIterator end, OutputIterator result, + template + inline _OutputIterator + partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::partial_sum(begin, end, result); } + { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result); } // Sequential fallback. - template - inline OutputIterator - partial_sum(InputIterator begin, InputIterator end, OutputIterator result, - BinaryOperation bin_op, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::partial_sum(begin, end, result, bin_op); } + template + inline _OutputIterator + partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result, + _BinaryOperation __bin_op, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result, __bin_op); } // Sequential fallback for input iterator case. - template - inline OutputIterator - partial_sum_switch(InputIterator begin, InputIterator end, - OutputIterator result, BinaryOperation bin_op, - IteratorTag1, IteratorTag2) - { return _GLIBCXX_STD_P::partial_sum(begin, end, result, bin_op); } + template + inline _OutputIterator + __partial_sum_switch(_IIter __begin, _IIter __end, + _OutputIterator __result, _BinaryOperation __bin_op, + _IteratorTag1, _IteratorTag2) + { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result, __bin_op); } // Parallel algorithm for random access iterators. - template - OutputIterator - partial_sum_switch(InputIterator begin, InputIterator end, - OutputIterator result, BinaryOperation bin_op, + template + _OutputIterator + __partial_sum_switch(_IIter __begin, _IIter __end, + _OutputIterator __result, _BinaryOperation __bin_op, random_access_iterator_tag, random_access_iterator_tag) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().partial_sum_minimal_n)) - return __gnu_parallel::parallel_partial_sum(begin, end, - result, bin_op); + return __gnu_parallel::__parallel_partial_sum(__begin, __end, + __result, __bin_op); else - return partial_sum(begin, end, result, bin_op, + return partial_sum(__begin, __end, __result, __bin_op, __gnu_parallel::sequential_tag()); } // Public interface. - template - inline OutputIterator - partial_sum(InputIterator begin, InputIterator end, OutputIterator result) + template + inline _OutputIterator + partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result) { - typedef typename iterator_traits::value_type value_type; - return partial_sum(begin, end, result, std::plus()); + typedef typename iterator_traits<_IIter>::value_type _ValueType; + return partial_sum(__begin, __end, __result, std::plus<_ValueType>()); } // Public interface - template - inline OutputIterator - partial_sum(InputIterator begin, InputIterator end, OutputIterator result, - BinaryOperation binary_op) + template + inline _OutputIterator + partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result, + _BinaryOperation __binary_op) { - typedef iterator_traits traitsi_type; - typedef typename traitsi_type::iterator_category iteratori_category; + typedef iterator_traits<_IIter> traitsi_type; + typedef typename traitsi_type::iterator_category _IIteratorCategory; - typedef iterator_traits traitso_type; - typedef typename traitso_type::iterator_category iteratoro_category; + typedef iterator_traits<_OutputIterator> _OTraitsType; + typedef typename _OTraitsType::iterator_category _OIterCategory; - return partial_sum_switch(begin, end, result, binary_op, - iteratori_category(), iteratoro_category()); + return __partial_sum_switch(__begin, __end, __result, __binary_op, + _IIteratorCategory(), _OIterCategory()); } // Sequential fallback. - template - inline OutputIterator - adjacent_difference(InputIterator begin, InputIterator end, - OutputIterator result, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::adjacent_difference(begin, end, result); } + template + inline _OutputIterator + adjacent_difference(_IIter __begin, _IIter __end, + _OutputIterator __result, __gnu_parallel::sequential_tag) + { return _GLIBCXX_STD_P::adjacent_difference(__begin, __end, __result); } // Sequential fallback. - template - inline OutputIterator - adjacent_difference(InputIterator begin, InputIterator end, - OutputIterator result, BinaryOperation bin_op, + template + inline _OutputIterator + adjacent_difference(_IIter __begin, _IIter __end, + _OutputIterator __result, _BinaryOperation __bin_op, __gnu_parallel::sequential_tag) - { return _GLIBCXX_STD_P::adjacent_difference(begin, end, result, bin_op); } + { return _GLIBCXX_STD_P::adjacent_difference(__begin, __end, __result, __bin_op); } // Sequential fallback for input iterator case. - template - inline OutputIterator - adjacent_difference_switch(InputIterator begin, InputIterator end, - OutputIterator result, BinaryOperation bin_op, - IteratorTag1, IteratorTag2) - { return adjacent_difference(begin, end, result, bin_op, + template + inline _OutputIterator + __adjacent_difference_switch(_IIter __begin, _IIter __end, + _OutputIterator __result, _BinaryOperation __bin_op, + _IteratorTag1, _IteratorTag2) + { return adjacent_difference(__begin, __end, __result, __bin_op, __gnu_parallel::sequential_tag()); } // Parallel algorithm for random access iterators. - template - OutputIterator - adjacent_difference_switch(InputIterator begin, InputIterator end, - OutputIterator result, BinaryOperation bin_op, + template + _OutputIterator + __adjacent_difference_switch(_IIter __begin, _IIter __end, + _OutputIterator __result, _BinaryOperation __bin_op, random_access_iterator_tag, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism_tag + __gnu_parallel::_Parallelism __parallelism_tag = __gnu_parallel::parallel_balanced) { if (_GLIBCXX_PARALLEL_CONDITION( - static_cast<__gnu_parallel::sequence_index_t>(end - begin) + static_cast<__gnu_parallel::_SequenceIndex>(__end - __begin) >= __gnu_parallel::_Settings::get().adjacent_difference_minimal_n - && __gnu_parallel::is_parallel(parallelism_tag))) + && __gnu_parallel::__is_parallel(__parallelism_tag))) { - bool dummy = true; - typedef __gnu_parallel::iterator_pair ip; - *result = *begin; - ip begin_pair(begin + 1, result + 1), - end_pair(end, result + (end - begin)); - __gnu_parallel::adjacent_difference_selector functionality; + bool __dummy = true; + typedef __gnu_parallel::_IteratorPair<_IIter, _OutputIterator, + random_access_iterator_tag> _ItTrip; + *__result = *__begin; + _ItTrip begin_pair(__begin + 1, __result + 1), + end_pair(__end, __result + (__end - __begin)); + __gnu_parallel::__adjacent_difference_selector<_ItTrip> __functionality; __gnu_parallel:: - for_each_template_random_access_ed(begin_pair, end_pair, bin_op, - functionality, - __gnu_parallel::dummy_reduct(), - dummy, dummy, -1); - return functionality.finish_iterator; + for_each_template_random_access_ed(begin_pair, end_pair, __bin_op, + __functionality, + __gnu_parallel::_DummyReduct(), + __dummy, __dummy, -1); + return __functionality.finish_iterator; } else - return adjacent_difference(begin, end, result, bin_op, + return adjacent_difference(__begin, __end, __result, __bin_op, __gnu_parallel::sequential_tag()); } // Public interface. - template - inline OutputIterator - adjacent_difference(InputIterator begin, InputIterator end, - OutputIterator result, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _OutputIterator + adjacent_difference(_IIter __begin, _IIter __end, + _OutputIterator __result, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - return adjacent_difference(begin, end, result, std::minus(), - parallelism_tag); + typedef iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + return adjacent_difference(__begin, __end, __result, std::minus<_ValueType>(), + __parallelism_tag); } - template - inline OutputIterator - adjacent_difference(InputIterator begin, InputIterator end, - OutputIterator result) + template + inline _OutputIterator + adjacent_difference(_IIter __begin, _IIter __end, + _OutputIterator __result) { - typedef iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - return adjacent_difference(begin, end, result, std::minus()); + typedef iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + return adjacent_difference(__begin, __end, __result, std::minus<_ValueType>()); } - template - inline OutputIterator - adjacent_difference(InputIterator begin, InputIterator end, - OutputIterator result, BinaryOperation binary_op, - __gnu_parallel::_Parallelism parallelism_tag) + template + inline _OutputIterator + adjacent_difference(_IIter __begin, _IIter __end, + _OutputIterator __result, _BinaryOperation __binary_op, + __gnu_parallel::_Parallelism __parallelism_tag) { - typedef iterator_traits traitsi_type; - typedef typename traitsi_type::iterator_category iteratori_category; + typedef iterator_traits<_IIter> traitsi_type; + typedef typename traitsi_type::iterator_category _IIteratorCategory; - typedef iterator_traits traitso_type; - typedef typename traitso_type::iterator_category iteratoro_category; + typedef iterator_traits<_OutputIterator> _OTraitsType; + typedef typename _OTraitsType::iterator_category _OIterCategory; - return adjacent_difference_switch(begin, end, result, binary_op, - iteratori_category(), - iteratoro_category(), parallelism_tag); + return __adjacent_difference_switch(__begin, __end, __result, __binary_op, + _IIteratorCategory(), + _OIterCategory(), __parallelism_tag); } - template - inline OutputIterator - adjacent_difference(InputIterator begin, InputIterator end, - OutputIterator result, BinaryOperation binary_op) + template + inline _OutputIterator + adjacent_difference(_IIter __begin, _IIter __end, + _OutputIterator __result, _BinaryOperation __binary_op) { - typedef iterator_traits traitsi_type; - typedef typename traitsi_type::iterator_category iteratori_category; + typedef iterator_traits<_IIter> traitsi_type; + typedef typename traitsi_type::iterator_category _IIteratorCategory; - typedef iterator_traits traitso_type; - typedef typename traitso_type::iterator_category iteratoro_category; + typedef iterator_traits<_OutputIterator> _OTraitsType; + typedef typename _OTraitsType::iterator_category _OIterCategory; - return adjacent_difference_switch(begin, end, result, binary_op, - iteratori_category(), - iteratoro_category()); + return __adjacent_difference_switch(__begin, __end, __result, __binary_op, + _IIteratorCategory(), + _OIterCategory()); } } // end namespace } // end namespace diff --git a/libstdc++-v3/include/parallel/numericfwd.h b/libstdc++-v3/include/parallel/numericfwd.h index af2d0416f6fb..754d5ba0d9ef 100644 --- a/libstdc++-v3/include/parallel/numericfwd.h +++ b/libstdc++-v3/include/parallel/numericfwd.h @@ -52,7 +52,7 @@ namespace __parallel template _Tp - accumulate_switch(_IIter, _IIter, _Tp, _Tag); + __accumulate_switch(_IIter, _IIter, _Tp, _Tag); template _Tp @@ -71,13 +71,13 @@ namespace __parallel template _Tp - accumulate_switch(_IIter, _IIter, _Tp, _BinaryOper, _Tag); + __accumulate_switch(_IIter, _IIter, _Tp, _BinaryOper, _Tag); template _Tp - accumulate_switch(_RAIter, _RAIter, _Tp, _BinaryOper, + __accumulate_switch(_RAIter, _RAIter, _Tp, _BinaryOper, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism + __gnu_parallel::_Parallelism __parallelism = __gnu_parallel::parallel_unbalanced); template @@ -111,15 +111,15 @@ namespace __parallel template _OIter - adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, + __adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2); template _OIter - adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, + __adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, random_access_iterator_tag, random_access_iterator_tag, - __gnu_parallel::_Parallelism parallelism + __gnu_parallel::_Parallelism __parallelism = __gnu_parallel::parallel_unbalanced); template @@ -157,7 +157,7 @@ namespace __parallel template _Tp - inner_product_switch(_RAIter1, _RAIter1, _RAIter2, _Tp, BinaryFunction1, + __inner_product_switch(_RAIter1, _RAIter1, _RAIter2, _Tp, BinaryFunction1, BinaryFunction2, random_access_iterator_tag, random_access_iterator_tag, __gnu_parallel::_Parallelism @@ -167,7 +167,7 @@ namespace __parallel typename _BinaryFunction1, typename _BinaryFunction2, typename _Tag1, typename _Tag2> _Tp - inner_product_switch(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1, + __inner_product_switch(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1, _BinaryFunction2, _Tag1, _Tag2); @@ -182,7 +182,7 @@ namespace __parallel template _OIter - partial_sum(_IIter, _IIter, _OIter result); + partial_sum(_IIter, _IIter, _OIter __result); template _OIter @@ -191,11 +191,11 @@ namespace __parallel template _OIter - partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2); + __partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2); template _OIter - partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, + __partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, random_access_iterator_tag, random_access_iterator_tag); } // end namespace } // end namespace diff --git a/libstdc++-v3/include/parallel/omp_loop.h b/libstdc++-v3/include/parallel/omp_loop.h index 66f6d44bccc5..55191d474d63 100644 --- a/libstdc++-v3/include/parallel/omp_loop.h +++ b/libstdc++-v3/include/parallel/omp_loop.h @@ -44,73 +44,73 @@ namespace __gnu_parallel /** @brief Embarrassingly parallel algorithm for random access * iterators, using an OpenMP for loop. * - * @param begin Begin iterator of element sequence. - * @param end End iterator of element sequence. - * @param o User-supplied functor (comparator, predicate, adding + * @param __begin Begin iterator of element __sequence. + * @param __end End iterator of element __sequence. + * @param __o User-supplied functor (comparator, predicate, adding * functor, etc.). - * @param f Functor to "process" an element with op (depends on + * @param __f Functor to "process" an element with __op (depends on * desired functionality, e. g. for std::for_each(), ...). - * @param r Functor to "add" a single result to the already - * processed elements (depends on functionality). - * @param base Base value for reduction. - * @param output Pointer to position where final result is written to - * @param bound Maximum number of elements processed (e. g. for + * @param __r Functor to "add" a single __result to the already + * processed __elements (depends on functionality). + * @param __base Base value for reduction. + * @param __output Pointer to position where final result is written to + * @param __bound Maximum number of elements processed (e. g. for * std::count_n()). * @return User-supplied functor (that may contain a part of the result). */ -template - Op - for_each_template_random_access_omp_loop(RandomAccessIterator begin, - RandomAccessIterator end, - Op o, Fu& f, Red r, Result base, - Result& output, +template + _Op + for_each_template_random_access_omp_loop(_RAIter __begin, + _RAIter __end, + _Op __o, _Fu& __f, _Red __r, _Result __base, + _Result& __output, typename std::iterator_traits - :: - difference_type bound) + <_RAIter>:: + difference_type __bound) { typedef typename - std::iterator_traits::difference_type - difference_type; + std::iterator_traits<_RAIter>::difference_type + _DifferenceType; - difference_type length = end - begin; - thread_index_t num_threads = - __gnu_parallel::min(get_max_threads(), length); + _DifferenceType __length = __end - __begin; + _ThreadIndex __num_threads = + __gnu_parallel::min<_DifferenceType>(__get_max_threads(), __length); - Result *thread_results; + _Result *__thread_results; -# pragma omp parallel num_threads(num_threads) +# pragma omp parallel num_threads(__num_threads) { # pragma omp single { - num_threads = omp_get_num_threads(); - thread_results = new Result[num_threads]; + __num_threads = omp_get_num_threads(); + __thread_results = new _Result[__num_threads]; - for (thread_index_t i = 0; i < num_threads; ++i) - thread_results[i] = Result(); + for (_ThreadIndex __i = 0; __i < __num_threads; ++__i) + __thread_results[__i] = _Result(); } - thread_index_t iam = omp_get_thread_num(); + _ThreadIndex __iam = omp_get_thread_num(); # pragma omp for schedule(dynamic, _Settings::get().workstealing_chunk_size) - for (difference_type pos = 0; pos < length; ++pos) - thread_results[iam] = - r(thread_results[iam], f(o, begin+pos)); + for (_DifferenceType __pos = 0; __pos < __length; ++__pos) + __thread_results[__iam] = + __r(__thread_results[__iam], __f(__o, __begin+__pos)); } //parallel - for (thread_index_t i = 0; i < num_threads; ++i) - output = r(output, thread_results[i]); + for (_ThreadIndex __i = 0; __i < __num_threads; ++__i) + __output = __r(__output, __thread_results[__i]); - delete [] thread_results; + delete [] __thread_results; // Points to last element processed (needed as return value for // some algorithms like transform). - f.finish_iterator = begin + length; + __f.finish_iterator = __begin + __length; - return o; + return __o; } } // end namespace diff --git a/libstdc++-v3/include/parallel/omp_loop_static.h b/libstdc++-v3/include/parallel/omp_loop_static.h index 523618307296..5244d11494a0 100644 --- a/libstdc++-v3/include/parallel/omp_loop_static.h +++ b/libstdc++-v3/include/parallel/omp_loop_static.h @@ -44,72 +44,72 @@ namespace __gnu_parallel /** @brief Embarrassingly parallel algorithm for random access * iterators, using an OpenMP for loop with static scheduling. * - * @param begin Begin iterator of element sequence. - * @param end End iterator of element sequence. - * @param o User-supplied functor (comparator, predicate, adding + * @param __begin Begin iterator of element __sequence. + * @param __end End iterator of element __sequence. + * @param __o User-supplied functor (comparator, predicate, adding * functor, ...). - * @param f Functor to "process" an element with op (depends on + * @param __f Functor to "process" an element with __op (depends on * desired functionality, e. g. for std::for_each(), ...). - * @param r Functor to "add" a single result to the already processed - * elements (depends on functionality). - * @param base Base value for reduction. - * @param output Pointer to position where final result is written to - * @param bound Maximum number of elements processed (e. g. for + * @param __r Functor to "add" a single __result to the already processed + * __elements (depends on functionality). + * @param __base Base value for reduction. + * @param __output Pointer to position where final result is written to + * @param __bound Maximum number of elements processed (e. g. for * std::count_n()). * @return User-supplied functor (that may contain a part of the result). */ -template - Op - for_each_template_random_access_omp_loop_static(RandomAccessIterator begin, - RandomAccessIterator end, - Op o, Fu& f, Red r, - Result base, Result& output, +template + _Op + for_each_template_random_access_omp_loop_static(_RAIter __begin, + _RAIter __end, + _Op __o, _Fu& __f, _Red __r, + _Result __base, _Result& __output, typename std::iterator_traits - :: - difference_type bound) + <_RAIter>:: + difference_type __bound) { typedef typename - std::iterator_traits::difference_type - difference_type; + std::iterator_traits<_RAIter>::difference_type + _DifferenceType; - difference_type length = end - begin; - thread_index_t num_threads = - std::min(get_max_threads(), length); + _DifferenceType __length = __end - __begin; + _ThreadIndex __num_threads = + std::min<_DifferenceType>(__get_max_threads(), __length); - Result *thread_results; + _Result *__thread_results; -# pragma omp parallel num_threads(num_threads) +# pragma omp parallel num_threads(__num_threads) { # pragma omp single { - num_threads = omp_get_num_threads(); - thread_results = new Result[num_threads]; + __num_threads = omp_get_num_threads(); + __thread_results = new _Result[__num_threads]; - for (thread_index_t i = 0; i < num_threads; ++i) - thread_results[i] = Result(); + for (_ThreadIndex __i = 0; __i < __num_threads; ++__i) + __thread_results[__i] = _Result(); } - thread_index_t iam = omp_get_thread_num(); + _ThreadIndex __iam = omp_get_thread_num(); # pragma omp for schedule(static, _Settings::get().workstealing_chunk_size) - for (difference_type pos = 0; pos < length; ++pos) - thread_results[iam] = r(thread_results[iam], f(o, begin+pos)); + for (_DifferenceType __pos = 0; __pos < __length; ++__pos) + __thread_results[__iam] = __r(__thread_results[__iam], __f(__o, __begin+__pos)); } //parallel - for (thread_index_t i = 0; i < num_threads; ++i) - output = r(output, thread_results[i]); + for (_ThreadIndex __i = 0; __i < __num_threads; ++__i) + __output = __r(__output, __thread_results[__i]); - delete [] thread_results; + delete [] __thread_results; // Points to last element processed (needed as return value for // some algorithms like transform). - f.finish_iterator = begin + length; + __f.finish_iterator = __begin + __length; - return o; + return __o; } } // end namespace diff --git a/libstdc++-v3/include/parallel/par_loop.h b/libstdc++-v3/include/parallel/par_loop.h index be61d4ca2235..0b5e47abb22a 100644 --- a/libstdc++-v3/include/parallel/par_loop.h +++ b/libstdc++-v3/include/parallel/par_loop.h @@ -45,89 +45,89 @@ namespace __gnu_parallel * iterators, using hand-crafted parallelization by equal splitting * the work. * - * @param begin Begin iterator of element sequence. - * @param end End iterator of element sequence. - * @param o User-supplied functor (comparator, predicate, adding + * @param __begin Begin iterator of element __sequence. + * @param __end End iterator of element __sequence. + * @param __o User-supplied functor (comparator, predicate, adding * functor, ...) - * @param f Functor to "process" an element with op (depends on + * @param __f Functor to "process" an element with __op (depends on * desired functionality, e. g. for std::for_each(), ...). - * @param r Functor to "add" a single result to the already - * processed elements (depends on functionality). - * @param base Base value for reduction. - * @param output Pointer to position where final result is written to - * @param bound Maximum number of elements processed (e. g. for + * @param __r Functor to "add" a single __result to the already + * processed __elements (depends on functionality). + * @param __base Base value for reduction. + * @param __output Pointer to position where final result is written to + * @param __bound Maximum number of elements processed (e. g. for * std::count_n()). * @return User-supplied functor (that may contain a part of the result). */ -template - Op - for_each_template_random_access_ed(RandomAccessIterator begin, - RandomAccessIterator end, - Op o, Fu& f, Red r, Result base, - Result& output, +template + _Op + for_each_template_random_access_ed(_RAIter __begin, + _RAIter __end, + _Op __o, _Fu& __f, _Red __r, _Result __base, + _Result& __output, typename std::iterator_traits - :: - difference_type bound) + <_RAIter>:: + difference_type __bound) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; - const difference_type length = end - begin; - Result *thread_results; - bool* constructed; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; + const _DifferenceType __length = __end - __begin; + _Result *__thread_results; + bool* __constructed; - thread_index_t num_threads = - __gnu_parallel::min(get_max_threads(), length); + _ThreadIndex __num_threads = + __gnu_parallel::min<_DifferenceType>(__get_max_threads(), __length); -# pragma omp parallel num_threads(num_threads) +# pragma omp parallel num_threads(__num_threads) { # pragma omp single { - num_threads = omp_get_num_threads(); - thread_results = static_cast( - ::operator new(num_threads * sizeof(Result))); - constructed = new bool[num_threads]; + __num_threads = omp_get_num_threads(); + __thread_results = static_cast<_Result*>( + ::operator new(__num_threads * sizeof(_Result))); + __constructed = new bool[__num_threads]; } - thread_index_t iam = omp_get_thread_num(); + _ThreadIndex __iam = omp_get_thread_num(); // Neutral element. - Result* reduct = static_cast(::operator new(sizeof(Result))); + _Result* __reduct = static_cast<_Result*>(::operator new(sizeof(_Result))); - difference_type - start = equally_split_point(length, num_threads, iam), - stop = equally_split_point(length, num_threads, iam + 1); + _DifferenceType + __start = equally_split_point(__length, __num_threads, __iam), + __stop = equally_split_point(__length, __num_threads, __iam + 1); - if (start < stop) + if (__start < __stop) { - new(reduct) Result(f(o, begin + start)); - ++start; - constructed[iam] = true; + new(__reduct) _Result(__f(__o, __begin + __start)); + ++__start; + __constructed[__iam] = true; } else - constructed[iam] = false; + __constructed[__iam] = false; - for (; start < stop; ++start) - *reduct = r(*reduct, f(o, begin + start)); + for (; __start < __stop; ++__start) + *__reduct = __r(*__reduct, __f(__o, __begin + __start)); - thread_results[iam] = *reduct; + __thread_results[__iam] = *__reduct; } //parallel - for (thread_index_t i = 0; i < num_threads; ++i) - if (constructed[i]) - output = r(output, thread_results[i]); + for (_ThreadIndex __i = 0; __i < __num_threads; ++__i) + if (__constructed[__i]) + __output = __r(__output, __thread_results[__i]); // Points to last element processed (needed as return value for // some algorithms like transform). - f.finish_iterator = begin + length; + __f.finish_iterator = __begin + __length; - delete[] thread_results; - delete[] constructed; + delete[] __thread_results; + delete[] __constructed; - return o; + return __o; } } // end namespace diff --git a/libstdc++-v3/include/parallel/partial_sum.h b/libstdc++-v3/include/parallel/partial_sum.h index 92630936d3f9..40f6299d37bf 100644 --- a/libstdc++-v3/include/parallel/partial_sum.h +++ b/libstdc++-v3/include/parallel/partial_sum.h @@ -23,8 +23,8 @@ // . /** @file parallel/partial_sum.h - * @brief Parallel implementation of std::partial_sum(), i. e. prefix - * sums. + * @brief Parallel implementation of std::partial_sum(), i.e. prefix +* sums. * This file is a GNU parallel extension to the Standard C++ Library. */ @@ -44,175 +44,175 @@ namespace __gnu_parallel // Problem: there is no 0-element given. /** @brief Base case prefix sum routine. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param result Begin iterator of output sequence. - * @param bin_op Associative binary function. - * @param value Start value. Must be passed since the neutral + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __result Begin iterator of output sequence. + * @param __bin_op Associative binary function. + * @param __value Start value. Must be passed since the neutral * element is unknown in general. * @return End iterator of output sequence. */ -template - OutputIterator - parallel_partial_sum_basecase(InputIterator begin, InputIterator end, - OutputIterator result, BinaryOperation bin_op, +template + _OutputIterator + __parallel_partial_sum_basecase(_IIter __begin, _IIter __end, + _OutputIterator __result, _BinaryOperation __bin_op, typename std::iterator_traits - ::value_type value) + <_IIter>::value_type __value) { - if (begin == end) - return result; + if (__begin == __end) + return __result; - while (begin != end) + while (__begin != __end) { - value = bin_op(value, *begin); - *result = value; - ++result; - ++begin; + __value = __bin_op(__value, *__begin); + *__result = __value; + ++__result; + ++__begin; } - return result; + return __result; } /** @brief Parallel partial sum implementation, two-phase approach, no recursion. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param result Begin iterator of output sequence. - * @param bin_op Associative binary function. - * @param n Length of sequence. - * @param num_threads Number of threads to use. + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __result Begin iterator of output sequence. + * @param __bin_op Associative binary function. + * @param __n Length of sequence. + * @param __num_threads Number of threads to use. * @return End iterator of output sequence. */ -template - OutputIterator - parallel_partial_sum_linear(InputIterator begin, InputIterator end, - OutputIterator result, BinaryOperation bin_op, +template + _OutputIterator + __parallel_partial_sum_linear(_IIter __begin, _IIter __end, + _OutputIterator __result, _BinaryOperation __bin_op, typename std::iterator_traits - ::difference_type n) + <_IIter>::difference_type __n) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - if (begin == end) - return result; + if (__begin == __end) + return __result; - thread_index_t num_threads = - std::min(get_max_threads(), n - 1); + _ThreadIndex __num_threads = + std::min<_DifferenceType>(__get_max_threads(), __n - 1); - if (num_threads < 2) + if (__num_threads < 2) { - *result = *begin; - return parallel_partial_sum_basecase( - begin + 1, end, result + 1, bin_op, *begin); + *__result = *__begin; + return __parallel_partial_sum_basecase( + __begin + 1, __end, __result + 1, __bin_op, *__begin); } - difference_type* borders; - value_type* sums; + _DifferenceType* __borders; + _ValueType* __sums; const _Settings& __s = _Settings::get(); -# pragma omp parallel num_threads(num_threads) +# pragma omp parallel num_threads(__num_threads) { # pragma omp single { - num_threads = omp_get_num_threads(); + __num_threads = omp_get_num_threads(); - borders = new difference_type[num_threads + 2]; + __borders = new _DifferenceType[__num_threads + 2]; if (__s.partial_sum_dilation == 1.0f) - equally_split(n, num_threads + 1, borders); + equally_split(__n, __num_threads + 1, __borders); else { - difference_type chunk_length = - ((double)n - / ((double)num_threads + __s.partial_sum_dilation)), - borderstart = n - num_threads * chunk_length; - borders[0] = 0; - for (int i = 1; i < (num_threads + 1); ++i) + _DifferenceType __chunk_length = + ((double)__n + / ((double)__num_threads + __s.partial_sum_dilation)), + __borderstart = __n - __num_threads * __chunk_length; + __borders[0] = 0; + for (int __i = 1; __i < (__num_threads + 1); ++__i) { - borders[i] = borderstart; - borderstart += chunk_length; + __borders[__i] = __borderstart; + __borderstart += __chunk_length; } - borders[num_threads + 1] = n; + __borders[__num_threads + 1] = __n; } - sums = static_cast(::operator new(sizeof(value_type) - * num_threads)); - OutputIterator target_end; + __sums = static_cast<_ValueType*>(::operator new(sizeof(_ValueType) + * __num_threads)); + _OutputIterator __target_end; } //single - thread_index_t iam = omp_get_thread_num(); - if (iam == 0) + _ThreadIndex __iam = omp_get_thread_num(); + if (__iam == 0) { - *result = *begin; - parallel_partial_sum_basecase(begin + 1, begin + borders[1], - result + 1, bin_op, *begin); - ::new(&(sums[iam])) value_type(*(result + borders[1] - 1)); + *__result = *__begin; + __parallel_partial_sum_basecase(__begin + 1, __begin + __borders[1], + __result + 1, __bin_op, *__begin); + ::new(&(__sums[__iam])) _ValueType(*(__result + __borders[1] - 1)); } else { - ::new(&(sums[iam])) - value_type(std::accumulate(begin + borders[iam] + 1, - begin + borders[iam + 1], - *(begin + borders[iam]), - bin_op, + ::new(&(__sums[__iam])) + _ValueType(std::accumulate(__begin + __borders[__iam] + 1, + __begin + __borders[__iam + 1], + *(__begin + __borders[__iam]), + __bin_op, __gnu_parallel::sequential_tag())); } # pragma omp barrier # pragma omp single - parallel_partial_sum_basecase( - sums + 1, sums + num_threads, sums + 1, bin_op, sums[0]); + __parallel_partial_sum_basecase( + __sums + 1, __sums + __num_threads, __sums + 1, __bin_op, __sums[0]); # pragma omp barrier // Still same team. - parallel_partial_sum_basecase(begin + borders[iam + 1], - begin + borders[iam + 2], - result + borders[iam + 1], bin_op, - sums[iam]); + __parallel_partial_sum_basecase(__begin + __borders[__iam + 1], + __begin + __borders[__iam + 2], + __result + __borders[__iam + 1], __bin_op, + __sums[__iam]); } //parallel - ::operator delete(sums); - delete[] borders; + ::operator delete(__sums); + delete[] __borders; - return result + n; + return __result + __n; } -/** @brief Parallel partial sum front-end. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param result Begin iterator of output sequence. - * @param bin_op Associative binary function. +/** @brief Parallel partial sum front-__end. + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __result Begin iterator of output sequence. + * @param __bin_op Associative binary function. * @return End iterator of output sequence. */ -template - OutputIterator - parallel_partial_sum(InputIterator begin, InputIterator end, - OutputIterator result, BinaryOperation bin_op) +template + _OutputIterator + __parallel_partial_sum(_IIter __begin, _IIter __end, + _OutputIterator __result, _BinaryOperation __bin_op) { - _GLIBCXX_CALL(begin - end) + _GLIBCXX_CALL(__begin - __end) - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - difference_type n = end - begin; + _DifferenceType __n = __end - __begin; switch (_Settings::get().partial_sum_algorithm) { case LINEAR: - // Need an initial offset. - return parallel_partial_sum_linear(begin, end, result, bin_op, n); + // Need an initial __offset. + return __parallel_partial_sum_linear(__begin, __end, __result, __bin_op, __n); default: // Partial_sum algorithm not implemented. _GLIBCXX_PARALLEL_ASSERT(0); - return result + n; + return __result + __n; } } } diff --git a/libstdc++-v3/include/parallel/partition.h b/libstdc++-v3/include/parallel/partition.h index b88133c59e62..81b72998b5fe 100644 --- a/libstdc++-v3/include/parallel/partition.h +++ b/libstdc++-v3/include/parallel/partition.h @@ -45,231 +45,231 @@ namespace __gnu_parallel { /** @brief Parallel implementation of std::partition. - * @param begin Begin iterator of input sequence to split. - * @param end End iterator of input sequence to split. - * @param pred Partition predicate, possibly including some kind of pivot. - * @param num_threads Maximum number of threads to use for this task. + * @param __begin Begin iterator of input sequence to split. + * @param __end End iterator of input sequence to split. + * @param __pred Partition predicate, possibly including some kind of pivot. + * @param __num_threads Maximum number of threads to use for this task. * @return Number of elements not fulfilling the predicate. */ -template - typename std::iterator_traits::difference_type - parallel_partition(RandomAccessIterator begin, RandomAccessIterator end, - Predicate pred, thread_index_t num_threads) +template + typename std::iterator_traits<_RAIter>::difference_type + __parallel_partition(_RAIter __begin, _RAIter __end, + _Predicate __pred, _ThreadIndex __num_threads) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - difference_type n = end - begin; + _DifferenceType __n = __end - __begin; - _GLIBCXX_CALL(n) + _GLIBCXX_CALL(__n) const _Settings& __s = _Settings::get(); // Shared. - _GLIBCXX_VOLATILE difference_type left = 0, right = n - 1; - _GLIBCXX_VOLATILE difference_type leftover_left, leftover_right; - _GLIBCXX_VOLATILE difference_type leftnew, rightnew; + _GLIBCXX_VOLATILE _DifferenceType __left = 0, __right = __n - 1; + _GLIBCXX_VOLATILE _DifferenceType __leftover_left, __leftover_right; + _GLIBCXX_VOLATILE _DifferenceType __leftnew, __rightnew; - bool* reserved_left = NULL, * reserved_right = NULL; + bool* __reserved_left = NULL, * __reserved_right = NULL; - difference_type chunk_size; + _DifferenceType __chunk_size; - omp_lock_t result_lock; - omp_init_lock(&result_lock); + omp_lock_t __result_lock; + omp_init_lock(&__result_lock); - //at least two chunks per thread - if(right - left + 1 >= 2 * num_threads * chunk_size) -# pragma omp parallel num_threads(num_threads) + //at least two __chunks per thread + if(__right - __left + 1 >= 2 * __num_threads * __chunk_size) +# pragma omp parallel num_threads(__num_threads) { # pragma omp single { - num_threads = omp_get_num_threads(); - reserved_left = new bool[num_threads]; - reserved_right = new bool[num_threads]; + __num_threads = omp_get_num_threads(); + __reserved_left = new bool[__num_threads]; + __reserved_right = new bool[__num_threads]; if (__s.partition_chunk_share > 0.0) - chunk_size = std::max(__s.partition_chunk_size, - (double)n * __s.partition_chunk_share - / (double)num_threads); + __chunk_size = std::max<_DifferenceType>(__s.partition_chunk_size, + (double)__n * __s.partition_chunk_share + / (double)__num_threads); else - chunk_size = __s.partition_chunk_size; + __chunk_size = __s.partition_chunk_size; } - while (right - left + 1 >= 2 * num_threads * chunk_size) + while (__right - __left + 1 >= 2 * __num_threads * __chunk_size) { # pragma omp single { - difference_type num_chunks = (right - left + 1) / chunk_size; + _DifferenceType __num_chunks = (__right - __left + 1) / __chunk_size; - for (int r = 0; r < num_threads; ++r) + for (int __r = 0; __r < __num_threads; ++__r) { - reserved_left[r] = false; - reserved_right[r] = false; + __reserved_left[__r] = false; + __reserved_right[__r] = false; } - leftover_left = 0; - leftover_right = 0; + __leftover_left = 0; + __leftover_right = 0; } //implicit barrier // Private. - difference_type thread_left, thread_left_border, - thread_right, thread_right_border; - thread_left = left + 1; + _DifferenceType __thread_left, __thread_left_border, + thread_right, __thread_right_border; + __thread_left = __left + 1; // Just to satisfy the condition below. - thread_left_border = thread_left - 1; - thread_right = n - 1; - thread_right_border = thread_right + 1; + __thread_left_border = __thread_left - 1; + thread_right = __n - 1; + __thread_right_border = thread_right + 1; - bool iam_finished = false; - while (!iam_finished) + bool __iam_finished = false; + while (!__iam_finished) { - if (thread_left > thread_left_border) + if (__thread_left > __thread_left_border) { - omp_set_lock(&result_lock); - if (left + (chunk_size - 1) > right) - iam_finished = true; + omp_set_lock(&__result_lock); + if (__left + (__chunk_size - 1) > __right) + __iam_finished = true; else { - thread_left = left; - thread_left_border = left + (chunk_size - 1); - left += chunk_size; + __thread_left = __left; + __thread_left_border = __left + (__chunk_size - 1); + __left += __chunk_size; } - omp_unset_lock(&result_lock); + omp_unset_lock(&__result_lock); } - if (thread_right < thread_right_border) + if (thread_right < __thread_right_border) { - omp_set_lock(&result_lock); - if (left > right - (chunk_size - 1)) - iam_finished = true; + omp_set_lock(&__result_lock); + if (__left > __right - (__chunk_size - 1)) + __iam_finished = true; else { - thread_right = right; - thread_right_border = right - (chunk_size - 1); - right -= chunk_size; + thread_right = __right; + __thread_right_border = __right - (__chunk_size - 1); + __right -= __chunk_size; } - omp_unset_lock(&result_lock); + omp_unset_lock(&__result_lock); } - if (iam_finished) + if (__iam_finished) break; // Swap as usual. - while (thread_left < thread_right) + while (__thread_left < thread_right) { - while (pred(begin[thread_left]) - && thread_left <= thread_left_border) - ++thread_left; - while (!pred(begin[thread_right]) - && thread_right >= thread_right_border) + while (__pred(__begin[__thread_left]) + && __thread_left <= __thread_left_border) + ++__thread_left; + while (!__pred(__begin[thread_right]) + && thread_right >= __thread_right_border) --thread_right; - if (thread_left > thread_left_border - || thread_right < thread_right_border) - // Fetch new chunk(s). + if (__thread_left > __thread_left_border + || thread_right < __thread_right_border) + // Fetch new chunk(__s). break; - std::swap(begin[thread_left], begin[thread_right]); - ++thread_left; + std::swap(__begin[__thread_left], __begin[thread_right]); + ++__thread_left; --thread_right; } } // Now swap the leftover chunks to the right places. - if (thread_left <= thread_left_border) + if (__thread_left <= __thread_left_border) # pragma omp atomic - ++leftover_left; - if (thread_right >= thread_right_border) + ++__leftover_left; + if (thread_right >= __thread_right_border) # pragma omp atomic - ++leftover_right; + ++__leftover_right; # pragma omp barrier # pragma omp single { - leftnew = left - leftover_left * chunk_size; - rightnew = right + leftover_right * chunk_size; + __leftnew = __left - __leftover_left * __chunk_size; + __rightnew = __right + __leftover_right * __chunk_size; } # pragma omp barrier - // <=> thread_left_border + (chunk_size - 1) >= leftnew - if (thread_left <= thread_left_border - && thread_left_border >= leftnew) + // <=> __thread_left_border + (__chunk_size - 1) >= __leftnew + if (__thread_left <= __thread_left_border + && __thread_left_border >= __leftnew) { // Chunk already in place, reserve spot. - reserved_left[(left - (thread_left_border + 1)) / chunk_size] + __reserved_left[(__left - (__thread_left_border + 1)) / __chunk_size] = true; } - // <=> thread_right_border - (chunk_size - 1) <= rightnew - if (thread_right >= thread_right_border - && thread_right_border <= rightnew) + // <=> __thread_right_border - (__chunk_size - 1) <= __rightnew + if (thread_right >= __thread_right_border + && __thread_right_border <= __rightnew) { // Chunk already in place, reserve spot. - reserved_right[((thread_right_border - 1) - right) - / chunk_size] = true; + __reserved_right[((__thread_right_border - 1) - __right) + / __chunk_size] = true; } # pragma omp barrier - if (thread_left <= thread_left_border - && thread_left_border < leftnew) + if (__thread_left <= __thread_left_border + && __thread_left_border < __leftnew) { // Find spot and swap. - difference_type swapstart = -1; - omp_set_lock(&result_lock); - for (int r = 0; r < leftover_left; ++r) - if (!reserved_left[r]) + _DifferenceType __swapstart = -1; + omp_set_lock(&__result_lock); + for (int __r = 0; __r < __leftover_left; ++__r) + if (!__reserved_left[__r]) { - reserved_left[r] = true; - swapstart = left - (r + 1) * chunk_size; + __reserved_left[__r] = true; + __swapstart = __left - (__r + 1) * __chunk_size; break; } - omp_unset_lock(&result_lock); + omp_unset_lock(&__result_lock); #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(swapstart != -1); + _GLIBCXX_PARALLEL_ASSERT(__swapstart != -1); #endif - std::swap_ranges(begin + thread_left_border - - (chunk_size - 1), - begin + thread_left_border + 1, - begin + swapstart); + std::swap_ranges(__begin + __thread_left_border + - (__chunk_size - 1), + __begin + __thread_left_border + 1, + __begin + __swapstart); } - if (thread_right >= thread_right_border - && thread_right_border > rightnew) + if (thread_right >= __thread_right_border + && __thread_right_border > __rightnew) { // Find spot and swap - difference_type swapstart = -1; - omp_set_lock(&result_lock); - for (int r = 0; r < leftover_right; ++r) - if (!reserved_right[r]) + _DifferenceType __swapstart = -1; + omp_set_lock(&__result_lock); + for (int __r = 0; __r < __leftover_right; ++__r) + if (!__reserved_right[__r]) { - reserved_right[r] = true; - swapstart = right + r * chunk_size + 1; + __reserved_right[__r] = true; + __swapstart = __right + __r * __chunk_size + 1; break; } - omp_unset_lock(&result_lock); + omp_unset_lock(&__result_lock); #if _GLIBCXX_ASSERTIONS - _GLIBCXX_PARALLEL_ASSERT(swapstart != -1); + _GLIBCXX_PARALLEL_ASSERT(__swapstart != -1); #endif - std::swap_ranges(begin + thread_right_border, - begin + thread_right_border + chunk_size, - begin + swapstart); + std::swap_ranges(__begin + __thread_right_border, + __begin + __thread_right_border + __chunk_size, + __begin + __swapstart); } #if _GLIBCXX_ASSERTIONS # pragma omp barrier # pragma omp single { - for (int r = 0; r < leftover_left; ++r) - _GLIBCXX_PARALLEL_ASSERT(reserved_left[r]); - for (int r = 0; r < leftover_right; ++r) - _GLIBCXX_PARALLEL_ASSERT(reserved_right[r]); + for (int __r = 0; __r < __leftover_left; ++__r) + _GLIBCXX_PARALLEL_ASSERT(__reserved_left[__r]); + for (int __r = 0; __r < __leftover_right; ++__r) + _GLIBCXX_PARALLEL_ASSERT(__reserved_right[__r]); } # pragma omp barrier @@ -277,149 +277,149 @@ template # pragma omp barrier - left = leftnew; - right = rightnew; + __left = __leftnew; + __right = __rightnew; } -# pragma omp flush(left, right) +# pragma omp flush(__left, __right) } // end "recursion" //parallel - difference_type final_left = left, final_right = right; + _DifferenceType __final_left = __left, __final_right = __right; - while (final_left < final_right) + while (__final_left < __final_right) { // Go right until key is geq than pivot. - while (pred(begin[final_left]) && final_left < final_right) - ++final_left; + while (__pred(__begin[__final_left]) && __final_left < __final_right) + ++__final_left; // Go left until key is less than pivot. - while (!pred(begin[final_right]) && final_left < final_right) - --final_right; + while (!__pred(__begin[__final_right]) && __final_left < __final_right) + --__final_right; - if (final_left == final_right) + if (__final_left == __final_right) break; - std::swap(begin[final_left], begin[final_right]); - ++final_left; - --final_right; + std::swap(__begin[__final_left], __begin[__final_right]); + ++__final_left; + --__final_right; } // All elements on the left side are < piv, all elements on the // right are >= piv - delete[] reserved_left; - delete[] reserved_right; + delete[] __reserved_left; + delete[] __reserved_right; - omp_destroy_lock(&result_lock); + omp_destroy_lock(&__result_lock); - // Element "between" final_left and final_right might not have + // Element "between" __final_left and __final_right might not have // been regarded yet - if (final_left < n && !pred(begin[final_left])) + if (__final_left < __n && !__pred(__begin[__final_left])) // Really swapped. - return final_left; + return __final_left; else - return final_left + 1; + return __final_left + 1; } /** * @brief Parallel implementation of std::nth_element(). - * @param begin Begin iterator of input sequence. - * @param nth Iterator of element that must be in position afterwards. - * @param end End iterator of input sequence. - * @param comp Comparator. + * @param __begin Begin iterator of input sequence. + * @param __nth _Iterator of element that must be in position afterwards. + * @param __end End iterator of input sequence. + * @param __comp Comparator. */ -template +template void - parallel_nth_element(RandomAccessIterator begin, RandomAccessIterator nth, - RandomAccessIterator end, Comparator comp) + parallel_nth_element(_RAIter __begin, _RAIter __nth, + _RAIter __end, _Compare __comp) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - _GLIBCXX_CALL(end - begin) + _GLIBCXX_CALL(__end - __begin) - RandomAccessIterator split; - random_number rng; + _RAIter __split; + _RandomNumber __rng; - difference_type minimum_length = - std::max(2, _Settings::get().partition_minimal_n); + _DifferenceType minimum_length = + std::max<_DifferenceType>(2, _Settings::get().partition_minimal_n); // Break if input range to small. - while (static_cast(end - begin) >= minimum_length) + while (static_cast<_SequenceIndex>(__end - __begin) >= minimum_length) { - difference_type n = end - begin; + _DifferenceType __n = __end - __begin; - RandomAccessIterator pivot_pos = begin + rng(n); + _RAIter __pivot_pos = __begin + __rng(__n); - // Swap pivot_pos value to end. - if (pivot_pos != (end - 1)) - std::swap(*pivot_pos, *(end - 1)); - pivot_pos = end - 1; + // Swap __pivot_pos value to end. + if (__pivot_pos != (__end - 1)) + std::swap(*__pivot_pos, *(__end - 1)); + __pivot_pos = __end - 1; - // XXX Comparator must have first_value_type, second_value_type, - // result_type - // Comparator == __gnu_parallel::lexicographic > - // pivot_pos == std::pair* - // XXX binder2nd only for RandomAccessIterators?? - __gnu_parallel::binder2nd - pred(comp, *pivot_pos); + // XXX _Compare must have first__ValueType, second__ValueType, + // _ResultType + // _Compare == __gnu_parallel::_Lexicographic > + // __pivot_pos == std::pair* + // XXX binder2nd only for _RAIters?? + __gnu_parallel::binder2nd<_Compare, _ValueType, _ValueType, bool> + __pred(__comp, *__pivot_pos); // Divide, leave pivot unchanged in last place. - RandomAccessIterator split_pos1, split_pos2; - split_pos1 = begin + parallel_partition(begin, end - 1, pred, - get_max_threads()); + _RAIter __split_pos1, __split_pos2; + __split_pos1 = __begin + __parallel_partition(__begin, __end - 1, __pred, + __get_max_threads()); - // Left side: < pivot_pos; right side: >= pivot_pos + // Left side: < __pivot_pos; __right side: >= __pivot_pos // Swap pivot back to middle. - if (split_pos1 != pivot_pos) - std::swap(*split_pos1, *pivot_pos); - pivot_pos = split_pos1; + if (__split_pos1 != __pivot_pos) + std::swap(*__split_pos1, *__pivot_pos); + __pivot_pos = __split_pos1; - // In case all elements are equal, split_pos1 == 0 - if ((split_pos1 + 1 - begin) < (n >> 7) - || (end - split_pos1) < (n >> 7)) + // In case all elements are equal, __split_pos1 == 0 + if ((__split_pos1 + 1 - __begin) < (__n >> 7) + || (__end - __split_pos1) < (__n >> 7)) { // Very unequal split, one part smaller than one 128th // elements not strictly larger than the pivot. - __gnu_parallel::unary_negate<__gnu_parallel:: - binder1st, value_type> - pred(__gnu_parallel::binder1st(comp, *pivot_pos)); + __gnu_parallel::__unary_negate<__gnu_parallel:: + __binder1st<_Compare, _ValueType, _ValueType, bool>, _ValueType> + __pred(__gnu_parallel::__binder1st<_Compare, _ValueType, + _ValueType, bool>(__comp, *__pivot_pos)); // Find other end of pivot-equal range. - split_pos2 = __gnu_sequential::partition(split_pos1 + 1, - end, pred); + __split_pos2 = __gnu_sequential::partition(__split_pos1 + 1, + __end, __pred); } else // Only skip the pivot. - split_pos2 = split_pos1 + 1; + __split_pos2 = __split_pos1 + 1; // Compare iterators. - if (split_pos2 <= nth) - begin = split_pos2; - else if (nth < split_pos1) - end = split_pos1; + if (__split_pos2 <= __nth) + __begin = __split_pos2; + else if (__nth < __split_pos1) + __end = __split_pos1; else break; } - // Only at most _Settings::partition_minimal_n elements left. - __gnu_sequential::sort(begin, end, comp); + // Only at most _Settings::partition_minimal_n __elements __left. + __gnu_sequential::sort(__begin, __end, __comp); } /** @brief Parallel implementation of std::partial_sort(). -* @param begin Begin iterator of input sequence. -* @param middle Sort until this position. -* @param end End iterator of input sequence. -* @param comp Comparator. */ -template +* @param __begin Begin iterator of input sequence. +* @param __middle Sort until this position. +* @param __end End iterator of input sequence. +* @param __comp Comparator. */ +template void - parallel_partial_sort(RandomAccessIterator begin, - RandomAccessIterator middle, - RandomAccessIterator end, Comparator comp) + parallel_partial_sort(_RAIter __begin, + _RAIter __middle, + _RAIter __end, _Compare __comp) { - parallel_nth_element(begin, middle, end, comp); - std::sort(begin, middle, comp); + parallel_nth_element(__begin, __middle, __end, __comp); + std::sort(__begin, __middle, __comp); } } //namespace __gnu_parallel diff --git a/libstdc++-v3/include/parallel/queue.h b/libstdc++-v3/include/parallel/queue.h index 9686a9ac2b65..ab6e2d3a291d 100644 --- a/libstdc++-v3/include/parallel/queue.h +++ b/libstdc++-v3/include/parallel/queue.h @@ -45,99 +45,99 @@ namespace __gnu_parallel * atomic access. push_front() and pop_front() must not be called * concurrently to each other, while pop_back() can be called * concurrently at all times. - * @c empty(), @c size(), and @c top() are intentionally not provided. + * @__c empty(), @__c size(), and @__c top() are intentionally not provided. * Calling them would not make sense in a concurrent setting. - * @param T Contained element type. */ - template - class RestrictedBoundedConcurrentQueue + * @param _Tp Contained element type. */ + template + class _RestrictedBoundedConcurrentQueue { private: /** @brief Array of elements, seen as cyclic buffer. */ - T* base; + _Tp* _M_base; /** @brief Maximal number of elements contained at the same time. */ - sequence_index_t max_size; + _SequenceIndex _M_max_size; - /** @brief Cyclic begin and end pointers contained in one + /** @brief Cyclic __begin and __end pointers contained in one atomically changeable value. */ - _GLIBCXX_VOLATILE lcas_t borders; + _GLIBCXX_VOLATILE _CASable _M_borders; public: /** @brief Constructor. Not to be called concurrent, of course. - * @param max_size Maximal number of elements to be contained. */ - RestrictedBoundedConcurrentQueue(sequence_index_t max_size) + * @param _M_max_size Maximal number of elements to be contained. */ + _RestrictedBoundedConcurrentQueue(_SequenceIndex _M_max_size) { - this->max_size = max_size; - base = new T[max_size]; - borders = encode2(0, 0); + this->_M_max_size = _M_max_size; + _M_base = new _Tp[_M_max_size]; + _M_borders = __encode2(0, 0); #pragma omp flush } /** @brief Destructor. Not to be called concurrent, of course. */ - ~RestrictedBoundedConcurrentQueue() - { delete[] base; } + ~_RestrictedBoundedConcurrentQueue() + { delete[] _M_base; } - /** @brief Pushes one element into the queue at the front end. + /** @brief Pushes one element into the queue at the front __end. * Must not be called concurrently with pop_front(). */ void - push_front(const T& t) + push_front(const _Tp& __t) { - lcas_t former_borders = borders; - int former_front, former_back; - decode2(former_borders, former_front, former_back); - *(base + former_front % max_size) = t; + _CASable __former_borders = _M_borders; + int __former_front, __former_back; + decode2(__former_borders, __former_front, __former_back); + *(_M_base + __former_front % _M_max_size) = __t; #if _GLIBCXX_ASSERTIONS - // Otherwise: front - back > max_size eventually. - _GLIBCXX_PARALLEL_ASSERT(((former_front + 1) - former_back) - <= max_size); + // Otherwise: front - back > _M_max_size eventually. + _GLIBCXX_PARALLEL_ASSERT(((__former_front + 1) - __former_back) + <= _M_max_size); #endif - fetch_and_add(&borders, encode2(1, 0)); + __fetch_and_add(&_M_borders, __encode2(1, 0)); } - /** @brief Pops one element from the queue at the front end. + /** @brief Pops one element from the queue at the front __end. * Must not be called concurrently with pop_front(). */ bool - pop_front(T& t) + pop_front(_Tp& __t) { - int former_front, former_back; + int __former_front, __former_back; #pragma omp flush - decode2(borders, former_front, former_back); - while (former_front > former_back) + decode2(_M_borders, __former_front, __former_back); + while (__former_front > __former_back) { // Chance. - lcas_t former_borders = encode2(former_front, former_back); - lcas_t new_borders = encode2(former_front - 1, former_back); - if (compare_and_swap(&borders, former_borders, new_borders)) + _CASable __former_borders = __encode2(__former_front, __former_back); + _CASable __new_borders = __encode2(__former_front - 1, __former_back); + if (__compare_and_swap(&_M_borders, __former_borders, __new_borders)) { - t = *(base + (former_front - 1) % max_size); + __t = *(_M_base + (__former_front - 1) % _M_max_size); return true; } #pragma omp flush - decode2(borders, former_front, former_back); + decode2(_M_borders, __former_front, __former_back); } return false; } - /** @brief Pops one element from the queue at the front end. + /** @brief Pops one element from the queue at the front __end. * Must not be called concurrently with pop_front(). */ bool - pop_back(T& t) //queue behavior + pop_back(_Tp& __t) //queue behavior { - int former_front, former_back; + int __former_front, __former_back; #pragma omp flush - decode2(borders, former_front, former_back); - while (former_front > former_back) + decode2(_M_borders, __former_front, __former_back); + while (__former_front > __former_back) { // Chance. - lcas_t former_borders = encode2(former_front, former_back); - lcas_t new_borders = encode2(former_front, former_back + 1); - if (compare_and_swap(&borders, former_borders, new_borders)) + _CASable __former_borders = __encode2(__former_front, __former_back); + _CASable __new_borders = __encode2(__former_front, __former_back + 1); + if (__compare_and_swap(&_M_borders, __former_borders, __new_borders)) { - t = *(base + former_back % max_size); + __t = *(_M_base + __former_back % _M_max_size); return true; } #pragma omp flush - decode2(borders, former_front, former_back); + decode2(_M_borders, __former_front, __former_back); } return false; } diff --git a/libstdc++-v3/include/parallel/quicksort.h b/libstdc++-v3/include/parallel/quicksort.h index 712b479e7e72..60f4b23bcd81 100644 --- a/libstdc++-v3/include/parallel/quicksort.h +++ b/libstdc++-v3/include/parallel/quicksort.h @@ -38,140 +38,140 @@ namespace __gnu_parallel { /** @brief Unbalanced quicksort divide step. - * @param begin Begin iterator of subsequence. - * @param end End iterator of subsequence. - * @param comp Comparator. - * @param pivot_rank Desired rank of the pivot. - * @param num_samples Choose pivot from that many samples. - * @param num_threads Number of threads that are allowed to work on + * @param __begin Begin iterator of subsequence. + * @param __end End iterator of subsequence. + * @param __comp Comparator. + * @param __pivot_rank Desired __rank of the pivot. + * @param __num_samples Choose pivot from that many samples. + * @param __num_threads Number of threads that are allowed to work on * this part. */ - template - typename std::iterator_traits::difference_type - parallel_sort_qs_divide(RandomAccessIterator begin, - RandomAccessIterator end, - Comparator comp, typename std::iterator_traits - ::difference_type pivot_rank, + template + typename std::iterator_traits<_RAIter>::difference_type + __parallel_sort_qs_divide(_RAIter __begin, + _RAIter __end, + _Compare __comp, typename std::iterator_traits + <_RAIter>::difference_type __pivot_rank, typename std::iterator_traits - ::difference_type - num_samples, thread_index_t num_threads) + <_RAIter>::difference_type + __num_samples, _ThreadIndex __num_threads) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - difference_type n = end - begin; - num_samples = std::min(num_samples, n); + _DifferenceType __n = __end - __begin; + __num_samples = std::min(__num_samples, __n); // Allocate uninitialized, to avoid default constructor. - value_type* samples = - static_cast(::operator new(num_samples - * sizeof(value_type))); + _ValueType* __samples = + static_cast<_ValueType*>(::operator new(__num_samples + * sizeof(_ValueType))); - for (difference_type s = 0; s < num_samples; ++s) + for (_DifferenceType __s = 0; __s < __num_samples; ++__s) { - const unsigned long long index = static_cast(s) - * n / num_samples; - ::new(&(samples[s])) value_type(begin[index]); + const unsigned long long __index = static_cast(__s) + * __n / __num_samples; + ::new(&(__samples[__s])) _ValueType(__begin[__index]); } - __gnu_sequential::sort(samples, samples + num_samples, comp); + __gnu_sequential::sort(__samples, __samples + __num_samples, __comp); - value_type& pivot = samples[pivot_rank * num_samples / n]; + _ValueType& pivot = __samples[__pivot_rank * __num_samples / __n]; - __gnu_parallel::binder2nd - pred(comp, pivot); - difference_type split = - parallel_partition(begin, end, pred, num_threads); + __gnu_parallel::binder2nd<_Compare, _ValueType, _ValueType, bool> + __pred(__comp, pivot); + _DifferenceType __split = + __parallel_partition(__begin, __end, __pred, __num_threads); - ::operator delete(samples); + ::operator delete(__samples); - return split; + return __split; } /** @brief Unbalanced quicksort conquer step. - * @param begin Begin iterator of subsequence. - * @param end End iterator of subsequence. - * @param comp Comparator. - * @param num_threads Number of threads that are allowed to work on + * @param __begin Begin iterator of subsequence. + * @param __end End iterator of subsequence. + * @param __comp Comparator. + * @param __num_threads Number of threads that are allowed to work on * this part. */ - template + template void - parallel_sort_qs_conquer(RandomAccessIterator begin, - RandomAccessIterator end, - Comparator comp, - thread_index_t num_threads) + __parallel_sort_qs_conquer(_RAIter __begin, + _RAIter __end, + _Compare __comp, + _ThreadIndex __num_threads) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - if (num_threads <= 1) + if (__num_threads <= 1) { - __gnu_sequential::sort(begin, end, comp); + __gnu_sequential::sort(__begin, __end, __comp); return; } - difference_type n = end - begin, pivot_rank; + _DifferenceType __n = __end - __begin, __pivot_rank; - if (n <= 1) + if (__n <= 1) return; - thread_index_t num_threads_left; + _ThreadIndex __num_threads_left; - if ((num_threads % 2) == 1) - num_threads_left = num_threads / 2 + 1; + if ((__num_threads % 2) == 1) + __num_threads_left = __num_threads / 2 + 1; else - num_threads_left = num_threads / 2; + __num_threads_left = __num_threads / 2; - pivot_rank = n * num_threads_left / num_threads; + __pivot_rank = __n * __num_threads_left / __num_threads; - difference_type split = - parallel_sort_qs_divide(begin, end, comp, pivot_rank, + _DifferenceType __split = + __parallel_sort_qs_divide(__begin, __end, __comp, __pivot_rank, _Settings::get().sort_qs_num_samples_preset, - num_threads); + __num_threads); #pragma omp parallel sections num_threads(2) { #pragma omp section - parallel_sort_qs_conquer(begin, begin + split, - comp, num_threads_left); + __parallel_sort_qs_conquer(__begin, __begin + __split, + __comp, __num_threads_left); #pragma omp section - parallel_sort_qs_conquer(begin + split, end, - comp, num_threads - num_threads_left); + __parallel_sort_qs_conquer(__begin + __split, __end, + __comp, __num_threads - __num_threads_left); } } /** @brief Unbalanced quicksort main call. - * @param begin Begin iterator of input sequence. - * @param end End iterator input sequence, ignored. - * @param comp Comparator. - * @param num_threads Number of threads that are allowed to work on + * @param __begin Begin iterator of input sequence. + * @param __end End iterator input sequence, ignored. + * @param __comp Comparator. + * @param __num_threads Number of threads that are allowed to work on * this part. */ - template + template void - parallel_sort_qs(RandomAccessIterator begin, - RandomAccessIterator end, - Comparator comp, - thread_index_t num_threads) + __parallel_sort_qs(_RAIter __begin, + _RAIter __end, + _Compare __comp, + _ThreadIndex __num_threads) { - _GLIBCXX_CALL(n) + _GLIBCXX_CALL(__n) - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - difference_type n = end - begin; + _DifferenceType __n = __end - __begin; // At least one element per processor. - if (num_threads > n) - num_threads = static_cast(n); + if (__num_threads > __n) + __num_threads = static_cast<_ThreadIndex>(__n); - parallel_sort_qs_conquer(begin, begin + n, comp, num_threads); + __parallel_sort_qs_conquer(__begin, __begin + __n, __comp, __num_threads); } } //namespace __gnu_parallel diff --git a/libstdc++-v3/include/parallel/random_number.h b/libstdc++-v3/include/parallel/random_number.h index 7e821a47390b..69cbc94cc223 100644 --- a/libstdc++-v3/include/parallel/random_number.h +++ b/libstdc++-v3/include/parallel/random_number.h @@ -38,84 +38,84 @@ namespace __gnu_parallel { /** @brief Random number generator, based on the Mersenne twister. */ - class random_number + class _RandomNumber { private: - std::tr1::mt19937 mt; - uint64 supremum; - uint64 RAND_SUP; - double supremum_reciprocal; - double RAND_SUP_REC; + std::tr1::mt19937 _M_mt; + uint64 _M_supremum; + uint64 _RAND_SUP; + double _M_supremum_reciprocal; + double _RAND_SUP_REC; // Assumed to be twice as long as the usual random number. - uint64 cache; + uint64 __cache; // Bit results. - int bits_left; + int __bits_left; static uint32 - scale_down(uint64 x, + __scale_down(uint64 __x, #if _GLIBCXX_SCALE_DOWN_FPU - uint64 /*supremum*/, double supremum_reciprocal) + uint64 /*_M_supremum*/, double _M_supremum_reciprocal) #else - uint64 supremum, double /*supremum_reciprocal*/) + uint64 _M_supremum, double /*_M_supremum_reciprocal*/) #endif { #if _GLIBCXX_SCALE_DOWN_FPU - return uint32(x * supremum_reciprocal); + return uint32(__x * _M_supremum_reciprocal); #else - return static_cast(x % supremum); + return static_cast(__x % _M_supremum); #endif } public: /** @brief Default constructor. Seed with 0. */ - random_number() - : mt(0), supremum(0x100000000ULL), - RAND_SUP(1ULL << (sizeof(uint32) * 8)), - supremum_reciprocal(double(supremum) / double(RAND_SUP)), - RAND_SUP_REC(1.0 / double(RAND_SUP)), - cache(0), bits_left(0) { } + _RandomNumber() + : _M_mt(0), _M_supremum(0x100000000ULL), + _RAND_SUP(1ULL << (sizeof(uint32) * 8)), + _M_supremum_reciprocal(double(_M_supremum) / double(_RAND_SUP)), + _RAND_SUP_REC(1.0 / double(_RAND_SUP)), + __cache(0), __bits_left(0) { } /** @brief Constructor. - * @param seed Random seed. - * @param supremum Generate integer random numbers in the - * interval @c [0,supremum). */ - random_number(uint32 seed, uint64 supremum = 0x100000000ULL) - : mt(seed), supremum(supremum), - RAND_SUP(1ULL << (sizeof(uint32) * 8)), - supremum_reciprocal(double(supremum) / double(RAND_SUP)), - RAND_SUP_REC(1.0 / double(RAND_SUP)), - cache(0), bits_left(0) { } + * @param __seed Random __seed. + * @param _M_supremum Generate integer random numbers in the + * interval @__c [0,_M_supremum). */ + _RandomNumber(uint32 __seed, uint64 _M_supremum = 0x100000000ULL) + : _M_mt(__seed), _M_supremum(_M_supremum), + _RAND_SUP(1ULL << (sizeof(uint32) * 8)), + _M_supremum_reciprocal(double(_M_supremum) / double(_RAND_SUP)), + _RAND_SUP_REC(1.0 / double(_RAND_SUP)), + __cache(0), __bits_left(0) { } /** @brief Generate unsigned random 32-bit integer. */ uint32 operator()() - { return scale_down(mt(), supremum, supremum_reciprocal); } + { return __scale_down(_M_mt(), _M_supremum, _M_supremum_reciprocal); } /** @brief Generate unsigned random 32-bit integer in the - interval @c [0,local_supremum). */ + interval @__c [0,local_supremum). */ uint32 operator()(uint64 local_supremum) { - return scale_down(mt(), local_supremum, - double(local_supremum * RAND_SUP_REC)); + return __scale_down(_M_mt(), local_supremum, + double(local_supremum * _RAND_SUP_REC)); } /** @brief Generate a number of random bits, run-time parameter. * @param bits Number of bits to generate. */ unsigned long - genrand_bits(int bits) + __genrand_bits(int bits) { - unsigned long res = cache & ((1 << bits) - 1); - cache = cache >> bits; - bits_left -= bits; - if (bits_left < 32) + unsigned long __res = __cache & ((1 << bits) - 1); + __cache = __cache >> bits; + __bits_left -= bits; + if (__bits_left < 32) { - cache |= ((uint64(mt())) << bits_left); - bits_left += 32; + __cache |= ((uint64(_M_mt())) << __bits_left); + __bits_left += 32; } - return res; + return __res; } }; diff --git a/libstdc++-v3/include/parallel/random_shuffle.h b/libstdc++-v3/include/parallel/random_shuffle.h index 6e0ebef1523e..5d6bfcec374e 100644 --- a/libstdc++-v3/include/parallel/random_shuffle.h +++ b/libstdc++-v3/include/parallel/random_shuffle.h @@ -41,477 +41,477 @@ namespace __gnu_parallel { /** @brief Type to hold the index of a bin. * - * Since many variables of this type are allocated, it should be + * Since many variables of this _Self are allocated, it should be * chosen as small as possible. */ -typedef unsigned short bin_index; +typedef unsigned short _BinIndex; /** @brief Data known to every thread participating in - __gnu_parallel::parallel_random_shuffle(). */ -template - struct DRandomShufflingGlobalData + __gnu_parallel::__parallel_random_shuffle(). */ +template + struct _DRandomShufflingGlobalData { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - /** @brief Begin iterator of the source. */ - RandomAccessIterator& source; + /** @brief Begin iterator of the _M_source. */ + _RAIter& _M_source; /** @brief Temporary arrays for each thread. */ - value_type** temporaries; + _ValueType** _M_temporaries; /** @brief Two-dimensional array to hold the thread-bin distribution. * - * Dimensions (num_threads + 1) x (num_bins + 1). */ - difference_type** dist; + * Dimensions (__num_threads + 1) __x (_M_num_bins + 1). */ + _DifferenceType** _M_dist; - /** @brief Start indexes of the threads' chunks. */ - difference_type* starts; + /** @brief Start indexes of the threads' __chunks. */ + _DifferenceType* _M_starts; /** @brief Number of the thread that will further process the corresponding bin. */ - thread_index_t* bin_proc; + _ThreadIndex* _M_bin_proc; /** @brief Number of bins to distribute to. */ - int num_bins; + int _M_num_bins; /** @brief Number of bits needed to address the bins. */ - int num_bits; + int _M_num_bits; /** @brief Constructor. */ - DRandomShufflingGlobalData(RandomAccessIterator& _source) - : source(_source) { } + _DRandomShufflingGlobalData(_RAIter& _source) + : _M_source(_source) { } }; /** @brief Local data for a thread participating in - __gnu_parallel::parallel_random_shuffle(). + __gnu_parallel::__parallel_random_shuffle(). */ -template - struct DRSSorterPU +template + struct _DRSSorterPU { /** @brief Number of threads participating in total. */ - int num_threads; + int __num_threads; - /** @brief Begin index for bins taken care of by this thread. */ - bin_index bins_begin; + /** @brief Begin __index for bins taken care of by this thread. */ + _BinIndex _M_bins_begin; - /** @brief End index for bins taken care of by this thread. */ - bin_index bins_end; + /** @brief End __index for bins taken care of by this thread. */ + _BinIndex __bins_end; - /** @brief Random seed for this thread. */ - uint32 seed; + /** @brief Random _M_seed for this thread. */ + uint32 _M_seed; /** @brief Pointer to global data. */ - DRandomShufflingGlobalData* sd; + _DRandomShufflingGlobalData<_RAIter>* _M_sd; }; -/** @brief Generate a random number in @c [0,2^logp). - * @param logp Logarithm (basis 2) of the upper range bound. - * @param rng Random number generator to use. +/** @brief Generate a random number in @__c [0,2^logp). + * @param logp Logarithm (basis 2) of the upper range __bound. + * @param __rng Random number generator to use. */ template inline int - random_number_pow2(int logp, RandomNumberGenerator& rng) - { return rng.genrand_bits(logp); } + __random_number_pow2(int logp, RandomNumberGenerator& __rng) + { return __rng.__genrand_bits(logp); } /** @brief Random shuffle code executed by each thread. - * @param pus Array of thread-local data records. */ -template + * @param __pus Array of thread-local data records. */ +template void - parallel_random_shuffle_drs_pu(DRSSorterPU* pus) + __parallel_random_shuffle_drs_pu(_DRSSorterPU<_RAIter, + RandomNumberGenerator>* __pus) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - thread_index_t iam = omp_get_thread_num(); - DRSSorterPU* d = &pus[iam]; - DRandomShufflingGlobalData* sd = d->sd; + _ThreadIndex __iam = omp_get_thread_num(); + _DRSSorterPU<_RAIter, RandomNumberGenerator>* d = &__pus[__iam]; + _DRandomShufflingGlobalData<_RAIter>* _M_sd = d->_M_sd; - // Indexing: dist[bin][processor] - difference_type length = sd->starts[iam + 1] - sd->starts[iam]; - bin_index* oracles = new bin_index[length]; - difference_type* dist = new difference_type[sd->num_bins + 1]; - bin_index* bin_proc = new bin_index[sd->num_bins]; - value_type** temporaries = new value_type*[d->num_threads]; + // Indexing: _M_dist[bin][processor] + _DifferenceType __length = _M_sd->_M_starts[__iam + 1] - _M_sd->_M_starts[__iam]; + _BinIndex* __oracles = new _BinIndex[__length]; + _DifferenceType* _M_dist = new _DifferenceType[_M_sd->_M_num_bins + 1]; + _BinIndex* _M_bin_proc = new _BinIndex[_M_sd->_M_num_bins]; + _ValueType** _M_temporaries = new _ValueType*[d->__num_threads]; // Compute oracles and count appearances. - for (bin_index b = 0; b < sd->num_bins + 1; ++b) - dist[b] = 0; - int num_bits = sd->num_bits; + for (_BinIndex __b = 0; __b < _M_sd->_M_num_bins + 1; ++__b) + _M_dist[__b] = 0; + int _M_num_bits = _M_sd->_M_num_bits; - random_number rng(d->seed); + _RandomNumber __rng(d->_M_seed); // First main loop. - for (difference_type i = 0; i < length; ++i) + for (_DifferenceType __i = 0; __i < __length; ++__i) { - bin_index oracle = random_number_pow2(num_bits, rng); - oracles[i] = oracle; + _BinIndex __oracle = __random_number_pow2(_M_num_bits, __rng); + __oracles[__i] = __oracle; // To allow prefix (partial) sum. - ++(dist[oracle + 1]); + ++(_M_dist[__oracle + 1]); } - for (bin_index b = 0; b < sd->num_bins + 1; ++b) - sd->dist[b][iam + 1] = dist[b]; + for (_BinIndex __b = 0; __b < _M_sd->_M_num_bins + 1; ++__b) + _M_sd->_M_dist[__b][__iam + 1] = _M_dist[__b]; # pragma omp barrier # pragma omp single { - // Sum up bins, sd->dist[s + 1][d->num_threads] now contains the - // total number of items in bin s - for (bin_index s = 0; s < sd->num_bins; ++s) - __gnu_sequential::partial_sum(sd->dist[s + 1], - sd->dist[s + 1] + d->num_threads + 1, - sd->dist[s + 1]); + // Sum up bins, _M_sd->_M_dist[__s + 1][d->__num_threads] now contains the + // total number of items in bin __s + for (_BinIndex __s = 0; __s < _M_sd->_M_num_bins; ++__s) + __gnu_sequential::partial_sum(_M_sd->_M_dist[__s + 1], + _M_sd->_M_dist[__s + 1] + d->__num_threads + 1, + _M_sd->_M_dist[__s + 1]); } # pragma omp barrier - sequence_index_t offset = 0, global_offset = 0; - for (bin_index s = 0; s < d->bins_begin; ++s) - global_offset += sd->dist[s + 1][d->num_threads]; + _SequenceIndex __offset = 0, __global_offset = 0; + for (_BinIndex __s = 0; __s < d->_M_bins_begin; ++__s) + __global_offset += _M_sd->_M_dist[__s + 1][d->__num_threads]; # pragma omp barrier - for (bin_index s = d->bins_begin; s < d->bins_end; ++s) + for (_BinIndex __s = d->_M_bins_begin; __s < d->__bins_end; ++__s) { - for (int t = 0; t < d->num_threads + 1; ++t) - sd->dist[s + 1][t] += offset; - offset = sd->dist[s + 1][d->num_threads]; + for (int __t = 0; __t < d->__num_threads + 1; ++__t) + _M_sd->_M_dist[__s + 1][__t] += __offset; + __offset = _M_sd->_M_dist[__s + 1][d->__num_threads]; } - sd->temporaries[iam] = static_cast( - ::operator new(sizeof(value_type) * offset)); + _M_sd->_M_temporaries[__iam] = static_cast<_ValueType*>( + ::operator new(sizeof(_ValueType) * __offset)); # pragma omp barrier // Draw local copies to avoid false sharing. - for (bin_index b = 0; b < sd->num_bins + 1; ++b) - dist[b] = sd->dist[b][iam]; - for (bin_index b = 0; b < sd->num_bins; ++b) - bin_proc[b] = sd->bin_proc[b]; - for (thread_index_t t = 0; t < d->num_threads; ++t) - temporaries[t] = sd->temporaries[t]; + for (_BinIndex __b = 0; __b < _M_sd->_M_num_bins + 1; ++__b) + _M_dist[__b] = _M_sd->_M_dist[__b][__iam]; + for (_BinIndex __b = 0; __b < _M_sd->_M_num_bins; ++__b) + _M_bin_proc[__b] = _M_sd->_M_bin_proc[__b]; + for (_ThreadIndex __t = 0; __t < d->__num_threads; ++__t) + _M_temporaries[__t] = _M_sd->_M_temporaries[__t]; - RandomAccessIterator source = sd->source; - difference_type start = sd->starts[iam]; + _RAIter _M_source = _M_sd->_M_source; + _DifferenceType __start = _M_sd->_M_starts[__iam]; // Distribute according to oracles, second main loop. - for (difference_type i = 0; i < length; ++i) + for (_DifferenceType __i = 0; __i < __length; ++__i) { - bin_index target_bin = oracles[i]; - thread_index_t target_p = bin_proc[target_bin]; + _BinIndex target_bin = __oracles[__i]; + _ThreadIndex target_p = _M_bin_proc[target_bin]; - // Last column [d->num_threads] stays unchanged. - ::new(&(temporaries[target_p][dist[target_bin + 1]++])) - value_type(*(source + i + start)); + // Last column [d->__num_threads] stays unchanged. + ::new(&(_M_temporaries[target_p][_M_dist[target_bin + 1]++])) + _ValueType(*(_M_source + __i + __start)); } - delete[] oracles; - delete[] dist; - delete[] bin_proc; - delete[] temporaries; + delete[] __oracles; + delete[] _M_dist; + delete[] _M_bin_proc; + delete[] _M_temporaries; # pragma omp barrier // Shuffle bins internally. - for (bin_index b = d->bins_begin; b < d->bins_end; ++b) + for (_BinIndex __b = d->_M_bins_begin; __b < d->__bins_end; ++__b) { - value_type* begin = - sd->temporaries[iam] + - ((b == d->bins_begin) ? 0 : sd->dist[b][d->num_threads]), - * end = - sd->temporaries[iam] + sd->dist[b + 1][d->num_threads]; - sequential_random_shuffle(begin, end, rng); - std::copy(begin, end, sd->source + global_offset + - ((b == d->bins_begin) ? 0 : sd->dist[b][d->num_threads])); + _ValueType* __begin = + _M_sd->_M_temporaries[__iam] + + ((__b == d->_M_bins_begin) ? 0 : _M_sd->_M_dist[__b][d->__num_threads]), + * __end = + _M_sd->_M_temporaries[__iam] + _M_sd->_M_dist[__b + 1][d->__num_threads]; + __sequential_random_shuffle(__begin, __end, __rng); + std::copy(__begin, __end, _M_sd->_M_source + __global_offset + + ((__b == d->_M_bins_begin) ? 0 : _M_sd->_M_dist[__b][d->__num_threads])); } - ::operator delete(sd->temporaries[iam]); + ::operator delete(_M_sd->_M_temporaries[__iam]); } /** @brief Round up to the next greater power of 2. - * @param x Integer to round up */ -template - T - round_up_to_pow2(T x) + * @param __x _Integer to round up */ +template + _Tp + __round_up_to_pow2(_Tp __x) { - if (x <= 1) + if (__x <= 1) return 1; else - return (T)1 << (__log2(x - 1) + 1); + return (_Tp)1 << (__log2(__x - 1) + 1); } /** @brief Main parallel random shuffle step. - * @param begin Begin iterator of sequence. - * @param end End iterator of sequence. - * @param n Length of sequence. - * @param num_threads Number of threads to use. - * @param rng Random number generator to use. + * @param __begin Begin iterator of sequence. + * @param __end End iterator of sequence. + * @param __n Length of sequence. + * @param __num_threads Number of threads to use. + * @param __rng Random number generator to use. */ -template +template void - parallel_random_shuffle_drs(RandomAccessIterator begin, - RandomAccessIterator end, + __parallel_random_shuffle_drs(_RAIter __begin, + _RAIter __end, typename std::iterator_traits - ::difference_type n, - thread_index_t num_threads, - RandomNumberGenerator& rng) + <_RAIter>::difference_type __n, + _ThreadIndex __num_threads, + RandomNumberGenerator& __rng) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - _GLIBCXX_CALL(n) + _GLIBCXX_CALL(__n) const _Settings& __s = _Settings::get(); - if (num_threads > n) - num_threads = static_cast(n); + if (__num_threads > __n) + __num_threads = static_cast<_ThreadIndex>(__n); - bin_index num_bins, num_bins_cache; + _BinIndex _M_num_bins, __num_bins_cache; #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1 // Try the L1 cache first. // Must fit into L1. - num_bins_cache = std::max( - 1, n / (__s.L1_cache_size_lb / sizeof(value_type))); - num_bins_cache = round_up_to_pow2(num_bins_cache); + __num_bins_cache = std::max<_DifferenceType>( + 1, __n / (__s.L1_cache_size_lb / sizeof(_ValueType))); + __num_bins_cache = __round_up_to_pow2(__num_bins_cache); // No more buckets than TLB entries, power of 2 // Power of 2 and at least one element per bin, at most the TLB size. - num_bins = std::min(n, num_bins_cache); + _M_num_bins = std::min<_DifferenceType>(__n, __num_bins_cache); #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB // 2 TLB entries needed per bin. - num_bins = std::min(__s.TLB_size / 2, num_bins); + _M_num_bins = std::min<_DifferenceType>(__s.TLB_size / 2, _M_num_bins); #endif - num_bins = round_up_to_pow2(num_bins); + _M_num_bins = __round_up_to_pow2(_M_num_bins); - if (num_bins < num_bins_cache) + if (_M_num_bins < __num_bins_cache) { #endif // Now try the L2 cache // Must fit into L2 - num_bins_cache = static_cast(std::max( - 1, n / (__s.L2_cache_size / sizeof(value_type)))); - num_bins_cache = round_up_to_pow2(num_bins_cache); + __num_bins_cache = static_cast<_BinIndex>(std::max<_DifferenceType>( + 1, __n / (__s.L2_cache_size / sizeof(_ValueType)))); + __num_bins_cache = __round_up_to_pow2(__num_bins_cache); // No more buckets than TLB entries, power of 2. - num_bins = static_cast( - std::min(n, static_cast(num_bins_cache))); + _M_num_bins = static_cast<_BinIndex>( + std::min(__n, static_cast<_DifferenceType>(__num_bins_cache))); // Power of 2 and at least one element per bin, at most the TLB size. #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB // 2 TLB entries needed per bin. - num_bins = std::min( - static_cast(__s.TLB_size / 2), num_bins); + _M_num_bins = std::min( + static_cast<_DifferenceType>(__s.TLB_size / 2), _M_num_bins); #endif - num_bins = round_up_to_pow2(num_bins); + _M_num_bins = __round_up_to_pow2(_M_num_bins); #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1 } #endif - num_threads = std::min(num_threads, num_bins); + __num_threads = std::min<_BinIndex>(__num_threads, _M_num_bins); - if (num_threads <= 1) - return sequential_random_shuffle(begin, end, rng); + if (__num_threads <= 1) + return __sequential_random_shuffle(__begin, __end, __rng); - DRandomShufflingGlobalData sd(begin); - DRSSorterPU* pus; - difference_type* starts; + _DRandomShufflingGlobalData<_RAIter> _M_sd(__begin); + _DRSSorterPU<_RAIter, _RandomNumber >* __pus; + _DifferenceType* _M_starts; -# pragma omp parallel num_threads(num_threads) +# pragma omp parallel num_threads(__num_threads) { - thread_index_t num_threads = omp_get_num_threads(); + _ThreadIndex __num_threads = omp_get_num_threads(); # pragma omp single { - pus = new DRSSorterPU - [num_threads]; - - sd.temporaries = new value_type*[num_threads]; - sd.dist = new difference_type*[num_bins + 1]; - sd.bin_proc = new thread_index_t[num_bins]; - for (bin_index b = 0; b < num_bins + 1; ++b) - sd.dist[b] = new difference_type[num_threads + 1]; - for (bin_index b = 0; b < (num_bins + 1); ++b) + __pus = new _DRSSorterPU<_RAIter, _RandomNumber> + [__num_threads]; + + _M_sd._M_temporaries = new _ValueType*[__num_threads]; + _M_sd._M_dist = new _DifferenceType*[_M_num_bins + 1]; + _M_sd._M_bin_proc = new _ThreadIndex[_M_num_bins]; + for (_BinIndex __b = 0; __b < _M_num_bins + 1; ++__b) + _M_sd._M_dist[__b] = new _DifferenceType[__num_threads + 1]; + for (_BinIndex __b = 0; __b < (_M_num_bins + 1); ++__b) { - sd.dist[0][0] = 0; - sd.dist[b][0] = 0; + _M_sd._M_dist[0][0] = 0; + _M_sd._M_dist[__b][0] = 0; } - starts = sd.starts = new difference_type[num_threads + 1]; + _M_starts = _M_sd._M_starts = new _DifferenceType[__num_threads + 1]; int bin_cursor = 0; - sd.num_bins = num_bins; - sd.num_bits = __log2(num_bins); - - difference_type chunk_length = n / num_threads, - split = n % num_threads, start = 0; - difference_type bin_chunk_length = num_bins / num_threads, - bin_split = num_bins % num_threads; - for (thread_index_t i = 0; i < num_threads; ++i) + _M_sd._M_num_bins = _M_num_bins; + _M_sd._M_num_bits = __log2(_M_num_bins); + + _DifferenceType __chunk_length = __n / __num_threads, + __split = __n % __num_threads, __start = 0; + _DifferenceType bin_chunk_length = _M_num_bins / __num_threads, + bin_split = _M_num_bins % __num_threads; + for (_ThreadIndex __i = 0; __i < __num_threads; ++__i) { - starts[i] = start; - start += (i < split) ? (chunk_length + 1) : chunk_length; - int j = pus[i].bins_begin = bin_cursor; + _M_starts[__i] = __start; + __start += (__i < __split) ? (__chunk_length + 1) : __chunk_length; + int __j = __pus[__i]._M_bins_begin = bin_cursor; // Range of bins for this processor. - bin_cursor += (i < bin_split) ? + bin_cursor += (__i < bin_split) ? (bin_chunk_length + 1) : bin_chunk_length; - pus[i].bins_end = bin_cursor; - for (; j < bin_cursor; ++j) - sd.bin_proc[j] = i; - pus[i].num_threads = num_threads; - pus[i].seed = rng(std::numeric_limits::max()); - pus[i].sd = &sd; + __pus[__i].__bins_end = bin_cursor; + for (; __j < bin_cursor; ++__j) + _M_sd._M_bin_proc[__j] = __i; + __pus[__i].__num_threads = __num_threads; + __pus[__i]._M_seed = __rng(std::numeric_limits::max()); + __pus[__i]._M_sd = &_M_sd; } - starts[num_threads] = start; + _M_starts[__num_threads] = __start; } //single // Now shuffle in parallel. - parallel_random_shuffle_drs_pu(pus); + __parallel_random_shuffle_drs_pu(__pus); } // parallel - delete[] starts; - delete[] sd.bin_proc; - for (int s = 0; s < (num_bins + 1); ++s) - delete[] sd.dist[s]; - delete[] sd.dist; - delete[] sd.temporaries; + delete[] _M_starts; + delete[] _M_sd._M_bin_proc; + for (int __s = 0; __s < (_M_num_bins + 1); ++__s) + delete[] _M_sd._M_dist[__s]; + delete[] _M_sd._M_dist; + delete[] _M_sd._M_temporaries; - delete[] pus; + delete[] __pus; } -/** @brief Sequential cache-efficient random shuffle. - * @param begin Begin iterator of sequence. - * @param end End iterator of sequence. - * @param rng Random number generator to use. +/** @brief Sequential __cache-efficient random shuffle. + * @param __begin Begin iterator of sequence. + * @param __end End iterator of sequence. + * @param __rng Random number generator to use. */ -template +template void - sequential_random_shuffle(RandomAccessIterator begin, - RandomAccessIterator end, - RandomNumberGenerator& rng) + __sequential_random_shuffle(_RAIter __begin, + _RAIter __end, + RandomNumberGenerator& __rng) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - difference_type n = end - begin; + _DifferenceType __n = __end - __begin; const _Settings& __s = _Settings::get(); - bin_index num_bins, num_bins_cache; + _BinIndex _M_num_bins, __num_bins_cache; #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1 // Try the L1 cache first, must fit into L1. - num_bins_cache = - std::max - (1, n / (__s.L1_cache_size_lb / sizeof(value_type))); - num_bins_cache = round_up_to_pow2(num_bins_cache); + __num_bins_cache = + std::max<_DifferenceType> + (1, __n / (__s.L1_cache_size_lb / sizeof(_ValueType))); + __num_bins_cache = __round_up_to_pow2(__num_bins_cache); // No more buckets than TLB entries, power of 2 // Power of 2 and at least one element per bin, at most the TLB size - num_bins = std::min(n, (difference_type)num_bins_cache); + _M_num_bins = std::min(__n, (_DifferenceType)__num_bins_cache); #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB // 2 TLB entries needed per bin - num_bins = std::min((difference_type)__s.TLB_size / 2, num_bins); + _M_num_bins = std::min((_DifferenceType)__s.TLB_size / 2, _M_num_bins); #endif - num_bins = round_up_to_pow2(num_bins); + _M_num_bins = __round_up_to_pow2(_M_num_bins); - if (num_bins < num_bins_cache) + if (_M_num_bins < __num_bins_cache) { #endif // Now try the L2 cache, must fit into L2. - num_bins_cache = - static_cast(std::max( - 1, n / (__s.L2_cache_size / sizeof(value_type)))); - num_bins_cache = round_up_to_pow2(num_bins_cache); + __num_bins_cache = + static_cast<_BinIndex>(std::max<_DifferenceType>( + 1, __n / (__s.L2_cache_size / sizeof(_ValueType)))); + __num_bins_cache = __round_up_to_pow2(__num_bins_cache); // No more buckets than TLB entries, power of 2 // Power of 2 and at least one element per bin, at most the TLB size. - num_bins = static_cast - (std::min(n, static_cast(num_bins_cache))); + _M_num_bins = static_cast<_BinIndex> + (std::min(__n, static_cast<_DifferenceType>(__num_bins_cache))); #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_TLB // 2 TLB entries needed per bin - num_bins = - std::min(__s.TLB_size / 2, num_bins); + _M_num_bins = + std::min<_DifferenceType>(__s.TLB_size / 2, _M_num_bins); #endif - num_bins = round_up_to_pow2(num_bins); + _M_num_bins = __round_up_to_pow2(_M_num_bins); #if _GLIBCXX_RANDOM_SHUFFLE_CONSIDER_L1 } #endif - int num_bits = __log2(num_bins); + int _M_num_bits = __log2(_M_num_bins); - if (num_bins > 1) + if (_M_num_bins > 1) { - value_type* target = static_cast( - ::operator new(sizeof(value_type) * n)); - bin_index* oracles = new bin_index[n]; - difference_type* dist0 = new difference_type[num_bins + 1], - * dist1 = new difference_type[num_bins + 1]; + _ValueType* __target = static_cast<_ValueType*>( + ::operator new(sizeof(_ValueType) * __n)); + _BinIndex* __oracles = new _BinIndex[__n]; + _DifferenceType* __dist0 = new _DifferenceType[_M_num_bins + 1], + * __dist1 = new _DifferenceType[_M_num_bins + 1]; - for (int b = 0; b < num_bins + 1; ++b) - dist0[b] = 0; + for (int __b = 0; __b < _M_num_bins + 1; ++__b) + __dist0[__b] = 0; - random_number bitrng(rng(0xFFFFFFFF)); + _RandomNumber bitrng(__rng(0xFFFFFFFF)); - for (difference_type i = 0; i < n; ++i) + for (_DifferenceType __i = 0; __i < __n; ++__i) { - bin_index oracle = random_number_pow2(num_bits, bitrng); - oracles[i] = oracle; + _BinIndex __oracle = __random_number_pow2(_M_num_bits, bitrng); + __oracles[__i] = __oracle; // To allow prefix (partial) sum. - ++(dist0[oracle + 1]); + ++(__dist0[__oracle + 1]); } // Sum up bins. - __gnu_sequential::partial_sum(dist0, dist0 + num_bins + 1, dist0); + __gnu_sequential::partial_sum(__dist0, __dist0 + _M_num_bins + 1, __dist0); - for (int b = 0; b < num_bins + 1; ++b) - dist1[b] = dist0[b]; + for (int __b = 0; __b < _M_num_bins + 1; ++__b) + __dist1[__b] = __dist0[__b]; // Distribute according to oracles. - for (difference_type i = 0; i < n; ++i) - ::new(&(target[(dist0[oracles[i]])++])) value_type(*(begin + i)); + for (_DifferenceType __i = 0; __i < __n; ++__i) + ::new(&(__target[(__dist0[__oracles[__i]])++])) _ValueType(*(__begin + __i)); - for (int b = 0; b < num_bins; ++b) + for (int __b = 0; __b < _M_num_bins; ++__b) { - sequential_random_shuffle(target + dist1[b], - target + dist1[b + 1], - rng); + __sequential_random_shuffle(__target + __dist1[__b], + __target + __dist1[__b + 1], + __rng); } // Copy elements back. - std::copy(target, target + n, begin); + std::copy(__target, __target + __n, __begin); - delete[] dist0; - delete[] dist1; - delete[] oracles; - ::operator delete(target); + delete[] __dist0; + delete[] __dist1; + delete[] __oracles; + ::operator delete(__target); } else - __gnu_sequential::random_shuffle(begin, end, rng); + __gnu_sequential::random_shuffle(__begin, __end, __rng); } /** @brief Parallel random public call. - * @param begin Begin iterator of sequence. - * @param end End iterator of sequence. - * @param rng Random number generator to use. + * @param __begin Begin iterator of sequence. + * @param __end End iterator of sequence. + * @param __rng Random number generator to use. */ -template +template inline void - parallel_random_shuffle(RandomAccessIterator begin, - RandomAccessIterator end, - RandomNumberGenerator rng = random_number()) + __parallel_random_shuffle(_RAIter __begin, + _RAIter __end, + RandomNumberGenerator __rng = _RandomNumber()) { - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; - difference_type n = end - begin; - parallel_random_shuffle_drs(begin, end, n, get_max_threads(), rng) ; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; + _DifferenceType __n = __end - __begin; + __parallel_random_shuffle_drs(__begin, __end, __n, __get_max_threads(), __rng) ; } } diff --git a/libstdc++-v3/include/parallel/search.h b/libstdc++-v3/include/parallel/search.h index 31a8534029b8..b0a9f6918bf8 100644 --- a/libstdc++-v3/include/parallel/search.h +++ b/libstdc++-v3/include/parallel/search.h @@ -23,7 +23,7 @@ // . /** @file parallel/search.h - * @brief Parallel implementation base for std::search() and + * @brief Parallel implementation __base for std::search() and * std::search_n(). * This file is a GNU parallel extension to the Standard C++ Library. */ @@ -42,130 +42,130 @@ namespace __gnu_parallel { /** - * @brief Precalculate advances for Knuth-Morris-Pratt algorithm. - * @param elements Begin iterator of sequence to search for. - * @param length Length of sequence to search for. - * @param advances Returned offsets. + * @brief Precalculate __advances for Knuth-Morris-Pratt algorithm. + * @param __elements Begin iterator of sequence to search for. + * @param __length Length of sequence to search for. + * @param __advances Returned __offsets. */ -template +template void - calc_borders(RandomAccessIterator elements, _DifferenceTp length, - _DifferenceTp* off) + __calc_borders(_RAIter __elements, _DifferenceTp __length, + _DifferenceTp* __off) { - typedef _DifferenceTp difference_type; + typedef _DifferenceTp _DifferenceType; - off[0] = -1; - if (length > 1) - off[1] = 0; - difference_type k = 0; - for (difference_type j = 2; j <= length; j++) + __off[0] = -1; + if (__length > 1) + __off[1] = 0; + _DifferenceType __k = 0; + for (_DifferenceType __j = 2; __j <= __length; __j++) { - while ((k >= 0) && !(elements[k] == elements[j-1])) - k = off[k]; - off[j] = ++k; + while ((__k >= 0) && !(__elements[__k] == __elements[__j-1])) + __k = __off[__k]; + __off[__j] = ++__k; } } // Generic parallel find algorithm (requires random access iterator). /** @brief Parallel std::search. - * @param begin1 Begin iterator of first sequence. - * @param end1 End iterator of first sequence. - * @param begin2 Begin iterator of second sequence. - * @param end2 End iterator of second sequence. - * @param pred Find predicate. + * @param __begin1 Begin iterator of first sequence. + * @param __end1 End iterator of first sequence. + * @param __begin2 Begin iterator of second sequence. + * @param __end2 End iterator of second sequence. + * @param __pred Find predicate. * @return Place of finding in first sequences. */ -template - _RandomAccessIterator1 - search_template(_RandomAccessIterator1 begin1, _RandomAccessIterator1 end1, - _RandomAccessIterator2 begin2, _RandomAccessIterator2 end2, - Pred pred) +template + __RAIter1 + __search_template(__RAIter1 __begin1, __RAIter1 __end1, + __RAIter2 __begin2, __RAIter2 __end2, + _Pred __pred) { - typedef std::iterator_traits<_RandomAccessIterator1> traits_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<__RAIter1> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; - _GLIBCXX_CALL((end1 - begin1) + (end2 - begin2)); + _GLIBCXX_CALL((__end1 - __begin1) + (__end2 - __begin2)); - difference_type pattern_length = end2 - begin2; + _DifferenceType __pattern_length = __end2 - __begin2; // Pattern too short. - if(pattern_length <= 0) - return end1; + if(__pattern_length <= 0) + return __end1; // Last point to start search. - difference_type input_length = (end1 - begin1) - pattern_length; + _DifferenceType __input_length = (__end1 - __begin1) - __pattern_length; // Where is first occurrence of pattern? defaults to end. - difference_type result = (end1 - begin1); - difference_type *splitters; + _DifferenceType __result = (__end1 - __begin1); + _DifferenceType *__splitters; // Pattern too long. - if (input_length < 0) - return end1; + if (__input_length < 0) + return __end1; - omp_lock_t result_lock; - omp_init_lock(&result_lock); + omp_lock_t __result_lock; + omp_init_lock(&__result_lock); - thread_index_t num_threads = - std::max(1, - std::min(input_length, get_max_threads())); + _ThreadIndex __num_threads = + std::max<_DifferenceType>(1, + std::min<_DifferenceType>(__input_length, __get_max_threads())); - difference_type advances[pattern_length]; - calc_borders(begin2, pattern_length, advances); + _DifferenceType __advances[__pattern_length]; + __calc_borders(__begin2, __pattern_length, __advances); -# pragma omp parallel num_threads(num_threads) +# pragma omp parallel num_threads(__num_threads) { # pragma omp single { - num_threads = omp_get_num_threads(); - splitters = new difference_type[num_threads + 1]; - equally_split(input_length, num_threads, splitters); + __num_threads = omp_get_num_threads(); + __splitters = new _DifferenceType[__num_threads + 1]; + equally_split(__input_length, __num_threads, __splitters); } - thread_index_t iam = omp_get_thread_num(); + _ThreadIndex __iam = omp_get_thread_num(); - difference_type start = splitters[iam], stop = splitters[iam + 1]; + _DifferenceType __start = __splitters[__iam], __stop = __splitters[__iam + 1]; - difference_type pos_in_pattern = 0; - bool found_pattern = false; + _DifferenceType __pos_in_pattern = 0; + bool __found_pattern = false; - while (start <= stop && !found_pattern) + while (__start <= __stop && !__found_pattern) { // Get new value of result. - #pragma omp flush(result) + #pragma omp flush(__result) // No chance for this thread to find first occurrence. - if (result < start) + if (__result < __start) break; - while (pred(begin1[start + pos_in_pattern], - begin2[pos_in_pattern])) + while (__pred(__begin1[__start + __pos_in_pattern], + __begin2[__pos_in_pattern])) { - ++pos_in_pattern; - if (pos_in_pattern == pattern_length) + ++__pos_in_pattern; + if (__pos_in_pattern == __pattern_length) { // Found new candidate for result. - omp_set_lock(&result_lock); - result = std::min(result, start); - omp_unset_lock(&result_lock); + omp_set_lock(&__result_lock); + __result = std::min(__result, __start); + omp_unset_lock(&__result_lock); - found_pattern = true; + __found_pattern = true; break; } } // Make safe jump. - start += (pos_in_pattern - advances[pos_in_pattern]); - pos_in_pattern = - (advances[pos_in_pattern] < 0) ? 0 : advances[pos_in_pattern]; + __start += (__pos_in_pattern - __advances[__pos_in_pattern]); + __pos_in_pattern = + (__advances[__pos_in_pattern] < 0) ? 0 : __advances[__pos_in_pattern]; } } //parallel - omp_destroy_lock(&result_lock); + omp_destroy_lock(&__result_lock); - delete[] splitters; + delete[] __splitters; // Return iterator on found element. - return (begin1 + result); + return (__begin1 + __result); } } // end namespace diff --git a/libstdc++-v3/include/parallel/set_operations.h b/libstdc++-v3/include/parallel/set_operations.h index 28008195b6fb..a726d309ce44 100644 --- a/libstdc++-v3/include/parallel/set_operations.h +++ b/libstdc++-v3/include/parallel/set_operations.h @@ -41,482 +41,482 @@ namespace __gnu_parallel { -template - OutputIterator - copy_tail(std::pair b, - std::pair e, OutputIterator r) +template + _OutputIterator + copy_tail(std::pair<_IIter, _IIter> __b, + std::pair<_IIter, _IIter> __e, _OutputIterator __r) { - if (b.first != e.first) + if (__b.first != __e.first) { do { - *r++ = *b.first++; + *__r++ = *__b.first++; } - while (b.first != e.first); + while (__b.first != __e.first); } else { - while (b.second != e.second) - *r++ = *b.second++; + while (__b.second != __e.second) + *__r++ = *__b.second++; } - return r; + return __r; } -template +template struct symmetric_difference_func { - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; - typedef typename std::pair iterator_pair; + typedef std::iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; + typedef typename std::pair<_IIter, _IIter> _IteratorPair; - symmetric_difference_func(Comparator c) : comp(c) {} + symmetric_difference_func(_Compare __c) : __comp(__c) {} - Comparator comp; + _Compare __comp; - OutputIterator - invoke(InputIterator a, InputIterator b, - InputIterator c, InputIterator d, - OutputIterator r) const + _OutputIterator + _M_invoke(_IIter __a, _IIter __b, + _IIter __c, _IIter d, + _OutputIterator __r) const { - while (a != b && c != d) + while (__a != __b && __c != d) { - if (comp(*a, *c)) + if (__comp(*__a, *__c)) { - *r = *a; - ++a; - ++r; + *__r = *__a; + ++__a; + ++__r; } - else if (comp(*c, *a)) + else if (__comp(*__c, *__a)) { - *r = *c; - ++c; - ++r; + *__r = *__c; + ++__c; + ++__r; } else { - ++a; - ++c; + ++__a; + ++__c; } } - return std::copy(c, d, std::copy(a, b, r)); + return std::copy(__c, d, std::copy(__a, __b, __r)); } - difference_type - count(InputIterator a, InputIterator b, - InputIterator c, InputIterator d) const + _DifferenceType + __count(_IIter __a, _IIter __b, + _IIter __c, _IIter d) const { - difference_type counter = 0; + _DifferenceType __counter = 0; - while (a != b && c != d) + while (__a != __b && __c != d) { - if (comp(*a, *c)) + if (__comp(*__a, *__c)) { - ++a; - ++counter; + ++__a; + ++__counter; } - else if (comp(*c, *a)) + else if (__comp(*__c, *__a)) { - ++c; - ++counter; + ++__c; + ++__counter; } else { - ++a; - ++c; + ++__a; + ++__c; } } - return counter + (b - a) + (d - c); + return __counter + (__b - __a) + (d - __c); } - OutputIterator - first_empty(InputIterator c, InputIterator d, OutputIterator out) const - { return std::copy(c, d, out); } + _OutputIterator + __first_empty(_IIter __c, _IIter d, _OutputIterator __out) const + { return std::copy(__c, d, __out); } - OutputIterator - second_empty(InputIterator a, InputIterator b, OutputIterator out) const - { return std::copy(a, b, out); } + _OutputIterator + __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const + { return std::copy(__a, __b, __out); } }; -template - struct difference_func +template + struct __difference_func { - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; - typedef typename std::pair iterator_pair; + typedef std::iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; + typedef typename std::pair<_IIter, _IIter> _IteratorPair; - difference_func(Comparator c) : comp(c) {} + __difference_func(_Compare __c) : __comp(__c) {} - Comparator comp; + _Compare __comp; - OutputIterator - invoke(InputIterator a, InputIterator b, InputIterator c, InputIterator d, - OutputIterator r) const + _OutputIterator + _M_invoke(_IIter __a, _IIter __b, _IIter __c, _IIter d, + _OutputIterator __r) const { - while (a != b && c != d) + while (__a != __b && __c != d) { - if (comp(*a, *c)) + if (__comp(*__a, *__c)) { - *r = *a; - ++a; - ++r; + *__r = *__a; + ++__a; + ++__r; } - else if (comp(*c, *a)) - { ++c; } + else if (__comp(*__c, *__a)) + { ++__c; } else { - ++a; - ++c; + ++__a; + ++__c; } } - return std::copy(a, b, r); + return std::copy(__a, __b, __r); } - difference_type - count(InputIterator a, InputIterator b, - InputIterator c, InputIterator d) const + _DifferenceType + __count(_IIter __a, _IIter __b, + _IIter __c, _IIter d) const { - difference_type counter = 0; + _DifferenceType __counter = 0; - while (a != b && c != d) + while (__a != __b && __c != d) { - if (comp(*a, *c)) + if (__comp(*__a, *__c)) { - ++a; - ++counter; + ++__a; + ++__counter; } - else if (comp(*c, *a)) - { ++c; } + else if (__comp(*__c, *__a)) + { ++__c; } else - { ++a; ++c; } + { ++__a; ++__c; } } - return counter + (b - a); + return __counter + (__b - __a); } - inline OutputIterator - first_empty(InputIterator c, InputIterator d, OutputIterator out) const - { return out; } + inline _OutputIterator + __first_empty(_IIter __c, _IIter d, _OutputIterator __out) const + { return __out; } - inline OutputIterator - second_empty(InputIterator a, InputIterator b, OutputIterator out) const - { return std::copy(a, b, out); } + inline _OutputIterator + __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const + { return std::copy(__a, __b, __out); } }; -template - struct intersection_func +template + struct __intersection_func { - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; - typedef typename std::pair iterator_pair; + typedef std::iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; + typedef typename std::pair<_IIter, _IIter> _IteratorPair; - intersection_func(Comparator c) : comp(c) {} + __intersection_func(_Compare __c) : __comp(__c) {} - Comparator comp; + _Compare __comp; - OutputIterator - invoke(InputIterator a, InputIterator b, InputIterator c, InputIterator d, - OutputIterator r) const + _OutputIterator + _M_invoke(_IIter __a, _IIter __b, _IIter __c, _IIter d, + _OutputIterator __r) const { - while (a != b && c != d) + while (__a != __b && __c != d) { - if (comp(*a, *c)) - { ++a; } - else if (comp(*c, *a)) - { ++c; } + if (__comp(*__a, *__c)) + { ++__a; } + else if (__comp(*__c, *__a)) + { ++__c; } else { - *r = *a; - ++a; - ++c; - ++r; + *__r = *__a; + ++__a; + ++__c; + ++__r; } } - return r; + return __r; } - difference_type - count(InputIterator a, InputIterator b, - InputIterator c, InputIterator d) const + _DifferenceType + __count(_IIter __a, _IIter __b, + _IIter __c, _IIter d) const { - difference_type counter = 0; + _DifferenceType __counter = 0; - while (a != b && c != d) + while (__a != __b && __c != d) { - if (comp(*a, *c)) - { ++a; } - else if (comp(*c, *a)) - { ++c; } + if (__comp(*__a, *__c)) + { ++__a; } + else if (__comp(*__c, *__a)) + { ++__c; } else { - ++a; - ++c; - ++counter; + ++__a; + ++__c; + ++__counter; } } - return counter; + return __counter; } - inline OutputIterator - first_empty(InputIterator c, InputIterator d, OutputIterator out) const - { return out; } + inline _OutputIterator + __first_empty(_IIter __c, _IIter d, _OutputIterator __out) const + { return __out; } - inline OutputIterator - second_empty(InputIterator a, InputIterator b, OutputIterator out) const - { return out; } + inline _OutputIterator + __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const + { return __out; } }; -template - struct union_func +template + struct __union_func { - typedef typename std::iterator_traits::difference_type - difference_type; + typedef typename std::iterator_traits<_IIter>::difference_type + _DifferenceType; - union_func(Comparator c) : comp(c) {} + __union_func(_Compare __c) : __comp(__c) {} - Comparator comp; + _Compare __comp; - OutputIterator - invoke(InputIterator a, const InputIterator b, InputIterator c, - const InputIterator d, OutputIterator r) const + _OutputIterator + _M_invoke(_IIter __a, const _IIter __b, _IIter __c, + const _IIter d, _OutputIterator __r) const { - while (a != b && c != d) + while (__a != __b && __c != d) { - if (comp(*a, *c)) + if (__comp(*__a, *__c)) { - *r = *a; - ++a; + *__r = *__a; + ++__a; } - else if (comp(*c, *a)) + else if (__comp(*__c, *__a)) { - *r = *c; - ++c; + *__r = *__c; + ++__c; } else { - *r = *a; - ++a; - ++c; + *__r = *__a; + ++__a; + ++__c; } - ++r; + ++__r; } - return std::copy(c, d, std::copy(a, b, r)); + return std::copy(__c, d, std::copy(__a, __b, __r)); } - difference_type - count(InputIterator a, InputIterator b, - InputIterator c, InputIterator d) const + _DifferenceType + __count(_IIter __a, _IIter __b, + _IIter __c, _IIter d) const { - difference_type counter = 0; + _DifferenceType __counter = 0; - while (a != b && c != d) + while (__a != __b && __c != d) { - if (comp(*a, *c)) - { ++a; } - else if (comp(*c, *a)) - { ++c; } + if (__comp(*__a, *__c)) + { ++__a; } + else if (__comp(*__c, *__a)) + { ++__c; } else { - ++a; - ++c; + ++__a; + ++__c; } - ++counter; + ++__counter; } - counter += (b - a); - counter += (d - c); - return counter; + __counter += (__b - __a); + __counter += (d - __c); + return __counter; } - inline OutputIterator - first_empty(InputIterator c, InputIterator d, OutputIterator out) const - { return std::copy(c, d, out); } + inline _OutputIterator + __first_empty(_IIter __c, _IIter d, _OutputIterator __out) const + { return std::copy(__c, d, __out); } - inline OutputIterator - second_empty(InputIterator a, InputIterator b, OutputIterator out) const - { return std::copy(a, b, out); } + inline _OutputIterator + __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const + { return std::copy(__a, __b, __out); } }; -template - OutputIterator - parallel_set_operation(InputIterator begin1, InputIterator end1, - InputIterator begin2, InputIterator end2, - OutputIterator result, Operation op) + _OutputIterator + __parallel_set_operation(_IIter __begin1, _IIter __end1, + _IIter __begin2, _IIter __end2, + _OutputIterator __result, Operation __op) { - _GLIBCXX_CALL((end1 - begin1) + (end2 - begin2)) + _GLIBCXX_CALL((__end1 - __begin1) + (__end2 - __begin2)) - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; - typedef typename std::pair iterator_pair; + typedef std::iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; + typedef typename std::pair<_IIter, _IIter> _IteratorPair; - if (begin1 == end1) - return op.first_empty(begin2, end2, result); + if (__begin1 == __end1) + return __op.__first_empty(__begin2, __end2, __result); - if (begin2 == end2) - return op.second_empty(begin1, end1, result); + if (__begin2 == __end2) + return __op.__second_empty(__begin1, __end1, __result); - const difference_type size = (end1 - begin1) + (end2 - begin2); + const _DifferenceType size = (__end1 - __begin1) + (__end2 - __begin2); - const iterator_pair sequence[ 2 ] = - { std::make_pair(begin1, end1), std::make_pair(begin2, end2) } ; - OutputIterator return_value = result; - difference_type *borders; - iterator_pair *block_begins; - difference_type* lengths; + const _IteratorPair __sequence[ 2 ] = + { std::make_pair(__begin1, __end1), std::make_pair(__begin2, __end2) } ; + _OutputIterator return_value = __result; + _DifferenceType *__borders; + _IteratorPair *__block_begins; + _DifferenceType* __lengths; - thread_index_t num_threads = - std::min(get_max_threads(), - std::min(end1 - begin1, end2 - begin2)); + _ThreadIndex __num_threads = + std::min<_DifferenceType>(__get_max_threads(), + std::min(__end1 - __begin1, __end2 - __begin2)); -# pragma omp parallel num_threads(num_threads) +# pragma omp parallel num_threads(__num_threads) { # pragma omp single { - num_threads = omp_get_num_threads(); - - borders = new difference_type[num_threads + 2]; - equally_split(size, num_threads + 1, borders); - block_begins = new iterator_pair[num_threads + 1]; - // Very start. - block_begins[0] = std::make_pair(begin1, begin2); - lengths = new difference_type[num_threads]; + __num_threads = omp_get_num_threads(); + + __borders = new _DifferenceType[__num_threads + 2]; + equally_split(size, __num_threads + 1, __borders); + __block_begins = new _IteratorPair[__num_threads + 1]; + // Very __start. + __block_begins[0] = std::make_pair(__begin1, __begin2); + __lengths = new _DifferenceType[__num_threads]; } //single - thread_index_t iam = omp_get_thread_num(); + _ThreadIndex __iam = omp_get_thread_num(); - // Result from multiseq_partition. - InputIterator offset[2]; - const difference_type rank = borders[iam + 1]; + // _Result from multiseq_partition. + _IIter __offset[2]; + const _DifferenceType __rank = __borders[__iam + 1]; - multiseq_partition(sequence, sequence + 2, rank, offset, op.comp); + multiseq_partition(__sequence, __sequence + 2, __rank, __offset, __op.__comp); // allowed to read? // together - // *(offset[ 0 ] - 1) == *offset[ 1 ] - if (offset[ 0 ] != begin1 && offset[ 1 ] != end2 - && !op.comp(*(offset[ 0 ] - 1), *offset[ 1 ]) - && !op.comp(*offset[ 1 ], *(offset[ 0 ] - 1))) + // *(__offset[ 0 ] - 1) == *__offset[ 1 ] + if (__offset[ 0 ] != __begin1 && __offset[ 1 ] != __end2 + && !__op.__comp(*(__offset[ 0 ] - 1), *__offset[ 1 ]) + && !__op.__comp(*__offset[ 1 ], *(__offset[ 0 ] - 1))) { // Avoid split between globally equal elements: move one to // front in first sequence. - --offset[ 0 ]; + --__offset[ 0 ]; } - iterator_pair block_end = block_begins[ iam + 1 ] = - iterator_pair(offset[ 0 ], offset[ 1 ]); + _IteratorPair block_end = __block_begins[ __iam + 1 ] = + _IteratorPair(__offset[ 0 ], __offset[ 1 ]); // Make sure all threads have their block_begin result written out. # pragma omp barrier - iterator_pair block_begin = block_begins[ iam ]; + _IteratorPair __block_begin = __block_begins[ __iam ]; // Begin working for the first block, while the others except // the last start to count. - if (iam == 0) + if (__iam == 0) { // The first thread can copy already. - lengths[ iam ] = op.invoke(block_begin.first, block_end.first, - block_begin.second, block_end.second, - result) - - result; + __lengths[ __iam ] = __op._M_invoke(__block_begin.first, block_end.first, + __block_begin.second, block_end.second, + __result) + - __result; } else { - lengths[ iam ] = op.count(block_begin.first, block_end.first, - block_begin.second, block_end.second); + __lengths[ __iam ] = __op.__count(__block_begin.first, block_end.first, + __block_begin.second, block_end.second); } // Make sure everyone wrote their lengths. # pragma omp barrier - OutputIterator r = result; + _OutputIterator __r = __result; - if (iam == 0) + if (__iam == 0) { // Do the last block. - for (int i = 0; i < num_threads; ++i) - r += lengths[i]; + for (int __i = 0; __i < __num_threads; ++__i) + __r += __lengths[__i]; - block_begin = block_begins[num_threads]; + __block_begin = __block_begins[__num_threads]; // Return the result iterator of the last block. - return_value = op.invoke( - block_begin.first, end1, block_begin.second, end2, r); + return_value = __op._M_invoke( + __block_begin.first, __end1, __block_begin.second, __end2, __r); } else { - for (int i = 0; i < iam; ++i) - r += lengths[ i ]; + for (int __i = 0; __i < __iam; ++__i) + __r += __lengths[ __i ]; // Reset begins for copy pass. - op.invoke(block_begin.first, block_end.first, - block_begin.second, block_end.second, r); + __op._M_invoke(__block_begin.first, block_end.first, + __block_begin.second, block_end.second, __r); } } return return_value; } -template - inline OutputIterator - parallel_set_union(InputIterator begin1, InputIterator end1, - InputIterator begin2, InputIterator end2, - OutputIterator result, Comparator comp) +template + inline _OutputIterator + __parallel_set_union(_IIter __begin1, _IIter __end1, + _IIter __begin2, _IIter __end2, + _OutputIterator __result, _Compare __comp) { - return parallel_set_operation(begin1, end1, begin2, end2, result, - union_func< InputIterator, OutputIterator, Comparator>(comp)); + return __parallel_set_operation(__begin1, __end1, __begin2, __end2, __result, + __union_func< _IIter, _OutputIterator, _Compare>(__comp)); } -template - inline OutputIterator - parallel_set_intersection(InputIterator begin1, InputIterator end1, - InputIterator begin2, InputIterator end2, - OutputIterator result, Comparator comp) +template + inline _OutputIterator + __parallel_set_intersection(_IIter __begin1, _IIter __end1, + _IIter __begin2, _IIter __end2, + _OutputIterator __result, _Compare __comp) { - return parallel_set_operation(begin1, end1, begin2, end2, result, - intersection_func(comp)); + return __parallel_set_operation(__begin1, __end1, __begin2, __end2, __result, + __intersection_func<_IIter, _OutputIterator, _Compare>(__comp)); } -template - inline OutputIterator - parallel_set_difference(InputIterator begin1, InputIterator end1, - InputIterator begin2, InputIterator end2, - OutputIterator result, Comparator comp) +template + inline _OutputIterator + __parallel_set_difference(_IIter __begin1, _IIter __end1, + _IIter __begin2, _IIter __end2, + _OutputIterator __result, _Compare __comp) { - return parallel_set_operation(begin1, end1, begin2, end2, result, - difference_func(comp)); + return __parallel_set_operation(__begin1, __end1, __begin2, __end2, __result, + __difference_func<_IIter, _OutputIterator, _Compare>(__comp)); } -template - inline OutputIterator - parallel_set_symmetric_difference(InputIterator begin1, InputIterator end1, - InputIterator begin2, InputIterator end2, - OutputIterator result, Comparator comp) +template + inline _OutputIterator + __parallel_set_symmetric_difference(_IIter __begin1, _IIter __end1, + _IIter __begin2, _IIter __end2, + _OutputIterator __result, _Compare __comp) { - return parallel_set_operation(begin1, end1, begin2, end2, result, - symmetric_difference_func - (comp)); + return __parallel_set_operation(__begin1, __end1, __begin2, __end2, __result, + symmetric_difference_func<_IIter, _OutputIterator, _Compare> + (__comp)); } } diff --git a/libstdc++-v3/include/parallel/settings.h b/libstdc++-v3/include/parallel/settings.h index e4873b4100b5..525bd9e64451 100644 --- a/libstdc++-v3/include/parallel/settings.h +++ b/libstdc++-v3/include/parallel/settings.h @@ -30,7 +30,7 @@ * @section parallelization_decision * The decision whether to run an algorithm in parallel. * - * There are several ways the user can switch on and off the parallel + * There are several ways the user can switch on and __off the parallel * execution of an algorithm, both at compile- and run-time. * * Only sequential execution can be forced at compile-time. This @@ -46,11 +46,11 @@ * * To force sequential execution of an algorithm ultimately at * compile-time, the user must add the tag - * __gnu_parallel::sequential_tag() to the end of the parameter list, +* gnu_parallel::sequential_tag() to the end of the parameter list, * e. g. * * \code - * std::sort(v.begin(), v.end(), __gnu_parallel::sequential_tag()); + * std::sort(__v.begin(), __v.end(), __gnu_parallel::sequential_tag()); * \endcode * * This is compatible with all overloaded algorithm variants. No @@ -60,18 +60,18 @@ * If the algorithm call is not forced to be executed sequentially * at compile-time, the decision is made at run-time. * The global variable __gnu_parallel::_Settings::algorithm_strategy - * is checked. It is a tristate variable corresponding to: + * is checked. _It is a tristate variable corresponding to: * * a. force_sequential, meaning the sequential algorithm is executed. - * b. force_parallel, meaning the parallel algorithm is executed. - * c. heuristic +* b. force_parallel, meaning the parallel algorithm is executed. +* c. heuristic * * For heuristic, the parallel algorithm implementation is called * only if the input size is sufficiently large. For most * algorithms, the input size is the (combined) length of the input - * sequence(s). The threshold can be set by the user, individually +* sequence(__s). The threshold can be set by the user, individually * for each algorithm. The according variables are called - * __gnu_parallel::_Settings::[algorithm]_minimal_n . +* gnu_parallel::_Settings::[algorithm]_minimal_n . * * For some of the algorithms, there are even more tuning options, * e. g. the ability to choose from multiple algorithm variants. See @@ -88,24 +88,24 @@ /** * @brief Determine at compile(?)-time if the parallel variant of an * algorithm should be called. - * @param c A condition that is convertible to bool that is overruled by + * @param __c A condition that is convertible to bool that is overruled by * __gnu_parallel::_Settings::algorithm_strategy. Usually a decision * based on the input size. */ -#define _GLIBCXX_PARALLEL_CONDITION(c) (__gnu_parallel::_Settings::get().algorithm_strategy != __gnu_parallel::force_sequential && ((__gnu_parallel::get_max_threads() > 1 && (c)) || __gnu_parallel::_Settings::get().algorithm_strategy == __gnu_parallel::force_parallel)) +#define _GLIBCXX_PARALLEL_CONDITION(__c) (__gnu_parallel::_Settings::get().algorithm_strategy != __gnu_parallel::force_sequential && ((__gnu_parallel::__get_max_threads() > 1 && (__c)) || __gnu_parallel::_Settings::get().algorithm_strategy == __gnu_parallel::force_parallel)) /* inline bool -parallel_condition(bool c) +parallel_condition(bool __c) { bool ret = false; - const _Settings& s = _Settings::get(); - if (s.algorithm_strategy != force_seqential) + const _Settings& __s = _Settings::get(); + if (__s.algorithm_strategy != force_seqential) { - if (s.algorithm_strategy == force_parallel) + if (__s.algorithm_strategy == force_parallel) ret = true; else - ret = get_max_threads() > 1 && c; + ret = __get_max_threads() > 1 && __c; } return ret; } @@ -131,49 +131,49 @@ namespace __gnu_parallel // Per-algorithm settings. /// Minimal input size for accumulate. - sequence_index_t accumulate_minimal_n; + _SequenceIndex accumulate_minimal_n; /// Minimal input size for adjacent_difference. unsigned int adjacent_difference_minimal_n; /// Minimal input size for count and count_if. - sequence_index_t count_minimal_n; + _SequenceIndex count_minimal_n; /// Minimal input size for fill. - sequence_index_t fill_minimal_n; + _SequenceIndex fill_minimal_n; /// Block size increase factor for find. double find_increasing_factor; /// Initial block size for find. - sequence_index_t find_initial_block_size; + _SequenceIndex find_initial_block_size; /// Maximal block size for find. - sequence_index_t find_maximum_block_size; + _SequenceIndex find_maximum_block_size; /// Start with looking for this many elements sequentially, for find. - sequence_index_t find_sequential_search_size; + _SequenceIndex find_sequential_search_size; /// Minimal input size for for_each. - sequence_index_t for_each_minimal_n; + _SequenceIndex for_each_minimal_n; /// Minimal input size for generate. - sequence_index_t generate_minimal_n; + _SequenceIndex generate_minimal_n; /// Minimal input size for max_element. - sequence_index_t max_element_minimal_n; + _SequenceIndex max_element_minimal_n; /// Minimal input size for merge. - sequence_index_t merge_minimal_n; + _SequenceIndex merge_minimal_n; /// Oversampling factor for merge. unsigned int merge_oversampling; /// Minimal input size for min_element. - sequence_index_t min_element_minimal_n; + _SequenceIndex min_element_minimal_n; /// Minimal input size for multiway_merge. - sequence_index_t multiway_merge_minimal_n; + _SequenceIndex multiway_merge_minimal_n; /// Oversampling factor for multiway_merge. int multiway_merge_minimal_k; @@ -182,22 +182,22 @@ namespace __gnu_parallel unsigned int multiway_merge_oversampling; /// Minimal input size for nth_element. - sequence_index_t nth_element_minimal_n; + _SequenceIndex nth_element_minimal_n; /// Chunk size for partition. - sequence_index_t partition_chunk_size; + _SequenceIndex partition_chunk_size; /// Chunk size for partition, relative to input size. If > 0.0, /// this value overrides partition_chunk_size. double partition_chunk_share; /// Minimal input size for partition. - sequence_index_t partition_minimal_n; + _SequenceIndex partition_minimal_n; /// Minimal input size for partial_sort. - sequence_index_t partial_sort_minimal_n; + _SequenceIndex partial_sort_minimal_n; - /// Ratio for partial_sum. Assume "sum and write result" to be + /// Ratio for partial_sum. Assume "sum and write __result" to be /// this factor slower than just "sum". float partial_sum_dilation; @@ -208,22 +208,22 @@ namespace __gnu_parallel unsigned int random_shuffle_minimal_n; /// Minimal input size for replace and replace_if. - sequence_index_t replace_minimal_n; + _SequenceIndex replace_minimal_n; /// Minimal input size for set_difference. - sequence_index_t set_difference_minimal_n; + _SequenceIndex set_difference_minimal_n; /// Minimal input size for set_intersection. - sequence_index_t set_intersection_minimal_n; + _SequenceIndex set_intersection_minimal_n; /// Minimal input size for set_symmetric_difference. - sequence_index_t set_symmetric_difference_minimal_n; + _SequenceIndex set_symmetric_difference_minimal_n; /// Minimal input size for set_union. - sequence_index_t set_union_minimal_n; + _SequenceIndex set_union_minimal_n; /// Minimal input size for parallel sorting. - sequence_index_t sort_minimal_n; + _SequenceIndex sort_minimal_n; /// Oversampling factor for parallel std::sort (MWMS). unsigned int sort_mwms_oversampling; @@ -231,38 +231,38 @@ namespace __gnu_parallel /// Such many samples to take to find a good pivot (quicksort). unsigned int sort_qs_num_samples_preset; - /// Maximal subsequence length to switch to unbalanced base case. + /// Maximal subsequence __length to switch to unbalanced __base case. /// Applies to std::sort with dynamically load-balanced quicksort. - sequence_index_t sort_qsb_base_case_maximal_n; + _SequenceIndex sort_qsb_base_case_maximal_n; /// Minimal input size for parallel std::transform. - sequence_index_t transform_minimal_n; + _SequenceIndex transform_minimal_n; /// Minimal input size for unique_copy. - sequence_index_t unique_copy_minimal_n; + _SequenceIndex unique_copy_minimal_n; - sequence_index_t workstealing_chunk_size; + _SequenceIndex workstealing_chunk_size; // Hardware dependent tuning parameters. - /// Size of the L1 cache in bytes (underestimation). + /// size of the L1 cache in bytes (underestimation). unsigned long long L1_cache_size; - /// Size of the L2 cache in bytes (underestimation). + /// size of the L2 cache in bytes (underestimation). unsigned long long L2_cache_size; - /// Size of the Translation Lookaside Buffer (underestimation). + /// size of the Translation Lookaside Buffer (underestimation). unsigned int TLB_size; /// Overestimation of cache line size. Used to avoid false - /// sharing, i. e. elements of different threads are at least this + /// sharing, i.e. elements of different threads are at least this /// amount apart. unsigned int cache_line_size; // Statistics. /// The number of stolen ranges in load-balanced quicksort. - sequence_index_t qsb_steals; + _SequenceIndex qsb_steals; /// Get the global settings. _GLIBCXX_CONST static const _Settings& diff --git a/libstdc++-v3/include/parallel/sort.h b/libstdc++-v3/include/parallel/sort.h index de226e8b418f..a34d773474d4 100644 --- a/libstdc++-v3/include/parallel/sort.h +++ b/libstdc++-v3/include/parallel/sort.h @@ -55,174 +55,174 @@ namespace __gnu_parallel { //prototype - template + template void - parallel_sort(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, Parallelism parallelism); + parallel_sort(_RAIter __begin, _RAIter __end, + _Compare __comp, _Parallelism __parallelism); /** * @brief Choose multiway mergesort, splitting variant at run-time, * for parallel sorting. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param comp Comparator. + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __comp Comparator. * @callgraph */ - template + template inline void - parallel_sort(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, multiway_mergesort_tag parallelism) + parallel_sort(_RAIter __begin, _RAIter __end, + _Compare __comp, multiway_mergesort_tag __parallelism) { - _GLIBCXX_CALL(end - begin) + _GLIBCXX_CALL(__end - __begin) if(_Settings::get().sort_splitting == EXACT) - parallel_sort_mwms - (begin, end, comp, parallelism.get_num_threads()); + parallel_sort_mwms<__stable, true> + (__begin, __end, __comp, __parallelism.__get_num_threads()); else - parallel_sort_mwms - (begin, end, comp, parallelism.get_num_threads()); + parallel_sort_mwms<__stable, false> + (__begin, __end, __comp, __parallelism.__get_num_threads()); } /** - * @brief Choose multiway mergesort with exact splitting, + * @brief Choose multiway mergesort with __exact splitting, * for parallel sorting. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param comp Comparator. + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __comp Comparator. * @callgraph */ - template + template inline void - parallel_sort(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, multiway_mergesort_exact_tag parallelism) + parallel_sort(_RAIter __begin, _RAIter __end, + _Compare __comp, multiway_mergesort_exact_tag __parallelism) { - _GLIBCXX_CALL(end - begin) + _GLIBCXX_CALL(__end - __begin) - parallel_sort_mwms - (begin, end, comp, parallelism.get_num_threads()); + parallel_sort_mwms<__stable, true> + (__begin, __end, __comp, __parallelism.__get_num_threads()); } /** * @brief Choose multiway mergesort with splitting by sampling, * for parallel sorting. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param comp Comparator. + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __comp Comparator. * @callgraph */ - template + template inline void - parallel_sort(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, multiway_mergesort_sampling_tag parallelism) + parallel_sort(_RAIter __begin, _RAIter __end, + _Compare __comp, multiway_mergesort_sampling_tag __parallelism) { - _GLIBCXX_CALL(end - begin) + _GLIBCXX_CALL(__end - __begin) - parallel_sort_mwms - (begin, end, comp, parallelism.get_num_threads()); + parallel_sort_mwms<__stable, false> + (__begin, __end, __comp, __parallelism.__get_num_threads()); } /** * @brief Choose quicksort for parallel sorting. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param comp Comparator. + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __comp Comparator. * @callgraph */ - template + template inline void - parallel_sort(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, quicksort_tag parallelism) + parallel_sort(_RAIter __begin, _RAIter __end, + _Compare __comp, quicksort_tag __parallelism) { - _GLIBCXX_CALL(end - begin) + _GLIBCXX_CALL(__end - __begin) - _GLIBCXX_PARALLEL_ASSERT(stable == false); + _GLIBCXX_PARALLEL_ASSERT(__stable == false); - parallel_sort_qs(begin, end, comp, parallelism.get_num_threads()); + __parallel_sort_qs(__begin, __end, __comp, __parallelism.__get_num_threads()); } /** * @brief Choose balanced quicksort for parallel sorting. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param comp Comparator. - * @param stable Sort stable. + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __comp Comparator. + * @param __stable Sort __stable. * @callgraph */ - template + template inline void - parallel_sort(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, balanced_quicksort_tag parallelism) + parallel_sort(_RAIter __begin, _RAIter __end, + _Compare __comp, balanced_quicksort_tag __parallelism) { - _GLIBCXX_CALL(end - begin) + _GLIBCXX_CALL(__end - __begin) - _GLIBCXX_PARALLEL_ASSERT(stable == false); + _GLIBCXX_PARALLEL_ASSERT(__stable == false); - parallel_sort_qsb(begin, end, comp, parallelism.get_num_threads()); + __parallel_sort_qsb(__begin, __end, __comp, __parallelism.__get_num_threads()); } /** - * @brief Choose multiway mergesort with exact splitting, + * @brief Choose multiway mergesort with __exact splitting, * for parallel sorting. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param comp Comparator. + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __comp Comparator. * @callgraph */ - template + template inline void - parallel_sort(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, default_parallel_tag parallelism) + parallel_sort(_RAIter __begin, _RAIter __end, + _Compare __comp, default_parallel_tag __parallelism) { - _GLIBCXX_CALL(end - begin) + _GLIBCXX_CALL(__end - __begin) - parallel_sort - (begin, end, comp, - multiway_mergesort_exact_tag(parallelism.get_num_threads())); + parallel_sort<__stable> + (__begin, __end, __comp, + multiway_mergesort_exact_tag(__parallelism.__get_num_threads())); } /** * @brief Choose a parallel sorting algorithm. - * @param begin Begin iterator of input sequence. - * @param end End iterator of input sequence. - * @param comp Comparator. - * @param stable Sort stable. + * @param __begin Begin iterator of input sequence. + * @param __end End iterator of input sequence. + * @param __comp Comparator. + * @param __stable Sort __stable. * @callgraph */ - template + template inline void - parallel_sort(RandomAccessIterator begin, RandomAccessIterator end, - Comparator comp, parallel_tag parallelism) + parallel_sort(_RAIter __begin, _RAIter __end, + _Compare __comp, parallel_tag __parallelism) { - _GLIBCXX_CALL(end - begin) - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + _GLIBCXX_CALL(__end - __begin) + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; if (false) ; #if _GLIBCXX_MERGESORT - else if (stable || _Settings::get().sort_algorithm == MWMS) + else if (__stable || _Settings::get().sort_algorithm == MWMS) { if(_Settings::get().sort_splitting == EXACT) - parallel_sort_mwms - (begin, end, comp, parallelism.get_num_threads()); + parallel_sort_mwms<__stable, true> + (__begin, __end, __comp, __parallelism.__get_num_threads()); else parallel_sort_mwms - (begin, end, comp, parallelism.get_num_threads()); + (__begin, __end, __comp, __parallelism.__get_num_threads()); } #endif #if _GLIBCXX_QUICKSORT else if (_Settings::get().sort_algorithm == QS) - parallel_sort_qs(begin, end, comp, parallelism.get_num_threads()); + __parallel_sort_qs(__begin, __end, __comp, __parallelism.__get_num_threads()); #endif #if _GLIBCXX_BAL_QUICKSORT else if (_Settings::get().sort_algorithm == QS_BALANCED) - parallel_sort_qsb(begin, end, comp, parallelism.get_num_threads()); + __parallel_sort_qsb(__begin, __end, __comp, __parallelism.__get_num_threads()); #endif else - __gnu_sequential::sort(begin, end, comp); + __gnu_sequential::sort(__begin, __end, __comp); } } // end namespace __gnu_parallel diff --git a/libstdc++-v3/include/parallel/tags.h b/libstdc++-v3/include/parallel/tags.h index bc1a7e5c6352..ae0c2027833d 100644 --- a/libstdc++-v3/include/parallel/tags.h +++ b/libstdc++-v3/include/parallel/tags.h @@ -46,37 +46,37 @@ namespace __gnu_parallel struct parallel_tag { private: - thread_index_t num_threads; + _ThreadIndex __num_threads; public: /** @brief Default constructor. Use default number of threads. */ parallel_tag() { - this->num_threads = 0; + this->__num_threads = 0; } /** @brief Default constructor. Recommend number of threads to use. - * @param num_threads Desired number of threads. */ - parallel_tag(thread_index_t num_threads) + * @param __num_threads Desired number of threads. */ + parallel_tag(_ThreadIndex __num_threads) { - this->num_threads = num_threads; + this->__num_threads = __num_threads; } - /** @brief Find out desired number of threads. + /** @brief Find __out desired number of threads. * @return Desired number of threads. */ - inline thread_index_t get_num_threads() + inline _ThreadIndex __get_num_threads() { - if(num_threads == 0) + if(__num_threads == 0) return omp_get_max_threads(); else - return num_threads; + return __num_threads; } /** @brief Set the desired number of threads. - * @param num_threads Desired number of threads. */ - inline void set_num_threads(thread_index_t num_threads) + * @param __num_threads Desired number of threads. */ + inline void set_num_threads(_ThreadIndex __num_threads) { - this->num_threads = num_threads; + this->__num_threads = __num_threads; } }; @@ -85,8 +85,8 @@ namespace __gnu_parallel struct default_parallel_tag : public parallel_tag { default_parallel_tag() { } - default_parallel_tag(thread_index_t num_threads) - : parallel_tag(num_threads) { } + default_parallel_tag(_ThreadIndex __num_threads) + : parallel_tag(__num_threads) { } }; /** @brief Recommends parallel execution using dynamic @@ -111,21 +111,21 @@ namespace __gnu_parallel /** @brief Forces parallel merging - * with exact splitting, at compile time. */ + * with __exact splitting, at compile time. */ struct exact_tag : public parallel_tag { exact_tag() { } - exact_tag(thread_index_t num_threads) - : parallel_tag(num_threads) { } + exact_tag(_ThreadIndex __num_threads) + : parallel_tag(__num_threads) { } }; /** @brief Forces parallel merging - * with exact splitting, at compile time. */ + * with __exact splitting, at compile time. */ struct sampling_tag : public parallel_tag { sampling_tag() { } - sampling_tag(thread_index_t num_threads) - : parallel_tag(num_threads) { } + sampling_tag(_ThreadIndex __num_threads) + : parallel_tag(__num_threads) { } }; @@ -134,17 +134,17 @@ namespace __gnu_parallel struct multiway_mergesort_tag : public parallel_tag { multiway_mergesort_tag() { } - multiway_mergesort_tag(thread_index_t num_threads) - : parallel_tag(num_threads) { } + multiway_mergesort_tag(_ThreadIndex __num_threads) + : parallel_tag(__num_threads) { } }; /** @brief Forces parallel sorting using multiway mergesort - * with exact splitting at compile time. */ + * with __exact splitting at compile time. */ struct multiway_mergesort_exact_tag : public parallel_tag { multiway_mergesort_exact_tag() { } - multiway_mergesort_exact_tag(thread_index_t num_threads) - : parallel_tag(num_threads) { } + multiway_mergesort_exact_tag(_ThreadIndex __num_threads) + : parallel_tag(__num_threads) { } }; /** @brief Forces parallel sorting using multiway mergesort @@ -152,8 +152,8 @@ namespace __gnu_parallel struct multiway_mergesort_sampling_tag : public parallel_tag { multiway_mergesort_sampling_tag() { } - multiway_mergesort_sampling_tag(thread_index_t num_threads) - : parallel_tag(num_threads) { } + multiway_mergesort_sampling_tag(_ThreadIndex __num_threads) + : parallel_tag(__num_threads) { } }; /** @brief Forces parallel sorting using unbalanced quicksort @@ -161,8 +161,8 @@ namespace __gnu_parallel struct quicksort_tag : public parallel_tag { quicksort_tag() { } - quicksort_tag(thread_index_t num_threads) - : parallel_tag(num_threads) { } + quicksort_tag(_ThreadIndex __num_threads) + : parallel_tag(__num_threads) { } }; /** @brief Forces parallel sorting using balanced quicksort @@ -170,8 +170,8 @@ namespace __gnu_parallel struct balanced_quicksort_tag : public parallel_tag { balanced_quicksort_tag() { } - balanced_quicksort_tag(thread_index_t num_threads) - : parallel_tag(num_threads) { } + balanced_quicksort_tag(_ThreadIndex __num_threads) + : parallel_tag(__num_threads) { } }; diff --git a/libstdc++-v3/include/parallel/types.h b/libstdc++-v3/include/parallel/types.h index 053dfff159b5..70bfb64120a2 100644 --- a/libstdc++-v3/include/parallel/types.h +++ b/libstdc++-v3/include/parallel/types.h @@ -79,7 +79,7 @@ namespace __gnu_parallel }; /// Merging algorithms: - // bubblesort-alike, loser-tree variants, enum sentinel. + // bubblesort-alike, loser-tree variants, enum __sentinel. enum _MultiwayMergeAlgorithm { LOSER_TREE @@ -92,7 +92,7 @@ namespace __gnu_parallel LINEAR }; - /// Sorting/merging algorithms: sampling, exact. + /// Sorting/merging algorithms: sampling, __exact. enum _SplittingAlgorithm { SAMPLING, @@ -108,7 +108,7 @@ namespace __gnu_parallel EQUAL_SPLIT }; - /// Integer Types. + /// _Integer Types. // XXX need to use /** @brief 16-bit signed integer. */ typedef short int16; @@ -129,27 +129,27 @@ namespace __gnu_parallel typedef unsigned long long uint64; /** - * @brief Unsigned integer to index elements. + * @brief Unsigned integer to index __elements. * The total number of elements for each algorithm must fit into this type. */ - typedef uint64 sequence_index_t; + typedef uint64 _SequenceIndex; /** * @brief Unsigned integer to index a thread number. * The maximum thread number (for each processor) must fit into this type. */ - typedef uint16 thread_index_t; + typedef uint16 _ThreadIndex; // XXX atomics interface? /// Longest compare-and-swappable integer type on this platform. - typedef int64 lcas_t; + typedef int64 _CASable; // XXX numeric_limits::digits? - /// Number of bits of ::lcas_t. - static const int lcas_t_bits = sizeof(lcas_t) * 8; + /// Number of bits of ::_CASable. + static const int _CASable_bits = sizeof(_CASable) * 8; - /// ::lcas_t with the right half of bits set to 1. - static const lcas_t lcas_t_mask = ((lcas_t(1) << (lcas_t_bits / 2)) - 1); + /// ::_CASable with the right half of bits set to 1. + static const _CASable _CASable_mask = ((_CASable(1) << (_CASable_bits / 2)) - 1); } #endif /* _GLIBCXX_PARALLEL_TYPES_H */ diff --git a/libstdc++-v3/include/parallel/unique_copy.h b/libstdc++-v3/include/parallel/unique_copy.h index a83c2c0c5048..db2e820a7083 100644 --- a/libstdc++-v3/include/parallel/unique_copy.h +++ b/libstdc++-v3/include/parallel/unique_copy.h @@ -38,153 +38,153 @@ namespace __gnu_parallel { -/** @brief Parallel std::unique_copy(), w/o explicit equality predicate. - * @param first Begin iterator of input sequence. - * @param last End iterator of input sequence. - * @param result Begin iterator of result sequence. - * @param binary_pred Equality predicate. - * @return End iterator of result sequence. */ -template - OutputIterator - parallel_unique_copy(InputIterator first, InputIterator last, - OutputIterator result, BinaryPredicate binary_pred) +/** @brief Parallel std::unique_copy(), w/__o explicit equality predicate. + * @param __first Begin iterator of input sequence. + * @param __last End iterator of input sequence. + * @param __result Begin iterator of result __sequence. + * @param __binary_pred Equality predicate. + * @return End iterator of result __sequence. */ +template + _OutputIterator + __parallel_unique_copy(_IIter __first, _IIter __last, + _OutputIterator __result, _BinaryPredicate __binary_pred) { - _GLIBCXX_CALL(last - first) + _GLIBCXX_CALL(__last - __first) - typedef std::iterator_traits traits_type; - typedef typename traits_type::value_type value_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_IIter> _TraitsType; + typedef typename _TraitsType::value_type _ValueType; + typedef typename _TraitsType::difference_type _DifferenceType; - difference_type size = last - first; + _DifferenceType size = __last - __first; if (size == 0) - return result; + return __result; // Let the first thread process two parts. - difference_type *counter; - difference_type *borders; + _DifferenceType *__counter; + _DifferenceType *__borders; - thread_index_t num_threads = get_max_threads(); + _ThreadIndex __num_threads = __get_max_threads(); // First part contains at least one element. -# pragma omp parallel num_threads(num_threads) +# pragma omp parallel num_threads(__num_threads) { # pragma omp single { - num_threads = omp_get_num_threads(); - borders = new difference_type[num_threads + 2]; - equally_split(size, num_threads + 1, borders); - counter = new difference_type[num_threads + 1]; + __num_threads = omp_get_num_threads(); + __borders = new _DifferenceType[__num_threads + 2]; + equally_split(size, __num_threads + 1, __borders); + __counter = new _DifferenceType[__num_threads + 1]; } - thread_index_t iam = omp_get_thread_num(); + _ThreadIndex __iam = omp_get_thread_num(); - difference_type begin, end; + _DifferenceType __begin, __end; // Check for length without duplicates // Needed for position in output - difference_type i = 0; - OutputIterator out = result; + _DifferenceType __i = 0; + _OutputIterator __out = __result; - if (iam == 0) + if (__iam == 0) { - begin = borders[0] + 1; // == 1 - end = borders[iam + 1]; + __begin = __borders[0] + 1; // == 1 + __end = __borders[__iam + 1]; - ++i; - *out++ = *first; + ++__i; + *__out++ = *__first; - for (InputIterator iter = first + begin; iter < first + end; ++iter) + for (_IIter iter = __first + __begin; iter < __first + __end; ++iter) { - if (!binary_pred(*iter, *(iter-1))) + if (!__binary_pred(*iter, *(iter-1))) { - ++i; - *out++ = *iter; + ++__i; + *__out++ = *iter; } } } else { - begin = borders[iam]; //one part - end = borders[iam + 1]; + __begin = __borders[__iam]; //one part + __end = __borders[__iam + 1]; - for (InputIterator iter = first + begin; iter < first + end; ++iter) + for (_IIter iter = __first + __begin; iter < __first + __end; ++iter) { - if (!binary_pred(*iter, *(iter - 1))) - ++i; + if (!__binary_pred(*iter, *(iter - 1))) + ++__i; } } - counter[iam] = i; + __counter[__iam] = __i; // Last part still untouched. - difference_type begin_output; + _DifferenceType __begin_output; # pragma omp barrier // Store result in output on calculated positions. - begin_output = 0; + __begin_output = 0; - if (iam == 0) + if (__iam == 0) { - for (int t = 0; t < num_threads; ++t) - begin_output += counter[t]; + for (int __t = 0; __t < __num_threads; ++__t) + __begin_output += __counter[__t]; - i = 0; + __i = 0; - OutputIterator iter_out = result + begin_output; + _OutputIterator __iter_out = __result + __begin_output; - begin = borders[num_threads]; - end = size; + __begin = __borders[__num_threads]; + __end = size; - for (InputIterator iter = first + begin; iter < first + end; ++iter) + for (_IIter iter = __first + __begin; iter < __first + __end; ++iter) { - if (iter == first || !binary_pred(*iter, *(iter - 1))) + if (iter == __first || !__binary_pred(*iter, *(iter - 1))) { - ++i; - *iter_out++ = *iter; + ++__i; + *__iter_out++ = *iter; } } - counter[num_threads] = i; + __counter[__num_threads] = __i; } else { - for (int t = 0; t < iam; t++) - begin_output += counter[t]; + for (int __t = 0; __t < __iam; __t++) + __begin_output += __counter[__t]; - OutputIterator iter_out = result + begin_output; - for (InputIterator iter = first + begin; iter < first + end; ++iter) + _OutputIterator __iter_out = __result + __begin_output; + for (_IIter iter = __first + __begin; iter < __first + __end; ++iter) { - if (!binary_pred(*iter, *(iter-1))) - *iter_out++ = *iter; + if (!__binary_pred(*iter, *(iter-1))) + *__iter_out++ = *iter; } } } - difference_type end_output = 0; - for (int t = 0; t < num_threads + 1; t++) - end_output += counter[t]; + _DifferenceType __end_output = 0; + for (int __t = 0; __t < __num_threads + 1; __t++) + __end_output += __counter[__t]; - delete[] borders; + delete[] __borders; - return result + end_output; + return __result + __end_output; } /** @brief Parallel std::unique_copy(), without explicit equality predicate - * @param first Begin iterator of input sequence. - * @param last End iterator of input sequence. - * @param result Begin iterator of result sequence. - * @return End iterator of result sequence. */ -template - inline OutputIterator - parallel_unique_copy(InputIterator first, InputIterator last, - OutputIterator result) + * @param __first Begin iterator of input sequence. + * @param __last End iterator of input sequence. + * @param __result Begin iterator of result __sequence. + * @return End iterator of result __sequence. */ +template + inline _OutputIterator + __parallel_unique_copy(_IIter __first, _IIter __last, + _OutputIterator __result) { - typedef typename std::iterator_traits::value_type - value_type; - return parallel_unique_copy(first, last, result, - std::equal_to()); + typedef typename std::iterator_traits<_IIter>::value_type + _ValueType; + return __parallel_unique_copy(__first, __last, __result, + std::equal_to<_ValueType>()); } }//namespace __gnu_parallel diff --git a/libstdc++-v3/include/parallel/workstealing.h b/libstdc++-v3/include/parallel/workstealing.h index b82fe7cef987..a43c261ebc3c 100644 --- a/libstdc++-v3/include/parallel/workstealing.h +++ b/libstdc++-v3/include/parallel/workstealing.h @@ -49,257 +49,257 @@ namespace __gnu_parallel #define _GLIBCXX_JOB_VOLATILE volatile -/** @brief One job for a certain thread. */ +/** @brief One __job for a certain thread. */ template - struct Job + struct _Job { - typedef _DifferenceTp difference_type; + typedef _DifferenceTp _DifferenceType; /** @brief First element. * * Changed by owning and stealing thread. By stealing thread, * always incremented. */ - _GLIBCXX_JOB_VOLATILE difference_type first; + _GLIBCXX_JOB_VOLATILE _DifferenceType __first; /** @brief Last element. * * Changed by owning thread only. */ - _GLIBCXX_JOB_VOLATILE difference_type last; + _GLIBCXX_JOB_VOLATILE _DifferenceType __last; - /** @brief Number of elements, i. e. @c last-first+1. + /** @brief Number of elements, i.e. @__c __last-__first+1. * * Changed by owning thread only. */ - _GLIBCXX_JOB_VOLATILE difference_type load; + _GLIBCXX_JOB_VOLATILE _DifferenceType __load; }; /** @brief Work stealing algorithm for random access iterators. * - * Uses O(1) additional memory. Synchronization at job lists is + * Uses O(1) additional memory. Synchronization at __job lists is * done with atomic operations. - * @param begin Begin iterator of element sequence. - * @param end End iterator of element sequence. - * @param op User-supplied functor (comparator, predicate, adding + * @param __begin Begin iterator of element __sequence. + * @param __end End iterator of element __sequence. + * @param __op User-supplied functor (comparator, predicate, adding * functor, ...). - * @param f Functor to "process" an element with op (depends on + * @param __f Functor to "process" an element with __op (depends on * desired functionality, e. g. for std::for_each(), ...). - * @param r Functor to "add" a single result to the already - * processed elements (depends on functionality). - * @param base Base value for reduction. - * @param output Pointer to position where final result is written to - * @param bound Maximum number of elements processed (e. g. for + * @param __r Functor to "add" a single __result to the already + * processed __elements (depends on functionality). + * @param __base Base value for reduction. + * @param __output Pointer to position where final result is written to + * @param __bound Maximum number of elements processed (e. g. for * std::count_n()). * @return User-supplied functor (that may contain a part of the result). */ -template - Op - for_each_template_random_access_workstealing(RandomAccessIterator begin, - RandomAccessIterator end, - Op op, Fu& f, Red r, - Result base, Result& output, +template + _Op + for_each_template_random_access_workstealing(_RAIter __begin, + _RAIter __end, + _Op __op, _Fu& __f, _Red __r, + _Result __base, _Result& __output, typename std::iterator_traits - :: - difference_type bound) + <_RAIter>:: + difference_type __bound) { - _GLIBCXX_CALL(end - begin) + _GLIBCXX_CALL(__end - __begin) - typedef std::iterator_traits traits_type; - typedef typename traits_type::difference_type difference_type; + typedef std::iterator_traits<_RAIter> _TraitsType; + typedef typename _TraitsType::difference_type _DifferenceType; const _Settings& __s = _Settings::get(); - difference_type chunk_size = static_cast(__s.workstealing_chunk_size); + _DifferenceType __chunk_size = static_cast<_DifferenceType>(__s.workstealing_chunk_size); // How many jobs? - difference_type length = (bound < 0) ? (end - begin) : bound; + _DifferenceType __length = (__bound < 0) ? (__end - __begin) : __bound; // To avoid false sharing in a cache line. - const int stride = __s.cache_line_size * 10 / sizeof(Job) + 1; + const int __stride = __s.cache_line_size * 10 / sizeof(_Job<_DifferenceType>) + 1; // Total number of threads currently working. - thread_index_t busy = 0; + _ThreadIndex __busy = 0; - Job *job; + _Job<_DifferenceType> *__job; - omp_lock_t output_lock; - omp_init_lock(&output_lock); + omp_lock_t __output_lock; + omp_init_lock(&__output_lock); - // Write base value to output. - output = base; + // Write __base __value to output. + __output = __base; // No more threads than jobs, at least one thread. - thread_index_t num_threads = - __gnu_parallel::max(1, - __gnu_parallel::min(length, get_max_threads())); + _ThreadIndex __num_threads = + __gnu_parallel::max<_ThreadIndex>(1, + __gnu_parallel::min<_DifferenceType>(__length, __get_max_threads())); -# pragma omp parallel shared(busy) num_threads(num_threads) +# pragma omp parallel shared(__busy) num_threads(__num_threads) { # pragma omp single { - num_threads = omp_get_num_threads(); + __num_threads = omp_get_num_threads(); - // Create job description array. - job = new Job[num_threads * stride]; + // Create __job description array. + __job = new _Job<_DifferenceType>[__num_threads * __stride]; } // Initialization phase. // Flags for every thread if it is doing productive work. - bool iam_working = false; + bool __iam_working = false; // Thread id. - thread_index_t iam = omp_get_thread_num(); + _ThreadIndex __iam = omp_get_thread_num(); - // This job. - Job& my_job = job[iam * stride]; + // This __job. + _Job<_DifferenceType>& __my_job = __job[__iam * __stride]; // Random number (for work stealing). - thread_index_t victim; + _ThreadIndex __victim; // Local value for reduction. - Result result = Result(); + _Result __result = _Result(); // Number of elements to steal in one attempt. - difference_type steal; + _DifferenceType __steal; // Every thread has its own random number generator - // (modulo num_threads). - random_number rand_gen(iam, num_threads); + // (modulo __num_threads). + _RandomNumber rand_gen(__iam, __num_threads); // This thread is currently working. # pragma omp atomic - ++busy; + ++__busy; - iam_working = true; + __iam_working = true; // How many jobs per thread? last thread gets the rest. - my_job.first = - static_cast(iam * (length / num_threads)); + __my_job.__first = + static_cast<_DifferenceType>(__iam * (__length / __num_threads)); - my_job.last = (iam == (num_threads - 1)) ? - (length - 1) : ((iam + 1) * (length / num_threads) - 1); - my_job.load = my_job.last - my_job.first + 1; + __my_job.__last = (__iam == (__num_threads - 1)) ? + (__length - 1) : ((__iam + 1) * (__length / __num_threads) - 1); + __my_job.__load = __my_job.__last - __my_job.__first + 1; - // Init result with first value (to have a base value for reduction). - if (my_job.first <= my_job.last) + // Init __result with __first __value (to have a base value for reduction). + if (__my_job.__first <= __my_job.__last) { // Cannot use volatile variable directly. - difference_type my_first = my_job.first; - result = f(op, begin + my_first); - ++my_job.first; - --my_job.load; + _DifferenceType __my_first = __my_job.__first; + __result = __f(__op, __begin + __my_first); + ++__my_job.__first; + --__my_job.__load; } - RandomAccessIterator current; + _RAIter __current; # pragma omp barrier // Actual work phase - // Work on own or stolen start - while (busy > 0) + // Work on own or stolen __start + while (__busy > 0) { - // Work until no productive thread left. -# pragma omp flush(busy) + // Work until no productive thread __left. +# pragma omp flush(__busy) // Thread has own work to do - while (my_job.first <= my_job.last) + while (__my_job.__first <= __my_job.__last) { // fetch-and-add call - // Reserve current job block (size chunk_size) in my queue. - difference_type current_job = - fetch_and_add(&(my_job.first), chunk_size); - - // Update load, to make the three values consistent, - // first might have been changed in the meantime - my_job.load = my_job.last - my_job.first + 1; - for (difference_type job_counter = 0; - job_counter < chunk_size && current_job <= my_job.last; + // Reserve __current __job block (size __chunk_size) in my queue. + _DifferenceType current_job = + __fetch_and_add<_DifferenceType>(&(__my_job.__first), __chunk_size); + + // Update __load, to make the three values consistent, + // __first might have been changed in the meantime + __my_job.__load = __my_job.__last - __my_job.__first + 1; + for (_DifferenceType job_counter = 0; + job_counter < __chunk_size && current_job <= __my_job.__last; ++job_counter) { // Yes: process it! - current = begin + current_job; + __current = __begin + current_job; ++current_job; // Do actual work. - result = r(result, f(op, current)); + __result = __r(__result, __f(__op, __current)); } -# pragma omp flush(busy) +# pragma omp flush(__busy) } - // After reaching this point, a thread's job list is empty. - if (iam_working) + // After reaching this point, a thread's __job list is empty. + if (__iam_working) { // This thread no longer has work. # pragma omp atomic - --busy; + --__busy; - iam_working = false; + __iam_working = false; } - difference_type supposed_first, supposed_last, supposed_load; + _DifferenceType __supposed_first, __supposed_last, __supposed_load; do { // Find random nonempty deque (not own), do consistency check. - yield(); -# pragma omp flush(busy) - victim = rand_gen(); - supposed_first = job[victim * stride].first; - supposed_last = job[victim * stride].last; - supposed_load = job[victim * stride].load; + __yield(); +# pragma omp flush(__busy) + __victim = rand_gen(); + __supposed_first = __job[__victim * __stride].__first; + __supposed_last = __job[__victim * __stride].__last; + __supposed_load = __job[__victim * __stride].__load; } - while (busy > 0 - && ((supposed_load <= 0) - || ((supposed_first + supposed_load - 1) != supposed_last))); + while (__busy > 0 + && ((__supposed_load <= 0) + || ((__supposed_first + __supposed_load - 1) != __supposed_last))); - if (busy == 0) + if (__busy == 0) break; - if (supposed_load > 0) + if (__supposed_load > 0) { // Has work and work to do. // Number of elements to steal (at least one). - steal = (supposed_load < 2) ? 1 : supposed_load / 2; + __steal = (__supposed_load < 2) ? 1 : __supposed_load / 2; - // Push victim's start forward. - difference_type stolen_first = - fetch_and_add( - &(job[victim * stride].first), steal); - difference_type stolen_try = - stolen_first + steal - difference_type(1); + // Push __victim's __start forward. + _DifferenceType __stolen_first = + __fetch_and_add<_DifferenceType>( + &(__job[__victim * __stride].__first), __steal); + _DifferenceType stolen_try = + __stolen_first + __steal - _DifferenceType(1); - my_job.first = stolen_first; - my_job.last = __gnu_parallel::min(stolen_try, supposed_last); - my_job.load = my_job.last - my_job.first + 1; + __my_job.__first = __stolen_first; + __my_job.__last = __gnu_parallel::min(stolen_try, __supposed_last); + __my_job.__load = __my_job.__last - __my_job.__first + 1; // Has potential work again. # pragma omp atomic - ++busy; - iam_working = true; + ++__busy; + __iam_working = true; -# pragma omp flush(busy) +# pragma omp flush(__busy) } -# pragma omp flush(busy) - } // end while busy > 0 - // Add accumulated result to output. - omp_set_lock(&output_lock); - output = r(output, result); - omp_unset_lock(&output_lock); +# pragma omp flush(__busy) + } // end while __busy > 0 + // Add accumulated __result to output. + omp_set_lock(&__output_lock); + __output = __r(__output, __result); + omp_unset_lock(&__output_lock); } - delete[] job; + delete[] __job; // Points to last element processed (needed as return value for // some algorithms like transform) - f.finish_iterator = begin + length; + __f.finish_iterator = __begin + __length; - omp_destroy_lock(&output_lock); + omp_destroy_lock(&__output_lock); - return op; + return __op; } } // end namespace -- 2.39.5