procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

multiway_merge.h (multiway_merge_*, [...]): Replace int by appropriate difference_type (typedef to _SeqNumber) or _ThreadIndex.

Browse source 
2009-11-09  Johannes Singler  <singler@kit.edu>

	* include/parallel/multiway_merge.h (multiway_merge_*,
	__sequential_multiway_merge, parallel_multiway_merge): Replace
	int by appropriate difference_type (typedef to _SeqNumber) or
	_ThreadIndex.
	* include/parallel/multiseq_selection.h (multiseq_partition,
	multiseq_selection): Replace int by appropriate difference_type
	(typedef to _SeqNumber)
	* include/parallel/base.h (__get_max_threads): Replace int by
	_ThreadIndex.
	* include/parallel/balanced_quicksort.h
	(__qsb_local_sort_with_helping, __parallel_sort_qsb): Likewise.
	* include/parallel/set_operations.h (__parallel_set_operation):
	Likewise.
	* include/parallel/unique_copy.h (__parallel_unique_copy): Likewise.
	* include/parallel/multiway_mergesort.h (_SplitConsistently,
	parallel_sort_mwms_pu, parallel_sort_mwms): Likewise.
	* include/parallel/partial_sum.h (__parallel_partial_sum_linear):
	Likewise.
	* include/parallel/partition.h (__parallel_partition): Replace int
	by appropriate difference_type or _ThreadIndex.

From-SVN: r154039
This commit is contained in:
Johannes Singler 2009-11-09 16:36:59 +00:00 • committed by Paolo Carlini
parent e0dc3601d3
commit 8b0c13a824
10 changed files with 139 additions and 96 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
libstdc++-v3/ChangeLog
View file

@ -1,3 +1,26 @@
2009-11-09 Johannes Singler <singler@kit.edu>
* include/parallel/multiway_merge.h (multiway_merge_*,
__sequential_multiway_merge, parallel_multiway_merge): Replace
int by appropriate difference_type (typedef to _SeqNumber) or
_ThreadIndex.
* include/parallel/multiseq_selection.h (multiseq_partition,
multiseq_selection): Replace int by appropriate difference_type
(typedef to _SeqNumber)
* include/parallel/base.h (__get_max_threads): Replace int by
_ThreadIndex.
* include/parallel/balanced_quicksort.h
(__qsb_local_sort_with_helping, __parallel_sort_qsb): Likewise.
* include/parallel/set_operations.h (__parallel_set_operation):
Likewise.
* include/parallel/unique_copy.h (__parallel_unique_copy): Likewise.
* include/parallel/multiway_mergesort.h (_SplitConsistently,
parallel_sort_mwms_pu, parallel_sort_mwms): Likewise.
* include/parallel/partial_sum.h (__parallel_partial_sum_linear):
Likewise.
* include/parallel/partition.h (__parallel_partition): Replace int
by appropriate difference_type or _ThreadIndex.
2009-11-08 Jason Merrill <jason@redhat.com>
* include/ext/sso_string_base.h (_M_mutate): Remove extra 'const'.

9
libstdc++-v3/include/parallel/balanced_quicksort.h
View file

