+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'.
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;
// 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;
#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;
}
// 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;
}
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);
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;
__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);
// 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;
#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)
{
__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)
{
}
}
- int __i;
+ _SeqNumber __i;
for (__i = 0; __i < __m; __i++)
{
_DifferenceType __middle = (__b[__i] + __a[__i]) / 2;
}
_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;
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]
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;
// 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)
{
}
}
- 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;
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).
_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);
__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);
// 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;
#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)
__n /= 2;
const _Tp* __lmax = NULL;
- for (int __i = 0; __i < __m; ++__i)
+ for (_SeqNumber __i = 0; __i < __m; ++__i)
{
if (__a[__i] > 0)
{
}
}
- int __i;
+ _SeqNumber __i;
for (__i = 0; __i < __m; __i++)
{
_DifferenceType __middle = (__b[__i] + __a[__i]) / 2;
}
_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;
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]
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;
// 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)
{
// 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],
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);
__lt.__init();
- int __source;
+ _SeqNumber __source;
for (_DifferenceType __i = 0; __i < __length; ++__i)
{
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
__lt.__init();
- int __source;
+ _SeqNumber __source;
#if _GLIBCXX_ASSERTIONS
_DifferenceType __i = 0;
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,
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
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)
{
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;
typedef typename std::iterator_traits<_RAIter1>::value_type
_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;
_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>
_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)
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;
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).
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],
}
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)
_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;
// 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)
// 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 =
_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
__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))
_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]
__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)
/ ((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;
_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;
// 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;
// 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;
# 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]);
}
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];
}
else
{
- for (int __i = 0; __i < __iam; ++__i)
+ for (_ThreadIndex __i = 0; __i < __iam; ++__i)
__r += __lengths[ __i ];
// Reset begins for copy pass.
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;
}
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;
}
_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;
OSDN Git Service
