multiway_merge.h (multiway_merge_*, [...]): Replace int by appropriate…

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

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

libstdc++-v3/ChangeLog

+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'.

libstdc++-v3/include/parallel/balanced_quicksort.h

@@ -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;
     }

libstdc++-v3/include/parallel/base.h

@@ -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; 
   }
 

libstdc++-v3/include/parallel/multiseq_selection.h

@@ -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],

libstdc++-v3/include/parallel/multiway_merge.h

@@ -490,26 +490,28 @@ namespace __gnu_parallel
 
       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)
 	{
@@ -575,16 +577,18 @@ namespace __gnu_parallel
       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,
@@ -921,6 +926,8 @@ namespace __gnu_parallel
 
       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
@@ -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)
 	{
@@ -1030,15 +1037,17 @@ namespace __gnu_parallel
      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;
@@ -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)
@@ -1108,15 +1117,17 @@ namespace __gnu_parallel
        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).
@@ -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)
@@ -1219,6 +1230,8 @@ namespace __gnu_parallel
 
 	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
@@ -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

libstdc++-v3/include/parallel/multiway_mergesort.h

@@ -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)

libstdc++-v3/include/parallel/partial_sum.h

@@ -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;

libstdc++-v3/include/parallel/partition.h

@@ -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]);
 	      }
 

libstdc++-v3/include/parallel/set_operations.h

@@ -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.

libstdc++-v3/include/parallel/unique_copy.h

@@ -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;