@ -245,7 +245,8 @@ namespace __gnu_parallel
template<typename _RAIter, typename _Compare>
void
__qsb_local_sort_with_helping(_QSBThreadLocal<_RAIter>** __tls,
_Compare& __comp, int __iam, bool __wait)
_Compare& __comp, _ThreadIndex __iam,
bool __wait)
{
typedef std::iterator_traits<_RAIter> _TraitsType;
typedef typename _TraitsType::value_type _ValueType;
@ -460,7 +461,7 @@ namespace __gnu_parallel
// 2. The largest range has at most length __n
// 3. Each range is larger than half of the range remaining
volatile _DifferenceType __elements_leftover = __n;
for (int __i = 0; __i < __num_threads; ++__i)
for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
{
__tls[__i]->_M_elements_leftover = &__elements_leftover;
__tls[__i]->_M_num_threads = __num_threads;
@ -477,12 +478,12 @@ namespace __gnu_parallel
#if _GLIBCXX_ASSERTIONS
// All stack must be empty.
_Piece __dummy;
for (int __i = 1; __i < __num_threads; ++__i)
for (_ThreadIndex __i = 1; __i < __num_threads; ++__i)
_GLIBCXX_PARALLEL_ASSERT(
!__tls[__i]->_M_leftover_parts.pop_back(__dummy));
#endif
for (int __i = 0; __i < __num_threads; ++__i)
for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
delete __tls[__i];
delete[] __tls;
}

4
libstdc++-v3/include/parallel/base.h
View file

@ -81,10 +81,10 @@ namespace __gnu_parallel
// the OpenMP runtime unless the parallel mode is actually invoked
// and active, which imples that the OpenMP runtime is actually
// going to be linked in.
inline int
inline _ThreadIndex
__get_max_threads()
{
int __i = omp_get_max_threads();
_ThreadIndex __i = omp_get_max_threads();
return __i > 1 ? __i : 1;
}

108
libstdc++-v3/include/parallel/multiseq_selection.h
View file

@ -133,19 +133,21 @@ namespace __gnu_parallel
typedef typename std::iterator_traits<_RanSeqs>::value_type::first_type
_It;
typedef typename std::iterator_traits<_RanSeqs>::difference_type
_SeqNumber;
typedef typename std::iterator_traits<_It>::difference_type
_DifferenceType;
typedef typename std::iterator_traits<_It>::value_type _ValueType;
_Lexicographic<_ValueType, int, _Compare> __lcomp(__comp);
_LexicographicReverse<_ValueType, int, _Compare> __lrcomp(__comp);
_Lexicographic<_ValueType, _SeqNumber, _Compare> __lcomp(__comp);
_LexicographicReverse<_ValueType, _SeqNumber, _Compare> __lrcomp(__comp);
// Number of sequences, number of elements in total (possibly
// including padding).
_DifferenceType __m = std::distance(__begin_seqs, __end_seqs), __nn = 0,
__nmax, __n, __r;
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
{
__nn += std::distance(__begin_seqs[__i].first,
__begin_seqs[__i].second);
@ -156,7 +158,7 @@ namespace __gnu_parallel
if (__rank == __nn)
{
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
__begin_offsets[__i] = __begin_seqs[__i].second; // Very end.
// Return __m - 1;
return;
@ -174,7 +176,7 @@ namespace __gnu_parallel
__ns[0] = std::distance(__begin_seqs[0].first, __begin_seqs[0].second);
__nmax = __ns[0];
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
{
__ns[__i] = std::distance(__begin_seqs[__i].first,
__begin_seqs[__i].second);
@ -187,7 +189,7 @@ namespace __gnu_parallel
// equality iff __nmax = 2^__k - 1.
__l = (1ULL << __r) - 1;
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
{
__a[__i] = 0;
__b[__i] = __l;
@ -200,21 +202,21 @@ namespace __gnu_parallel
#define __S(__i) (__begin_seqs[__i].first)
// Initial partition.
std::vector<std::pair<_ValueType, int> > __sample;
std::vector<std::pair<_ValueType, _SeqNumber> > __sample;
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
if (__n < __ns[__i]) //__sequence long enough
__sample.push_back(std::make_pair(__S(__i)[__n], __i));
__gnu_sequential::sort(__sample.begin(), __sample.end(), __lcomp);
for (int __i = 0; __i < __m; __i++) //conceptual infinity
for (_SeqNumber __i = 0; __i < __m; __i++) //conceptual infinity
if (__n >= __ns[__i]) //__sequence too short, conceptual infinity
__sample.push_back(
std::make_pair(__S(__i)[0] /*__dummy element*/, __i));
_DifferenceType __localrank = __rank / __l;
int __j;
_SeqNumber __j;
for (__j = 0;
__j < __localrank && ((__n + 1) <= __ns[__sample[__j].second]);
++__j)
@ -227,9 +229,9 @@ namespace __gnu_parallel
{
__n /= 2;
int __lmax_seq = -1; // to avoid warning
_SeqNumber __lmax_seq = -1; // to avoid warning
const _ValueType* __lmax = NULL; // impossible to avoid the warning?
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
{
if (__a[__i] > 0)
{
@ -250,7 +252,7 @@ namespace __gnu_parallel
}
}
int __i;
_SeqNumber __i;
for (__i = 0; __i < __m; __i++)
{
_DifferenceType __middle = (__b[__i] + __a[__i]) / 2;
@ -263,7 +265,7 @@ namespace __gnu_parallel
}
_DifferenceType __leftsize = 0;
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
__leftsize += __a[__i] / (__n + 1);
_DifferenceType __skew = __rank / (__n + 1) - __leftsize;
@ -271,18 +273,18 @@ namespace __gnu_parallel
if (__skew > 0)
{
// Move to the left, find smallest.
std::priority_queue<std::pair<_ValueType, int>,
std::vector<std::pair<_ValueType, int> >,
_LexicographicReverse<_ValueType, int, _Compare> >
std::priority_queue<std::pair<_ValueType, _SeqNumber>,
std::vector<std::pair<_ValueType, _SeqNumber> >,
_LexicographicReverse<_ValueType, _SeqNumber, _Compare> >
__pq(__lrcomp);
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __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)
{
int __source = __pq.top().second;
_SeqNumber __source = __pq.top().second;
__pq.pop();
__a[__source]
@ -297,17 +299,18 @@ namespace __gnu_parallel
else if (__skew < 0)
{
// Move to the right, find greatest.
std::priority_queue<std::pair<_ValueType, int>,
std::vector<std::pair<_ValueType, int> >,
_Lexicographic<_ValueType, int, _Compare> > __pq(__lcomp);
std::priority_queue<std::pair<_ValueType, _SeqNumber>,
std::vector<std::pair<_ValueType, _SeqNumber> >,
_Lexicographic<_ValueType, _SeqNumber, _Compare> >
__pq(__lcomp);
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
if (__a[__i] > 0)
__pq.push(std::make_pair(__S(__i)[__a[__i] - 1], __i));
for (; __skew != 0; ++__skew)
{
int __source = __pq.top().second;
_SeqNumber __source = __pq.top().second;
__pq.pop();
__a[__source] -= __n + 1;
@ -331,7 +334,7 @@ namespace __gnu_parallel
// Maximum of left edge, minimum of right edge.
_ValueType* __maxleft = NULL;
_ValueType* __minright = NULL;
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
{
if (__a[__i] > 0)
{
@ -357,8 +360,8 @@ namespace __gnu_parallel
}
}
int __seq = 0;
for (int __i = 0; __i < __m; __i++)
_SeqNumber __seq = 0;
for (_SeqNumber __i = 0; __i < __m; __i++)
__begin_offsets[__i] = __S(__i) + __a[__i];
delete[] __ns;
@ -392,11 +395,13 @@ namespace __gnu_parallel
typedef typename std::iterator_traits<_RanSeqs>::value_type::first_type
_It;
typedef typename std::iterator_traits<_RanSeqs>::difference_type
_SeqNumber;
typedef typename std::iterator_traits<_It>::difference_type
_DifferenceType;
_Lexicographic<_Tp, int, _Compare> __lcomp(__comp);
_LexicographicReverse<_Tp, int, _Compare> __lrcomp(__comp);
_Lexicographic<_Tp, _SeqNumber, _Compare> __lcomp(__comp);
_LexicographicReverse<_Tp, _SeqNumber, _Compare> __lrcomp(__comp);
// Number of sequences, number of elements in total (possibly
// including padding).
@ -404,7 +409,7 @@ namespace __gnu_parallel
_DifferenceType __nn = 0;
_DifferenceType __nmax, __n, __r;
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
__nn += std::distance(__begin_seqs[__i].first,
__begin_seqs[__i].second);
@ -422,7 +427,7 @@ namespace __gnu_parallel
__ns[0] = std::distance(__begin_seqs[0].first, __begin_seqs[0].second);
__nmax = __ns[0];
for (int __i = 0; __i < __m; ++__i)
for (_SeqNumber __i = 0; __i < __m; ++__i)
{
__ns[__i] = std::distance(__begin_seqs[__i].first,
__begin_seqs[__i].second);
@ -435,7 +440,7 @@ namespace __gnu_parallel
// equality iff __nmax = 2^__k - 1
__l = __round_up_to_pow2(__r) - 1;
for (int __i = 0; __i < __m; ++__i)
for (_SeqNumber __i = 0; __i < __m; ++__i)
{
__a[__i] = 0;
__b[__i] = __l;
@ -448,23 +453,23 @@ namespace __gnu_parallel
#define __S(__i) (__begin_seqs[__i].first)
// Initial partition.
std::vector<std::pair<_Tp, int> > __sample;
std::vector<std::pair<_Tp, _SeqNumber> > __sample;
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
if (__n < __ns[__i])
__sample.push_back(std::make_pair(__S(__i)[__n], __i));
__gnu_sequential::sort(__sample.begin(), __sample.end(),
__lcomp, sequential_tag());
// Conceptual infinity.
for (int __i = 0; __i < __m; __i++)
for (_SeqNumber __i = 0; __i < __m; __i++)
if (__n >= __ns[__i])
__sample.push_back(
std::make_pair(__S(__i)[0] /*__dummy element*/, __i));
_DifferenceType __localrank = __rank / __l;
int __j;
_SeqNumber __j;
for (__j = 0;
__j < __localrank && ((__n + 1) <= __ns[__sample[__j].second]);
++__j)
@ -478,7 +483,7 @@ namespace __gnu_parallel
__n /= 2;
const _Tp* __lmax = NULL;
for (int __i = 0; __i < __m; ++__i)
for (_SeqNumber __i = 0; __i < __m; ++__i)
{
if (__a[__i] > 0)
{
@ -492,7 +497,7 @@ namespace __gnu_parallel
}
}
int __i;
_SeqNumber __i;
for (__i = 0; __i < __m; __i++)
{
_DifferenceType __middle = (__b[__i] + __a[__i]) / 2;
@ -504,7 +509,7 @@ namespace __gnu_parallel
}
_DifferenceType __leftsize = 0;
for (int __i = 0; __i < __m; ++__i)
for (_SeqNumber __i = 0; __i < __m; ++__i)
__leftsize += __a[__i] / (__n + 1);
_DifferenceType __skew = __rank / (__n + 1) - __leftsize;
@ -512,17 +517,18 @@ namespace __gnu_parallel
if (__skew > 0)
{
// Move to the left, find smallest.
std::priority_queue<std::pair<_Tp, int>,
std::vector<std::pair<_Tp, int> >,
_LexicographicReverse<_Tp, int, _Compare> > __pq(__lrcomp);
std::priority_queue<std::pair<_Tp, _SeqNumber>,
std::vector<std::pair<_Tp, _SeqNumber> >,
_LexicographicReverse<_Tp, _SeqNumber, _Compare> >
__pq(__lrcomp);
for (int __i = 0; __i < __m; ++__i)
for (_SeqNumber __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)
{
int __source = __pq.top().second;
_SeqNumber __source = __pq.top().second;
__pq.pop();
__a[__source]
@ -537,17 +543,17 @@ namespace __gnu_parallel
else if (__skew < 0)
{
// Move to the right, find greatest.
std::priority_queue<std::pair<_Tp, int>,
std::vector<std::pair<_Tp, int> >,
_Lexicographic<_Tp, int, _Compare> > __pq(__lcomp);
std::priority_queue<std::pair<_Tp, _SeqNumber>,
std::vector<std::pair<_Tp, _SeqNumber> >,
_Lexicographic<_Tp, _SeqNumber, _Compare> > __pq(__lcomp);
for (int __i = 0; __i < __m; ++__i)
for (_SeqNumber __i = 0; __i < __m; ++__i)
if (__a[__i] > 0)
__pq.push(std::make_pair(__S(__i)[__a[__i] - 1], __i));
for (; __skew != 0; ++__skew)
{
int __source = __pq.top().second;
_SeqNumber __source = __pq.top().second;
__pq.pop();
__a[__source] -= __n + 1;
@ -573,7 +579,7 @@ namespace __gnu_parallel
// Impossible to avoid the warning?
_Tp __maxleft, __minright;
for (int __i = 0; __i < __m; ++__i)
for (_SeqNumber __i = 0; __i < __m; ++__i)
{
if (__a[__i] > 0)
{
@ -617,7 +623,7 @@ namespace __gnu_parallel
// We have to calculate an offset.
__offset = 0;
for (int __i = 0; __i < __m; ++__i)
for (_SeqNumber __i = 0; __i < __m; ++__i)
{
_DifferenceType lb
= std::lower_bound(__S(__i), __S(__i) + __ns[__i],

61
libstdc++-v3/include/parallel/multiway_merge.h
View file

@ -489,27 +489,29 @@ namespace __gnu_parallel
_GLIBCXX_CALL(__length)
typedef _DifferenceTp _DifferenceType;
typedef typename std::iterator_traits<_RAIterIterator>
::difference_type _SeqNumber;
typedef typename std::iterator_traits<_RAIterIterator>
::value_type::first_type
_RAIter1;
typedef typename std::iterator_traits<_RAIter1>::value_type
_ValueType;
int __k = static_cast<int>(__seqs_end - __seqs_begin);
_SeqNumber __k = static_cast<_SeqNumber>(__seqs_end - __seqs_begin);
_LT __lt(__k, __comp);
// Default value for potentially non-default-constructible types.
_ValueType* __arbitrary_element = NULL;
for (int __t = 0; __t < __k; ++__t)
for (_SeqNumber __t = 0; __t < __k; ++__t)
{
if(__arbitrary_element == NULL
&& _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__t]) > 0)
__arbitrary_element = &(*__seqs_begin[__t].first);
}
for (int __t = 0; __t < __k; ++__t)
for (_SeqNumber __t = 0; __t < __k; ++__t)
{
if (__seqs_begin[__t].first == __seqs_begin[__t].second)
__lt.__insert_start(*__arbitrary_element, __t, true);
@ -519,7 +521,7 @@ namespace __gnu_parallel
__lt.__init();
int __source;
_SeqNumber __source;
for (_DifferenceType __i = 0; __i < __length; ++__i)
{
@ -574,17 +576,19 @@ namespace __gnu_parallel
_GLIBCXX_CALL(__length)
typedef _DifferenceTp _DifferenceType;
typedef typename std::iterator_traits<_RAIterIterator>
::difference_type _SeqNumber;
typedef typename std::iterator_traits<_RAIterIterator>
::value_type::first_type
_RAIter1;
typedef typename std::iterator_traits<_RAIter1>::value_type
_ValueType;
int __k = __seqs_end - __seqs_begin;
_SeqNumber __k = __seqs_end - __seqs_begin;
_LT __lt(__k, __sentinel, __comp);
for (int __t = 0; __t < __k; ++__t)
for (_SeqNumber __t = 0; __t < __k; ++__t)
{
#if _GLIBCXX_ASSERTIONS
_GLIBCXX_PARALLEL_ASSERT(__seqs_begin[__t].first
@ -595,7 +599,7 @@ namespace __gnu_parallel
__lt.__init();
int __source;
_SeqNumber __source;
#if _GLIBCXX_ASSERTIONS
_DifferenceType __i = 0;
@ -862,8 +866,9 @@ namespace __gnu_parallel
typename _DifferenceTp,
typename _Compare>
struct __multiway_merge_k_variant_sentinel_switch<false, __stable,
_RAIterIterator, _RAIter3,
_DifferenceTp, _Compare>
_RAIterIterator,
_RAIter3, _DifferenceTp,
_Compare>
{
_RAIter3
operator()(_RAIterIterator __seqs_begin,
@ -920,6 +925,8 @@ namespace __gnu_parallel
_GLIBCXX_CALL(__length)
typedef _DifferenceTp _DifferenceType;
typedef typename std::iterator_traits<_RAIterIterator>
::difference_type _SeqNumber;
typedef typename std::iterator_traits<_RAIterIterator>
::value_type::first_type
_RAIter1;
@ -944,7 +951,7 @@ namespace __gnu_parallel
return __target;
_RAIter3 __return_target = __target;
int __k = static_cast<int>(__seqs_end - __seqs_begin);
_SeqNumber __k = static_cast<_SeqNumber>(__seqs_end - __seqs_begin);
switch (__k)
{
@ -1029,6 +1036,8 @@ namespace __gnu_parallel
_Compare __comp,
std::vector<std::pair<_DifferenceType, _DifferenceType> > *__pieces)
{
typedef typename std::iterator_traits<_RAIterIterator>
::difference_type _SeqNumber;
typedef typename std::iterator_traits<_RAIterIterator>
::value_type::first_type
_RAIter1;
@ -1036,9 +1045,9 @@ namespace __gnu_parallel
_ValueType;
// __k sequences.
int __k = static_cast<int>(__seqs_end - __seqs_begin);
_SeqNumber __k = static_cast<_SeqNumber>(__seqs_end - __seqs_begin);
int __num_threads = omp_get_num_threads();
_ThreadIndex __num_threads = omp_get_num_threads();
_DifferenceType __num_samples =
__gnu_parallel::_Settings::get().merge_oversampling * __num_threads;
@ -1046,7 +1055,7 @@ namespace __gnu_parallel
_ValueType* __samples = static_cast<_ValueType*>
(::operator new(sizeof(_ValueType) * __k * __num_samples));
// Sample.
for (int __s = 0; __s < __k; ++__s)
for (_SeqNumber __s = 0; __s < __k; ++__s)
for (_DifferenceType __i = 0; __i < __num_samples; ++__i)
{
_DifferenceType sample_index = static_cast<_DifferenceType>
@ -1062,9 +1071,9 @@ namespace __gnu_parallel
_SamplingSorter<__stable, _ValueType*, _Compare>()
(__samples, __samples + (__num_samples * __k), __comp);
for (int __slab = 0; __slab < __num_threads; ++__slab)
for (_ThreadIndex __slab = 0; __slab < __num_threads; ++__slab)
// For each slab / processor.
for (int __seq = 0; __seq < __k; ++__seq)
for (_SeqNumber __seq = 0; __seq < __k; ++__seq)
{
// For each sequence.
if (__slab > 0)
@ -1107,6 +1116,8 @@ namespace __gnu_parallel
_Compare __comp,
std::vector<std::pair<_DifferenceType, _DifferenceType> > *__pieces)
{
typedef typename std::iterator_traits<_RAIterIterator>
::difference_type _SeqNumber;
typedef typename std::iterator_traits<_RAIterIterator>
::value_type::first_type
_RAIter1;
@ -1114,9 +1125,9 @@ namespace __gnu_parallel
const bool __tight = (__total_length == __length);
// __k sequences.
const int __k = static_cast<int>(__seqs_end - __seqs_begin);
const _SeqNumber __k = __seqs_end - __seqs_begin;
const int __num_threads = omp_get_num_threads();
const _ThreadIndex __num_threads = omp_get_num_threads();
// (Settings::multiway_merge_splitting
// == __gnu_parallel::_Settings::EXACT).
@ -1130,7 +1141,7 @@ namespace __gnu_parallel
new _DifferenceType[__num_threads + 1];
equally_split(__length, __num_threads, __borders);
for (int __s = 0; __s < (__num_threads - 1); ++__s)
for (_ThreadIndex __s = 0; __s < (__num_threads - 1); ++__s)
{
__offsets[__s].resize(__k);
multiseq_partition(__se.begin(), __se.end(), __borders[__s + 1],
@ -1148,10 +1159,10 @@ namespace __gnu_parallel
}
delete[] __borders;
for (int __slab = 0; __slab < __num_threads; ++__slab)
for (_ThreadIndex __slab = 0; __slab < __num_threads; ++__slab)
{
// For each slab / processor.
for (int __seq = 0; __seq < __k; ++__seq)
for (_SeqNumber __seq = 0; __seq < __k; ++__seq)
{
// For each sequence.
if (__slab == 0)
@ -1218,6 +1229,8 @@ namespace __gnu_parallel
_GLIBCXX_CALL(__length)
typedef _DifferenceTp _DifferenceType;
typedef typename std::iterator_traits<_RAIterIterator>
::difference_type _SeqNumber;
typedef typename std::iterator_traits<_RAIterIterator>
::value_type::first_type
_RAIter1;
@ -1227,7 +1240,7 @@ namespace __gnu_parallel
// Leave only non-empty sequences.
typedef std::pair<_RAIter1, _RAIter1> seq_type;
seq_type* __ne_seqs = new seq_type[__seqs_end - __seqs_begin];
int __k = 0;
_SeqNumber __k = 0;
_DifferenceType __total_length = 0;
for (_RAIterIterator __raii = __seqs_begin;
__raii != __seqs_end; ++__raii)
@ -1263,7 +1276,7 @@ namespace __gnu_parallel
// Thread __t will have to merge pieces[__iam][0..__k - 1]
__pieces = new std::vector<
std::pair<_DifferenceType, _DifferenceType> >[__num_threads];
for (int __s = 0; __s < __num_threads; ++__s)
for (_ThreadIndex __s = 0; __s < __num_threads; ++__s)
__pieces[__s].resize(__k);
_DifferenceType __num_samples =
@ -1278,12 +1291,12 @@ namespace __gnu_parallel
_DifferenceType __target_position = 0;
for (int __c = 0; __c < __k; ++__c)
for (_SeqNumber __c = 0; __c < __k; ++__c)
__target_position += __pieces[__iam][__c].first;
seq_type* __chunks = new seq_type[__k];
for (int __s = 0; __s < __k; ++__s)
for (_SeqNumber __s = 0; __s < __k; ++__s)
__chunks[__s] = std::make_pair(__ne_seqs[__s].first
+ __pieces[__iam][__s].first,
__ne_seqs[__s].first

8
libstdc++-v3/include/parallel/multiway_mergesort.h
View file

@ -154,7 +154,7 @@ namespace __gnu_parallel
__sd->_M_starts[__iam + 1], __offsets.begin(),
__comp);
for (int __seq = 0; __seq < __sd->_M_num_threads; __seq++)
for (_ThreadIndex __seq = 0; __seq < __sd->_M_num_threads; __seq++)
{
// for each sequence
if (__iam < (__sd->_M_num_threads - 1))
@ -361,7 +361,7 @@ namespace __gnu_parallel
_SeqVector;
_SeqVector __seqs(__sd->_M_num_threads);
for (int __s = 0; __s < __sd->_M_num_threads; ++__s)
for (_ThreadIndex __s = 0; __s < __sd->_M_num_threads; ++__s)
{
__seqs[__s] =
std::make_pair(__sd->_M_temporary[__s]
@ -439,14 +439,14 @@ namespace __gnu_parallel
__sd._M_offsets = new _DifferenceType[__num_threads - 1];
__sd._M_pieces
= new std::vector<_Piece<_DifferenceType> >[__num_threads];
for (int __s = 0; __s < __num_threads; ++__s)
for (_ThreadIndex __s = 0; __s < __num_threads; ++__s)
__sd._M_pieces[__s].resize(__num_threads);
__starts = __sd._M_starts = new _DifferenceType[__num_threads + 1];
_DifferenceType __chunk_length = __n / __num_threads;
_DifferenceType __split = __n % __num_threads;
_DifferenceType __pos = 0;
for (int __i = 0; __i < __num_threads; ++__i)
for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
{
__starts[__i] = __pos;
__pos += ((__i < __split)

2
libstdc++-v3/include/parallel/partial_sum.h
View file

@ -132,7 +132,7 @@ namespace __gnu_parallel
/ ((double)__num_threads + __s.partial_sum_dilation)),
__borderstart = __n - __num_threads * __chunk_length;
__borders[0] = 0;
for (int __i = 1; __i < (__num_threads + 1); ++__i)
for (_ThreadIndex __i = 1; __i < (__num_threads + 1); ++__i)
{
__borders[__i] = __borderstart;
__borderstart += __chunk_length;

10
libstdc++-v3/include/parallel/partition.h
View file

@ -103,7 +103,7 @@ namespace __gnu_parallel
_DifferenceType __num_chunks = ((__right - __left + 1)
/ __chunk_size);
for (int __r = 0; __r < __num_threads; ++__r)
for (_ThreadIndex __r = 0; __r < __num_threads; ++__r)
{
__reserved_left[__r] = false;
__reserved_right[__r] = false;
@ -222,7 +222,7 @@ namespace __gnu_parallel
// Find spot and swap.
_DifferenceType __swapstart = -1;
omp_set_lock(&__result_lock);
for (int __r = 0; __r < __leftover_left; ++__r)
for (_DifferenceType __r = 0; __r < __leftover_left; ++__r)
if (!__reserved_left[__r])
{
__reserved_left[__r] = true;
@ -247,7 +247,7 @@ namespace __gnu_parallel
// Find spot and swap
_DifferenceType __swapstart = -1;
omp_set_lock(&__result_lock);
for (int __r = 0; __r < __leftover_right; ++__r)
for (_DifferenceType __r = 0; __r < __leftover_right; ++__r)
if (!__reserved_right[__r])
{
__reserved_right[__r] = true;
@ -269,9 +269,9 @@ namespace __gnu_parallel
# pragma omp single
{
for (int __r = 0; __r < __leftover_left; ++__r)
for (_DifferenceType __r = 0; __r < __leftover_left; ++__r)
_GLIBCXX_PARALLEL_ASSERT(__reserved_left[__r]);
for (int __r = 0; __r < __leftover_right; ++__r)
for (_DifferenceType __r = 0; __r < __leftover_right; ++__r)
_GLIBCXX_PARALLEL_ASSERT(__reserved_right[__r]);
}

4
libstdc++-v3/include/parallel/set_operations.h
View file

@ -444,7 +444,7 @@ namespace __gnu_parallel
if (__iam == 0)
{
// Do the last block.
for (int __i = 0; __i < __num_threads; ++__i)
for (_ThreadIndex __i = 0; __i < __num_threads; ++__i)
__r += __lengths[__i];
__block_begin = __block_begins[__num_threads];
@ -457,7 +457,7 @@ namespace __gnu_parallel
}
else
{
for (int __i = 0; __i < __iam; ++__i)
for (_ThreadIndex __i = 0; __i < __iam; ++__i)
__r += __lengths[ __i ];
// Reset begins for copy pass.

6
libstdc++-v3/include/parallel/unique_copy.h
View file

@ -129,7 +129,7 @@ namespace __gnu_parallel
if (__iam == 0)
{
for (int __t = 0; __t < __num_threads; ++__t)
for (_ThreadIndex __t = 0; __t < __num_threads; ++__t)
__begin_output += __counter[__t];
__i = 0;
@ -154,7 +154,7 @@ namespace __gnu_parallel
}
else
{
for (int __t = 0; __t < __iam; __t++)
for (_ThreadIndex __t = 0; __t < __iam; __t++)
__begin_output += __counter[__t];
_OutputIterator __iter_out = __result + __begin_output;
@ -168,7 +168,7 @@ namespace __gnu_parallel
}
_DifferenceType __end_output = 0;
for (int __t = 0; __t < __num_threads + 1; __t++)
for (_ThreadIndex __t = 0; __t < __num_threads + 1; __t++)
__end_output += __counter[__t];
delete[] __borders;