Skip to content

R
riscv-gcc-1
Commit 531898c3 by Paolo Carlini Committed by Paolo Carlini
Options

iterator.h: Reformat to 80 columns; adjust some inline specifiers. 

2008-01-09  Paolo Carlini  <pcarlini@suse.de>

	* include/parallel/iterator.h: Reformat to 80 columns; adjust some
	inline specifiers.
	* include/parallel/find_selectors.h: Likewise.
	* include/parallel/losertree.h: Likewise.
	* include/parallel/list_partition.h: Likewise.
	* include/parallel/for_each.h: Likewise.
	* include/parallel/multiseq_selection.h: Likewise.
	* include/parallel/algorithmfwd.h: Likewise.
	* include/parallel/for_each_selectors.h: Likewise.
	* include/parallel/balanced_quicksort.h: Likewise.
	* include/parallel/merge.h: Likewise.
	* include/parallel/algobase.h: Likewise.
	* include/parallel/find.h: Likewise.
	* include/parallel/algo.h: Likewise.
	* include/parallel/checkers.h: Likewise.

From-SVN: r131431
parent c3e203cf
Showing with 1336 additions and 749 deletions
libstdc++-v3/ChangeLog
2008-01-09 Paolo Carlini <pcarlini@suse.de>
* include/parallel/iterator.h: Reformat to 80 columns; adjust some
inline specifiers.
* include/parallel/find_selectors.h: Likewise.
* include/parallel/losertree.h: Likewise.
* include/parallel/list_partition.h: Likewise.
* include/parallel/for_each.h: Likewise.
* include/parallel/multiseq_selection.h: Likewise.
* include/parallel/algorithmfwd.h: Likewise.
* include/parallel/for_each_selectors.h: Likewise.
* include/parallel/balanced_quicksort.h: Likewise.
* include/parallel/merge.h: Likewise.
* include/parallel/algobase.h: Likewise.
* include/parallel/find.h: Likewise.
* include/parallel/algo.h: Likewise.
* include/parallel/checkers.h: Likewise.
2008-01-09 Francesco Biscani <bluescarni@gmail.com>
* include/tr1_impl/hashtable (_Hashtable): Fix friend declaration
......
libstdc++-v3/include/parallel/algo.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -77,7 +77,7 @@ namespace __parallel
// Sequential fallback for input iterator case
template<typename InputIterator, typename Function, typename IteratorTag>
Function
inline Function
for_each_switch(InputIterator begin, InputIterator end, Function f,
IteratorTag)
{ return for_each(begin, end, f, __gnu_parallel::sequential_tag()); }
......@@ -90,11 +90,21 @@ namespace __parallel
__gnu_parallel::parallelism parallelism_tag
= __gnu_parallel::parallel_balanced)
{
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::for_each_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
for_each_minimal_n
&& __gnu_parallel::
is_parallel(parallelism_tag)))
{
bool dummy;
__gnu_parallel::for_each_selector<RandomAccessIterator> functionality;
return __gnu_parallel::for_each_template_random_access(begin, end, f, functionality, __gnu_parallel::dummy_reduct(), true, dummy, -1, parallelism_tag);
__gnu_parallel::for_each_selector<RandomAccessIterator>
functionality;
return __gnu_parallel::
for_each_template_random_access(begin, end, f, functionality,
__gnu_parallel::dummy_reduct(),
true, dummy, -1, parallelism_tag);
}
else
return for_each(begin, end, f, __gnu_parallel::sequential_tag());
......@@ -132,21 +142,26 @@ namespace __parallel
// Sequential fallback for input iterator case
template<typename InputIterator, typename T, typename IteratorTag>
inline InputIterator
find_switch(InputIterator begin, InputIterator end, const T& val, IteratorTag)
find_switch(InputIterator begin, InputIterator end, const T& val,
IteratorTag)
{ return _GLIBCXX_STD_P::find(begin, end, val); }
// Parallel find for random access iterators
template<typename RandomAccessIterator, typename T>
RandomAccessIterator
find_switch(RandomAccessIterator begin, RandomAccessIterator end, const T& val, random_access_iterator_tag)
find_switch(RandomAccessIterator begin, RandomAccessIterator end,
const T& val, random_access_iterator_tag)
{
typedef iterator_traits<RandomAccessIterator> traits_type;
typedef typename traits_type::value_type value_type;
if (_GLIBCXX_PARALLEL_CONDITION(true))
{
binder2nd<__gnu_parallel::equal_to<value_type, T> > comp(__gnu_parallel::equal_to<value_type, T>(), val);
return __gnu_parallel::find_template(begin, end, begin, comp, __gnu_parallel::find_if_selector()).first;
binder2nd<__gnu_parallel::equal_to<value_type, T> >
comp(__gnu_parallel::equal_to<value_type, T>(), val);
return __gnu_parallel::find_template(begin, end, begin, comp,
__gnu_parallel::
find_if_selector()).first;
}
else
return _GLIBCXX_STD_P::find(begin, end, val);
......@@ -184,7 +199,8 @@ namespace __parallel
{
if (_GLIBCXX_PARALLEL_CONDITION(true))
return __gnu_parallel::find_template(begin, end, begin, pred,
__gnu_parallel::find_if_selector()).first;
__gnu_parallel::
find_if_selector()).first;
else
return _GLIBCXX_STD_P::find_if(begin, end, pred);
}
......@@ -192,7 +208,7 @@ namespace __parallel
// Public interface
template<typename InputIterator, typename Predicate>
inline InputIterator
find_if (InputIterator begin, InputIterator end, Predicate pred)
find_if(InputIterator begin, InputIterator end, Predicate pred)
{
typedef std::iterator_traits<InputIterator> iterator_traits;
typedef typename iterator_traits::iterator_category iterator_category;
......@@ -217,41 +233,45 @@ namespace __parallel
{ return _GLIBCXX_STD_P::find_first_of(begin1, end1, begin2, end2, comp); }
// Sequential fallback for input iterator type
template<typename InputIterator, typename ForwardIterator, typename IteratorTag1, typename IteratorTag2>
template<typename InputIterator, typename ForwardIterator,
typename IteratorTag1, typename IteratorTag2>
inline InputIterator
find_first_of_switch(InputIterator begin1, InputIterator end1,
ForwardIterator begin2, ForwardIterator end2,
IteratorTag1, IteratorTag2)
{
return find_first_of(begin1, end1, begin2, end2,
__gnu_parallel::sequential_tag());
}
{ return find_first_of(begin1, end1, begin2, end2,
__gnu_parallel::sequential_tag()); }
// Parallel algorithm for random access iterators
template<typename RandomAccessIterator, typename ForwardIterator, typename BinaryPredicate, typename IteratorTag>
template<typename RandomAccessIterator, typename ForwardIterator,
typename BinaryPredicate, typename IteratorTag>
inline RandomAccessIterator
find_first_of_switch(RandomAccessIterator begin1, RandomAccessIterator end1,
find_first_of_switch(RandomAccessIterator begin1,
RandomAccessIterator 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<ForwardIterator>(begin2, end2)).first;
return __gnu_parallel::
find_template(begin1, end1, begin1, comp,
__gnu_parallel::find_first_of_selector
<ForwardIterator>(begin2, end2)).first;
}
// Sequential fallback for input iterator type
template<typename InputIterator, typename ForwardIterator, typename BinaryPredicate, typename IteratorTag1, typename IteratorTag2>
inline
InputIterator
template<typename InputIterator, typename ForwardIterator,
typename BinaryPredicate, typename IteratorTag1,
typename IteratorTag2>
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,
__gnu_parallel::sequential_tag());
}
{ return find_first_of(begin1, end1, begin2, end2, comp,
__gnu_parallel::sequential_tag()); }
// Public interface
template<typename InputIterator, typename ForwardIterator, typename BinaryPredicate>
template<typename InputIterator, typename ForwardIterator,
typename BinaryPredicate>
inline InputIterator
find_first_of(InputIterator begin1, InputIterator end1,
ForwardIterator begin2, ForwardIterator end2,
......@@ -268,7 +288,7 @@ namespace __parallel
// Public interface, insert default comparator
template<typename InputIterator, typename ForwardIterator>
InputIterator
inline InputIterator
find_first_of(InputIterator begin1, InputIterator end1,
ForwardIterator begin2, ForwardIterator end2)
{
......@@ -277,8 +297,8 @@ namespace __parallel
typedef typename iteratori_traits::value_type valuei_type;
typedef typename iteratorf_traits::value_type valuef_type;
return find_first_of(begin1, end1, begin2, end2,
__gnu_parallel::equal_to<valuei_type, valuef_type>());
return find_first_of(begin1, end1, begin2, end2, __gnu_parallel::
equal_to<valuei_type, valuef_type>());
}
// Sequential fallback
......@@ -289,14 +309,16 @@ namespace __parallel
{ return _GLIBCXX_STD_P::unique_copy(begin1, end1, out); }
// Sequential fallback
template<typename InputIterator, typename OutputIterator, typename Predicate>
template<typename InputIterator, typename OutputIterator,
typename Predicate>
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); }
// Sequential fallback for input iterator case
template<typename InputIterator, typename OutputIterator, typename Predicate, typename IteratorTag1, typename IteratorTag2>
template<typename InputIterator, typename OutputIterator,
typename Predicate, typename IteratorTag1, typename IteratorTag2>
inline OutputIterator
unique_copy_switch(InputIterator begin, InputIterator last,
OutputIterator out, Predicate pred,
......@@ -304,13 +326,17 @@ namespace __parallel
{ return _GLIBCXX_STD_P::unique_copy(begin, last, out, pred); }
// Parallel unique_copy for random access iterators
template<typename RandomAccessIterator, typename RandomAccessOutputIterator, typename Predicate>
template<typename RandomAccessIterator, typename RandomAccessOutputIterator,
typename Predicate>
RandomAccessOutputIterator
unique_copy_switch(RandomAccessIterator begin, RandomAccessIterator 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) > __gnu_parallel::Settings::unique_copy_minimal_n))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(last - begin)
> __gnu_parallel::Settings::
unique_copy_minimal_n))
return __gnu_parallel::parallel_unique_copy(begin, last, out, pred);
else
return _GLIBCXX_STD_P::unique_copy(begin, last, out, pred);
......@@ -347,7 +373,8 @@ namespace __parallel
}
// Sequential fallback
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator>
inline OutputIterator
set_union(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
......@@ -355,24 +382,27 @@ namespace __parallel
{ return _GLIBCXX_STD_P::set_union(begin1, end1, begin2, end2, out); }
// Sequential fallback
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Predicate>
inline OutputIterator
set_union(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
OutputIterator out, Predicate pred, __gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_P::set_union(begin1, end1, begin2, end2, out, pred); }
OutputIterator out, Predicate pred,
__gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_P::set_union(begin1, end1,
begin2, end2, out, pred); }
// Sequential fallback for input iterator case
template<typename InputIterator1, typename InputIterator2, typename Predicate,
typename OutputIterator, typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
template<typename InputIterator1, typename InputIterator2,
typename Predicate, typename OutputIterator,
typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
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);
}
{ return _GLIBCXX_STD_P::set_union(begin1, end1,
begin2, end2, result, pred); }
// Parallel set_union for random access iterators
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
......@@ -384,23 +414,35 @@ namespace __parallel
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) >= __gnu_parallel::Settings::set_union_minimal_n || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) >= __gnu_parallel::Settings::set_union_minimal_n))
return __gnu_parallel::parallel_set_union(begin1, end1, begin2, end2, result, pred);
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end1 - begin1)
>= __gnu_parallel::Settings::
set_union_minimal_n
|| static_cast<__gnu_parallel::
sequence_index_t>(end2 - begin2)
>= __gnu_parallel::Settings::
set_union_minimal_n))
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<typename InputIterator1, typename InputIterator2, typename OutputIterator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator>
inline OutputIterator
set_union(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
InputIterator2 end2, OutputIterator out)
set_union(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, OutputIterator out)
{
typedef std::iterator_traits<InputIterator1> iteratori1_traits;
typedef std::iterator_traits<InputIterator2> iteratori2_traits;
typedef std::iterator_traits<OutputIterator> iteratoro_traits;
typedef typename iteratori1_traits::iterator_category iteratori1_category;
typedef typename iteratori2_traits::iterator_category iteratori2_category;
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;
......@@ -412,16 +454,20 @@ namespace __parallel
}
// Public interface
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Predicate>
inline OutputIterator
set_union(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
InputIterator2 end2, OutputIterator out, Predicate pred)
set_union(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
OutputIterator out, Predicate pred)
{
typedef std::iterator_traits<InputIterator1> iteratori1_traits;
typedef std::iterator_traits<InputIterator2> iteratori2_traits;
typedef std::iterator_traits<OutputIterator> iteratoro_traits;
typedef typename iteratori1_traits::iterator_category iteratori1_category;
typedef typename iteratori2_traits::iterator_category iteratori2_category;
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,
......@@ -430,47 +476,61 @@ namespace __parallel
}
// Sequential fallback.
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator>
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);
}
{ return _GLIBCXX_STD_P::set_intersection(begin1, end1,
begin2, end2, out); }
// Sequential fallback.
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Predicate>
inline OutputIterator
set_intersection(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 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<typename InputIterator1, typename InputIterator2, typename Predicate,
typename OutputIterator, typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
template<typename InputIterator1, typename InputIterator2,
typename Predicate, typename OutputIterator,
typename IteratorTag1, typename IteratorTag2,
typename IteratorTag3>
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);
}
{ return _GLIBCXX_STD_P::set_intersection(begin1, end1, begin2,
end2, result, pred); }
// Parallel set_intersection for random access iterators
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename OutputRandomAccessIterator, typename Predicate>
OutputRandomAccessIterator
set_intersection_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, RandomAccessIterator2 end2, OutputRandomAccessIterator result, Predicate pred, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag)
set_intersection_switch(RandomAccessIterator1 begin1,
RandomAccessIterator1 end1,
RandomAccessIterator2 begin2,
RandomAccessIterator2 end2,
OutputRandomAccessIterator 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) >= __gnu_parallel::Settings::set_union_minimal_n || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) >= __gnu_parallel::Settings::set_union_minimal_n))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end1 - begin1)
>= __gnu_parallel::Settings::
set_union_minimal_n
|| static_cast<__gnu_parallel::
sequence_index_t>(end2 - begin2)
>= __gnu_parallel::Settings::
set_union_minimal_n))
return __gnu_parallel::parallel_set_intersection(begin1, end1, begin2,
end2, result, pred);
else
......@@ -479,7 +539,8 @@ namespace __parallel
}
// Public interface
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator>
inline OutputIterator
set_intersection(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
......@@ -488,32 +549,41 @@ namespace __parallel
typedef std::iterator_traits<InputIterator1> iteratori1_traits;
typedef std::iterator_traits<InputIterator2> iteratori2_traits;
typedef std::iterator_traits<OutputIterator> iteratoro_traits;
typedef typename iteratori1_traits::iterator_category iteratori1_category;
typedef typename iteratori2_traits::iterator_category iteratori2_category;
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,
__gnu_parallel::less<value1_type, value2_type>(),
iteratori1_category(), iteratori2_category(),
__gnu_parallel::
less<value1_type, value2_type>(),
iteratori1_category(),
iteratori2_category(),
iteratoro_category());
}
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Predicate>
inline OutputIterator
set_intersection(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
InputIterator2 end2, OutputIterator out, Predicate pred)
set_intersection(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
OutputIterator out, Predicate pred)
{
typedef std::iterator_traits<InputIterator1> iteratori1_traits;
typedef std::iterator_traits<InputIterator2> iteratori2_traits;
typedef std::iterator_traits<OutputIterator> iteratoro_traits;
typedef typename iteratori1_traits::iterator_category iteratori1_category;
typedef typename iteratori2_traits::iterator_category iteratori2_category;
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(),
iteratori1_category(),
iteratori2_category(),
iteratoro_category());
}
......@@ -523,11 +593,10 @@ namespace __parallel
inline OutputIterator
set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
OutputIterator out, __gnu_parallel::sequential_tag)
{
return _GLIBCXX_STD_P::set_symmetric_difference(begin1,end1, begin2,
end2, out);
}
OutputIterator out,
__gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_P::set_symmetric_difference(begin1,end1,
begin2, end2, out); }
// Sequential fallback
template<typename InputIterator1, typename InputIterator2,
......@@ -535,72 +604,111 @@ namespace __parallel
inline OutputIterator
set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
OutputIterator out, Predicate pred, __gnu_parallel::sequential_tag)
{
return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1, begin2,
end2, out, pred);
}
OutputIterator out, Predicate pred,
__gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_P::set_symmetric_difference(begin1, end1, begin2,
end2, out, pred); }
// Sequential fallback for input iterator case
template<typename InputIterator1, typename InputIterator2, typename Predicate, typename OutputIterator, typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
template<typename InputIterator1, typename InputIterator2,
typename Predicate, typename OutputIterator,
typename IteratorTag1, typename IteratorTag2,
typename IteratorTag3>
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);
}
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); }
// Parallel set_symmetric_difference for random access iterators
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename OutputRandomAccessIterator, typename Predicate>
OutputRandomAccessIterator
set_symmetric_difference_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, RandomAccessIterator2 end2, OutputRandomAccessIterator result, Predicate pred, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag)
set_symmetric_difference_switch(RandomAccessIterator1 begin1,
RandomAccessIterator1 end1,
RandomAccessIterator2 begin2,
RandomAccessIterator2 end2,
OutputRandomAccessIterator 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) >= __gnu_parallel::Settings::set_symmetric_difference_minimal_n || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) >= __gnu_parallel::Settings::set_symmetric_difference_minimal_n))
return __gnu_parallel::parallel_set_symmetric_difference(begin1, end1, begin2, end2, result, pred);
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end1 - begin1)
>= __gnu_parallel::Settings::
set_symmetric_difference_minimal_n
|| static_cast<__gnu_parallel::
sequence_index_t>(end2 - begin2)
>= __gnu_parallel::Settings::
set_symmetric_difference_minimal_n))
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<typename InputIterator1, typename InputIterator2, typename OutputIterator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator>
inline OutputIterator
set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, OutputIterator out)
set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
OutputIterator out)
{
typedef std::iterator_traits<InputIterator1> iteratori1_traits;
typedef std::iterator_traits<InputIterator2> iteratori2_traits;
typedef std::iterator_traits<OutputIterator> iteratoro_traits;
typedef typename iteratori1_traits::iterator_category iteratori1_category;
typedef typename iteratori2_traits::iterator_category iteratori2_category;
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,
__gnu_parallel::less<value1_type, value2_type>(),
iteratori1_category(), iteratori2_category(),
__gnu_parallel::
less<value1_type, value2_type>(),
iteratori1_category(),
iteratori2_category(),
iteratoro_category());
}
// Public interface.
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Predicate>
inline OutputIterator
set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, OutputIterator out, Predicate pred)
set_symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
OutputIterator out, Predicate pred)
{
typedef std::iterator_traits<InputIterator1> iteratori1_traits;
typedef std::iterator_traits<InputIterator2> iteratori2_traits;
typedef std::iterator_traits<OutputIterator> iteratoro_traits;
typedef typename iteratori1_traits::iterator_category iteratori1_category;
typedef typename iteratori2_traits::iterator_category iteratori2_category;
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());
iteratori2_category(),
iteratoro_category());
}
// Sequential fallback.
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator>
inline OutputIterator
set_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
......@@ -608,42 +716,60 @@ namespace __parallel
{ return _GLIBCXX_STD_P::set_difference(begin1,end1, begin2, end2, out); }
// Sequential fallback.
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Predicate>
inline OutputIterator
set_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 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<typename InputIterator1, typename InputIterator2, typename Predicate,
typename OutputIterator, typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
template<typename InputIterator1, typename InputIterator2,
typename Predicate, typename OutputIterator,
typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
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);
}
{ return _GLIBCXX_STD_P::set_difference(begin1, end1,
begin2, end2, result, pred); }
// Parallel set_difference for random access iterators
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename OutputRandomAccessIterator, typename Predicate>
OutputRandomAccessIterator
set_difference_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, RandomAccessIterator2 end2, OutputRandomAccessIterator result, Predicate pred, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag)
set_difference_switch(RandomAccessIterator1 begin1,
RandomAccessIterator1 end1,
RandomAccessIterator2 begin2,
RandomAccessIterator2 end2,
OutputRandomAccessIterator 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) >= __gnu_parallel::Settings::set_difference_minimal_n || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) >= __gnu_parallel::Settings::set_difference_minimal_n))
return __gnu_parallel::parallel_set_difference(begin1, end1, begin2, end2, result, pred);
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end1 - begin1)
>= __gnu_parallel::Settings::
set_difference_minimal_n
|| static_cast<__gnu_parallel::
sequence_index_t>(end2 - begin2)
>= __gnu_parallel::Settings::
set_difference_minimal_n))
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<typename InputIterator1, typename InputIterator2, typename OutputIterator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator>
inline OutputIterator
set_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
......@@ -652,20 +778,25 @@ namespace __parallel
typedef std::iterator_traits<InputIterator1> iteratori1_traits;
typedef std::iterator_traits<InputIterator2> iteratori2_traits;
typedef std::iterator_traits<OutputIterator> iteratoro_traits;
typedef typename iteratori1_traits::iterator_category iteratori1_category;
typedef typename iteratori2_traits::iterator_category iteratori2_category;
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,
__gnu_parallel::less<value1_type, value2_type>(),
iteratori1_category(), iteratori2_category(),
__gnu_parallel::
less<value1_type, value2_type>(),
iteratori1_category(),
iteratori2_category(),
iteratoro_category());
}
// Public interface
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Predicate>
inline OutputIterator
set_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
......@@ -674,12 +805,15 @@ namespace __parallel
typedef std::iterator_traits<InputIterator1> iteratori1_traits;
typedef std::iterator_traits<InputIterator2> iteratori2_traits;
typedef std::iterator_traits<OutputIterator> iteratoro_traits;
typedef typename iteratori1_traits::iterator_category iteratori1_category;
typedef typename iteratori2_traits::iterator_category iteratori2_category;
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(),
iteratori1_category(),
iteratori2_category(),
iteratoro_category());
}
......@@ -708,7 +842,9 @@ namespace __parallel
if (_GLIBCXX_PARALLEL_CONDITION(true))
{
RandomAccessIterator spot = __gnu_parallel::find_template(begin, end - 1, begin, equal_to<value_type>(), __gnu_parallel::adjacent_find_selector()).first;
RandomAccessIterator spot = __gnu_parallel::
find_template(begin, end - 1, begin, equal_to<value_type>(),
__gnu_parallel::adjacent_find_selector()).first;
if (spot == (end - 1))
return end;
else
......@@ -721,7 +857,8 @@ namespace __parallel
// Sequential fallback for input iterator case
template<typename ForwardIterator, typename IteratorTag>
inline ForwardIterator
adjacent_find_switch(ForwardIterator begin, ForwardIterator end, IteratorTag)
adjacent_find_switch(ForwardIterator begin, ForwardIterator end,
IteratorTag)
{ return adjacent_find(begin, end, __gnu_parallel::sequential_tag()); }
// Public interface
......@@ -735,11 +872,13 @@ namespace __parallel
}
// Sequential fallback for input iterator case
template<typename ForwardIterator, typename BinaryPredicate, typename IteratorTag>
template<typename ForwardIterator, typename BinaryPredicate,
typename IteratorTag>
inline ForwardIterator
adjacent_find_switch(ForwardIterator begin, ForwardIterator end,
BinaryPredicate pred, IteratorTag)
{ return adjacent_find(begin, end, pred, __gnu_parallel::sequential_tag()); }
{ return adjacent_find(begin, end, pred,
__gnu_parallel::sequential_tag()); }
// Parallel algorithm for random access iterators
template<typename RandomAccessIterator, typename BinaryPredicate>
......@@ -749,9 +888,11 @@ namespace __parallel
{
if (_GLIBCXX_PARALLEL_CONDITION(true))
return __gnu_parallel::find_template(begin, end, begin, pred,
__gnu_parallel::adjacent_find_selector()).first;
__gnu_parallel::
adjacent_find_selector()).first;
else
return adjacent_find(begin, end, pred, __gnu_parallel::sequential_tag());
return adjacent_find(begin, end, pred,
__gnu_parallel::sequential_tag());
}
// Public interface
......@@ -785,11 +926,21 @@ namespace __parallel
typedef typename traits_type::difference_type difference_type;
typedef __gnu_parallel::sequence_index_t sequence_index_t;
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<sequence_index_t>(end - begin) >= __gnu_parallel::Settings::count_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<sequence_index_t>
(end - begin)
>= __gnu_parallel::Settings::
count_minimal_n
&& __gnu_parallel::
is_parallel(parallelism_tag)))
{
__gnu_parallel::count_selector<RandomAccessIterator, difference_type> functionality;
__gnu_parallel::count_selector<RandomAccessIterator, difference_type>
functionality;
difference_type res = 0;
__gnu_parallel::for_each_template_random_access(begin, end, value, functionality, std::plus<sequence_index_t>(), res, res, -1, parallelism_tag);
__gnu_parallel::
for_each_template_random_access(begin, end, value,
functionality,
std::plus<sequence_index_t>(),
res, res, -1, parallelism_tag);
return res;
}
else
......@@ -798,7 +949,7 @@ namespace __parallel
// Sequential fallback for input iterator case.
template<typename InputIterator, typename T, typename IteratorTag>
typename iterator_traits<InputIterator>::difference_type
inline typename iterator_traits<InputIterator>::difference_type
count_switch(InputIterator begin, InputIterator end, const T& value,
IteratorTag)
{ return count(begin, end, value, __gnu_parallel::sequential_tag()); }
......@@ -845,11 +996,22 @@ namespace __parallel
typedef typename traits_type::difference_type difference_type;
typedef __gnu_parallel::sequence_index_t sequence_index_t;
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<sequence_index_t>(end - begin) >= __gnu_parallel::Settings::count_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<sequence_index_t>
(end - begin)
>= __gnu_parallel::Settings::
count_minimal_n
&& __gnu_parallel::
is_parallel(parallelism_tag)))
{
difference_type res = 0;
__gnu_parallel::count_if_selector<RandomAccessIterator, difference_type> functionality;
__gnu_parallel::for_each_template_random_access(begin, end, pred, functionality, std::plus<sequence_index_t>(), res, res, -1, parallelism_tag);
__gnu_parallel::
count_if_selector<RandomAccessIterator, difference_type>
functionality;
__gnu_parallel::
for_each_template_random_access(begin, end, pred,
functionality,
std::plus<sequence_index_t>(),
res, res, -1, parallelism_tag);
return res;
}
else
......@@ -858,7 +1020,7 @@ namespace __parallel
// Sequential fallback for input iterator case.
template<typename InputIterator, typename Predicate, typename IteratorTag>
typename iterator_traits<InputIterator>::difference_type
inline typename iterator_traits<InputIterator>::difference_type
count_if_switch(InputIterator begin, InputIterator end, Predicate pred,
IteratorTag)
{ return count_if(begin, end, pred, __gnu_parallel::sequential_tag()); }
......@@ -888,15 +1050,17 @@ namespace __parallel
// Sequential fallback.
template<typename ForwardIterator1, typename ForwardIterator2>
inline ForwardIterator1
search(ForwardIterator1 begin1, ForwardIterator1 end1, ForwardIterator2 begin2, ForwardIterator2 end2, __gnu_parallel::sequential_tag)
{
return _GLIBCXX_STD_P::search(begin1, end1, begin2, end2);
}
search(ForwardIterator1 begin1, ForwardIterator1 end1,
ForwardIterator2 begin2, ForwardIterator2 end2,
__gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_P::search(begin1, end1, begin2, end2); }
// Parallel algorithm for random access iterator
template<typename RandomAccessIterator1, typename RandomAccessIterator2>
RandomAccessIterator1
search_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, RandomAccessIterator2 end2, random_access_iterator_tag, random_access_iterator_tag)
search_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
RandomAccessIterator2 begin2, RandomAccessIterator2 end2,
random_access_iterator_tag, random_access_iterator_tag)
{
typedef std::iterator_traits<RandomAccessIterator1> iterator1_traits;
typedef typename iterator1_traits::value_type value1_type;
......@@ -904,148 +1068,194 @@ namespace __parallel
typedef typename iterator2_traits::value_type value2_type;
if (_GLIBCXX_PARALLEL_CONDITION(true))
return __gnu_parallel::search_template(begin1, end1, begin2, end2, __gnu_parallel::equal_to<value1_type, value2_type>());
return __gnu_parallel::
search_template(begin1, end1, begin2, end2, __gnu_parallel::
equal_to<value1_type, value2_type>());
else
return search(begin1, end1, begin2, end2, __gnu_parallel::sequential_tag());
return search(begin1, end1, begin2, end2,
__gnu_parallel::sequential_tag());
}
// Sequential fallback for input iterator case
template<typename ForwardIterator1, typename ForwardIterator2, typename IteratorTag1, typename IteratorTag2>
template<typename ForwardIterator1, typename ForwardIterator2,
typename IteratorTag1, typename IteratorTag2>
inline ForwardIterator1
search_switch(ForwardIterator1 begin1, ForwardIterator1 end1, ForwardIterator2 begin2, ForwardIterator2 end2, IteratorTag1, IteratorTag2)
{
return search(begin1, end1, begin2, end2, __gnu_parallel::sequential_tag());
}
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<typename ForwardIterator1, typename ForwardIterator2>
inline ForwardIterator1
search(ForwardIterator1 begin1, ForwardIterator1 end1, ForwardIterator2 begin2, ForwardIterator2 end2)
search(ForwardIterator1 begin1, ForwardIterator1 end1,
ForwardIterator2 begin2, ForwardIterator2 end2)
{
typedef std::iterator_traits<ForwardIterator1> iterator1_traits;
typedef typename iterator1_traits::iterator_category iterator1_category;
typedef std::iterator_traits<ForwardIterator2> iterator2_traits;
typedef typename iterator2_traits::iterator_category iterator2_category;
return search_switch(begin1, end1, begin2, end2, iterator1_category(), iterator2_category());
return search_switch(begin1, end1, begin2, end2,
iterator1_category(), iterator2_category());
}
// Public interface.
template<typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate>
template<typename ForwardIterator1, typename ForwardIterator2,
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<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename BinaryPredicate>
RandomAccessIterator1
search_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
RandomAccessIterator2 begin2, RandomAccessIterator2 end2, BinaryPredicate pred, random_access_iterator_tag, random_access_iterator_tag)
RandomAccessIterator2 begin2, RandomAccessIterator2 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, __gnu_parallel::sequential_tag());
return search(begin1, end1, begin2, end2, pred,
__gnu_parallel::sequential_tag());
}
// Sequential fallback for input iterator case
template<typename ForwardIterator1, typename ForwardIterator2,
typename BinaryPredicate, typename IteratorTag1, typename IteratorTag2>
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, __gnu_parallel::sequential_tag());
}
ForwardIterator2 begin2, ForwardIterator2 end2,
BinaryPredicate pred, IteratorTag1, IteratorTag2)
{ return search(begin1, end1, begin2, end2, pred,
__gnu_parallel::sequential_tag()); }
// Public interface
template<typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate>
template<typename ForwardIterator1, typename ForwardIterator2,
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<ForwardIterator1> iterator1_traits;
typedef typename iterator1_traits::iterator_category iterator1_category;
typedef std::iterator_traits<ForwardIterator2> iterator2_traits;
typedef typename iterator2_traits::iterator_category iterator2_category;
return search_switch(begin1, end1, begin2, end2, pred, iterator1_category(), iterator2_category());
return search_switch(begin1, end1, begin2, end2, pred,
iterator1_category(), iterator2_category());
}
// Sequential fallback
template<typename ForwardIterator, typename Integer, typename T>
inline ForwardIterator
search_n(ForwardIterator begin, ForwardIterator end, Integer count, const T& val, __gnu_parallel::sequential_tag)
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); }
// Sequential fallback
template<typename ForwardIterator, typename Integer, typename T, typename BinaryPredicate>
template<typename ForwardIterator, typename Integer, typename T,
typename BinaryPredicate>
inline ForwardIterator
search_n(ForwardIterator begin, ForwardIterator end, Integer count, const T& val, BinaryPredicate binary_pred, __gnu_parallel::sequential_tag)
{
return _GLIBCXX_STD_P::search_n(begin, end, count, val, binary_pred);
}
search_n(ForwardIterator begin, ForwardIterator end, Integer count,
const T& val, BinaryPredicate binary_pred,
__gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_P::search_n(begin, end, count, val, binary_pred); }
// Public interface.
template<typename ForwardIterator, typename Integer, typename T>
inline ForwardIterator
search_n(ForwardIterator begin, ForwardIterator end, Integer count, const T& val)
search_n(ForwardIterator begin, ForwardIterator end, Integer count,
const T& val)
{
typedef typename iterator_traits<ForwardIterator>::value_type value_type;
return search_n(begin, end, count, val, __gnu_parallel::equal_to<value_type, T>());
return search_n(begin, end, count, val,
__gnu_parallel::equal_to<value_type, T>());
}
// Parallel algorithm for random access iterators.
template<typename RandomAccessIterator, typename Integer, typename T, typename BinaryPredicate>
template<typename RandomAccessIterator, typename Integer,
typename T, typename BinaryPredicate>
RandomAccessIterator
search_n_switch(RandomAccessIterator begin, RandomAccessIterator end, Integer count, const T& val, BinaryPredicate binary_pred, random_access_iterator_tag)
search_n_switch(RandomAccessIterator begin, RandomAccessIterator end,
Integer count, const T& val, BinaryPredicate binary_pred,
random_access_iterator_tag)
{
if (_GLIBCXX_PARALLEL_CONDITION(true))
{
__gnu_parallel::pseudo_sequence<T, Integer> ps(val, count);
return __gnu_parallel::search_template(begin, end, ps.begin(), ps.end(), binary_pred);
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<typename ForwardIterator, typename Integer, typename T, typename BinaryPredicate, typename IteratorTag>
template<typename ForwardIterator, typename Integer, typename T,
typename BinaryPredicate, typename IteratorTag>
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());
}
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()); }
// Public interface.
template<typename ForwardIterator, typename Integer, typename T, typename BinaryPredicate>
template<typename ForwardIterator, typename Integer, typename T,
typename BinaryPredicate>
inline ForwardIterator
search_n(ForwardIterator begin, ForwardIterator end, Integer count, const T& val, BinaryPredicate binary_pred)
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<ForwardIterator>::iterator_category());
return search_n_switch(begin, end, count, val, binary_pred,
typename std::iterator_traits<ForwardIterator>::
iterator_category());
}
// Sequential fallback.
template<typename InputIterator, typename OutputIterator, typename UnaryOperation>
template<typename InputIterator, typename OutputIterator,
typename UnaryOperation>
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); }
// Parallel unary transform for random access iterators.
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename UnaryOperation>
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename UnaryOperation>
RandomAccessIterator2
transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end, RandomAccessIterator2 result, UnaryOperation unary_op, random_access_iterator_tag, random_access_iterator_tag, __gnu_parallel::parallelism parallelism_tag = __gnu_parallel::parallel_balanced)
transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end,
RandomAccessIterator2 result, UnaryOperation unary_op,
random_access_iterator_tag, 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) >= __gnu_parallel::Settings::transform_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
transform_minimal_n
&& __gnu_parallel::
is_parallel(parallelism_tag)))
{
bool dummy = true;
typedef __gnu_parallel::iterator_pair<RandomAccessIterator1, RandomAccessIterator2, random_access_iterator_tag> ip;
typedef __gnu_parallel::iterator_pair<RandomAccessIterator1,
RandomAccessIterator2, random_access_iterator_tag> ip;
ip begin_pair(begin, result), end_pair(end, result + (end - begin));
__gnu_parallel::transform1_selector<ip> functionality;
__gnu_parallel::for_each_template_random_access(begin_pair, end_pair, unary_op, functionality, __gnu_parallel::dummy_reduct(), dummy, dummy, -1, parallelism_tag);
__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;
}
else
......@@ -1054,16 +1264,19 @@ namespace __parallel
}
// Sequential fallback for input iterator case.
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename UnaryOperation, typename IteratorTag1, typename IteratorTag2>
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename UnaryOperation, typename IteratorTag1,
typename IteratorTag2>
inline RandomAccessIterator2
transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end, RandomAccessIterator2 result, UnaryOperation unary_op, IteratorTag1, IteratorTag2)
{
return transform(begin, end, result, unary_op,
__gnu_parallel::sequential_tag());
}
transform1_switch(RandomAccessIterator1 begin, RandomAccessIterator1 end,
RandomAccessIterator2 result, UnaryOperation unary_op,
IteratorTag1, IteratorTag2)
{ return transform(begin, end, result, unary_op,
__gnu_parallel::sequential_tag()); }
// Public interface.
template<typename InputIterator, typename OutputIterator, typename UnaryOperation>
template<typename InputIterator, typename OutputIterator,
typename UnaryOperation>
inline OutputIterator
transform(InputIterator begin, InputIterator end, OutputIterator result,
UnaryOperation unary_op,
......@@ -1079,7 +1292,8 @@ namespace __parallel
parallelism_tag);
}
template<typename InputIterator, typename OutputIterator, typename UnaryOperation>
template<typename InputIterator, typename OutputIterator,
typename UnaryOperation>
inline OutputIterator
transform(InputIterator begin, InputIterator end, OutputIterator result,
UnaryOperation unary_op)
......@@ -1095,27 +1309,47 @@ namespace __parallel
// Sequential fallback
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename BinaryOperation>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename BinaryOperation>
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);
}
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); }
// Parallel binary transform for random access iterators.
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename RandomAccessIterator3, typename BinaryOperation>
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename RandomAccessIterator3, typename BinaryOperation>
RandomAccessIterator3
transform2_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, RandomAccessIterator3 result, BinaryOperation binary_op, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag, __gnu_parallel::parallelism parallelism_tag = __gnu_parallel::parallel_balanced)
transform2_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
RandomAccessIterator2 begin2,
RandomAccessIterator3 result, BinaryOperation binary_op,
random_access_iterator_tag, random_access_iterator_tag,
random_access_iterator_tag,
__gnu_parallel::parallelism parallelism_tag
= __gnu_parallel::parallel_balanced)
{
if (_GLIBCXX_PARALLEL_CONDITION((end1 - begin1) >= __gnu_parallel::Settings::transform_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
if (_GLIBCXX_PARALLEL_CONDITION((end1 - begin1)
>= __gnu_parallel::Settings::
transform_minimal_n
&& __gnu_parallel::
is_parallel(parallelism_tag)))
{
bool dummy = true;
typedef __gnu_parallel::iterator_triple<RandomAccessIterator1, RandomAccessIterator2, RandomAccessIterator3, random_access_iterator_tag> ip;
ip begin_triple(begin1, begin2, result), end_triple(end1, begin2 + (end1 - begin1), result + (end1 - begin1));
typedef __gnu_parallel::iterator_triple<RandomAccessIterator1,
RandomAccessIterator2, RandomAccessIterator3,
random_access_iterator_tag> ip;
ip begin_triple(begin1, begin2, result),
end_triple(end1, begin2 + (end1 - begin1),
result + (end1 - begin1));
__gnu_parallel::transform2_selector<ip> functionality;
__gnu_parallel::for_each_template_random_access(begin_triple, end_triple, binary_op, functionality, __gnu_parallel::dummy_reduct(), dummy, dummy, -1, parallelism_tag);
__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;
}
else
......@@ -1124,27 +1358,31 @@ namespace __parallel
}
// Sequential fallback for input iterator case.
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename BinaryOperation, typename tag1, typename tag2, typename tag3>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename BinaryOperation,
typename tag1, typename tag2, typename tag3>
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,
__gnu_parallel::sequential_tag());
}
{ return transform(begin1, end1, begin2, result, binary_op,
__gnu_parallel::sequential_tag()); }
// Public interface.
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename BinaryOperation>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename BinaryOperation>
inline OutputIterator
transform(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
OutputIterator result, BinaryOperation binary_op,
transform(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, OutputIterator result,
BinaryOperation binary_op,
__gnu_parallel::parallelism parallelism_tag)
{
typedef std::iterator_traits<InputIterator1> iteratori1_traits;
typedef typename iteratori1_traits::iterator_category iteratori1_category;
typedef typename iteratori1_traits::iterator_category
iteratori1_category;
typedef std::iterator_traits<InputIterator2> iteratori2_traits;
typedef typename iteratori2_traits::iterator_category iteratori2_category;
typedef typename iteratori2_traits::iterator_category
iteratori2_category;
typedef std::iterator_traits<OutputIterator> iteratoro_traits;
typedef typename iteratoro_traits::iterator_category iteratoro_category;
......@@ -1153,15 +1391,19 @@ namespace __parallel
iteratoro_category(), parallelism_tag);
}
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename BinaryOperation>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename BinaryOperation>
inline OutputIterator
transform(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
OutputIterator result, BinaryOperation binary_op)
transform(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, OutputIterator result,
BinaryOperation binary_op)
{
typedef std::iterator_traits<InputIterator1> iteratori1_traits;
typedef typename iteratori1_traits::iterator_category iteratori1_category;
typedef typename iteratori1_traits::iterator_category
iteratori1_category;
typedef std::iterator_traits<InputIterator2> iteratori2_traits;
typedef typename iteratori2_traits::iterator_category iteratori2_category;
typedef typename iteratori2_traits::iterator_category
iteratori2_category;
typedef std::iterator_traits<OutputIterator> iteratoro_traits;
typedef typename iteratoro_traits::iterator_category iteratoro_category;
......@@ -1179,17 +1421,15 @@ namespace __parallel
// Sequential fallback for input iterator case
template<typename ForwardIterator, typename T, typename IteratorTag>
void
inline void
replace_switch(ForwardIterator begin, ForwardIterator end,
const T& old_value, const T& new_value, IteratorTag)
{
replace(begin, end, old_value, new_value,
__gnu_parallel::sequential_tag());
}
{ replace(begin, end, old_value, new_value,
__gnu_parallel::sequential_tag()); }
// Parallel replace for random access iterators
template<typename RandomAccessIterator, typename T>
void
inline void
replace_switch(RandomAccessIterator begin, RandomAccessIterator end,
const T& old_value, const T& new_value,
random_access_iterator_tag,
......@@ -1232,11 +1472,13 @@ namespace __parallel
{ _GLIBCXX_STD_P::replace_if(begin, end, pred, new_value); }
// Sequential fallback for input iterator case
template<typename ForwardIterator, typename Predicate, typename T, typename IteratorTag>
void
replace_if_switch(ForwardIterator begin, ForwardIterator end, Predicate pred,
const T& new_value, IteratorTag)
{ replace_if(begin, end, pred, new_value, __gnu_parallel::sequential_tag()); }
template<typename ForwardIterator, typename Predicate, typename T,
typename IteratorTag>
inline void
replace_if_switch(ForwardIterator begin, ForwardIterator end,
Predicate pred, const T& new_value, IteratorTag)
{ replace_if(begin, end, pred, new_value,
__gnu_parallel::sequential_tag()); }
// Parallel algorithm for random access iterators.
template<typename RandomAccessIterator, typename Predicate, typename T>
......@@ -1247,11 +1489,22 @@ namespace __parallel
__gnu_parallel::parallelism parallelism_tag
= __gnu_parallel::parallel_balanced)
{
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::replace_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
replace_minimal_n
&& __gnu_parallel::
is_parallel(parallelism_tag)))
{
bool dummy;
__gnu_parallel::replace_if_selector<RandomAccessIterator, Predicate, T> functionality(new_value);
__gnu_parallel::for_each_template_random_access(begin, end, pred, functionality, __gnu_parallel::dummy_reduct(), true, dummy, -1, parallelism_tag);
__gnu_parallel::
replace_if_selector<RandomAccessIterator, Predicate, T>
functionality(new_value);
__gnu_parallel::
for_each_template_random_access(begin, end, pred,
functionality,
__gnu_parallel::dummy_reduct(),
true, dummy, -1, parallelism_tag);
}
else
replace_if(begin, end, pred, new_value,
......@@ -1290,7 +1543,7 @@ namespace __parallel
// Sequential fallback for input iterator case.
template<typename ForwardIterator, typename Generator, typename IteratorTag>
void
inline void
generate_switch(ForwardIterator begin, ForwardIterator end, Generator gen,
IteratorTag)
{ generate(begin, end, gen, __gnu_parallel::sequential_tag()); }
......@@ -1303,11 +1556,20 @@ namespace __parallel
__gnu_parallel::parallelism parallelism_tag
= __gnu_parallel::parallel_balanced)
{
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::generate_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
generate_minimal_n
&& __gnu_parallel::
is_parallel(parallelism_tag)))
{
bool dummy;
__gnu_parallel::generate_selector<RandomAccessIterator> functionality;
__gnu_parallel::for_each_template_random_access(begin, end, gen, functionality, __gnu_parallel::dummy_reduct(), true, dummy, -1, parallelism_tag);
__gnu_parallel::generate_selector<RandomAccessIterator>
functionality;
__gnu_parallel::
for_each_template_random_access(begin, end, gen, functionality,
__gnu_parallel::dummy_reduct(),
true, dummy, -1, parallelism_tag);
}
else
generate(begin, end, gen, __gnu_parallel::sequential_tag());
......@@ -1342,8 +1604,9 @@ namespace __parallel
{ return _GLIBCXX_STD_P::generate_n(begin, n, gen); }
// Sequential fallback for input iterator case.
template<typename OutputIterator, typename Size, typename Generator, typename IteratorTag>
OutputIterator
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()); }
......@@ -1400,7 +1663,8 @@ namespace __parallel
template<typename must_be_int = int>
struct c_rand_number
{
inline int operator()(int limit)
int
operator()(int limit)
{ return rand() % limit; }
};
......@@ -1422,7 +1686,10 @@ namespace __parallel
{
if (begin == end)
return;
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::random_shuffle_minimal_n))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
random_shuffle_minimal_n))
__gnu_parallel::parallel_random_shuffle(begin, end, rand);
else
__gnu_parallel::sequential_random_shuffle(begin, end, rand);
......@@ -1431,24 +1698,33 @@ namespace __parallel
// Sequential fallback.
template<typename ForwardIterator, typename Predicate>
inline ForwardIterator
partition(ForwardIterator begin, ForwardIterator end, Predicate pred, __gnu_parallel::sequential_tag)
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<typename ForwardIterator, typename Predicate, typename IteratorTag>
inline ForwardIterator
partition_switch(ForwardIterator begin, ForwardIterator end, Predicate pred, IteratorTag)
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<typename RandomAccessIterator, typename Predicate>
RandomAccessIterator
partition_switch(RandomAccessIterator begin, RandomAccessIterator end, Predicate pred, random_access_iterator_tag)
partition_switch(RandomAccessIterator begin, RandomAccessIterator end,
Predicate pred, random_access_iterator_tag)
{
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::partition_minimal_n))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
partition_minimal_n))
{
typedef typename std::iterator_traits<RandomAccessIterator>::difference_type difference_type;
difference_type middle = __gnu_parallel::parallel_partition(begin, end, pred, __gnu_parallel::get_max_threads());
typedef typename std::iterator_traits<RandomAccessIterator>::
difference_type difference_type;
difference_type middle = __gnu_parallel::
parallel_partition(begin, end, pred,
__gnu_parallel::get_max_threads());
return begin + middle;
}
else
......@@ -1477,7 +1753,8 @@ namespace __parallel
inline void
sort(RandomAccessIterator begin, RandomAccessIterator end, Comparator comp,
__gnu_parallel::sequential_tag)
{ _GLIBCXX_STD_P::sort<RandomAccessIterator, Comparator>(begin, end, comp); }
{ _GLIBCXX_STD_P::sort<RandomAccessIterator, Comparator>(begin, end,
comp); }
// Public interface, insert default comparator
template<typename RandomAccessIterator>
......@@ -1498,7 +1775,10 @@ namespace __parallel
if (begin != end)
{
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::sort_minimal_n))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
sort_minimal_n))
__gnu_parallel::parallel_sort(begin, end, comp, false);
else
sort(begin, end, comp, __gnu_parallel::sequential_tag());
......@@ -1520,7 +1800,7 @@ namespace __parallel
{ return _GLIBCXX_STD_P::stable_sort(begin, end, comp); }
template<typename RandomAccessIterator>
void
inline void
stable_sort(RandomAccessIterator begin, RandomAccessIterator end)
{
typedef iterator_traits<RandomAccessIterator> traits_type;
......@@ -1536,7 +1816,10 @@ namespace __parallel
{
if (begin != end)
{
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::sort_minimal_n))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
sort_minimal_n))
__gnu_parallel::parallel_sort(begin, end, comp, true);
else
stable_sort(begin, end, comp, __gnu_parallel::sequential_tag());
......@@ -1544,7 +1827,8 @@ namespace __parallel
}
// Sequential fallback
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator>
inline OutputIterator
merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
InputIterator2 end2, OutputIterator result,
......@@ -1552,7 +1836,8 @@ namespace __parallel
{ return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2, result); }
// Sequential fallback
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Comparator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Comparator>
inline OutputIterator
merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
InputIterator2 end2, OutputIterator result, Comparator comp,
......@@ -1560,13 +1845,20 @@ namespace __parallel
{ return _GLIBCXX_STD_P::merge(begin1, end1, begin2, end2, result, comp); }
// Sequential fallback for input iterator case
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Comparator, typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Comparator,
typename IteratorTag1, typename IteratorTag2, typename IteratorTag3>
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); }
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); }
// Parallel algorithm for random access iterators
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Comparator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Comparator>
OutputIterator
merge_switch(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
......@@ -1574,17 +1866,27 @@ namespace __parallel
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) >= __gnu_parallel::Settings::merge_minimal_n || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2) >= __gnu_parallel::Settings::merge_minimal_n)))
return __gnu_parallel::parallel_merge_advance(begin1, end1, begin2, end2,
result, (end1 - begin1) + (end2 - begin2), comp);
if (_GLIBCXX_PARALLEL_CONDITION((static_cast<__gnu_parallel::
sequence_index_t>(end1 - begin1)
>= __gnu_parallel::Settings::
merge_minimal_n
|| static_cast<__gnu_parallel::
sequence_index_t>(end2 - begin2)
>= __gnu_parallel::Settings::
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);
return __gnu_parallel::merge_advance(begin1, end1, begin2, end2,
result, (end1 - begin1)
+ (end2 - begin2), comp);
}
// Public interface
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Comparator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Comparator>
inline OutputIterator
merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
InputIterator2 end2, OutputIterator result, Comparator comp)
......@@ -1594,8 +1896,10 @@ namespace __parallel
typedef std::iterator_traits<InputIterator1> iteratori1_traits;
typedef std::iterator_traits<InputIterator2> iteratori2_traits;
typedef std::iterator_traits<OutputIterator> iteratoro_traits;
typedef typename iteratori1_traits::iterator_category iteratori1_category;
typedef typename iteratori2_traits::iterator_category iteratori2_category;
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,
......@@ -1605,7 +1909,8 @@ namespace __parallel
// Public interface, insert default comparator
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
template<typename InputIterator1, typename InputIterator2,
typename OutputIterator>
inline OutputIterator
merge(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
InputIterator2 end2, OutputIterator result)
......@@ -1628,7 +1933,7 @@ namespace __parallel
// Sequential fallback
template<typename RandomAccessIterator, typename Comparator>
void
inline void
nth_element(RandomAccessIterator begin, RandomAccessIterator nth,
RandomAccessIterator end, Comparator comp,
__gnu_parallel::sequential_tag)
......@@ -1640,7 +1945,10 @@ namespace __parallel
nth_element(RandomAccessIterator begin, RandomAccessIterator nth,
RandomAccessIterator end, Comparator comp)
{
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::nth_element_minimal_n))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
nth_element_minimal_n))
__gnu_parallel::parallel_nth_element(begin, nth, end, comp);
else
nth_element(begin, nth, end, comp, __gnu_parallel::sequential_tag());
......@@ -1648,7 +1956,7 @@ namespace __parallel
// Public interface, insert default comparator
template<typename RandomAccessIterator>
void
inline void
nth_element(RandomAccessIterator begin, RandomAccessIterator nth,
RandomAccessIterator end)
{
......@@ -1659,7 +1967,7 @@ namespace __parallel
// Sequential fallback
template<typename RandomAccessIterator, typename _Compare>
void
inline void
partial_sort(RandomAccessIterator begin, RandomAccessIterator middle,
RandomAccessIterator end, _Compare comp,
__gnu_parallel::sequential_tag)
......@@ -1678,15 +1986,19 @@ namespace __parallel
partial_sort(RandomAccessIterator begin, RandomAccessIterator middle,
RandomAccessIterator end, _Compare comp)
{
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::partial_sort_minimal_n))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
partial_sort_minimal_n))
__gnu_parallel::parallel_partial_sort(begin, middle, end, comp);
else
partial_sort(begin, middle, end, comp, __gnu_parallel::sequential_tag());
partial_sort(begin, middle, end, comp,
__gnu_parallel::sequential_tag());
}
// Public interface, insert default comparator
template<typename RandomAccessIterator>
void
inline void
partial_sort(RandomAccessIterator begin, RandomAccessIterator middle,
RandomAccessIterator end)
{
......@@ -1711,7 +2023,7 @@ namespace __parallel
// Sequential fallback for input iterator case
template<typename ForwardIterator, typename Comparator, typename IteratorTag>
ForwardIterator
inline ForwardIterator
max_element_switch(ForwardIterator begin, ForwardIterator end,
Comparator comp, IteratorTag)
{ return max_element(begin, end, comp, __gnu_parallel::sequential_tag()); }
......@@ -1724,11 +2036,24 @@ namespace __parallel
__gnu_parallel::parallelism parallelism_tag
= __gnu_parallel::parallel_balanced)
{
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::max_element_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
max_element_minimal_n
&& __gnu_parallel::
is_parallel(parallelism_tag)))
{
RandomAccessIterator res(begin);
__gnu_parallel::identity_selector<RandomAccessIterator> functionality;
__gnu_parallel::for_each_template_random_access(begin, end, __gnu_parallel::nothing(), functionality, __gnu_parallel::max_element_reduct<Comparator, RandomAccessIterator>(comp), res, res, -1, parallelism_tag);
__gnu_parallel::identity_selector<RandomAccessIterator>
functionality;
__gnu_parallel::
for_each_template_random_access(begin, end,
__gnu_parallel::nothing(),
functionality,
__gnu_parallel::
max_element_reduct<Comparator,
RandomAccessIterator>(comp),
res, res, -1, parallelism_tag);
return res;
}
else
......@@ -1777,8 +2102,7 @@ namespace __parallel
// Sequential fallback
template<typename ForwardIterator>
inline
ForwardIterator
inline ForwardIterator
min_element(ForwardIterator begin, ForwardIterator end,
__gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_P::min_element(begin, end); }
......@@ -1792,7 +2116,7 @@ namespace __parallel
// Sequential fallback for input iterator case
template<typename ForwardIterator, typename Comparator, typename IteratorTag>
ForwardIterator
inline ForwardIterator
min_element_switch(ForwardIterator begin, ForwardIterator end,
Comparator comp, IteratorTag)
{ return min_element(begin, end, comp, __gnu_parallel::sequential_tag()); }
......@@ -1805,11 +2129,24 @@ namespace __parallel
__gnu_parallel::parallelism parallelism_tag
= __gnu_parallel::parallel_balanced)
{
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::min_element_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
sequence_index_t>(end - begin)
>= __gnu_parallel::Settings::
min_element_minimal_n
&& __gnu_parallel::
is_parallel(parallelism_tag)))
{
RandomAccessIterator res(begin);
__gnu_parallel::identity_selector<RandomAccessIterator> functionality;
__gnu_parallel::for_each_template_random_access(begin, end, __gnu_parallel::nothing(), functionality, __gnu_parallel::min_element_reduct<Comparator, RandomAccessIterator>(comp), res, res, -1, parallelism_tag);
__gnu_parallel::identity_selector<RandomAccessIterator>
functionality;
__gnu_parallel::
for_each_template_random_access(begin, end,
__gnu_parallel::nothing(),
functionality,
__gnu_parallel::
min_element_reduct<Comparator,
RandomAccessIterator>(comp),
res, res, -1, parallelism_tag);
return res;
}
else
......
libstdc++-v3/include/parallel/algobase.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -63,14 +63,16 @@ namespace __parallel
{ return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2); }
// Sequential fallback
template<typename InputIterator1, typename InputIterator2, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename Predicate>
inline pair<InputIterator1, InputIterator2>
mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
Predicate pred, __gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); }
// Sequential fallback for input iterator case
template<typename InputIterator1, typename InputIterator2, typename Predicate, typename IteratorTag1, typename IteratorTag2>
template<typename InputIterator1, typename InputIterator2,
typename Predicate, typename IteratorTag1, typename IteratorTag2>
inline pair<InputIterator1, InputIterator2>
mismatch_switch(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, Predicate pred, IteratorTag1,
......@@ -78,7 +80,8 @@ namespace __parallel
{ return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); }
// Parallel mismatch for random access iterators
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Predicate>
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename Predicate>
pair<RandomAccessIterator1, RandomAccessIterator2>
mismatch_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
RandomAccessIterator2 begin2, Predicate pred,
......@@ -86,7 +89,10 @@ namespace __parallel
{
if (_GLIBCXX_PARALLEL_CONDITION(true))
{
RandomAccessIterator1 res = __gnu_parallel::find_template(begin1, end1, begin2, pred, __gnu_parallel::mismatch_selector()).first;
RandomAccessIterator1 res =
__gnu_parallel::find_template(begin1, end1, begin2, pred,
__gnu_parallel::
mismatch_selector()).first;
return make_pair(res , begin2 + (res - begin1));
}
else
......@@ -112,7 +118,8 @@ namespace __parallel
}
// Public interface
template<typename InputIterator1, typename InputIterator2, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename Predicate>
inline pair<InputIterator1, InputIterator2>
mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
Predicate pred)
......@@ -134,7 +141,8 @@ namespace __parallel
{ return _GLIBCXX_STD_P::equal(begin1, end1, begin2); }
// Sequential fallback
template<typename InputIterator1, typename InputIterator2, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename Predicate>
inline bool
equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
Predicate pred, __gnu_parallel::sequential_tag)
......@@ -147,7 +155,8 @@ namespace __parallel
{ return mismatch(begin1, end1, begin2).first == end1; }
// Public interface
template<typename InputIterator1, typename InputIterator2, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename Predicate>
inline bool
equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2,
Predicate pred)
......@@ -159,35 +168,33 @@ namespace __parallel
lexicographical_compare(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 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<typename InputIterator1, typename InputIterator2, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename Predicate>
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);
}
{ return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1,
begin2, end2, pred); }
// Sequential fallback for input iterator case
template<typename InputIterator1, typename InputIterator2, typename Predicate, typename IteratorTag1, typename IteratorTag2>
template<typename InputIterator1, typename InputIterator2,
typename Predicate, typename IteratorTag1, typename IteratorTag2>
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);
}
{ 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<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Predicate>
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename Predicate>
bool
lexicographical_compare_switch(RandomAccessIterator1 begin1,
RandomAccessIterator1 end1,
......@@ -204,12 +211,14 @@ namespace __parallel
typedef iterator_traits<RandomAccessIterator2> traits2_type;
typedef typename traits2_type::value_type value2_type;
typedef __gnu_parallel::equal_from_less<Predicate, value1_type, value2_type> equal_type;
typedef __gnu_parallel::equal_from_less<Predicate, value1_type,
value2_type> equal_type;
// Longer sequence in first place.
if ((end1 - begin1) < (end2 - begin2))
{
typedef pair<RandomAccessIterator1, RandomAccessIterator2> pair_type;
typedef pair<RandomAccessIterator1, RandomAccessIterator2>
pair_type;
pair_type mm = mismatch_switch(begin1, end1, begin2,
equal_type(pred),
random_access_iterator_tag(),
......@@ -219,7 +228,8 @@ namespace __parallel
}
else
{
typedef pair<RandomAccessIterator2, RandomAccessIterator1> pair_type;
typedef pair<RandomAccessIterator2, RandomAccessIterator1>
pair_type;
pair_type mm = mismatch_switch(begin2, end2, begin1,
equal_type(pred),
random_access_iterator_tag(),
......@@ -229,13 +239,15 @@ namespace __parallel
}
}
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<typename InputIterator1, typename InputIterator2>
inline bool
lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2)
lexicographical_compare(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2)
{
typedef iterator_traits<InputIterator1> traits1_type;
typedef typename traits1_type::value_type value1_type;
......@@ -252,9 +264,12 @@ namespace __parallel
}
// Public interface
template<typename InputIterator1, typename InputIterator2, typename Predicate>
template<typename InputIterator1, typename InputIterator2,
typename Predicate>
inline bool
lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, Predicate pred)
lexicographical_compare(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2,
Predicate pred)
{
typedef iterator_traits<InputIterator1> traits1_type;
typedef typename traits1_type::iterator_category iterator1_category;
......
libstdc++-v3/include/parallel/algorithmfwd.h
// <algorithm> parallel extensions -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -84,43 +84,43 @@ namespace __parallel
typename iterator_traits<_IIter>::difference_type
count(_IIter, _IIter, const _Tp&);
template<typename _IIter, typename T>
template<typename _IIter, typename _Tp>
typename iterator_traits<_IIter>::difference_type
count(_IIter, _IIter, const T&, __gnu_parallel::sequential_tag);
count(_IIter, _IIter, const _Tp&, __gnu_parallel::sequential_tag);
template<typename _IIter, typename T>
template<typename _IIter, typename _Tp>
typename iterator_traits<_IIter>::difference_type
count(_IIter, _IIter, const T&, __gnu_parallel::parallelism);
count(_IIter, _IIter, const _Tp&, __gnu_parallel::parallelism);
template<typename _IIter, typename T, typename _IterTag>
template<typename _IIter, typename _Tp, typename _IterTag>
typename iterator_traits<_IIter>::difference_type
count_switch(_IIter, _IIter, const T&, _IterTag);
count_switch(_IIter, _IIter, const _Tp&, _IterTag);
template<typename _RAIter, typename T>
template<typename _RAIter, typename _Tp>
typename iterator_traits<_RAIter>::difference_type
count_switch(_RAIter, _RAIter, const T&, random_access_iterator_tag,
count_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag,
__gnu_parallel::parallelism);
template<typename _IIter, typename Predicate>
template<typename _IIter, typename _Predicate>
typename iterator_traits<_IIter>::difference_type
count_if(_IIter, _IIter, Predicate);
count_if(_IIter, _IIter, _Predicate);
template<typename _IIter, typename Predicate>
template<typename _IIter, typename _Predicate>
typename iterator_traits<_IIter>::difference_type
count_if(_IIter, _IIter, Predicate, __gnu_parallel::sequential_tag);
count_if(_IIter, _IIter, _Predicate, __gnu_parallel::sequential_tag);
template<typename _IIter, typename Predicate>
template<typename _IIter, typename _Predicate>
typename iterator_traits<_IIter>::difference_type
count_if(_IIter, _IIter, Predicate, __gnu_parallel::parallelism);
count_if(_IIter, _IIter, _Predicate, __gnu_parallel::parallelism);
template<typename _IIter, typename Predicate, typename _IterTag>
template<typename _IIter, typename _Predicate, typename _IterTag>
typename iterator_traits<_IIter>::difference_type
count_if_switch(_IIter, _IIter, Predicate, _IterTag);
count_if_switch(_IIter, _IIter, _Predicate, _IterTag);
template<typename _RAIter, typename Predicate>
template<typename _RAIter, typename _Predicate>
typename iterator_traits<_RAIter>::difference_type
count_if_switch(_RAIter, _RAIter, Predicate, random_access_iterator_tag,
count_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag,
__gnu_parallel::parallelism);
// algobase.h
......@@ -130,7 +130,8 @@ namespace __parallel
template<typename _IIter1, typename _IIter2, typename Predicate>
bool
equal(_IIter1, _IIter1, _IIter2, Predicate, __gnu_parallel::sequential_tag);
equal(_IIter1, _IIter1, _IIter2, Predicate,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2>
bool
......@@ -140,45 +141,47 @@ namespace __parallel
bool
equal(_IIter1, _IIter1, _IIter2, Predicate);
template<typename _IIter, typename T>
template<typename _IIter, typename _Tp>
_IIter
find(_IIter, _IIter, const T&, __gnu_parallel::sequential_tag);
find(_IIter, _IIter, const _Tp&, __gnu_parallel::sequential_tag);
template<typename _IIter, typename T>
template<typename _IIter, typename _Tp>
_IIter
find(_IIter, _IIter, const T& val);
find(_IIter, _IIter, const _Tp& val);
template<typename _IIter, typename T, typename _IterTag>
template<typename _IIter, typename _Tp, typename _IterTag>
_IIter
find_switch(_IIter, _IIter, const T&, _IterTag);
find_switch(_IIter, _IIter, const _Tp&, _IterTag);
template<typename _RAIter, typename T>
template<typename _RAIter, typename _Tp>
_RAIter
find_switch(_RAIter, _RAIter, const T&, random_access_iterator_tag);
find_switch(_RAIter, _RAIter, const _Tp&, random_access_iterator_tag);
template<typename _IIter, typename Predicate>
template<typename _IIter, typename _Predicate>
_IIter
find_if(_IIter, _IIter, Predicate, __gnu_parallel::sequential_tag);
find_if(_IIter, _IIter, _Predicate, __gnu_parallel::sequential_tag);
template<typename _IIter, typename Predicate>
template<typename _IIter, typename _Predicate>
_IIter
find_if(_IIter, _IIter, Predicate);
find_if(_IIter, _IIter, _Predicate);
template<typename _IIter, typename Predicate, typename _IterTag>
template<typename _IIter, typename _Predicate, typename _IterTag>
_IIter
find_if_switch(_IIter, _IIter, Predicate, _IterTag);
find_if_switch(_IIter, _IIter, _Predicate, _IterTag);
template<typename _RAIter, typename Predicate>
template<typename _RAIter, typename _Predicate>
_RAIter
find_if_switch(_RAIter, _RAIter, Predicate, random_access_iterator_tag);
find_if_switch(_RAIter, _RAIter, _Predicate, random_access_iterator_tag);
template<typename _IIter, typename _FIter>
_IIter
find_first_of(_IIter, _IIter, _FIter, _FIter, __gnu_parallel::sequential_tag);
find_first_of(_IIter, _IIter, _FIter, _FIter,
__gnu_parallel::sequential_tag);
template<typename _IIter, typename _FIter, typename _BiPredicate>
_IIter
find_first_of(_IIter, _IIter, _FIter, _FIter, _BiPredicate, __gnu_parallel::sequential_tag);
find_first_of(_IIter, _IIter, _FIter, _FIter, _BiPredicate,
__gnu_parallel::sequential_tag);
template<typename _IIter, typename _FIter, typename _BiPredicate>
_IIter
......@@ -188,131 +191,147 @@ namespace __parallel
_IIter
find_first_of(_IIter, _IIter, _FIter, _FIter);
template<typename _IIter, typename _FIter, typename _IterTag1, typename _IterTag2>
template<typename _IIter, typename _FIter,
typename _IterTag1, typename _IterTag2>
_IIter
find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _IterTag1, _IterTag2);
template<typename _RAIter, typename _FIter, typename _BiPredicate, typename _IterTag>
template<typename _RAIter, typename _FIter, typename _BiPredicate,
typename _IterTag>
_RAIter
find_first_of_switch(_RAIter, _RAIter, _FIter, _FIter, _BiPredicate, random_access_iterator_tag, _IterTag);
find_first_of_switch(_RAIter, _RAIter, _FIter, _FIter, _BiPredicate,
random_access_iterator_tag, _IterTag);
template<typename _IIter, typename _FIter, typename _BiPredicate, typename _IterTag1, typename _IterTag2>
template<typename _IIter, typename _FIter, typename _BiPredicate,
typename _IterTag1, typename _IterTag2>
_IIter
find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _BiPredicate, _IterTag1, _IterTag2);
find_first_of_switch(_IIter, _IIter, _FIter, _FIter, _BiPredicate,
_IterTag1, _IterTag2);
template<typename _IIter, typename Function>
Function
for_each(_IIter, _IIter, Function);
template<typename _IIter, typename _Function>
_Function
for_each(_IIter, _IIter, _Function);
template<typename _IIter, typename Function>
Function
for_each(_IIter, _IIter, Function, __gnu_parallel::sequential_tag);
template<typename _IIter, typename _Function>
_Function
for_each(_IIter, _IIter, _Function, __gnu_parallel::sequential_tag);
template<typename Iterator, typename Function>
Function
for_each(Iterator, Iterator, Function, __gnu_parallel::parallelism);
template<typename _Iterator, typename _Function>
_Function
for_each(_Iterator, _Iterator, _Function, __gnu_parallel::parallelism);
template<typename _IIter, typename Function, typename _IterTag>
Function
for_each_switch(_IIter, _IIter, Function, _IterTag);
template<typename _IIter, typename _Function, typename _IterTag>
_Function
for_each_switch(_IIter, _IIter, _Function, _IterTag);
template<typename _RAIter, typename Function>
Function
for_each_switch(_RAIter, _RAIter, Function, random_access_iterator_tag,
template<typename _RAIter, typename _Function>
_Function
for_each_switch(_RAIter, _RAIter, _Function, random_access_iterator_tag,
__gnu_parallel::parallelism);
template<typename _FIter, typename Generator>
template<typename _FIter, typename _Generator>
void
generate(_FIter, _FIter, Generator);
generate(_FIter, _FIter, _Generator);
template<typename _FIter, typename Generator>
template<typename _FIter, typename _Generator>
void
generate(_FIter, _FIter, Generator, __gnu_parallel::sequential_tag);
generate(_FIter, _FIter, _Generator, __gnu_parallel::sequential_tag);
template<typename _FIter, typename Generator>
template<typename _FIter, typename _Generator>
void
generate(_FIter, _FIter, Generator, __gnu_parallel::parallelism);
generate(_FIter, _FIter, _Generator, __gnu_parallel::parallelism);
template<typename _FIter, typename Generator, typename _IterTag>
template<typename _FIter, typename _Generator, typename _IterTag>
void
generate_switch(_FIter, _FIter, Generator, _IterTag);
generate_switch(_FIter, _FIter, _Generator, _IterTag);
template<typename _RAIter, typename Generator>
template<typename _RAIter, typename _Generator>
void
generate_switch(_RAIter, _RAIter, Generator, random_access_iterator_tag,
generate_switch(_RAIter, _RAIter, _Generator, random_access_iterator_tag,
__gnu_parallel::parallelism);
template<typename _OIter, typename Size, typename Generator>
template<typename _OIter, typename _Size, typename _Generator>
_OIter
generate_n(_OIter, Size, Generator);
generate_n(_OIter, _Size, _Generator);
template<typename _OIter, typename Size, typename Generator>
template<typename _OIter, typename _Size, typename _Generator>
_OIter
generate_n(_OIter, Size, Generator, __gnu_parallel::sequential_tag);
generate_n(_OIter, _Size, _Generator, __gnu_parallel::sequential_tag);
template<typename _OIter, typename Size, typename Generator>
template<typename _OIter, typename _Size, typename _Generator>
_OIter
generate_n(_OIter, Size, Generator, __gnu_parallel::parallelism);
generate_n(_OIter, _Size, _Generator, __gnu_parallel::parallelism);
template<typename _OIter, typename Size, typename Generator, typename _IterTag>
template<typename _OIter, typename _Size, typename _Generator,
typename _IterTag>
_OIter
generate_n_switch(_OIter, Size, Generator, _IterTag);
generate_n_switch(_OIter, _Size, _Generator, _IterTag);
template<typename _RAIter, typename Size, typename Generator>
template<typename _RAIter, typename _Size, typename _Generator>
_RAIter
generate_n_switch(_RAIter, Size, Generator, random_access_iterator_tag,
generate_n_switch(_RAIter, _Size, _Generator, random_access_iterator_tag,
__gnu_parallel::parallelism);
template<typename _IIter1, typename _IIter2>
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, __gnu_parallel::sequential_tag);
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _Predicate>
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, Predicate, __gnu_parallel::sequential_tag);
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Predicate,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2>
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
template<typename _IIter1, typename _IIter2, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _Predicate>
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, Predicate);
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Predicate);
template<typename _IIter1, typename _IIter2, typename Predicate, typename _IterTag1, typename _IterTag2>
template<typename _IIter1, typename _IIter2,
typename _Predicate, typename _IterTag1, typename _IterTag2>
bool
lexicographical_compare_switch(_IIter1, _IIter1, _IIter2, _IIter2, Predicate, _IterTag1, _IterTag2);
lexicographical_compare_switch(_IIter1, _IIter1, _IIter2, _IIter2,
_Predicate, _IterTag1, _IterTag2);
template<typename _RAIter1, typename _RAIter2, typename Predicate>
template<typename _RAIter1, typename _RAIter2, typename _Predicate>
bool
lexicographical_compare_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Predicate, random_access_iterator_tag, random_access_iterator_tag);
lexicographical_compare_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
_Predicate, random_access_iterator_tag,
random_access_iterator_tag);
// algo.h
template<typename _IIter1, typename _IIter2>
pair<_IIter1, _IIter2>
mismatch(_IIter1, _IIter1, _IIter2, __gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _Predicate>
pair<_IIter1, _IIter2>
mismatch(_IIter1, _IIter1, _IIter2, Predicate, __gnu_parallel::sequential_tag);
mismatch(_IIter1, _IIter1, _IIter2, _Predicate,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2>
pair<_IIter1, _IIter2>
mismatch(_IIter1, _IIter1, _IIter2);
template<typename _IIter1, typename _IIter2, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _Predicate>
pair<_IIter1, _IIter2>
mismatch(_IIter1, _IIter1, _IIter2, Predicate);
mismatch(_IIter1, _IIter1, _IIter2, _Predicate);
template<typename _IIter1, typename _IIter2, typename Predicate, typename _IterTag1, typename _IterTag2>
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _IterTag1, typename _IterTag2>
pair<_IIter1, _IIter2>
mismatch_switch(_IIter1, _IIter1, _IIter2, Predicate, _IterTag1, _IterTag2);
mismatch_switch(_IIter1, _IIter1, _IIter2, _Predicate,
_IterTag1, _IterTag2);
template<typename _RAIter1, typename _RAIter2, typename Predicate>
template<typename _RAIter1, typename _RAIter2, typename _Predicate>
pair<_RAIter1, _RAIter2>
mismatch_switch(_RAIter1, _RAIter1, _RAIter2, Predicate, random_access_iterator_tag, random_access_iterator_tag);
mismatch_switch(_RAIter1, _RAIter1, _RAIter2, _Predicate,
random_access_iterator_tag, random_access_iterator_tag);
template<typename _FIter1, typename _FIter2>
_FIter1
......@@ -324,7 +343,8 @@ namespace __parallel
template<typename _FIter1, typename _FIter2, typename _BiPredicate>
_FIter1
search(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate, __gnu_parallel::sequential_tag);
search(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate,
__gnu_parallel::sequential_tag);
template<typename _FIter1, typename _FIter2, typename _BiPredicate>
_FIter1
......@@ -332,43 +352,56 @@ namespace __parallel
template<typename _RAIter1, typename _RAIter2>
_RAIter1
search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, random_access_iterator_tag, random_access_iterator_tag);
search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
random_access_iterator_tag, random_access_iterator_tag);
template<typename _FIter1, typename _FIter2, typename _IterTag1, typename _IterTag2>
template<typename _FIter1, typename _FIter2, typename _IterTag1,
typename _IterTag2>
_FIter1
search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _IterTag1, _IterTag2);
template<typename _RAIter1, typename _RAIter2, typename _BiPredicate>
_RAIter1
search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _BiPredicate , random_access_iterator_tag, random_access_iterator_tag);
search_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _BiPredicate,
random_access_iterator_tag, random_access_iterator_tag);
template<typename _FIter1, typename _FIter2, typename _BiPredicate, typename _IterTag1, typename _IterTag2>
template<typename _FIter1, typename _FIter2, typename _BiPredicate,
typename _IterTag1, typename _IterTag2>
_FIter1
search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate, _IterTag1, _IterTag2);
search_switch(_FIter1, _FIter1, _FIter2, _FIter2, _BiPredicate,
_IterTag1, _IterTag2);
template<typename _FIter, typename Integer, typename T>
template<typename _FIter, typename _Integer, typename _Tp>
_FIter
search_n(_FIter, _FIter, Integer, const T&, __gnu_parallel::sequential_tag);
search_n(_FIter, _FIter, _Integer, const _Tp&,
__gnu_parallel::sequential_tag);
template<typename _FIter, typename Integer, typename T, typename _BiPredicate>
template<typename _FIter, typename _Integer, typename _Tp,
typename _BiPredicate>
_FIter
search_n(_FIter, _FIter, Integer, const T&, _BiPredicate, __gnu_parallel::sequential_tag);
search_n(_FIter, _FIter, _Integer, const _Tp&, _BiPredicate,
__gnu_parallel::sequential_tag);
template<typename _FIter, typename Integer, typename T>
template<typename _FIter, typename _Integer, typename _Tp>
_FIter
search_n(_FIter, _FIter, Integer, const T& val);
search_n(_FIter, _FIter, _Integer, const _Tp&);
template<typename _FIter, typename Integer, typename T, typename _BiPredicate>
template<typename _FIter, typename _Integer, typename _Tp,
typename _BiPredicate>
_FIter
search_n(_FIter, _FIter, Integer, const T&, _BiPredicate);
search_n(_FIter, _FIter, _Integer, const _Tp&, _BiPredicate);
template<typename _RAIter, typename Integer, typename T, typename _BiPredicate>
template<typename _RAIter, typename _Integer, typename _Tp,
typename _BiPredicate>
_RAIter
search_n_switch(_RAIter, _RAIter, Integer, const T&, _BiPredicate, random_access_iterator_tag);
search_n_switch(_RAIter, _RAIter, _Integer, const _Tp&,
_BiPredicate, random_access_iterator_tag);
template<typename _FIter, typename Integer, typename T, typename _BiPredicate, typename _IterTag>
template<typename _FIter, typename _Integer, typename _Tp,
typename _BiPredicate, typename _IterTag>
_FIter
search_n_switch(_FIter, _FIter, Integer, const T&, _BiPredicate, _IterTag);
search_n_switch(_FIter, _FIter, _Integer, const _Tp&,
_BiPredicate, _IterTag);
template<typename _IIter, typename _OIter, typename UnaryOperation>
......@@ -385,7 +418,8 @@ namespace __parallel
transform(_IIter, _IIter, _OIter, UnaryOperation,
__gnu_parallel::parallelism);
template<typename _IIter, typename _OIter, typename UnaryOperation, typename _IterTag1, typename _IterTag2>
template<typename _IIter, typename _OIter, typename UnaryOperation,
typename _IterTag1, typename _IterTag2>
_OIter
transform1_switch(_IIter, _IIter, _OIter, UnaryOperation,
_IterTag1, _IterTag2);
......@@ -398,78 +432,87 @@ namespace __parallel
__gnu_parallel::parallelism);
template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _BiOperation>
_OIter
transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation);
template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _BiOperation>
_OIter
transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _BiOperation>
_OIter
transform(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation,
__gnu_parallel::parallelism);
template<typename _RAIter1, typename _RAIter2, typename _RAIter3, typename _BiOperation>
template<typename _RAIter1, typename _RAIter2, typename _RAIter3,
typename _BiOperation>
_RAIter3
transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation,
random_access_iterator_tag, random_access_iterator_tag,
random_access_iterator_tag,
__gnu_parallel::parallelism parallelism_tag);
template<typename _IIter1, typename _IIter2, typename _OIter, typename _BiOperation, typename tag1, typename tag2, typename tag3>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _BiOperation, typename _Tag1,
typename _Tag2, typename _Tag3>
_OIter
transform2_switch(_IIter1, _IIter1, _IIter2, _OIter, _BiOperation,
tag1, tag2, tag3);
_Tag1, _Tag2, _Tag3);
template<typename _FIter, typename T>
template<typename _FIter, typename _Tp>
void
replace(_FIter, _FIter, const T&, const T&);
replace(_FIter, _FIter, const _Tp&, const _Tp&);
template<typename _FIter, typename T>
template<typename _FIter, typename _Tp>
void
replace(_FIter, _FIter, const T&, const T&,
replace(_FIter, _FIter, const _Tp&, const _Tp&,
__gnu_parallel::sequential_tag);
template<typename _FIter, typename T>
template<typename _FIter, typename _Tp>
void
replace(_FIter, _FIter, const T&, const T&, __gnu_parallel::parallelism);
replace(_FIter, _FIter, const _Tp&, const _Tp&,
__gnu_parallel::parallelism);
template<typename _FIter, typename T, typename _IterTag>
template<typename _FIter, typename _Tp, typename _IterTag>
void
replace_switch(_FIter, _FIter, const T&, const T&, _IterTag);
replace_switch(_FIter, _FIter, const _Tp&, const _Tp&, _IterTag);
template<typename _RAIter, typename T>
template<typename _RAIter, typename _Tp>
void
replace_switch(_RAIter, _RAIter, const T&, const T&,
replace_switch(_RAIter, _RAIter, const _Tp&, const _Tp&,
random_access_iterator_tag, __gnu_parallel::parallelism);
template<typename _FIter, typename Predicate, typename T>
template<typename _FIter, typename _Predicate, typename _Tp>
void
replace_if(_FIter, _FIter, Predicate, const T&);
replace_if(_FIter, _FIter, _Predicate, const _Tp&);
template<typename _FIter, typename Predicate, typename T>
template<typename _FIter, typename _Predicate, typename _Tp>
void
replace_if(_FIter, _FIter, Predicate, const T&,
replace_if(_FIter, _FIter, _Predicate, const _Tp&,
__gnu_parallel::sequential_tag);
template<typename _FIter, typename Predicate, typename T>
template<typename _FIter, typename _Predicate, typename _Tp>
void
replace_if(_FIter, _FIter, Predicate, const T&,
replace_if(_FIter, _FIter, _Predicate, const _Tp&,
__gnu_parallel::parallelism);
template<typename _FIter, typename Predicate, typename T, typename _IterTag>
template<typename _FIter, typename _Predicate, typename _Tp,
typename _IterTag>
void
replace_if_switch(_FIter, _FIter, Predicate, const T&, _IterTag);
replace_if_switch(_FIter, _FIter, _Predicate, const _Tp&, _IterTag);
template<typename _RAIter, typename Predicate, typename T>
template<typename _RAIter, typename _Predicate, typename _Tp>
void
replace_if_switch(_RAIter, _RAIter, Predicate, const T&,
random_access_iterator_tag, __gnu_parallel::parallelism);
replace_if_switch(_RAIter, _RAIter, _Predicate, const _Tp&,
random_access_iterator_tag,
__gnu_parallel::parallelism);
template<typename _FIter>
......@@ -511,12 +554,14 @@ namespace __parallel
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
......@@ -524,12 +569,15 @@ namespace __parallel
_OIter
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare, typename _IterTag1, typename _IterTag2, typename _IterTag3>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare, typename _IterTag1, typename _IterTag2,
typename _IterTag3>
_OIter
merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare,
_IterTag1, _IterTag2, _IterTag3);
template<typename _IIter1, typename _IIter2, typename _OIter, typename _Compare>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
merge_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare,
random_access_iterator_tag, random_access_iterator_tag,
......@@ -575,7 +623,8 @@ namespace __parallel
template<typename _RAIter, typename _Compare>
void
nth_element(_RAIter, _RAIter, _RAIter, _Compare, __gnu_parallel::sequential_tag);
nth_element(_RAIter, _RAIter, _RAIter, _Compare,
__gnu_parallel::sequential_tag);
template<typename _RAIter, typename _Compare>
void
......@@ -587,7 +636,8 @@ namespace __parallel
template<typename _RAIter, typename _Compare>
void
partial_sort(_RAIter, _RAIter, _RAIter, _Compare, __gnu_parallel::sequential_tag);
partial_sort(_RAIter, _RAIter, _RAIter, _Compare,
__gnu_parallel::sequential_tag);
template<typename _RAIter>
void
......@@ -621,114 +671,163 @@ namespace __parallel
void
random_shuffle(_RAIter, _RAIter, __gnu_parallel::sequential_tag);
template<typename _RAIter, typename RandomNumberGenerator>
template<typename _RAIter, typename _RandomNumberGenerator>
void
random_shuffle(_RAIter, _RAIter, RandomNumberGenerator& rand, __gnu_parallel::sequential_tag);
random_shuffle(_RAIter, _RAIter, _RandomNumberGenerator&,
__gnu_parallel::sequential_tag);
template<typename _RAIter>
void
random_shuffle(_RAIter, _RAIter);
template<typename _RAIter, typename RandomNumberGenerator>
template<typename _RAIter, typename _RandomNumberGenerator>
void
random_shuffle(_RAIter, _RAIter, RandomNumberGenerator& rand);
random_shuffle(_RAIter, _RAIter, _RandomNumberGenerator&);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename Predicate>
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Predicate>
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _OIter, typename _IterTag1, typename _IterTag2,
typename _IterTag3>
_OIter
set_union_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
set_union_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
_Predicate, _IterTag1, _IterTag2, _IterTag3);
template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
Output_RAIter
set_union_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
typename _Predicate>
_Output_RAIter
set_union_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, _Output_RAIter,
_Predicate, random_access_iterator_tag,
random_access_iterator_tag, random_access_iterator_tag);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Predicate>
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Predicate>
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _OIter, typename _IterTag1, typename _IterTag2,
typename _IterTag3>
_OIter
set_intersection_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
set_intersection_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
_Predicate, _IterTag1, _IterTag2, _IterTag3);
template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
Output_RAIter
set_intersection_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
typename _Predicate>
_Output_RAIter
set_intersection_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
_Output_RAIter, _Predicate,
random_access_iterator_tag,
random_access_iterator_tag,
random_access_iterator_tag);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Predicate>
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
_Predicate, __gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Predicate>
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
_Predicate);
template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _OIter, typename _IterTag1, typename _IterTag2,
typename _IterTag3>
_OIter
set_symmetric_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
set_symmetric_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2,
_OIter, _Predicate, _IterTag1, _IterTag2,
_IterTag3);
template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
Output_RAIter
set_symmetric_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
typename _Predicate>
_Output_RAIter
set_symmetric_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
_Output_RAIter, _Predicate,
random_access_iterator_tag,
random_access_iterator_tag,
random_access_iterator_tag);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, __gnu_parallel::sequential_tag);
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Predicate>
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, __gnu_parallel::sequential_tag);
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate,
__gnu_parallel::sequential_tag);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter, typename Predicate>
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Predicate>
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate);
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Predicate);
template<typename _IIter1, typename _IIter2, typename Predicate, typename _OIter, typename _IterTag1, typename _IterTag2, typename _IterTag3>
template<typename _IIter1, typename _IIter2, typename _Predicate,
typename _OIter, typename _IterTag1, typename _IterTag2,
typename _IterTag3>
_OIter
set_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, Predicate, _IterTag1, _IterTag2, _IterTag3);
set_difference_switch(_IIter1, _IIter1, _IIter2, _IIter2, _OIter,
_Predicate, _IterTag1, _IterTag2, _IterTag3);
template<typename _RAIter1, typename _RAIter2, typename Output_RAIter, typename Predicate>
Output_RAIter
set_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2, Output_RAIter, Predicate, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag);
template<typename _RAIter1, typename _RAIter2, typename _Output_RAIter,
typename _Predicate>
_Output_RAIter
set_difference_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter2,
_Output_RAIter, _Predicate,
random_access_iterator_tag,
random_access_iterator_tag,
random_access_iterator_tag);
template<typename _RAIter>
......@@ -767,25 +866,28 @@ namespace __parallel
_OIter
unique_copy(_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag);
template<typename _IIter, typename _OIter, typename Predicate>
template<typename _IIter, typename _OIter, typename _Predicate>
_OIter
unique_copy(_IIter, _IIter, _OIter, Predicate, __gnu_parallel::sequential_tag);
unique_copy(_IIter, _IIter, _OIter, _Predicate,
__gnu_parallel::sequential_tag);
template<typename _IIter, typename _OIter>
_OIter
unique_copy(_IIter, _IIter, _OIter);
template<typename _IIter, typename _OIter, typename Predicate>
template<typename _IIter, typename _OIter, typename _Predicate>
_OIter
unique_copy(_IIter, _IIter, _OIter, Predicate);
unique_copy(_IIter, _IIter, _OIter, _Predicate);
template<typename _IIter, typename _OIter, typename Predicate, typename _IterTag1, typename _IterTag2>
template<typename _IIter, typename _OIter, typename _Predicate,
typename _IterTag1, typename _IterTag2>
_OIter
unique_copy_switch(_IIter, _IIter, _OIter, Predicate, _IterTag1, _IterTag2);
unique_copy_switch(_IIter, _IIter, _OIter, _Predicate,
_IterTag1, _IterTag2);
template<typename _RAIter, typename RandomAccess_OIter, typename Predicate>
RandomAccess_OIter
unique_copy_switch(_RAIter, _RAIter, RandomAccess_OIter, Predicate,
template<typename _RAIter, typename _RandomAccess_OIter, typename _Predicate>
_RandomAccess_OIter
unique_copy_switch(_RAIter, _RAIter, _RandomAccess_OIter, _Predicate,
random_access_iterator_tag, random_access_iterator_tag);
} // end namespace __parallel
} // end namespace std
......
libstdc++-v3/include/parallel/balanced_quicksort.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -102,7 +102,7 @@ template<typename RandomAccessIterator>
* this part.
* @pre @c (end-begin)>=1 */
template<typename RandomAccessIterator, typename Comparator>
inline typename std::iterator_traits<RandomAccessIterator>::difference_type
typename std::iterator_traits<RandomAccessIterator>::difference_type
qsb_divide(RandomAccessIterator begin, RandomAccessIterator end,
Comparator comp, thread_index_t num_threads)
{
......@@ -164,7 +164,7 @@ template<typename RandomAccessIterator, typename Comparator>
* @param num_threads
* Number of threads that are allowed to work on this part. */
template<typename RandomAccessIterator, typename Comparator>
inline void
void
qsb_conquer(QSBThreadLocal<RandomAccessIterator>** tls,
RandomAccessIterator begin, RandomAccessIterator end,
Comparator comp,
......@@ -240,7 +240,7 @@ template<typename RandomAccessIterator, typename Comparator>
* @param iam Number of the thread processing this function.
*/
template<typename RandomAccessIterator, typename Comparator>
inline void
void
qsb_local_sort_with_helping(QSBThreadLocal<RandomAccessIterator>** tls,
Comparator& comp, int iam, bool wait)
{
......@@ -418,7 +418,7 @@ template<typename RandomAccessIterator, typename Comparator>
* this part.
*/
template<typename RandomAccessIterator, typename Comparator>
inline void
void
parallel_sort_qsb(RandomAccessIterator begin, RandomAccessIterator end,
Comparator comp,
typename std::iterator_traits<RandomAccessIterator>
......
libstdc++-v3/include/parallel/checkers.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -54,7 +54,10 @@ namespace __gnu_parallel
// XXX Comparator default template argument
template<typename InputIterator, typename Comparator>
bool
is_sorted(InputIterator begin, InputIterator end, Comparator comp = std::less<typename std::iterator_traits<InputIterator>::value_type>())
is_sorted(InputIterator begin, InputIterator end,
Comparator comp
= std::less<typename std::iterator_traits<InputIterator>::
value_type>())
{
if (begin == end)
return true;
......@@ -66,7 +69,8 @@ namespace __gnu_parallel
{
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;
......@@ -88,7 +92,11 @@ namespace __gnu_parallel
// XXX Comparator default template argument
template<typename InputIterator, typename Comparator>
bool
is_sorted_failure(InputIterator begin, InputIterator end, InputIterator& first_failure, Comparator comp = std::less<typename std::iterator_traits<InputIterator>::value_type>())
is_sorted_failure(InputIterator begin, InputIterator end,
InputIterator& first_failure,
Comparator comp
= std::less<typename std::iterator_traits<InputIterator>::
value_type>())
{
if (begin == end)
return true;
......@@ -101,7 +109,8 @@ namespace __gnu_parallel
if (comp(*current, *recent))
{
first_failure = current;
printf("is_sorted: check failed before position %lld.\n", position);
printf("is_sorted: check failed before position %lld.\n",
position);
return false;
}
recent = current;
......@@ -123,7 +132,10 @@ namespace __gnu_parallel
template<typename InputIterator, typename Comparator>
bool
// XXX Comparator default template argument
is_sorted_print_failures(InputIterator begin, InputIterator end, Comparator comp = std::less<typename std::iterator_traits<InputIterator>::value_type>())
is_sorted_print_failures(InputIterator begin, InputIterator end,
Comparator comp
= std::less<typename std::iterator_traits
<InputIterator>::value_type>())
{
if (begin == end)
return true;
......
libstdc++-v3/include/parallel/find.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -58,8 +58,7 @@ namespace __gnu_parallel
* @param selector Functionality (e. g. std::find_if (), std::equal(),...)
* @return Place of finding in both sequences.
*/
template<
typename RandomAccessIterator1,
template<typename RandomAccessIterator1,
typename RandomAccessIterator2,
typename Pred,
typename Selector>
......@@ -96,8 +95,7 @@ template<
* @param selector Functionality (e. g. std::find_if (), std::equal(),...)
* @return Place of finding in both sequences.
*/
template<
typename RandomAccessIterator1,
template<typename RandomAccessIterator1,
typename RandomAccessIterator2,
typename Pred,
typename Selector>
......@@ -190,8 +188,7 @@ template<
* for CSB, the blocks are allocated in a predetermined manner,
* namely spacial round-robin.
*/
template<
typename RandomAccessIterator1,
template<typename RandomAccessIterator1,
typename RandomAccessIterator2,
typename Pred,
typename Selector>
......@@ -311,8 +308,7 @@ template<
* blocks are allocated in a predetermined manner, namely spacial
* round-robin.
*/
template<
typename RandomAccessIterator1,
template<typename RandomAccessIterator1,
typename RandomAccessIterator2,
typename Pred,
typename Selector>
......
libstdc++-v3/include/parallel/find_selectors.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -60,8 +60,9 @@ namespace __gnu_parallel
* @param i2 Iterator on second sequence (unused).
* @param pred Find predicate.
*/
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
inline bool
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename Pred>
bool
operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
{ return pred(*i1); }
......@@ -71,12 +72,14 @@ namespace __gnu_parallel
* @param begin2 Begin iterator of second sequence.
* @param pred Find predicate.
*/
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
sequential_algorithm(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Pred pred)
{
return std::make_pair(find_if(begin1, end1, pred, sequential_tag()), begin2);
}
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename Pred>
std::pair<RandomAccessIterator1, RandomAccessIterator2>
sequential_algorithm(RandomAccessIterator1 begin1,
RandomAccessIterator1 end1,
RandomAccessIterator2 begin2, Pred pred)
{ return std::make_pair(find_if(begin1, end1, pred,
sequential_tag()), begin2); }
};
/** @brief Test predicate on two adjacent elements. */
......@@ -87,8 +90,9 @@ namespace __gnu_parallel
* @param i2 Iterator on second sequence (unused).
* @param pred Find predicate.
*/
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
inline bool
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename Pred>
bool
operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
{
// Passed end iterator is one short.
......@@ -101,12 +105,16 @@ namespace __gnu_parallel
* @param begin2 Begin iterator of second sequence.
* @param pred Find predicate.
*/
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
sequential_algorithm(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Pred pred)
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename Pred>
std::pair<RandomAccessIterator1, RandomAccessIterator2>
sequential_algorithm(RandomAccessIterator1 begin1,
RandomAccessIterator1 end1,
RandomAccessIterator2 begin2, Pred pred)
{
// Passed end iterator is one short.
RandomAccessIterator1 spot = adjacent_find(begin1, end1 + 1, pred, sequential_tag());
RandomAccessIterator1 spot = adjacent_find(begin1, end1 + 1,
pred, sequential_tag());
if (spot == (end1 + 1))
spot = end1;
return std::make_pair(spot, begin2);
......@@ -122,8 +130,9 @@ namespace __gnu_parallel
* @param i2 Iterator on second sequence (unused).
* @param pred Find predicate.
*/
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
inline bool
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename Pred>
bool
operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
{ return !pred(*i1, *i2); }
......@@ -134,12 +143,13 @@ namespace __gnu_parallel
* @param begin2 Begin iterator of second sequence.
* @param pred Find predicate.
*/
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
sequential_algorithm(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Pred pred)
{
return mismatch(begin1, end1, begin2, pred, sequential_tag());
}
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename Pred>
std::pair<RandomAccessIterator1, RandomAccessIterator2>
sequential_algorithm(RandomAccessIterator1 begin1,
RandomAccessIterator1 end1,
RandomAccessIterator2 begin2, Pred pred)
{ return mismatch(begin1, end1, begin2, pred, sequential_tag()); }
};
......@@ -157,11 +167,13 @@ namespace __gnu_parallel
* @param i1 Iterator on first sequence.
* @param i2 Iterator on second sequence (unused).
* @param pred Find predicate. */
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
inline bool
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename Pred>
bool
operator()(RandomAccessIterator1 i1, RandomAccessIterator2 i2, Pred pred)
{
for (ForwardIterator pos_in_candidates = begin; pos_in_candidates != end; 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;
......@@ -172,12 +184,14 @@ namespace __gnu_parallel
* @param end1 End iterator of first sequence.
* @param begin2 Begin iterator of second sequence.
* @param pred Find predicate. */
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Pred>
inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
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);
}
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename Pred>
std::pair<RandomAccessIterator1, RandomAccessIterator2>
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); }
};
}
......
libstdc++-v3/include/parallel/for_each.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -61,22 +61,42 @@ namespace __gnu_parallel
* @param output Output iterator.
* @param bound Maximum number of elements processed.
* @param parallelism_tag Parallelization method */
template<typename InputIterator, typename UserOp, typename Functionality, typename Red, typename Result>
template<typename InputIterator, typename UserOp,
typename Functionality, typename Red, typename Result>
UserOp
for_each_template_random_access(InputIterator begin, InputIterator end,
UserOp user_op, Functionality& functionality,
UserOp user_op,
Functionality& functionality,
Red reduction, Result reduction_start,
Result& output,
typename std::iterator_traits<InputIterator>::difference_type bound, parallelism parallelism_tag)
Result& output, typename
std::iterator_traits<InputIterator>::
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);
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);
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);
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);
}
}
......
libstdc++-v3/include/parallel/for_each_selectors.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -63,7 +63,8 @@ namespace __gnu_parallel
* @param o Operator.
* @param i Iterator referencing object. */
template<typename Op>
inline bool operator()(Op& o, It i)
bool
operator()(Op& o, It i)
{
o(*i);
return true;
......@@ -78,7 +79,8 @@ namespace __gnu_parallel
* @param o Operator.
* @param i Iterator referencing object. */
template<typename Op>
inline bool operator()(Op& o, It i)
bool
operator()(Op& o, It i)
{
*i = o();
return true;
......@@ -93,7 +95,8 @@ namespace __gnu_parallel
* @param v Current value.
* @param i Iterator referencing object. */
template<typename Val>
inline bool operator()(Val& v, It i)
bool
operator()(Val& v, It i)
{
*i = v;
return true;
......@@ -108,7 +111,8 @@ namespace __gnu_parallel
* @param o Operator.
* @param i Iterator referencing object. */
template<typename Op>
inline bool operator()(Op& o, It i)
bool
operator()(Op& o, It i)
{
*i.second = o(*i.first);
return true;
......@@ -123,7 +127,8 @@ namespace __gnu_parallel
* @param o Operator.
* @param i Iterator referencing object. */
template<typename Op>
inline bool operator()(Op& o, It i)
bool
operator()(Op& o, It i)
{
*i.third = o(*i.first, *i.second);
return true;
......@@ -144,7 +149,8 @@ namespace __gnu_parallel
/** @brief Functor execution.
* @param v Current value.
* @param i Iterator referencing object. */
inline bool operator()(T& v, It i)
bool
operator()(T& v, It i)
{
if (*i == v)
*i = new_val;
......@@ -166,7 +172,8 @@ namespace __gnu_parallel
/** @brief Functor execution.
* @param o Operator.
* @param i Iterator referencing object. */
inline bool operator()(Op& o, It i)
bool
operator()(Op& o, It i)
{
if (o(*i))
*i = new_val;
......@@ -183,7 +190,8 @@ namespace __gnu_parallel
* @param i Iterator referencing object.
* @return 1 if count, 0 if does not count. */
template<typename Val>
inline Diff operator()(Val& v, It i)
Diff
operator()(Val& v, It i)
{ return (v == *i) ? 1 : 0; }
};
......@@ -196,7 +204,8 @@ namespace __gnu_parallel
* @param i Iterator referencing object.
* @return 1 if count, 0 if does not count. */
template<typename Op>
inline Diff operator()(Op& o, It i)
Diff
operator()(Op& o, It i)
{ return (o(*i)) ? 1 : 0; }
};
......@@ -209,7 +218,7 @@ namespace __gnu_parallel
* @param i Iterator referencing object.
* @return The current value. */
template<typename Op>
inline typename std::iterator_traits<It>::value_type operator()(Op o, It i)
typename std::iterator_traits<It>::value_type operator()(Op o, It i)
{ return *i; }
};
......@@ -226,16 +235,19 @@ namespace __gnu_parallel
/** @brief Constructor.
* @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) { }
explicit 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<typename Op>
inline T operator()(Op mult, It current)
T
operator()(Op mult, It current)
{
typename std::iterator_traits<It>::difference_type position = current - begin1_iterator;
typename std::iterator_traits<It>::difference_type position
= current - begin1_iterator;
return mult(*current, *(begin2_iterator + position));
}
};
......@@ -249,7 +261,8 @@ namespace __gnu_parallel
* @param i Iterator referencing object.
* @return Passed iterator. */
template<typename Op>
inline It operator()(Op o, It i)
It
operator()(Op o, It i)
{ return i; }
};
......@@ -260,7 +273,8 @@ namespace __gnu_parallel
struct adjacent_difference_selector : public generic_for_each_selector<It>
{
template<typename Op>
inline bool operator()(Op& o, It i)
bool
operator()(Op& o, It i)
{
typename It::first_type go_back_one = i.first;
--go_back_one;
......@@ -280,14 +294,15 @@ namespace __gnu_parallel
/** @brief Functor execution.
* @param i Iterator referencing object. */
template<typename It>
inline void operator()(It i)
{ }
void
operator()(It i) { }
};
/** @brief Reduction function doing nothing. */
struct dummy_reduct
{
inline bool operator()(bool /*x*/, bool /*y*/) const
bool
operator()(bool /*x*/, bool /*y*/) const
{ return true; }
};
......@@ -300,7 +315,8 @@ namespace __gnu_parallel
explicit min_element_reduct(Comp &c) : comp(c)
{ }
inline It operator()(It x, It y)
It
operator()(It x, It y)
{
if (comp(*x, *y))
return x;
......@@ -318,7 +334,8 @@ namespace __gnu_parallel
explicit max_element_reduct(Comp& c) : comp(c)
{ }
inline It operator()(It x, It y)
It
operator()(It x, It y)
{
if (comp(*x, *y))
return y;
......@@ -336,7 +353,9 @@ namespace __gnu_parallel
explicit accumulate_binop_reduct(BinOp& b) : binop(b) {}
template<typename Result, typename Addend>
Result operator()(const Result& x, const Addend& y) { return binop(x, y); }
Result
operator()(const Result& x, const Addend& y)
{ return binop(x, y); }
};
}
......
libstdc++-v3/include/parallel/iterator.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -120,11 +120,13 @@ namespace __gnu_parallel
/** @brief A triple of iterators. The usual iterator operations are
applied to all three child iterators.
*/
template<typename Iterator1, typename Iterator2, typename Iterator3, typename IteratorCategory>
template<typename Iterator1, typename Iterator2, typename Iterator3,
typename IteratorCategory>
class iterator_triple
{
private:
typedef iterator_triple<Iterator1, Iterator2, Iterator3, IteratorCategory> type;
typedef iterator_triple<Iterator1, Iterator2, Iterator3,
IteratorCategory> type;
public:
typedef IteratorCategory iterator_category;
......
libstdc++-v3/include/parallel/list_partition.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -53,13 +53,13 @@ namespace __gnu_parallel
*/
template<typename InputIterator>
void
shrink_and_double(std::vector<InputIterator>& os_starts, size_t& count_to_two, size_t& range_length, const bool make_twice)
shrink_and_double(std::vector<InputIterator>& 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);
}
else
{
os_starts.resize((os_starts.size() - 1) * 2 + 1);
......@@ -76,10 +76,9 @@ namespace __gnu_parallel
shrink(std::vector<InputIterator>& os_starts, size_t& count_to_two,
size_t& range_length)
{
for (typename std::vector<InputIterator>::size_type i = 0; i <= (os_starts.size() / 2); ++i)
{
for (typename std::vector<InputIterator>::size_type i = 0;
i <= (os_starts.size() / 2); ++i)
os_starts[i] = os_starts[i * 2];
}
range_length *= 2;
}
......@@ -125,11 +124,13 @@ namespace __gnu_parallel
size_t cur = 1, next = 1;
size_t range_length = 1;
size_t count_to_two = 0;
while (it != end){
while (it != end)
{
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;
......@@ -143,7 +144,7 @@ namespace __gnu_parallel
break;
shrink_and_double(os_starts, count_to_two, range_length, make_twice);
next = os_starts.size()/2 + 1;
next = os_starts.size() / 2 + 1;
}
// Calculation of the parts (one must be extracted from current
......
libstdc++-v3/include/parallel/losertree.h
......@@ -76,7 +76,6 @@ template<typename T, typename Comparator = std::less<T> >
Comparator comp;
public:
inline
LoserTreeExplicit(unsigned int _size, Comparator _comp = std::less<T>())
: comp(_comp)
{
......@@ -92,14 +91,14 @@ template<typename T, typename Comparator = std::less<T> >
}
}
inline ~LoserTreeExplicit()
~LoserTreeExplicit()
{ delete[] losers; }
inline int
int
get_min_source()
{ return losers[0].source; }
inline void
void
insert_start(T key, int source, bool sup)
{
bool inf = false;
......@@ -122,10 +121,10 @@ template<typename T, typename Comparator = std::less<T> >
losers[0].source = source;
}
inline void
void
init() { }
inline void
void
delete_min_insert(T key, bool sup)
{
bool inf = false;
......@@ -151,7 +150,7 @@ template<typename T, typename Comparator = std::less<T> >
losers[0].source = source;
}
inline void
void
insert_start_stable(T key, int source, bool sup)
{
bool inf = false;
......@@ -176,10 +175,10 @@ template<typename T, typename Comparator = std::less<T> >
losers[0].source = source;
}
inline void
void
init_stable() { }
inline void
void
delete_min_insert_stable(T key, bool sup)
{
bool inf = false;
......@@ -233,7 +232,7 @@ template<typename T, typename Comparator = std::less<T> >
bool first_insert;
public:
inline LoserTree(unsigned int _k, Comparator _comp = std::less<T>())
LoserTree(unsigned int _k, Comparator _comp = std::less<T>())
: comp(_comp)
{
ik = _k;
......@@ -249,14 +248,14 @@ template<typename T, typename Comparator = std::less<T> >
first_insert = true;
}
inline ~LoserTree()
~LoserTree()
{ ::operator delete(losers); }
inline int
int
get_min_source()
{ return losers[0].source; }
inline void
void
insert_start(const T& key, int source, bool sup)
{
unsigned int pos = k + source;
......@@ -303,12 +302,12 @@ template<typename T, typename Comparator = std::less<T> >
}
}
inline void
void
init()
{ losers[0] = losers[init_winner(1)]; }
// Do not pass const reference since key will be used as local variable.
inline void
void
delete_min_insert(T key, bool sup)
{
int source = losers[0].source;
......@@ -329,7 +328,7 @@ template<typename T, typename Comparator = std::less<T> >
losers[0].key = key;
}
inline void
void
insert_start_stable(const T& key, int source, bool sup)
{ return insert_start(key, source, sup); }
......@@ -361,12 +360,12 @@ template<typename T, typename Comparator = std::less<T> >
}
}
inline void
void
init_stable()
{ losers[0] = losers[init_winner_stable(1)]; }
// Do not pass const reference since key will be used as local variable.
inline void
void
delete_min_insert_stable(T key, bool sup)
{
int source = losers[0].source;
......@@ -432,7 +431,6 @@ template<typename T, typename Comparator = std::less<T> >
Comparator comp;
public:
inline
LoserTreeReference(unsigned int _k, Comparator _comp = std::less<T>())
: comp(_comp)
{
......@@ -449,7 +447,7 @@ template<typename T, typename Comparator = std::less<T> >
losers[i + k].sup = true;
}
inline ~LoserTreeReference()
~LoserTreeReference()
{
delete[] losers;
#ifndef COPY
......@@ -457,11 +455,11 @@ template<typename T, typename Comparator = std::less<T> >
#endif
}
inline int
int
get_min_source()
{ return losers[0].source; }
inline void
void
insert_start(T key, int source, bool sup)
{
unsigned int pos = k + source;
......@@ -498,13 +496,13 @@ template<typename T, typename Comparator = std::less<T> >
}
}
inline void
void
init()
{
losers[0] = losers[init_winner(1)];
}
inline void
void
delete_min_insert(T key, bool sup)
{
int source = losers[0].source;
......@@ -529,7 +527,7 @@ template<typename T, typename Comparator = std::less<T> >
#endif
}
inline void
void
insert_start_stable(T key, int source, bool sup)
{ return insert_start(key, source, sup); }
......@@ -560,11 +558,11 @@ template<typename T, typename Comparator = std::less<T> >
}
}
inline void
void
init_stable()
{ losers[0] = losers[init_winner_stable(1)]; }
inline void
void
delete_min_insert_stable(T key, bool sup)
{
int source = losers[0].source;
......@@ -622,7 +620,6 @@ template<typename T, typename Comparator = std::less<T> >
Comparator comp;
public:
inline
LoserTreePointer(unsigned int _k, Comparator _comp = std::less<T>())
: comp(_comp)
{
......@@ -636,14 +633,14 @@ template<typename T, typename Comparator = std::less<T> >
losers[i + k].sup = true;
}
inline ~LoserTreePointer()
~LoserTreePointer()
{ delete[] losers; }
inline int
int
get_min_source()
{ return losers[0].source; }
inline void
void
insert_start(const T& key, int source, bool sup)
{
unsigned int pos = k + source;
......@@ -657,9 +654,7 @@ template<typename T, typename Comparator = std::less<T> >
init_winner(unsigned int root)
{
if (root >= k)
{
return root;
}
else
{
unsigned int left = init_winner (2 * root);
......@@ -681,11 +676,11 @@ template<typename T, typename Comparator = std::less<T> >
}
}
inline void
void
init()
{ losers[0] = losers[init_winner(1)]; }
inline void
void
delete_min_insert(const T& key, bool sup)
{
const T* keyp = &key;
......@@ -707,7 +702,7 @@ template<typename T, typename Comparator = std::less<T> >
losers[0].keyp = keyp;
}
inline void
void
insert_start_stable(const T& key, int source, bool sup)
{ return insert_start(key, source, sup); }
......@@ -739,11 +734,11 @@ template<typename T, typename Comparator = std::less<T> >
}
}
inline void
void
init_stable()
{ losers[0] = losers[init_winner_stable(1)]; }
inline void
void
delete_min_insert_stable(const T& key, bool sup)
{
const T* keyp = &key;
......@@ -810,7 +805,6 @@ template<typename T, typename Comparator = std::less<T> >
}
public:
inline
LoserTreeUnguarded(unsigned int _k, Comparator _comp = std::less<T>())
: comp(_comp)
{
......@@ -823,17 +817,17 @@ template<typename T, typename Comparator = std::less<T> >
map(1, 0, ik);
}
inline ~LoserTreeUnguarded()
~LoserTreeUnguarded()
{
delete[] losers;
delete[] mapping;
}
inline int
int
get_min_source()
{ return losers[0].source; }
inline void
void
insert_start(const T& key, int source, bool)
{
unsigned int pos = mapping[source];
......@@ -868,12 +862,12 @@ template<typename T, typename Comparator = std::less<T> >
}
}
inline void
void
init()
{ losers[0] = losers[init_winner(1, 0, ik)]; }
// Do not pass const reference since key will be used as local variable.
inline void
void
delete_min_insert(const T& key, bool)
{
losers[0].key = key;
......@@ -891,15 +885,15 @@ template<typename T, typename Comparator = std::less<T> >
}
}
inline void
void
insert_start_stable(const T& key, int source, bool)
{ return insert_start(key, source, false); }
inline void
void
init_stable()
{ init(); }
inline void
void
delete_min_insert_stable(const T& key, bool)
{
losers[0].key = key;
......@@ -959,7 +953,6 @@ template<typename T, typename Comparator = std::less<T> >
}
public:
inline
LoserTreePointerUnguarded(unsigned int _k,
Comparator _comp = std::less<T>())
: comp(_comp)
......@@ -974,17 +967,17 @@ template<typename T, typename Comparator = std::less<T> >
map(1, 0, ik);
}
inline ~LoserTreePointerUnguarded()
~LoserTreePointerUnguarded()
{
delete[] losers;
delete[] mapping;
}
inline int
int
get_min_source()
{ return losers[0].source; }
inline void
void
insert_start(const T& key, int source, bool)
{
unsigned int pos = mapping[source];
......@@ -1019,13 +1012,11 @@ template<typename T, typename Comparator = std::less<T> >
}
}
inline void
void
init()
{
losers[0] = losers[init_winner(1, 0, ik)];
}
{ losers[0] = losers[init_winner(1, 0, ik)]; }
inline void
void
delete_min_insert(const T& key, bool)
{
const T* keyp = &key;
......@@ -1044,15 +1035,15 @@ template<typename T, typename Comparator = std::less<T> >
losers[0].keyp = keyp;
}
inline void
void
insert_start_stable(const T& key, int source, bool)
{ return insert_start(key, source, false); }
inline void
void
init_stable()
{ init(); }
inline void
void
delete_min_insert_stable(const T& key, bool)
{
int& source = losers[0].source;
......
libstdc++-v3/include/parallel/merge.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -56,9 +56,15 @@ namespace __gnu_parallel
* @param max_length Maximum number of elements to merge.
* @param comp Comparator.
* @return Output end iterator. */
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename OutputIterator, typename _DifferenceTp, typename Comparator>
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename OutputIterator, typename _DifferenceTp,
typename Comparator>
OutputIterator
merge_advance_usual(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator2& begin2, RandomAccessIterator2 end2, OutputIterator target, _DifferenceTp max_length, Comparator comp)
merge_advance_usual(RandomAccessIterator1& begin1,
RandomAccessIterator1 end1,
RandomAccessIterator2& begin2,
RandomAccessIterator2 end2, OutputIterator target,
_DifferenceTp max_length, Comparator comp)
{
typedef _DifferenceTp difference_type;
while (begin1 != end1 && begin2 != end2 && max_length > 0)
......@@ -99,13 +105,22 @@ namespace __gnu_parallel
* @param max_length Maximum number of elements to merge.
* @param comp Comparator.
* @return Output end iterator. */
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename OutputIterator, typename _DifferenceTp, typename Comparator>
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename OutputIterator, typename _DifferenceTp,
typename Comparator>
OutputIterator
merge_advance_movc(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator2& begin2, RandomAccessIterator2 end2, OutputIterator target, _DifferenceTp max_length, Comparator comp)
merge_advance_movc(RandomAccessIterator1& begin1,
RandomAccessIterator1 end1,
RandomAccessIterator2& begin2,
RandomAccessIterator2 end2,
OutputIterator target,
_DifferenceTp max_length, Comparator comp)
{
typedef _DifferenceTp difference_type;
typedef typename std::iterator_traits<RandomAccessIterator1>::value_type value_type1;
typedef typename std::iterator_traits<RandomAccessIterator2>::value_type value_type2;
typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
value_type1;
typedef typename std::iterator_traits<RandomAccessIterator2>::value_type
value_type2;
#if _GLIBCXX_ASSERTIONS
_GLIBCXX_PARALLEL_ASSERT(max_length >= 0);
......@@ -124,9 +139,7 @@ namespace __gnu_parallel
begin2 = next2;
}
else
{
begin1 = next1;
}
*target = element1;
......@@ -160,13 +173,19 @@ namespace __gnu_parallel
* @param max_length Maximum number of elements to merge.
* @param comp Comparator.
* @return Output end iterator. */
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename OutputIterator, typename _DifferenceTp, typename Comparator>
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename OutputIterator, typename _DifferenceTp,
typename Comparator>
inline OutputIterator
merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator2& begin2, RandomAccessIterator2 end2, OutputIterator target, _DifferenceTp max_length, Comparator comp)
merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1,
RandomAccessIterator2& begin2, RandomAccessIterator2 end2,
OutputIterator target, _DifferenceTp max_length,
Comparator comp)
{
_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
......@@ -179,15 +198,20 @@ namespace __gnu_parallel
* @param max_length Maximum number of elements to merge.
* @param comp Comparator.
* @return Output end iterator. */
template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename RandomAccessIterator3, typename Comparator>
template<typename RandomAccessIterator1, typename RandomAccessIterator2,
typename RandomAccessIterator3, typename Comparator>
inline RandomAccessIterator3
parallel_merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1,
RandomAccessIterator2& begin2, RandomAccessIterator2 end2, //different iterators, parallel implementation not available
RandomAccessIterator3 target,
typename std::iterator_traits<RandomAccessIterator1>::difference_type max_length, Comparator comp)
{
return merge_advance(begin1, end1, begin2, end2, target, max_length, comp);
}
parallel_merge_advance(RandomAccessIterator1& begin1,
RandomAccessIterator1 end1,
RandomAccessIterator2& begin2,
// different iterators, parallel implementation
// not available
RandomAccessIterator2 end2,
RandomAccessIterator3 target, typename
std::iterator_traits<RandomAccessIterator1>::
difference_type max_length, Comparator 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.
......@@ -204,19 +228,30 @@ namespace __gnu_parallel
* @param comp Comparator.
* @return Output end iterator.
*/
template<typename RandomAccessIterator1, typename RandomAccessIterator3, typename Comparator>
template<typename RandomAccessIterator1, typename RandomAccessIterator3,
typename Comparator>
inline RandomAccessIterator3
parallel_merge_advance(RandomAccessIterator1& begin1, RandomAccessIterator1 end1, RandomAccessIterator1& begin2, RandomAccessIterator1 end2, RandomAccessIterator3 target, typename std::iterator_traits<RandomAccessIterator1>::difference_type max_length, Comparator comp)
parallel_merge_advance(RandomAccessIterator1& begin1,
RandomAccessIterator1 end1,
RandomAccessIterator1& begin2,
RandomAccessIterator1 end2,
RandomAccessIterator3 target, typename
std::iterator_traits<RandomAccessIterator1>::
difference_type max_length, Comparator comp)
{
typedef typename std::iterator_traits<RandomAccessIterator1>::value_type
value_type;
typedef typename std::iterator_traits<RandomAccessIterator1>::difference_type
difference_type1 /* == difference_type2 */;
typedef typename std::iterator_traits<RandomAccessIterator3>::difference_type
difference_type3;
typedef typename std::iterator_traits<RandomAccessIterator1>::
difference_type difference_type1 /* == difference_type2 */;
typedef typename std::iterator_traits<RandomAccessIterator3>::
difference_type difference_type3;
std::pair<RandomAccessIterator1, RandomAccessIterator1> seqs[2] = { std::make_pair(begin1, end1), std::make_pair(begin2, end2) };
RandomAccessIterator3 target_end = parallel_multiway_merge(seqs, seqs + 2, target, comp, max_length, true, false);
std::pair<RandomAccessIterator1, RandomAccessIterator1>
seqs[2] = { std::make_pair(begin1, end1),
std::make_pair(begin2, end2) };
RandomAccessIterator3
target_end = parallel_multiway_merge(seqs, seqs + 2, target,
comp, max_length, true, false);
return target_end;
}
......
libstdc++-v3/include/parallel/multiseq_selection.h
// -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
// Copyright (C) 2007, 2008 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
......@@ -58,7 +58,8 @@ namespace __gnu_parallel
{
/** @brief Compare a pair of types lexicographically, ascending. */
template<typename T1, typename T2, typename Comparator>
class lexicographic : public std::binary_function<std::pair<T1, T2>, std::pair<T1, T2>, bool>
class lexicographic
: public std::binary_function<std::pair<T1, T2>, std::pair<T1, T2>, bool>
{
private:
Comparator& comp;
......@@ -67,8 +68,9 @@ namespace __gnu_parallel
lexicographic(Comparator& _comp) : comp(_comp) { }
// XXX const
inline bool
operator()(const std::pair<T1, T2>& p1, const std::pair<T1, T2>& p2) const
bool
operator()(const std::pair<T1, T2>& p1,
const std::pair<T1, T2>& p2) const
{
if (comp(p1.first, p2.first))
return true;
......@@ -91,8 +93,9 @@ namespace __gnu_parallel
public:
lexicographic_reverse(Comparator& _comp) : comp(_comp) { }
inline bool
operator()(const std::pair<T1, T2>& p1, const std::pair<T1, T2>& p2) const
bool
operator()(const std::pair<T1, T2>& p1,
const std::pair<T1, T2>& p2) const
{
if (comp(p2.first, p1.first))
return true;
......@@ -121,17 +124,23 @@ namespace __gnu_parallel
* the respective sequence.
* @param comp The ordering functor, defaults to std::less<T>.
*/
template<typename RanSeqs, typename RankType, typename RankIterator, typename Comparator>
template<typename RanSeqs, typename RankType, typename RankIterator,
typename Comparator>
void
multiseq_partition(RanSeqs begin_seqs, RanSeqs end_seqs, RankType rank,
multiseq_partition(RanSeqs begin_seqs, RanSeqs end_seqs,
RankType rank,
RankIterator begin_offsets,
Comparator comp = std::less<
typename std::iterator_traits<typename std::iterator_traits<RanSeqs>::value_type::first_type>::value_type>()) // std::less<T>
typename std::iterator_traits<typename
std::iterator_traits<RanSeqs>::value_type::
first_type>::value_type>()) // std::less<T>
{
_GLIBCXX_CALL(end_seqs - begin_seqs)
typedef typename std::iterator_traits<RanSeqs>::value_type::first_type It;
typedef typename std::iterator_traits<It>::difference_type difference_type;
typedef typename std::iterator_traits<RanSeqs>::value_type::first_type
It;
typedef typename std::iterator_traits<It>::difference_type
difference_type;
typedef typename std::iterator_traits<It>::value_type value_type;
lexicographic<value_type, int, Comparator> lcomp(comp);
......@@ -139,7 +148,8 @@ namespace __gnu_parallel
// 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;
difference_type m = std::distance(begin_seqs, end_seqs), N = 0,
nmax, n, r;
for (int i = 0; i < m; i++)
N += std::distance(begin_seqs[i].first, begin_seqs[i].second);
......@@ -240,7 +250,8 @@ namespace __gnu_parallel
{
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)))
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;
......@@ -253,12 +264,16 @@ namespace __gnu_parallel
total += l / (n + 1);
}
difference_type skew = static_cast<difference_type>(static_cast<uint64>(total) * rank / N - leftsize);
difference_type skew = static_cast<difference_type>
(static_cast<uint64>(total) * rank / N - leftsize);
if (skew > 0)
{
// Move to the left, find smallest.
std::priority_queue<std::pair<value_type, int>, std::vector<std::pair<value_type, int> >, lexicographic_reverse<value_type, int, Comparator> > pq(lrcomp);
std::priority_queue<std::pair<value_type, int>,
std::vector<std::pair<value_type, int> >,
lexicographic_reverse<value_type, int, Comparator> >
pq(lrcomp);
for (int i = 0; i < m; i++)
if (b[i] < ns[i])
......@@ -279,7 +294,9 @@ namespace __gnu_parallel
else if (skew < 0)
{
// Move to the right, find greatest.
std::priority_queue<std::pair<value_type, int>, std::vector<std::pair<value_type, int> >, lexicographic<value_type, int, Comparator> > pq(lcomp);
std::priority_queue<std::pair<value_type, int>,
std::vector<std::pair<value_type, int> >,
lexicographic<value_type, int, Comparator> > pq(lcomp);
for (int i = 0; i < m; i++)
if (a[i] > 0)
......@@ -360,15 +377,18 @@ namespace __gnu_parallel
* selected element is unique, this number is 0.
* @param comp The ordering functor, defaults to std::less.
*/
template<typename T, typename RanSeqs, typename RankType, typename Comparator>
template<typename T, typename RanSeqs, typename RankType,
typename Comparator>
T
multiseq_selection(RanSeqs begin_seqs, RanSeqs end_seqs, RankType rank,
RankType& offset, Comparator comp = std::less<T>())
{
_GLIBCXX_CALL(end_seqs - begin_seqs)
typedef typename std::iterator_traits<RanSeqs>::value_type::first_type It;
typedef typename std::iterator_traits<It>::difference_type difference_type;
typedef typename std::iterator_traits<RanSeqs>::value_type::first_type
It;
typedef typename std::iterator_traits<It>::difference_type
difference_type;
lexicographic<T, int, Comparator> lcomp(comp);
lexicographic_reverse<T, int, Comparator> lrcomp(comp);
......@@ -429,7 +449,8 @@ namespace __gnu_parallel
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());
__gnu_sequential::sort(sample.begin(), sample.end(),
lcomp, sequential_tag());
// Conceptual infinity.
for (int i = 0; i < m; i++)
......@@ -455,9 +476,7 @@ namespace __gnu_parallel
if (a[i] > 0)
{
if (!lmax)
{
lmax = &(S(i)[a[i] - 1]);
}
else
{
if (comp(*lmax, S(i)[a[i] - 1])) //max
......@@ -483,18 +502,21 @@ namespace __gnu_parallel
total += l / (n + 1);
}
difference_type skew = (unsigned long long)total * rank / N - leftsize;
difference_type skew = ((unsigned long long)total * rank / N
- leftsize);
if (skew > 0)
{
// Move to the left, find smallest.
std::priority_queue<std::pair<T, int>, std::vector<std::pair<T, int> >, lexicographic_reverse<T, int, Comparator> > pq(lrcomp);
std::priority_queue<std::pair<T, int>,
std::vector<std::pair<T, int> >,
lexicographic_reverse<T, int, Comparator> > 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 (; skew != 0 && !pq.empty(); skew--)
for (; skew != 0 && !pq.empty(); --skew)
{
int source = pq.top().second;
pq.pop();
......@@ -509,13 +531,15 @@ namespace __gnu_parallel
else if (skew < 0)
{
// Move to the right, find greatest.
std::priority_queue<std::pair<T, int>, std::vector<std::pair<T, int> >, lexicographic<T, int, Comparator> > pq(lcomp);
std::priority_queue<std::pair<T, int>,
std::vector<std::pair<T, int> >,
lexicographic<T, int, Comparator> > 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 (; skew != 0; skew++)
for (; skew != 0; ++skew)
{
int source = pq.top().second;
pq.pop();
......@@ -588,7 +612,8 @@ namespace __gnu_parallel
for (int i = 0; i < m; i++)
{
difference_type lb = std::lower_bound(S(i), S(i) + ns[i], minright,
difference_type lb = std::lower_bound(S(i), S(i) + ns[i],
minright,
comp) - S(i);
offset += a[i] - lb;
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment