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