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

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;