multiway_merge.h: Reformat to 80 columns; adjust some inline specifiers; other minor...
authorPaolo Carlini <pcarlini@suse.de>
Thu, 10 Jan 2008 02:07:41 +0000 (02:07 +0000)
committerPaolo Carlini <paolo@gcc.gnu.org>
Thu, 10 Jan 2008 02:07:41 +0000 (02:07 +0000)
2008-01-09  Paolo Carlini  <pcarlini@suse.de>

* include/parallel/multiway_merge.h: Reformat to 80 columns;
adjust some inline specifiers; other minor style fixes.
* include/parallel/losertree.h: Likewise.
* include/parallel/list_partition.h: Likewise.
* include/parallel/multiseq_selection.h: Likewise.
* include/parallel/workstealing.h: Likewise.
* include/parallel/base.h: Likewise.
* include/parallel/par_loop.h: Likewise.
* include/parallel/numeric: Likewise.
* include/parallel/quicksort.h: Likewise.
* include/parallel/algorithmfwd.h: Likewise.
* include/parallel/for_each_selectors.h: Likewise.
* include/parallel/omp_loop_static.h: Likewise.
* include/parallel/random_shuffle.h: Likewise.
* include/parallel/balanced_quicksort.h: Likewise.
* include/parallel/set_operations.h: Likewise.
* include/parallel/tree.h: Likewise.
* include/parallel/merge.h: Likewise.
* include/parallel/unique_copy.h: Likewise.
* include/parallel/settings.h: Likewise.
* include/parallel/multiway_mergesort.h: Likewise.
* include/parallel/numericfwd.h: Likewise.
* include/parallel/search.h: Likewise.
* include/parallel/partition.h: Likewise.
* include/parallel/compatibility.h: Likewise.
* include/parallel/partial_sum.h: Likewise.
* include/parallel/find.h: Likewise.
* include/parallel/algo.h: Likewise.
* include/parallel/queue.h: Likewise.
* include/parallel/omp_loop.h: Likewise.
* include/parallel/sort.h: Likewise.
* include/parallel/random_number.h: Likewise.

From-SVN: r131440

32 files changed:
libstdc++-v3/ChangeLog
libstdc++-v3/include/parallel/algo.h
libstdc++-v3/include/parallel/algorithmfwd.h
libstdc++-v3/include/parallel/balanced_quicksort.h
libstdc++-v3/include/parallel/base.h
libstdc++-v3/include/parallel/compatibility.h
libstdc++-v3/include/parallel/find.h
libstdc++-v3/include/parallel/for_each_selectors.h
libstdc++-v3/include/parallel/list_partition.h
libstdc++-v3/include/parallel/losertree.h
libstdc++-v3/include/parallel/merge.h
libstdc++-v3/include/parallel/multiseq_selection.h
libstdc++-v3/include/parallel/multiway_merge.h
libstdc++-v3/include/parallel/multiway_mergesort.h
libstdc++-v3/include/parallel/numeric
libstdc++-v3/include/parallel/numericfwd.h
libstdc++-v3/include/parallel/omp_loop.h
libstdc++-v3/include/parallel/omp_loop_static.h
libstdc++-v3/include/parallel/par_loop.h
libstdc++-v3/include/parallel/partial_sum.h
libstdc++-v3/include/parallel/partition.h
libstdc++-v3/include/parallel/queue.h
libstdc++-v3/include/parallel/quicksort.h
libstdc++-v3/include/parallel/random_number.h
libstdc++-v3/include/parallel/random_shuffle.h
libstdc++-v3/include/parallel/search.h
libstdc++-v3/include/parallel/set_operations.h
libstdc++-v3/include/parallel/settings.h
libstdc++-v3/include/parallel/sort.h
libstdc++-v3/include/parallel/tree.h
libstdc++-v3/include/parallel/unique_copy.h
libstdc++-v3/include/parallel/workstealing.h

index 842ce0b..30d5885 100644 (file)
@@ -1,3 +1,38 @@
+2008-01-09  Paolo Carlini  <pcarlini@suse.de>
+
+       * include/parallel/multiway_merge.h: Reformat to 80 columns;
+       adjust some inline specifiers; other minor style fixes.
+       * include/parallel/losertree.h: Likewise.
+       * include/parallel/list_partition.h: Likewise.
+       * include/parallel/multiseq_selection.h: Likewise.
+       * include/parallel/workstealing.h: Likewise.
+       * include/parallel/base.h: Likewise.
+       * include/parallel/par_loop.h: Likewise.
+       * include/parallel/numeric: Likewise.
+       * include/parallel/quicksort.h: Likewise.
+       * include/parallel/algorithmfwd.h: Likewise.
+       * include/parallel/for_each_selectors.h: Likewise.
+       * include/parallel/omp_loop_static.h: Likewise.
+       * include/parallel/random_shuffle.h: Likewise.
+       * include/parallel/balanced_quicksort.h: Likewise.
+       * include/parallel/set_operations.h: Likewise.
+       * include/parallel/tree.h: Likewise.
+       * include/parallel/merge.h: Likewise.
+       * include/parallel/unique_copy.h: Likewise.
+       * include/parallel/settings.h: Likewise.
+       * include/parallel/multiway_mergesort.h: Likewise.
+       * include/parallel/numericfwd.h: Likewise.
+       * include/parallel/search.h: Likewise.
+       * include/parallel/partition.h: Likewise.
+       * include/parallel/compatibility.h: Likewise.
+       * include/parallel/partial_sum.h: Likewise.
+       * include/parallel/find.h: Likewise.
+       * include/parallel/algo.h: Likewise.
+       * include/parallel/queue.h: Likewise.
+       * include/parallel/omp_loop.h: Likewise.
+       * include/parallel/sort.h: Likewise.
+       * include/parallel/random_number.h: Likewise.
+
 2008-01-09  Benjamin Kosnik  <bkoz@redhat.com>
 
        * docs/html/17_intro/api.html: Fix markup for rope.h.
index 2809588..47f305d 100644 (file)
@@ -90,12 +90,10 @@ namespace __parallel
                    __gnu_parallel::parallelism parallelism_tag
                    = __gnu_parallel::parallel_balanced)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     for_each_minimal_n
-                                     && __gnu_parallel::
-                                     is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::for_each_minimal_n
+           && __gnu_parallel::is_parallel(parallelism_tag)))
        {
          bool dummy;
          __gnu_parallel::for_each_selector<RandomAccessIterator>
@@ -333,10 +331,9 @@ namespace __parallel
                       RandomAccessOutputIterator out, Predicate pred, 
                       random_access_iterator_tag, random_access_iterator_tag)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(last - begin)
-                                     > __gnu_parallel::Settings::
-                                     unique_copy_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(last - begin)
+           > __gnu_parallel::Settings::unique_copy_minimal_n))
        return __gnu_parallel::parallel_unique_copy(begin, last, out, pred);
       else
        return _GLIBCXX_STD_P::unique_copy(begin, last, out, pred);
@@ -414,14 +411,11 @@ namespace __parallel
                     random_access_iterator_tag, random_access_iterator_tag, 
                     random_access_iterator_tag)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end1 - begin1)
-                                     >= __gnu_parallel::Settings::
-                                     set_union_minimal_n
-                                     || static_cast<__gnu_parallel::
-                                     sequence_index_t>(end2 - begin2)
-                                     >= __gnu_parallel::Settings::
-                                     set_union_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1)
+           >= __gnu_parallel::Settings::set_union_minimal_n
+           || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2)
+           >= __gnu_parallel::Settings::set_union_minimal_n))
        return __gnu_parallel::parallel_set_union(begin1, end1,
                                                  begin2, end2, result, pred);
       else
@@ -523,14 +517,11 @@ namespace __parallel
                            random_access_iterator_tag,
                            random_access_iterator_tag)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end1 - begin1)
-                                     >= __gnu_parallel::Settings::
-                                     set_union_minimal_n
-                                     || static_cast<__gnu_parallel::
-                                     sequence_index_t>(end2 - begin2)
-                                     >= __gnu_parallel::Settings::
-                                     set_union_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1)
+           >= __gnu_parallel::Settings::set_union_minimal_n
+           || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2)
+           >= __gnu_parallel::Settings::set_union_minimal_n))
        return __gnu_parallel::parallel_set_intersection(begin1, end1, begin2, 
                                                         end2, result, pred);
       else
@@ -639,14 +630,11 @@ namespace __parallel
                                    random_access_iterator_tag,
                                    random_access_iterator_tag)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end1 - begin1)
-                                     >= __gnu_parallel::Settings::
-                                     set_symmetric_difference_minimal_n
-                                     || static_cast<__gnu_parallel::
-                                     sequence_index_t>(end2 - begin2)
-                                     >= __gnu_parallel::Settings::
-                                     set_symmetric_difference_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1)
+           >= __gnu_parallel::Settings::set_symmetric_difference_minimal_n
+           || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2)
+           >= __gnu_parallel::Settings::set_symmetric_difference_minimal_n))
        return __gnu_parallel::parallel_set_symmetric_difference(begin1, end1,
                                                                 begin2, end2,
                                                                 result, pred);
@@ -751,14 +739,11 @@ namespace __parallel
                          random_access_iterator_tag,
                          random_access_iterator_tag)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end1 - begin1)
-                                     >= __gnu_parallel::Settings::
-                                     set_difference_minimal_n
-                                     || static_cast<__gnu_parallel::
-                                     sequence_index_t>(end2 - begin2)
-                                     >= __gnu_parallel::Settings::
-                                     set_difference_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1)
+           >= __gnu_parallel::Settings::set_difference_minimal_n
+           || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2)
+           >= __gnu_parallel::Settings::set_difference_minimal_n))
        return __gnu_parallel::parallel_set_difference(begin1, end1,
                                                       begin2, end2,
                                                       result, pred);
@@ -926,12 +911,10 @@ namespace __parallel
       typedef typename traits_type::difference_type difference_type;
       typedef __gnu_parallel::sequence_index_t sequence_index_t;
 
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<sequence_index_t>
-                                     (end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     count_minimal_n
-                                     && __gnu_parallel::
-                                     is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::count_minimal_n
+           && __gnu_parallel::is_parallel(parallelism_tag)))
        {
          __gnu_parallel::count_selector<RandomAccessIterator, difference_type>
            functionality;
@@ -996,12 +979,10 @@ namespace __parallel
       typedef typename traits_type::difference_type difference_type;
       typedef __gnu_parallel::sequence_index_t sequence_index_t;
 
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<sequence_index_t>
-                                     (end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     count_minimal_n
-                                     && __gnu_parallel::
-                                     is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::count_minimal_n
+           && __gnu_parallel::is_parallel(parallelism_tag)))
        {
          difference_type res = 0;
          __gnu_parallel::
@@ -1239,12 +1220,10 @@ namespace __parallel
                      __gnu_parallel::parallelism parallelism_tag
                      = __gnu_parallel::parallel_balanced)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     transform_minimal_n
-                                     && __gnu_parallel::
-                                     is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::transform_minimal_n
+           && __gnu_parallel::is_parallel(parallelism_tag)))
        {
          bool dummy = true;
          typedef __gnu_parallel::iterator_pair<RandomAccessIterator1,
@@ -1330,11 +1309,9 @@ namespace __parallel
                      __gnu_parallel::parallelism parallelism_tag 
                      = __gnu_parallel::parallel_balanced)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION((end1 - begin1)
-                                     >= __gnu_parallel::Settings::
-                                     transform_minimal_n
-                                     && __gnu_parallel::
-                                     is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           (end1 - begin1) >= __gnu_parallel::Settings::transform_minimal_n
+           && __gnu_parallel::is_parallel(parallelism_tag)))
        {
          bool dummy = true;
          typedef __gnu_parallel::iterator_triple<RandomAccessIterator1,
@@ -1489,12 +1466,10 @@ namespace __parallel
                      __gnu_parallel::parallelism parallelism_tag
                      = __gnu_parallel::parallel_balanced)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     replace_minimal_n
-                                     && __gnu_parallel::
-                                     is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::replace_minimal_n
+           && __gnu_parallel::is_parallel(parallelism_tag)))
        {
          bool dummy;
          __gnu_parallel::
@@ -1556,12 +1531,10 @@ namespace __parallel
                    __gnu_parallel::parallelism parallelism_tag
                    = __gnu_parallel::parallel_balanced)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     generate_minimal_n
-                                     && __gnu_parallel::
-                                     is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::generate_minimal_n
+           && __gnu_parallel::is_parallel(parallelism_tag)))
        {
          bool dummy;
          __gnu_parallel::generate_selector<RandomAccessIterator>
@@ -1686,10 +1659,9 @@ namespace __parallel
     {
       if (begin == end)
        return;
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     random_shuffle_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::random_shuffle_minimal_n))
        __gnu_parallel::parallel_random_shuffle(begin, end, rand);
       else
        __gnu_parallel::sequential_random_shuffle(begin, end, rand);
@@ -1715,10 +1687,9 @@ namespace __parallel
     partition_switch(RandomAccessIterator begin, RandomAccessIterator end,
                     Predicate pred, random_access_iterator_tag)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     partition_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::partition_minimal_n))
        {
          typedef typename std::iterator_traits<RandomAccessIterator>::
            difference_type difference_type;
@@ -1775,10 +1746,9 @@ namespace __parallel
 
       if (begin != end)
        {
-         if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                         sequence_index_t>(end - begin)
-                                         >= __gnu_parallel::Settings::
-                                         sort_minimal_n))
+         if (_GLIBCXX_PARALLEL_CONDITION(
+               static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+               >= __gnu_parallel::Settings::sort_minimal_n))
            __gnu_parallel::parallel_sort(begin, end, comp, false);
          else
            sort(begin, end, comp, __gnu_parallel::sequential_tag());
@@ -1816,10 +1786,9 @@ namespace __parallel
     {
       if (begin != end)
        {
-         if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                         sequence_index_t>(end - begin)
-                                         >= __gnu_parallel::Settings::
-                                         sort_minimal_n))
+         if (_GLIBCXX_PARALLEL_CONDITION(
+               static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+               >= __gnu_parallel::Settings::sort_minimal_n))
            __gnu_parallel::parallel_sort(begin, end, comp, true);
          else
            stable_sort(begin, end, comp, __gnu_parallel::sequential_tag());
@@ -1866,14 +1835,11 @@ namespace __parallel
                 random_access_iterator_tag, random_access_iterator_tag, 
                 random_access_iterator_tag)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION((static_cast<__gnu_parallel::
-                                      sequence_index_t>(end1 - begin1)
-                                      >= __gnu_parallel::Settings::
-                                      merge_minimal_n
-                                      || static_cast<__gnu_parallel::
-                                      sequence_index_t>(end2 - begin2)
-                                      >= __gnu_parallel::Settings::
-                                      merge_minimal_n)))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           (static_cast<__gnu_parallel::sequence_index_t>(end1 - begin1)
+            >= __gnu_parallel::Settings::merge_minimal_n
+            || static_cast<__gnu_parallel::sequence_index_t>(end2 - begin2)
+            >= __gnu_parallel::Settings::merge_minimal_n)))
        return __gnu_parallel::parallel_merge_advance(begin1, end1,
                                                      begin2, end2,
                                                      result, (end1 - begin1)
@@ -1945,10 +1911,9 @@ namespace __parallel
     nth_element(RandomAccessIterator begin, RandomAccessIterator nth, 
                RandomAccessIterator end, Comparator comp)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     nth_element_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::nth_element_minimal_n))
        __gnu_parallel::parallel_nth_element(begin, nth, end, comp);
       else
        nth_element(begin, nth, end, comp, __gnu_parallel::sequential_tag());
@@ -1986,10 +1951,9 @@ namespace __parallel
     partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, 
                 RandomAccessIterator end, _Compare comp)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     partial_sort_minimal_n))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::partial_sort_minimal_n))
        __gnu_parallel::parallel_partial_sort(begin, middle, end, comp);
       else
        partial_sort(begin, middle, end, comp,
@@ -2036,12 +2000,10 @@ namespace __parallel
                       __gnu_parallel::parallelism parallelism_tag
                       = __gnu_parallel::parallel_balanced)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     max_element_minimal_n
-                                     && __gnu_parallel::
-                                     is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::max_element_minimal_n
+           && __gnu_parallel::is_parallel(parallelism_tag)))
        {
          RandomAccessIterator res(begin);
          __gnu_parallel::identity_selector<RandomAccessIterator>
@@ -2129,12 +2091,10 @@ namespace __parallel
                       __gnu_parallel::parallelism parallelism_tag
                       = __gnu_parallel::parallel_balanced)
     {
-      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
-                                     sequence_index_t>(end - begin)
-                                     >= __gnu_parallel::Settings::
-                                     min_element_minimal_n
-                                     && __gnu_parallel::
-                                     is_parallel(parallelism_tag)))
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::min_element_minimal_n
+           && __gnu_parallel::is_parallel(parallelism_tag)))
        {
          RandomAccessIterator res(begin);
          __gnu_parallel::identity_selector<RandomAccessIterator>
index f4fc1ac..f1aa5d7 100644 (file)
@@ -454,8 +454,8 @@ namespace __parallel
     _RAIter3
     transform2_switch(_RAIter1, _RAIter1, _RAIter2, _RAIter3, _BiOperation, 
                      random_access_iterator_tag, random_access_iterator_tag, 
-                     random_access_iterator_tag, 
-                     __gnu_parallel::parallelism parallelism_tag);
+                     random_access_iterator_tag,
+                     __gnu_parallel::parallelism);
 
   template<typename _IIter1, typename _IIter2, typename _OIter,
           typename _BiOperation, typename _Tag1,
@@ -525,7 +525,7 @@ namespace __parallel
 
   template<typename _FIter>
     _FIter
-    max_element(_FIter, _FIter, __gnu_parallel::parallelism parallelism_tag);
+    max_element(_FIter, _FIter, __gnu_parallel::parallelism);
 
   template<typename _FIter, typename _Compare>
     _FIter
index ac05ec7..70d8115 100644 (file)
@@ -112,8 +112,9 @@ template<typename RandomAccessIterator, typename Comparator>
     typedef typename traits_type::value_type value_type;
     typedef typename traits_type::difference_type difference_type;
 
-    RandomAccessIterator pivot_pos = median_of_three_iterators(
-        begin, begin + (end - begin) / 2, end  - 1, comp);
+    RandomAccessIterator pivot_pos =
+      median_of_three_iterators(begin, begin + (end - begin) / 2,
+                               end  - 1, comp);
 
 #if defined(_GLIBCXX_ASSERTIONS)
     // Must be in between somewhere.
@@ -146,9 +147,9 @@ template<typename RandomAccessIterator, typename Comparator>
 
 #if _GLIBCXX_ASSERTIONS
     RandomAccessIterator r;
-    for (r = begin; r != pivot_pos; r++)
+    for (r = begin; r != pivot_pos; ++r)
       _GLIBCXX_PARALLEL_ASSERT(comp(*r, *pivot_pos));
-    for (; r != end; r++)
+    for (; r != end; ++r)
       _GLIBCXX_PARALLEL_ASSERT(!comp(*r, *pivot_pos));
 #endif
 
@@ -308,12 +309,12 @@ template<typename RandomAccessIterator, typename Comparator>
                 __gnu_parallel::unary_negate<__gnu_parallel::binder1st
                     <Comparator, value_type, value_type, bool>, value_type>
                     pred(__gnu_parallel::binder1st
-                        <Comparator, value_type, value_type, bool>(
-                        comp, *pivot_pos));
+                        <Comparator, value_type, value_type, bool>(comp,
+                                                                  *pivot_pos));
 
                 // Find other end of pivot-equal range.
-                split_pos2 = __gnu_sequential::partition(
-                    split_pos1 + 1, end, pred);
+                split_pos2 = __gnu_sequential::partition(split_pos1 + 1,
+                                                        end, pred);
               }
             else
               // Only skip the pivot.
@@ -339,8 +340,8 @@ template<typename RandomAccessIterator, typename Comparator>
               {
                 // Left side larger.
                 if (begin != split_pos1)
-                  tl.leftover_parts.push_front(
-                      std::make_pair(begin, split_pos1));
+                  tl.leftover_parts.push_front(std::make_pair(begin,
+                                                             split_pos1));
 
                 current.first = split_pos2;
                 //current.second = end;        //already set anyway
@@ -394,8 +395,8 @@ template<typename RandomAccessIterator, typename Comparator>
             if (omp_get_wtime() >= (search_start + 1.0))
               {
                 sleep(1);
-                _GLIBCXX_PARALLEL_ASSERT(
-                    omp_get_wtime() < (search_start + 1.0));
+                _GLIBCXX_PARALLEL_ASSERT(omp_get_wtime()
+                                        < (search_start + 1.0));
               }
 #endif
             if (!successfully_stolen)
@@ -452,7 +453,7 @@ template<typename RandomAccessIterator, typename Comparator>
     // 2. The largest range has at most length n
     // 3. Each range is larger than half of the range remaining
     volatile difference_type elements_leftover = n;
-    for (int i = 0; i < num_threads; i++)
+    for (int i = 0; i < num_threads; ++i)
       {
         tls[i]->elements_leftover = &elements_leftover;
         tls[i]->num_threads = num_threads;
@@ -468,11 +469,11 @@ template<typename RandomAccessIterator, typename Comparator>
 #if _GLIBCXX_ASSERTIONS
     // All stack must be empty.
     Piece dummy;
-    for (int i = 1; i < num_threads; i++)
+    for (int i = 1; i < num_threads; ++i)
       _GLIBCXX_PARALLEL_ASSERT(!tls[i]->leftover_parts.pop_back(dummy));
 #endif
 
-    for (int i = 0; i < num_threads; i++)
+    for (int i = 0; i < num_threads; ++i)
       delete tls[i];
     delete[] tls;
   }
index 5a756cd..8d1c073 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -96,17 +96,13 @@ decode2(lcas_t x, int& a, int& b)
 template<typename T>
   const T&
   min(const T& a, const T& b)
-  {
-    return (a < b) ? a : b;
-  };
+  { return (a < b) ? a : b; }
 
 /** @brief Equivalent to std::max. */
 template<typename T>
   const T&
   max(const T& a, const T& b)
-  {
-    return (a > b) ? a : b;
-  };
+  { return (a > b) ? a : b; }
 
 /** @brief Constructs predicate for equality from strict weak
   *  ordering predicate
@@ -402,7 +398,7 @@ template<typename _ValueTp>
   *  @param comp Comparator.
   */
 template<typename RandomAccessIterator, typename Comparator>
-RandomAccessIterator
+  RandomAccessIterator
   median_of_three_iterators(RandomAccessIterator a, RandomAccessIterator b,
                             RandomAccessIterator c, Comparator& comp)
   {
index cf8e318..c4e9061 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -105,7 +105,8 @@ namespace __gnu_parallel
 #elif defined(__ECC)   //IA-64 version
     return _InterlockedExchangeAdd((void*)ptr, addend);
 #elif defined(__ICL) || defined(_MSC_VER)
-    return _InterlockedExchangeAdd(reinterpret_cast<volatile long*>(ptr), addend);
+    return _InterlockedExchangeAdd(reinterpret_cast<volatile long*>(ptr),
+                                  addend);
 #elif defined(__GNUC__)
     return __sync_fetch_and_add(ptr, addend);
 #elif defined(__SUNPRO_CC) && defined(__sparc)
@@ -114,7 +115,8 @@ namespace __gnu_parallel
       {
        before = *ptr;
        after = before + addend;
-      } while (atomic_cas_32((volatile unsigned int*)ptr, before, after) != before);
+      } while (atomic_cas_32((volatile unsigned int*)ptr, before,
+                            after) != before);
     return before;
 #else  //fallback, slow
 #pragma message("slow fetch_and_add_32")
@@ -159,7 +161,8 @@ namespace __gnu_parallel
       {
        before = *ptr;
        after = before + addend;
-      } while (atomic_cas_64((volatile unsigned long long*)ptr, before, after) != before);
+      } while (atomic_cas_64((volatile unsigned long long*)ptr, before,
+                            after) != before);
     return before;
 #else  //fallback, slow
 #if defined(__GNUC__) && defined(__i386)
@@ -238,15 +241,19 @@ namespace __gnu_parallel
   compare_and_swap_32(volatile int32* ptr, int32 comparand, int32 replacement)
   {
 #if defined(__ICC)     //x86 version
-    return _InterlockedCompareExchange((void*)ptr, replacement, comparand) == comparand;
+    return _InterlockedCompareExchange((void*)ptr, replacement,
+                                      comparand) == comparand;
 #elif defined(__ECC)   //IA-64 version
-    return _InterlockedCompareExchange((void*)ptr, replacement, comparand) == comparand;
+    return _InterlockedCompareExchange((void*)ptr, replacement,
+                                      comparand) == comparand;
 #elif defined(__ICL) || defined(_MSC_VER)
-    return _InterlockedCompareExchange(reinterpret_cast<volatile long*>(ptr), replacement, comparand) == comparand;
+    return _InterlockedCompareExchange(reinterpret_cast<volatile long*>(ptr),
+                                      replacement, comparand) == comparand;
 #elif defined(__GNUC__)
     return __sync_bool_compare_and_swap(ptr, comparand, replacement);
 #elif defined(__SUNPRO_CC) && defined(__sparc)
-    return atomic_cas_32((volatile unsigned int*)ptr, comparand, replacement) == comparand;
+    return atomic_cas_32((volatile unsigned int*)ptr, comparand,
+                        replacement) == comparand;
 #else
 #pragma message("slow compare_and_swap_32")
     bool res = false;
@@ -276,13 +283,15 @@ namespace __gnu_parallel
 #if defined(__ICC) && defined(__x86_64)        //x86 version
     return cas64<int>(ptr, comparand, replacement) == comparand;
 #elif defined(__ECC)   //IA-64 version
-    return _InterlockedCompareExchange64((void*)ptr, replacement, comparand) == comparand;
+    return _InterlockedCompareExchange64((void*)ptr, replacement,
+                                        comparand) == comparand;
 #elif defined(__ICL) || defined(_MSC_VER)
 #ifndef _WIN64
     _GLIBCXX_PARALLEL_ASSERT(false);   //not available in this case
     return 0;
 #else
-    return _InterlockedCompareExchange64(ptr, replacement, comparand) == comparand;
+    return _InterlockedCompareExchange64(ptr, replacement,
+                                        comparand) == comparand;
 #endif
 
 #elif defined(__GNUC__) && defined(__x86_64)
@@ -291,7 +300,8 @@ namespace __gnu_parallel
   (defined(__i686) || defined(__pentium4) || defined(__athlon))
     return __sync_bool_compare_and_swap(ptr, comparand, replacement);
 #elif defined(__SUNPRO_CC) && defined(__sparc)
-    return atomic_cas_64((volatile unsigned long long*)ptr, comparand, replacement) == comparand;
+    return atomic_cas_64((volatile unsigned long long*)ptr,
+                        comparand, replacement) == comparand;
 #else
 #if defined(__GNUC__) && defined(__i386)
     // XXX -march=native
@@ -323,9 +333,11 @@ namespace __gnu_parallel
   compare_and_swap(volatile T* ptr, T comparand, T replacement)
   {
     if (sizeof(T) == sizeof(int32))
-      return compare_and_swap_32((volatile int32*) ptr, (int32)comparand, (int32)replacement);
+      return compare_and_swap_32((volatile int32*) ptr,
+                                (int32)comparand, (int32)replacement);
     else if (sizeof(T) == sizeof(int64))
-      return compare_and_swap_64((volatile int64*) ptr, (int64)comparand, (int64)replacement);
+      return compare_and_swap_64((volatile int64*) ptr,
+                                (int64)comparand, (int64)replacement);
     else
       _GLIBCXX_PARALLEL_ASSERT(false);
   }
index 3a0db1f..051c69e 100644 (file)
@@ -62,7 +62,7 @@ template<typename RandomAccessIterator1,
         typename RandomAccessIterator2,
         typename Pred,
         typename Selector>
-  std::pair<RandomAccessIterator1, RandomAccessIterator2>
+  inline std::pair<RandomAccessIterator1, RandomAccessIterator2>
   find_template(RandomAccessIterator1 begin1, RandomAccessIterator1 end1,
                 RandomAccessIterator2 begin2, Pred pred, Selector selector)
   {
@@ -70,13 +70,13 @@ template<typename RandomAccessIterator1,
       {
       case Settings::GROWING_BLOCKS:
         return find_template(begin1, end1, begin2, pred, selector,
-                            growing_blocks_tag());
+                            growing_blocks_tag());
       case Settings::CONSTANT_SIZE_BLOCKS:
         return find_template(begin1, end1, begin2, pred, selector,
-                            constant_size_blocks_tag());
+                            constant_size_blocks_tag());
       case Settings::EQUAL_SPLIT:
         return find_template(begin1, end1, begin2, pred, selector,
-                            equal_split_tag());
+                            equal_split_tag());
       default:
         _GLIBCXX_PARALLEL_ASSERT(false);
         return std::make_pair(begin1, begin2);
@@ -158,8 +158,9 @@ template<typename RandomAccessIterator1,
     omp_destroy_lock(&result_lock);
     delete[] borders;
 
-    return std::pair<RandomAccessIterator1, RandomAccessIterator2>(
-        begin1 + result, begin2 + result);
+    return
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>(begin1 + result,
+                                                             begin2 + result);
   }
 
 #endif
@@ -205,8 +206,8 @@ template<typename RandomAccessIterator1,
 
     difference_type length = end1 - begin1;
 
-    difference_type sequential_search_size = std::min<difference_type>(
-        length, Settings::find_sequential_search_size);
+    difference_type sequential_search_size =
+      std::min<difference_type>(length, Settings::find_sequential_search_size);
 
     // Try it sequentially first.
     std::pair<RandomAccessIterator1, RandomAccessIterator2> find_seq_result =
@@ -267,23 +268,25 @@ template<typename RandomAccessIterator1,
                   omp_unset_lock(&result_lock);
               }
 
-            block_size = std::min<difference_type>(
-                block_size * Settings::find_increasing_factor,
-                Settings::find_maximum_block_size);
+            block_size =
+             std::min<difference_type>(block_size
+                                       * Settings::find_increasing_factor,
+                                       Settings::find_maximum_block_size);
 
             // Get new block, update pointer to next block.
             start =
-                fetch_and_add<difference_type>(&next_block_start, block_size);
-            stop = (length < (start + block_size)) ?
-                        length : (start + block_size);
+             fetch_and_add<difference_type>(&next_block_start, block_size);
+            stop = ((length < (start + block_size))
+                   ? length : (start + block_size));
           }
       } //parallel
 
     omp_destroy_lock(&result_lock);
 
     // Return iterator on found element.
-    return std::pair<RandomAccessIterator1, RandomAccessIterator2>(
-        begin1 + result, begin2 + result);
+    return
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>(begin1 + result,
+                                                             begin2 + result);
   }
 
 #endif
@@ -391,8 +394,9 @@ template<typename RandomAccessIterator1,
     omp_destroy_lock(&result_lock);
 
     // Return iterator on found element.
-    return std::pair<RandomAccessIterator1, RandomAccessIterator2>(
-        begin1 + result, begin2 + result);
+    return
+      std::pair<RandomAccessIterator1, RandomAccessIterator2>(begin1 + result,
+                                                             begin2 + result);
   }
 #endif
 } // end namespace
index b38aded..eaa55fc 100644 (file)
@@ -57,231 +57,234 @@ namespace __gnu_parallel
 
   /** @brief std::for_each() selector. */
   template<typename It>
-  struct for_each_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Functor execution.
-     *  @param o Operator.
-     *  @param i Iterator referencing object. */
-    template<typename Op>
-      bool
-      operator()(Op& o, It i)
-      {
-       o(*i);
-       return true;
-      }
-  };
+    struct for_each_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Functor execution.
+       *  @param o Operator.
+       *  @param i Iterator referencing object. */
+      template<typename Op>
+        bool
+        operator()(Op& o, It i)
+       {
+         o(*i);
+         return true;
+       }
+    };
 
   /** @brief std::generate() selector. */
   template<typename It>
-  struct generate_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Functor execution.
-     *  @param o Operator.
-     *  @param i Iterator referencing object. */
-    template<typename Op>
-      bool
-      operator()(Op& o, It i)
-      {
-       *i = o();
-       return true;
-      }
-  };
+    struct generate_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Functor execution.
+       *  @param o Operator.
+       *  @param i Iterator referencing object. */
+      template<typename Op>
+        bool
+        operator()(Op& o, It i)
+        {
+         *i = o();
+         return true;
+       }
+    };
 
   /** @brief std::fill() selector. */
   template<typename It>
-  struct fill_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Functor execution.
-     *  @param v Current value.
-     *  @param i Iterator referencing object. */
-    template<typename Val>
-      bool
-      operator()(Val& v, It i)
-      {
-       *i = v;
-       return true;
-      }
-  };
+    struct fill_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Functor execution.
+       *  @param v Current value.
+       *  @param i Iterator referencing object. */
+      template<typename Val>
+        bool
+        operator()(Val& v, It i)
+       {
+         *i = v;
+         return true;
+       }
+    };
 
   /** @brief std::transform() selector, one input sequence variant. */
   template<typename It>
-  struct transform1_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Functor execution.
-     *  @param o Operator.
-     *  @param i Iterator referencing object. */
-    template<typename Op>
-      bool
-      operator()(Op& o, It i)
-      {
-       *i.second = o(*i.first);
-       return true;
-      }
-  };
+    struct transform1_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Functor execution.
+       *  @param o Operator.
+       *  @param i Iterator referencing object. */
+      template<typename Op>
+        bool
+        operator()(Op& o, It i)
+       {
+         *i.second = o(*i.first);
+         return true;
+       }
+    };
 
   /** @brief std::transform() selector, two input sequences variant. */
   template<typename It>
-  struct transform2_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Functor execution.
-     *  @param o Operator.
-     *  @param i Iterator referencing object. */
-    template<typename Op>
-      bool
-      operator()(Op& o, It i)
-      {
-       *i.third = o(*i.first, *i.second);
-       return true;
-      }
-  };
+    struct transform2_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Functor execution.
+       *  @param o Operator.
+       *  @param i Iterator referencing object. */
+      template<typename Op>
+        bool
+        operator()(Op& o, It i)
+       {
+         *i.third = o(*i.first, *i.second);
+         return true;
+       }
+    };
 
   /** @brief std::replace() selector. */
   template<typename It, typename T>
-  struct replace_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Value to replace with. */
-    const T& new_val;
+    struct replace_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Value to replace with. */
+      const T& new_val;
 
-    /** @brief Constructor
-     *  @param new_val Value to replace with. */
-    explicit replace_selector(const T &new_val) : new_val(new_val) {}
+      /** @brief Constructor
+       *  @param new_val Value to replace with. */
+      explicit
+      replace_selector(const T &new_val) : new_val(new_val) {}
 
-    /** @brief Functor execution.
-     *  @param v Current value.
-     *  @param i Iterator referencing object. */
-    bool
-    operator()(T& v, It i)
-    {
-      if (*i == v)
-       *i = new_val;
-      return true;
-    }
-  };
+      /** @brief Functor execution.
+       *  @param v Current value.
+       *  @param i Iterator referencing object. */
+      bool
+      operator()(T& v, It i)
+      {
+       if (*i == v)
+         *i = new_val;
+       return true;
+      }
+    };
 
   /** @brief std::replace() selector. */
   template<typename It, typename Op, typename T>
-  struct replace_if_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Value to replace with. */
-    const T& new_val;
+    struct replace_if_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Value to replace with. */
+      const T& new_val;
 
-    /** @brief Constructor.
-     *  @param new_val Value to replace with. */
-    explicit replace_if_selector(const T &new_val) : new_val(new_val) { }
+      /** @brief Constructor.
+       *  @param new_val Value to replace with. */
+      explicit
+      replace_if_selector(const T &new_val) : new_val(new_val) { }
 
-    /** @brief Functor execution.
-     *  @param o Operator.
-     *  @param i Iterator referencing object. */
-    bool
-    operator()(Op& o, It i)
-    {
-      if (o(*i))
-       *i = new_val;
-      return true;
-    }
-  };
+      /** @brief Functor execution.
+       *  @param o Operator.
+       *  @param i Iterator referencing object. */
+      bool
+      operator()(Op& o, It i)
+      {
+       if (o(*i))
+         *i = new_val;
+       return true;
+      }
+    };
 
   /** @brief std::count() selector. */
   template<typename It, typename Diff>
-  struct count_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Functor execution.
-     *  @param v Current value.
-     *  @param i Iterator referencing object.
-     *  @return 1 if count, 0 if does not count. */
-    template<typename Val>
-      Diff
-      operator()(Val& v, It i)
-      { return (v == *i) ? 1 : 0; }
-  };
+    struct count_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Functor execution.
+       *  @param v Current value.
+       *  @param i Iterator referencing object.
+       *  @return 1 if count, 0 if does not count. */
+      template<typename Val>
+        Diff
+        operator()(Val& v, It i)
+       { return (v == *i) ? 1 : 0; }
+    };
 
   /** @brief std::count_if () selector. */
   template<typename It, typename Diff>
-  struct count_if_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Functor execution.
-     *  @param o Operator.
-     *  @param i Iterator referencing object.
-     *  @return 1 if count, 0 if does not count. */
-    template<typename Op>
-      Diff
-      operator()(Op& o, It i)
-      { return (o(*i)) ? 1 : 0; }
-  };
+    struct count_if_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Functor execution.
+       *  @param o Operator.
+       *  @param i Iterator referencing object.
+       *  @return 1 if count, 0 if does not count. */
+      template<typename Op>
+        Diff
+        operator()(Op& o, It i)
+       { return (o(*i)) ? 1 : 0; }
+    };
 
   /** @brief std::accumulate() selector. */
   template<typename It>
-  struct accumulate_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Functor execution.
-     *  @param o Operator (unused).
-     *  @param i Iterator referencing object.
-     *  @return The current value. */
-    template<typename Op>
-      typename std::iterator_traits<It>::value_type operator()(Op o, It i)
-      { return *i; }
-  };
+    struct accumulate_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Functor execution.
+       *  @param o Operator (unused).
+       *  @param i Iterator referencing object.
+       *  @return The current value. */
+      template<typename Op>
+        typename std::iterator_traits<It>::value_type operator()(Op o, It i)
+       { return *i; }
+    };
 
   /** @brief std::inner_product() selector. */
   template<typename It, typename It2, typename T>
-  struct inner_product_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Begin iterator of first sequence. */
-    It begin1_iterator;
-
-    /** @brief Begin iterator of second sequence. */
-    It2 begin2_iterator;
-
-    /** @brief Constructor.
-     *  @param b1 Begin iterator of first sequence.
-     *  @param b2 Begin iterator of second sequence. */
-    explicit inner_product_selector(It b1, It2 b2)
-    : begin1_iterator(b1), begin2_iterator(b2) { }
-
-    /** @brief Functor execution.
-     *  @param mult Multiplication functor.
-     *  @param current Iterator referencing object.
-     *  @return Inner product elemental result. */
-    template<typename Op>
-      T
-      operator()(Op mult, It current)
-      {
-       typename std::iterator_traits<It>::difference_type position
-         = current - begin1_iterator;
-       return mult(*current, *(begin2_iterator + position));
-      }
-  };
+    struct inner_product_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Begin iterator of first sequence. */
+      It begin1_iterator;
+
+      /** @brief Begin iterator of second sequence. */
+      It2 begin2_iterator;
+
+      /** @brief Constructor.
+       *  @param b1 Begin iterator of first sequence.
+       *  @param b2 Begin iterator of second sequence. */
+      explicit
+      inner_product_selector(It b1, It2 b2)
+      : begin1_iterator(b1), begin2_iterator(b2) { }
+
+      /** @brief Functor execution.
+       *  @param mult Multiplication functor.
+       *  @param current Iterator referencing object.
+       *  @return Inner product elemental result. */
+      template<typename Op>
+        T
+        operator()(Op mult, It current)
+       {
+         typename std::iterator_traits<It>::difference_type position
+           = current - begin1_iterator;
+         return mult(*current, *(begin2_iterator + position));
+       }
+    };
 
   /** @brief Selector that just returns the passed iterator. */
   template<typename It>
-  struct identity_selector : public generic_for_each_selector<It>
-  {
-    /** @brief Functor execution.
-     *  @param o Operator (unused).
-     *  @param i Iterator referencing object.
-     *  @return Passed iterator. */
-    template<typename Op>
-      It
-      operator()(Op o, It i)
-      { return i; }
-  };
+    struct identity_selector : public generic_for_each_selector<It>
+    {
+      /** @brief Functor execution.
+       *  @param o Operator (unused).
+       *  @param i Iterator referencing object.
+       *  @return Passed iterator. */
+      template<typename Op>
+        It
+        operator()(Op o, It i)
+       { return i; }
+    };
 
   /** @brief Selector that returns the difference between two adjacent
    *  elements.
    */
   template<typename It>
-  struct adjacent_difference_selector : public generic_for_each_selector<It>
-  {
-    template<typename Op>
-      bool
-      operator()(Op& o, It i)
-      {
-       typename It::first_type go_back_one = i.first;
-       --go_back_one;
-       *i.second = o(*i.first, *go_back_one);
-       return true;
-      }
-  };
+    struct adjacent_difference_selector : public generic_for_each_selector<It>
+    {
+      template<typename Op>
+        bool
+        operator()(Op& o, It i)
+       {
+         typename It::first_type go_back_one = i.first;
+         --go_back_one;
+         *i.second = o(*i.first, *go_back_one);
+         return true;
+       }
+    };
 
   // XXX move into type_traits?
   /** @brief Functor doing nothing
@@ -308,55 +311,56 @@ namespace __gnu_parallel
 
   /** @brief Reduction for finding the maximum element, using a comparator. */
   template<typename Comp, typename It>
-  struct min_element_reduct
-  {
-    Comp& comp;
+    struct min_element_reduct
+    {
+      Comp& comp;
 
-    explicit min_element_reduct(Comp &c) : comp(c)
-    { }
+      explicit
+      min_element_reduct(Comp &c) : comp(c) { }
 
-    It
-    operator()(It x, It y)
-    {
-      if (comp(*x, *y))
-       return x;
-      else
-       return y;
-    }
-  };
+      It
+      operator()(It x, It y)
+      {
+       if (comp(*x, *y))
+         return x;
+       else
+         return y;
+      }
+    };
 
   /** @brief Reduction for finding the maximum element, using a comparator. */
   template<typename Comp, typename It>
-  struct max_element_reduct
-  {
-    Comp& comp;
+    struct max_element_reduct
+    {
+      Comp& comp;
 
-    explicit max_element_reduct(Comp& c) : comp(c)
-    { }
+      explicit
+      max_element_reduct(Comp& c) : comp(c) { }
 
-    It
-    operator()(It x, It y)
-    {
-      if (comp(*x, *y))
-       return y;
-      else
-       return x;
-    }
-  };
+      It
+      operator()(It x, It y)
+      {
+       if (comp(*x, *y))
+         return y;
+       else
+         return x;
+      }
+    };
 
   /** @brief General reduction, using a binary operator. */
   template<typename BinOp>
-  struct accumulate_binop_reduct
-  {
-    BinOp& binop;
+    struct accumulate_binop_reduct
+    {
+      BinOp& binop;
 
-    explicit accumulate_binop_reduct(BinOp& b) : binop(b) {}
+      explicit
+      accumulate_binop_reduct(BinOp& b) : binop(b) { }
 
-    template<typename Result, typename Addend>
-      Result
-      operator()(const Result& x, const Addend& y)
-      { return binop(x, y); }
-  };
+      template<typename Result, typename Addend>
+        Result
+        operator()(const Result& x, const Addend& y)
+       { return binop(x, y); }
+    };
 }
 
 #endif
index b346105..0fcc628 100644 (file)
@@ -159,7 +159,7 @@ namespace __gnu_parallel
       // Smallest partitions.
       for (int i = 1; i < (num_parts + 1 - size_greater); ++i)
        {
-         lengths[i-1] =  size_part * range_length;
+         lengths[i - 1] =  size_part * range_length;
          index += size_part;
          starts[i] = os_starts[index];
        }
@@ -167,7 +167,7 @@ namespace __gnu_parallel
       // Biggest partitions.
       for (int i = num_parts + 1 - size_greater; i <= num_parts; ++i)
        {
-         lengths[i-1] =  (size_part+1) * range_length;
+         lengths[i - 1] =  (size_part+1) * range_length;
          index += (size_part+1);
          starts[i] = os_starts[index];
        }
index 5726880..ddeb0d3 100644 (file)
@@ -82,7 +82,7 @@ template<typename T, typename Comparator = std::less<T> >
       size = _size;
       offset = size;
       losers = new Loser[size];
-      for (unsigned int l = 0; l < size; l++)
+      for (unsigned int l = 0; l < size; ++l)
         {
           //losers[l].key = ...        stays unset
           losers[l].inf = true;
@@ -156,9 +156,10 @@ template<typename T, typename Comparator = std::less<T> >
       bool inf = false;
       for (unsigned int pos = (offset + source) / 2; pos > 0; pos /= 2)
         {
-          if ((!inf && !losers[pos].inf && !sup && !losers[pos].sup &&
-              ((comp(losers[pos].key, key)) ||
-                (!comp(key, losers[pos].key) && losers[pos].source < source)))
+          if ((!inf && !losers[pos].inf && !sup && !losers[pos].sup
+              && ((comp(losers[pos].key, key))
+                  || (!comp(key, losers[pos].key)
+                      && losers[pos].source < source)))
               || losers[pos].inf || sup)
             {
               // Take next key.
@@ -186,8 +187,9 @@ template<typename T, typename Comparator = std::less<T> >
       for (unsigned int pos = (offset + source) / 2; pos > 0; pos /= 2)
         {
           if ((!inf && !losers[pos].inf && !sup && !losers[pos].sup
-              && ((comp(losers[pos].key, key)) ||
-                (!comp(key, losers[pos].key) && losers[pos].source < source)))
+              && ((comp(losers[pos].key, key))
+                 || (!comp(key, losers[pos].key)
+                     && losers[pos].source < source)))
               || losers[pos].inf || sup)
             {
               std::swap(losers[pos].key, key);
@@ -285,9 +287,9 @@ template<typename T, typename Comparator = std::less<T> >
         {
           unsigned int left = init_winner (2 * root);
           unsigned int right = init_winner (2 * root + 1);
-          if (losers[right].sup ||
-              (!losers[left].sup
-                && !comp(losers[right].key, losers[left].key)))
+          if (losers[right].sup
+             || (!losers[left].sup
+                 && !comp(losers[right].key, losers[left].key)))
             {
               // Left one is less or equal.
               losers[root] = losers[right];
@@ -345,7 +347,7 @@ template<typename T, typename Comparator = std::less<T> >
           unsigned int right = init_winner (2 * root + 1);
           if (losers[right].sup
               || (!losers[left].sup
-                && !comp(losers[right].key, losers[left].key)))
+                 && !comp(losers[right].key, losers[left].key)))
             {
               // Left one is less or equal.
               losers[root] = losers[right];
@@ -443,7 +445,7 @@ template<typename T, typename Comparator = std::less<T> >
 #ifndef COPY
       keys = new T[ik];
 #endif
-      for (unsigned int i = ik - 1; i < k; i++)
+      for (unsigned int i = ik - 1; i < k; ++i)
         losers[i + k].sup = true;
     }
 
@@ -569,11 +571,11 @@ template<typename T, typename Comparator = std::less<T> >
       for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
         {
           // The smaller one gets promoted, ties are broken by source.
-          if ( (sup && (!losers[pos].sup || losers[pos].source < source)) ||
-                (!sup && !losers[pos].sup &&
-                ((comp(KEY(pos), KEY_SOURCE(source))) ||
-                  (!comp(KEY_SOURCE(source), KEY(pos))
-                    && losers[pos].source < source))))
+          if ((sup && (!losers[pos].sup || losers[pos].source < source))
+             || (!sup && !losers[pos].sup
+                 && ((comp(KEY(pos), KEY_SOURCE(source)))
+                     || (!comp(KEY_SOURCE(source), KEY(pos))
+                         && losers[pos].source < source))))
             {
               // The other one is smaller.
               std::swap(losers[pos].sup, sup);
@@ -629,7 +631,7 @@ template<typename T, typename Comparator = std::less<T> >
       k = 1 << (log2(ik - 1) + 1);
       offset = k;
       losers = new Loser[k * 2];
-      for (unsigned int i = ik - 1; i < k; i++)
+      for (unsigned int i = ik - 1; i < k; ++i)
         losers[i + k].sup = true;
     }
 
@@ -746,11 +748,11 @@ template<typename T, typename Comparator = std::less<T> >
       for (unsigned int pos = (k + source) / 2; pos > 0; pos /= 2)
         {
           // The smaller one gets promoted, ties are broken by source.
-          if ( (sup && (!losers[pos].sup || losers[pos].source < source)) ||
-                (!sup && !losers[pos].sup &&
-                ((comp(*losers[pos].keyp, *keyp)) ||
-                  (!comp(*keyp, *losers[pos].keyp)
-                  && losers[pos].source < source))))
+          if ( (sup && (!losers[pos].sup || losers[pos].source < source))
+               || (!sup && !losers[pos].sup &&
+                   ((comp(*losers[pos].keyp, *keyp))
+                    || (!comp(*keyp, *losers[pos].keyp)
+                        && losers[pos].source < source))))
             {
               // The other one is smaller.
               std::swap(losers[pos].sup, sup);
@@ -995,8 +997,8 @@ template<typename T, typename Comparator = std::less<T> >
           // Next greater or equal power of 2.
           unsigned int division = 1 << (log2(end - begin - 1));
           unsigned int left = init_winner(2 * root, begin, begin + division);
-          unsigned int right
-                          = init_winner(2 * root + 1, begin + division, end);
+          unsigned int right = init_winner(2 * root + 1,
+                                          begin + division, end);
           if (!comp(*losers[right].keyp, *losers[left].keyp))
             {
               // Left one is less or equal.
index 6672130..f12f311 100644 (file)
@@ -74,7 +74,7 @@ namespace __gnu_parallel
            *target++ = *begin2++;
          else
            *target++ = *begin1++;
-         max_length--;
+         --max_length;
        }
 
       if (begin1 != end1)
@@ -143,8 +143,8 @@ namespace __gnu_parallel
 
          *target = element1;
 
-         target++;
-         max_length--;
+         ++target;
+         --max_length;
        }
       if (begin1 != end1)
        {
index df5bb87..855d90a 100644 (file)
@@ -212,7 +212,7 @@ namespace __gnu_parallel
       difference_type localrank = rank * m / N ;
 
       int j;
-      for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); j++)
+      for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); ++j)
        a[sample[j].second] += n + 1;
       for (; j < m; j++)
        b[sample[j].second] -= n + 1;
@@ -279,7 +279,7 @@ namespace __gnu_parallel
                if (b[i] < ns[i])
                  pq.push(std::make_pair(S(i)[b[i]], i));
 
-             for (; skew != 0 && !pq.empty(); skew--)
+             for (; skew != 0 && !pq.empty(); --skew)
                {
                  int source = pq.top().second;
                  pq.pop();
@@ -302,7 +302,7 @@ namespace __gnu_parallel
                if (a[i] > 0)
                  pq.push(std::make_pair(S(i)[a[i] - 1], i));
 
-             for (; skew != 0; skew++)
+             for (; skew != 0; ++skew)
                {
                  int source = pq.top().second;
                  pq.pop();
@@ -416,7 +416,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 (int i = 0; i < m; ++i)
        {
          ns[i] = std::distance(begin_seqs[i].first, begin_seqs[i].second);
          nmax = std::max(nmax, ns[i]);
@@ -431,7 +431,7 @@ namespace __gnu_parallel
       // From now on, including padding.
       N = l * m;
 
-      for (int i = 0; i < m; i++)
+      for (int i = 0; i < m; ++i)
        {
          a[i] = 0;
          b[i] = l;
@@ -460,9 +460,9 @@ namespace __gnu_parallel
       difference_type localrank = rank * m / N ;
 
       int j;
-      for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); j++)
+      for (j = 0; j < localrank && ((n + 1) <= ns[sample[j].second]); ++j)
        a[sample[j].second] += n + 1;
-      for (; j < m; j++)
+      for (; j < m; ++j)
        b[sample[j].second] -= n + 1;
 
       // Further refinement.
@@ -471,7 +471,7 @@ namespace __gnu_parallel
          n /= 2;
 
          const T* lmax = NULL;
-         for (int i = 0; i < m; i++)
+         for (int i = 0; i < m; ++i)
            {
              if (a[i] > 0)
                {
@@ -496,7 +496,7 @@ namespace __gnu_parallel
            }
 
          difference_type leftsize = 0, total = 0;
-         for (int i = 0; i < m; i++)
+         for (int i = 0; i < m; ++i)
            {
              leftsize += a[i] / (n + 1);
              total += l / (n + 1);
@@ -512,7 +512,7 @@ namespace __gnu_parallel
                std::vector<std::pair<T, int> >,
                lexicographic_reverse<T, int, Comparator> > pq(lrcomp);
 
-             for (int i = 0; i < m; i++)
+             for (int i = 0; i < m; ++i)
                if (b[i] < ns[i])
                  pq.push(std::make_pair(S(i)[b[i]], i));
 
@@ -535,7 +535,7 @@ namespace __gnu_parallel
                std::vector<std::pair<T, int> >,
                lexicographic<T, int, Comparator> > pq(lcomp);
 
-             for (int i = 0; i < m; i++)
+             for (int i = 0; i < m; ++i)
                if (a[i] > 0)
                  pq.push(std::make_pair(S(i)[a[i] - 1], i));
 
@@ -566,7 +566,7 @@ namespace __gnu_parallel
 
       // Impossible to avoid the warning?
       T maxleft, minright;
-      for (int i = 0; i < m; i++)
+      for (int i = 0; i < m; ++i)
        {
          if (a[i] > 0)
            {
@@ -610,7 +610,7 @@ namespace __gnu_parallel
          // We have to calculate an offset.
          offset = 0;
 
-         for (int i = 0; i < m; i++)
+         for (int i = 0; i < m; ++i)
            {
              difference_type lb = std::lower_bound(S(i), S(i) + ns[i],
                                                    minright,
index 98f19c2..419e96a 100644 (file)
@@ -73,7 +73,7 @@ template<typename RandomAccessIterator, typename Comparator>
 template<typename RandomAccessIterator, typename Comparator>
   inline bool
   operator<=(guarded_iterator<RandomAccessIterator, Comparator>& bi1,
-            guarded_iterator<RandomAccessIterator, Comparator>& bi2);
+            guarded_iterator<RandomAccessIterator, Comparator>& bi2);
 
   /** @brief Iterator wrapper supporting an implicit supremum at the end
       of the sequence, dominating all comparisons.
@@ -99,14 +99,14 @@ template<typename RandomAccessIterator, typename Comparator>
     *  @param end End iterator of sequence.
     *  @param comp Comparator provided for associated overloaded
     *  compare operators. */
-    inline guarded_iterator(RandomAccessIterator begin,
-                            RandomAccessIterator end, Comparator& comp)
+    guarded_iterator(RandomAccessIterator begin,
+                    RandomAccessIterator end, Comparator& comp)
     : current(begin), end(end), comp(comp)
     { }
 
     /** @brief Pre-increment operator.
     *  @return This. */
-    inline guarded_iterator<RandomAccessIterator, Comparator>&
+    guarded_iterator<RandomAccessIterator, Comparator>&
     operator++()
     {
       ++current;
@@ -115,24 +115,24 @@ template<typename RandomAccessIterator, typename Comparator>
 
     /** @brief Dereference operator.
     *  @return Referenced element. */
-    inline typename std::iterator_traits<RandomAccessIterator>::value_type
+    typename std::iterator_traits<RandomAccessIterator>::value_type
     operator*()
     { return *current; }
 
     /** @brief Convert to wrapped iterator.
     *  @return Wrapped iterator. */
-    inline operator RandomAccessIterator()
+    operator RandomAccessIterator()
     { return current; }
 
     friend bool
     operator< <RandomAccessIterator, Comparator>(
-        guarded_iterator<RandomAccessIterator, Comparator>& bi1,
-        guarded_iterator<RandomAccessIterator, Comparator>& bi2);
+      guarded_iterator<RandomAccessIterator, Comparator>& bi1,
+      guarded_iterator<RandomAccessIterator, Comparator>& bi2);
 
     friend bool
     operator<= <RandomAccessIterator, Comparator>(
-        guarded_iterator<RandomAccessIterator, Comparator>& bi1,
-        guarded_iterator<RandomAccessIterator, Comparator>& bi2);
+      guarded_iterator<RandomAccessIterator, Comparator>& bi1,
+      guarded_iterator<RandomAccessIterator, Comparator>& bi2);
   };
 
 /** @brief Compare two elements referenced by guarded iterators.
@@ -158,7 +158,7 @@ template<typename RandomAccessIterator, typename Comparator>
 template<typename RandomAccessIterator, typename Comparator>
   inline bool
   operator<=(guarded_iterator<RandomAccessIterator, Comparator>& bi1,
-            guarded_iterator<RandomAccessIterator, Comparator>& bi2)
+            guarded_iterator<RandomAccessIterator, Comparator>& bi2)
   {
     if (bi2.current == bi2.end)        //bi1 is sup
       return bi1.current != bi1.end;   //bi2 is not sup
@@ -194,14 +194,14 @@ template<typename RandomAccessIterator, typename Comparator>
     *  @param begin Begin iterator of sequence.
     *  @param end Unused, only for compatibility.
     *  @param comp Unused, only for compatibility. */
-    inline unguarded_iterator(RandomAccessIterator begin,
-                              RandomAccessIterator end, Comparator& comp)
+    unguarded_iterator(RandomAccessIterator begin,
+                      RandomAccessIterator end, Comparator& comp)
     : current(begin), comp(comp)
     { }
 
     /** @brief Pre-increment operator.
     *  @return This. */
-    inline  unguarded_iterator<RandomAccessIterator, Comparator>&
+    unguarded_iterator<RandomAccessIterator, Comparator>&
     operator++()
     {
       ++current;
@@ -210,25 +210,24 @@ template<typename RandomAccessIterator, typename Comparator>
 
     /** @brief Dereference operator.
     *  @return Referenced element. */
-    inline typename std::iterator_traits<RandomAccessIterator>::value_type
+    typename std::iterator_traits<RandomAccessIterator>::value_type
     operator*()
     { return *current; }
 
     /** @brief Convert to wrapped iterator.
     *  @return Wrapped iterator. */
-    inline
     operator RandomAccessIterator()
     { return current; }
 
     friend bool
     operator< <RandomAccessIterator, Comparator>(
-        unguarded_iterator<RandomAccessIterator, Comparator>& bi1,
-        unguarded_iterator<RandomAccessIterator, Comparator>& bi2);
+      unguarded_iterator<RandomAccessIterator, Comparator>& bi1,
+      unguarded_iterator<RandomAccessIterator, Comparator>& bi2);
 
     friend bool
     operator<= <RandomAccessIterator, Comparator>(
-        unguarded_iterator<RandomAccessIterator, Comparator>& bi1,
-        unguarded_iterator<RandomAccessIterator, Comparator>& bi2);
+      unguarded_iterator<RandomAccessIterator, Comparator>& bi1,
+      unguarded_iterator<RandomAccessIterator, Comparator>& bi2);
   };
 
 /** @brief Compare two elements referenced by unguarded iterators.
@@ -399,18 +398,17 @@ template<typename RandomAccessIteratorIterator, typename Comparator>
  *  @param length Maximum length to merge.
  *  @param stable Unused, stable anyway.
  *  @return End iterator of output sequence. */
-template<
-    template<typename RAI, typename C> class iterator,
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<template<typename RAI, typename C> class iterator,
+        typename RandomAccessIteratorIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
-  multiway_merge_3_variant(
-      RandomAccessIteratorIterator seqs_begin,
-      RandomAccessIteratorIterator seqs_end,
-      RandomAccessIterator3 target,
-      Comparator comp, _DifferenceTp length, bool stable)
+  multiway_merge_3_variant(RandomAccessIteratorIterator seqs_begin,
+                          RandomAccessIteratorIterator seqs_end,
+                          RandomAccessIterator3 target,
+                          Comparator comp, _DifferenceTp length,
+                          bool stable)
   {
     _GLIBCXX_CALL(length);
 
@@ -483,11 +481,10 @@ template<
     return target;
   }
 
-template<
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<typename RandomAccessIteratorIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
   multiway_merge_3_combined(RandomAccessIteratorIterator seqs_begin,
                             RandomAccessIteratorIterator seqs_end,
@@ -573,12 +570,11 @@ template<
  *  @param length Maximum length to merge.
  *  @param stable Unused, stable anyway.
  *  @return End iterator of output sequence. */
-template<
-    template<typename RAI, typename C> class iterator,
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<template<typename RAI, typename C> class iterator,
+        typename RandomAccessIteratorIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
   multiway_merge_4_variant(RandomAccessIteratorIterator seqs_begin,
                            RandomAccessIteratorIterator seqs_end,
@@ -680,11 +676,10 @@ template<
     return target;
   }
 
-template<
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<typename RandomAccessIteratorIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
   multiway_merge_4_combined(RandomAccessIteratorIterator seqs_begin,
                             RandomAccessIteratorIterator seqs_end,
@@ -765,11 +760,10 @@ template<
  *  @param stable Stable merging incurs a performance penalty.
  *  @return End iterator of output sequence.
  */
-template<
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<typename RandomAccessIteratorIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
   multiway_merge_bubble(RandomAccessIteratorIterator seqs_begin,
                         RandomAccessIteratorIterator seqs_end,
@@ -845,7 +839,8 @@ template<
                     ++target;
                     ++(seqs_begin[source[0]].first);
                     --length;
-                    if (seqs_begin[source[0]].first == seqs_begin[source[0]].second)
+                    if (seqs_begin[source[0]].first
+                       == seqs_begin[source[0]].second)
                       {
                         // Move everything to the left.
                         for (int s = 0; s < nrs - 1; ++s)
@@ -870,7 +865,8 @@ template<
                     ++target;
                     ++(seqs_begin[source[0]].first);
                     --length;
-                    if (seqs_begin[source[0]].first == seqs_begin[source[0]].second)
+                    if (seqs_begin[source[0]].first
+                       == seqs_begin[source[0]].second)
                       {
                         for (int s = 0; s < nrs - 1; ++s)
                           {
@@ -888,9 +884,9 @@ template<
 
             // Sink down.
             j = 1;
-            while ((j < nrs) && (comp(fe[j], fe[j - 1]) ||
-                                (!comp(fe[j - 1], fe[j])
-                                    && (source[j] < source[j - 1]))))
+            while ((j < nrs) && (comp(fe[j], fe[j - 1])
+                                || (!comp(fe[j - 1], fe[j])
+                                    && (source[j] < source[j - 1]))))
               {
                 std::swap(fe[j - 1], fe[j]);
                 std::swap(source[j - 1], source[j]);
@@ -910,7 +906,8 @@ template<
                 ++target;
                 ++seqs_begin[source[0]].first;
                 --length;
-                if (seqs_begin[source[0]].first == seqs_begin[source[0]].second)
+                if (seqs_begin[source[0]].first
+                   == seqs_begin[source[0]].second)
                   {
                     for (int s = 0; s < (nrs - 1); ++s)
                       {
@@ -954,12 +951,11 @@ template<
  *   @param stable Stable merging incurs a performance penalty.
  *  @return End iterator of output sequence.
  */
-template<
-    typename LT,
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<typename LT,
+        typename RandomAccessIteratorIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
   multiway_merge_loser_tree(RandomAccessIteratorIterator seqs_begin,
                             RandomAccessIteratorIterator seqs_end,
@@ -987,7 +983,8 @@ template<
 
     for (int t = 0; t < k; ++t)
       {
-        if(arbitrary_element == NULL && _GLIBCXX_PARALLEL_LENGTH(seqs_begin[t]) > 0)
+        if(arbitrary_element == NULL
+          && _GLIBCXX_PARALLEL_LENGTH(seqs_begin[t]) > 0)
           arbitrary_element = &(*seqs_begin[t].first);
         total_length += _GLIBCXX_PARALLEL_LENGTH(seqs_begin[t]);
       }
@@ -1074,11 +1071,10 @@ template<
  *  @return End iterator of output sequence.
  *  @pre No input will run out of elements during the merge.
  */
-template<
-    typename LT,
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp, typename Comparator>
+template<typename LT,
+        typename RandomAccessIteratorIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp, typename Comparator>
   RandomAccessIterator3
   multiway_merge_loser_tree_unguarded(RandomAccessIteratorIterator seqs_begin,
                                       RandomAccessIteratorIterator seqs_end,
@@ -1190,11 +1186,10 @@ template<
     return target;
   }
 
-template<
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<typename RandomAccessIteratorIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
   multiway_merge_loser_tree_combined(RandomAccessIteratorIterator seqs_begin,
                                      RandomAccessIteratorIterator seqs_end,
@@ -1254,17 +1249,16 @@ template<
     return target_end;
   }
 
-template<
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<typename RandomAccessIteratorIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
   multiway_merge_loser_tree_sentinel(RandomAccessIteratorIterator seqs_begin,
                                      RandomAccessIteratorIterator seqs_end,
-                                      RandomAccessIterator3 target,
-                                      Comparator comp,
-                                      _DifferenceTp length, bool stable)
+                                    RandomAccessIterator3 target,
+                                    Comparator comp,
+                                    _DifferenceTp length, bool stable)
   {
     _GLIBCXX_CALL(length)
 
@@ -1326,7 +1320,8 @@ template<
 
 /** @brief Sequential multi-way merging switch.
  *
- *  The _GLIBCXX_PARALLEL_DECISION if based on the branching factor and runtime settings.
+ *  The _GLIBCXX_PARALLEL_DECISION if based on the branching factor and
+ *  runtime settings.
  *  @param seqs_begin Begin iterator of iterator pair input sequence.
  *  @param seqs_end End iterator of iterator pair input sequence.
  *  @param target Begin iterator out output sequence.
@@ -1335,11 +1330,10 @@ template<
  *  @param stable Stable merging incurs a performance penalty.
  *  @param sentinel The sequences have a sentinel element.
  *  @return End iterator of output sequence. */
-template<
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<typename RandomAccessIteratorIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
   multiway_merge(RandomAccessIteratorIterator seqs_begin,
                  RandomAccessIteratorIterator seqs_end,
@@ -1393,23 +1387,26 @@ template<
           {
           case Settings::LOSER_TREE_COMBINED:
             return_target = multiway_merge_3_combined(seqs_begin,
-                seqs_end,
-                target,
-                comp, length, stable);
+                                                     seqs_end,
+                                                     target,
+                                                     comp, length,
+                                                     stable);
             break;
           case Settings::LOSER_TREE_SENTINEL:
-            return_target = multiway_merge_3_variant<unguarded_iterator>(
-                seqs_begin,
-                seqs_end,
-                target,
-                comp, length, stable);
+            return_target =
+             multiway_merge_3_variant<unguarded_iterator>(seqs_begin,
+                                                          seqs_end,
+                                                          target,
+                                                          comp, length,
+                                                          stable);
             break;
           default:
-            return_target = multiway_merge_3_variant<guarded_iterator>(
-                seqs_begin,
-                seqs_end,
-                target,
-                comp, length, stable);
+            return_target = 
+             multiway_merge_3_variant<guarded_iterator>(seqs_begin,
+                                                        seqs_end,
+                                                        target,
+                                                        comp, length,
+                                                        stable);
             break;
           }
         break;
@@ -1417,25 +1414,25 @@ template<
         switch (mwma)
           {
           case Settings::LOSER_TREE_COMBINED:
-            return_target = multiway_merge_4_combined(
-                seqs_begin,
-                seqs_end,
-                target,
-                comp, length, stable);
+            return_target = multiway_merge_4_combined(seqs_begin,
+                                                     seqs_end,
+                                                     target,
+                                                     comp, length, stable);
             break;
           case Settings::LOSER_TREE_SENTINEL:
-            return_target = multiway_merge_4_variant<unguarded_iterator>(
-                seqs_begin,
-                seqs_end,
-                target,
-                comp, length, stable);
+            return_target = 
+             multiway_merge_4_variant<unguarded_iterator>(seqs_begin,
+                                                          seqs_end,
+                                                          target,
+                                                          comp, length,
+                                                          stable);
             break;
           default:
             return_target = multiway_merge_4_variant<guarded_iterator>(
-                seqs_begin,
-                seqs_end,
-                target,
-                comp, length, stable);
+             seqs_begin,
+             seqs_end,
+             target,
+             comp, length, stable);
             break;
           }
         break;
@@ -1444,48 +1441,47 @@ template<
           switch (mwma)
             {
             case Settings::BUBBLE:
-              return_target = multiway_merge_bubble(
-                  seqs_begin,
-                  seqs_end,
-                  target,
-                  comp, length, stable);
+              return_target = multiway_merge_bubble(seqs_begin,
+                                                   seqs_end,
+                                                   target,
+                                                   comp, length, stable);
               break;
 #if _GLIBCXX_LOSER_TREE_EXPLICIT
             case Settings::LOSER_TREE_EXPLICIT:
               return_target = multiway_merge_loser_tree<
-                    LoserTreeExplicit<value_type, Comparator> >(
-                  seqs_begin,
-                  seqs_end,
-                  target,
-                  comp, length, stable);
+             LoserTreeExplicit<value_type, Comparator> >(seqs_begin,
+                                                         seqs_end,
+                                                         target,
+                                                         comp, length,
+                                                         stable);
               break;
 #endif
 #if _GLIBCXX_LOSER_TREE
             case Settings::LOSER_TREE:
               return_target = multiway_merge_loser_tree<
-                    LoserTree<value_type, Comparator> >(
-                  seqs_begin,
-                  seqs_end,
-                  target,
-                  comp, length, stable);
+                    LoserTree<value_type, Comparator> >(seqs_begin,
+                                                       seqs_end,
+                                                       target,
+                                                       comp, length,
+                                                       stable);
               break;
 #endif
 #if _GLIBCXX_LOSER_TREE_COMBINED
             case Settings::LOSER_TREE_COMBINED:
-              return_target = multiway_merge_loser_tree_combined(
-                  seqs_begin,
-                  seqs_end,
-                  target,
-                  comp, length, stable);
+              return_target = multiway_merge_loser_tree_combined(seqs_begin,
+                                                                seqs_end,
+                                                                target,
+                                                                comp, length,
+                                                                stable);
               break;
 #endif
 #if _GLIBCXX_LOSER_TREE_SENTINEL
             case Settings::LOSER_TREE_SENTINEL:
-              return_target = multiway_merge_loser_tree_sentinel(
-                  seqs_begin,
-                  seqs_end,
-                  target,
-                  comp, length, stable);
+              return_target = multiway_merge_loser_tree_sentinel(seqs_begin,
+                                                                seqs_end,
+                                                                target,
+                                                                comp, length,
+                                                                stable);
               break;
 #endif
             default:
@@ -1504,7 +1500,8 @@ template<
 
 /** @brief Parallel multi-way merge routine.
  *
- *  The _GLIBCXX_PARALLEL_DECISION if based on the branching factor and runtime settings.
+ *  The _GLIBCXX_PARALLEL_DECISION if based on the branching factor
+ *  and runtime settings.
  *  @param seqs_begin Begin iterator of iterator pair input sequence.
  *  @param seqs_end End iterator of iterator pair input sequence.
  *  @param target Begin iterator out output sequence.
@@ -1514,11 +1511,10 @@ template<
  *  @param sentinel Ignored.
  *  @return End iterator of output sequence.
  */
-template<
-    typename RandomAccessIteratorIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<typename RandomAccessIteratorIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
   parallel_multiway_merge(RandomAccessIteratorIterator seqs_begin,
                           RandomAccessIteratorIterator seqs_end,
@@ -1553,7 +1549,7 @@ template<
       std::vector<std::pair<difference_type, difference_type> >* pieces;
 
       thread_index_t num_threads = static_cast<thread_index_t>(
-          std::min<difference_type>(get_max_threads(), total_length));
+       std::min<difference_type>(get_max_threads(), total_length));
 
 #     pragma omp parallel num_threads (num_threads)
         {
@@ -1578,20 +1574,20 @@ template<
                     for (difference_type i = 0; i < num_samples; ++i)
                       {
                         difference_type sample_index =
-                            static_cast<difference_type>(
-                                _GLIBCXX_PARALLEL_LENGTH(seqs_begin[s]) * (double(i + 1) /
-                                (num_samples + 1)) * (double(length)
-                                / total_length));
-                        ::new(&(samples[s * num_samples + i])) value_type(
-                            seqs_begin[s].first[sample_index]);
+                         static_cast<difference_type>(
+                           _GLIBCXX_PARALLEL_LENGTH(seqs_begin[s])
+                           * (double(i + 1) / (num_samples + 1))
+                           * (double(length) / total_length));
+                        ::new(&(samples[s * num_samples + i]))
+                           value_type(seqs_begin[s].first[sample_index]);
                       }
 
                   if (stable)
-                    __gnu_sequential::stable_sort(
-                      samples, samples + (num_samples * k), comp);
+                    __gnu_sequential::stable_sort(samples, samples
+                                                 + (num_samples * k), comp);
                   else
-                    __gnu_sequential::sort(
-                      samples, samples + (num_samples * k), comp);
+                    __gnu_sequential::sort(samples, samples
+                                          + (num_samples * k), comp);
 
                   for (int slab = 0; slab < num_threads; ++slab)
                     // For each slab / processor.
@@ -1600,12 +1596,12 @@ template<
                         // For each sequence.
                         if (slab > 0)
                           pieces[slab][seq].first =
-                              std::upper_bound(
-                                seqs_begin[seq].first,
-                                seqs_begin[seq].second,
-                                samples[num_samples * k * slab / num_threads],
-                                  comp)
-                              - seqs_begin[seq].first;
+                              std::upper_bound(seqs_begin[seq].first,
+                                              seqs_begin[seq].second,
+                                              samples[num_samples * k
+                                                      * slab / num_threads],
+                                              comp)
+                           - seqs_begin[seq].first;
                         else
                           {
                             // Absolute beginning.
@@ -1613,14 +1609,15 @@ template<
                           }
                         if ((slab + 1) < num_threads)
                           pieces[slab][seq].second =
-                              std::upper_bound(
-                                  seqs_begin[seq].first,
-                                  seqs_begin[seq].second,
-                                  samples[num_samples * k * (slab + 1) /
-                                      num_threads], comp)
-                              - seqs_begin[seq].first;
+                           std::upper_bound(seqs_begin[seq].first,
+                                            seqs_begin[seq].second,
+                                            samples[num_samples * k
+                                                    * (slab + 1)
+                                                    / num_threads], comp)
+                           - seqs_begin[seq].first;
                         else
-                        pieces[slab][seq].second = _GLIBCXX_PARALLEL_LENGTH(seqs_begin[seq]);
+                         pieces[slab][seq].second 
+                           = _GLIBCXX_PARALLEL_LENGTH(seqs_begin[seq]);
                       }
                  ::operator delete(samples);
                 }
@@ -1651,8 +1648,9 @@ template<
                         {
                           offsets[num_threads - 1].resize(k);
                           multiseq_partition(se.begin(), se.end(),
-                                difference_type(length),
-                                offsets[num_threads - 1].begin(),  comp);
+                                            difference_type(length),
+                                            offsets[num_threads - 1].begin(),
+                                            comp);
                         }
                     }
 
@@ -1673,12 +1671,12 @@ template<
                                 pieces[slab - 1][seq].second;
                           if (!tight || slab < (num_threads - 1))
                             pieces[slab][seq].second =
-                                offsets[slab][seq] - seqs_begin[seq].first;
+                             offsets[slab][seq] - seqs_begin[seq].first;
                           else
                             {
                               // slab == num_threads - 1
                               pieces[slab][seq].second =
-                                  _GLIBCXX_PARALLEL_LENGTH(seqs_begin[seq]);
+                               _GLIBCXX_PARALLEL_LENGTH(seqs_begin[seq]);
                             }
                         }
                     }
@@ -1703,8 +1701,8 @@ template<
               for (int s = 0; s < k; ++s)
                 {
                   chunks[s] = std::make_pair(
-                      seqs_begin[s].first + pieces[iam][s].first,
-                      seqs_begin[s].first + pieces[iam][s].second);
+                   seqs_begin[s].first + pieces[iam][s].first,
+                   seqs_begin[s].first + pieces[iam][s].second);
                   local_length += _GLIBCXX_PARALLEL_LENGTH(chunks[s]);
                 }
 
@@ -1721,13 +1719,13 @@ template<
                   begin0 = seqs_begin[0].first + pieces[iam][0].first,
                   begin1 = seqs_begin[1].first + pieces[iam][1].first;
               merge_advance(begin0,
-                    seqs_begin[0].first + pieces[iam][0].second,
-                    begin1,
-                    seqs_begin[1].first + pieces[iam][1].second,
-                    target + target_position,
-                    (pieces[iam][0].second - pieces[iam][0].first) +
-                        (pieces[iam][1].second - pieces[iam][1].first),
-                    comp);
+                           seqs_begin[0].first + pieces[iam][0].second,
+                           begin1,
+                           seqs_begin[1].first + pieces[iam][1].second,
+                           target + target_position,
+                           (pieces[iam][0].second - pieces[iam][0].first) +
+                           (pieces[iam][1].second - pieces[iam][1].first),
+                           comp);
             }
         } //parallel
 
@@ -1754,11 +1752,10 @@ template<
  *  @param stable Stable merging incurs a performance penalty.
  *  @return End iterator of output sequence.
  */
-template<
-    typename RandomAccessIteratorPairIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<typename RandomAccessIteratorPairIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
   multiway_merge(RandomAccessIteratorPairIterator seqs_begin,
                 RandomAccessIteratorPairIterator seqs_end,
@@ -1775,13 +1772,13 @@ template<
     if (_GLIBCXX_PARALLEL_CONDITION(
         ((seqs_end - seqs_begin) >= Settings::multiway_merge_minimal_k)
         && ((sequence_index_t)length >= Settings::multiway_merge_minimal_n)))
-      target_end = parallel_multiway_merge(
-          seqs_begin, seqs_end,
-          target, comp, static_cast<difference_type>(length), stable, false);
+      target_end = parallel_multiway_merge(seqs_begin, seqs_end,
+                                          target, comp,
+                                         static_cast<difference_type>(length),
+                                          stable, false);
     else
-      target_end = multiway_merge(
-          seqs_begin, seqs_end,
-          target, comp, length, stable, false, sequential_tag());
+      target_end = multiway_merge(seqs_begin, seqs_end, target, comp, length,
+                                 stable, false, sequential_tag());
 
     return target_end;
   }
@@ -1797,11 +1794,10 @@ template<
  *  @pre For each @c i, @c seqs_begin[i].second must be the end
  *  marker of the sequence, but also reference the one more sentinel
  *  element. */
-template<
-    typename RandomAccessIteratorPairIterator,
-    typename RandomAccessIterator3,
-    typename _DifferenceTp,
-    typename Comparator>
+template<typename RandomAccessIteratorPairIterator,
+        typename RandomAccessIterator3,
+        typename _DifferenceTp,
+        typename Comparator>
   RandomAccessIterator3
   multiway_merge_sentinel(RandomAccessIteratorPairIterator seqs_begin,
                           RandomAccessIteratorPairIterator seqs_end,
@@ -1824,9 +1820,9 @@ template<
           seqs_begin, seqs_end,
           target, comp, static_cast<difference_type>(length), stable, true);
     else
-      return multiway_merge(
-          seqs_begin, seqs_end,
-          target, comp, length, stable, true, sequential_tag());
+      return multiway_merge(seqs_begin, seqs_end,
+                           target, comp, length, stable,
+                           true, sequential_tag());
   }
 }
 
index 502cfab..923a2a8 100644 (file)
@@ -120,7 +120,7 @@ template<typename RandomAccessIterator>
   *  @param num_samples Number of samples to select.
   */
 template<typename RandomAccessIterator, typename _DifferenceTp>
-  inline void 
+  void 
   determine_samples(PMWMSSortingData<RandomAccessIterator>* sd,
                     _DifferenceTp& num_samples)
   {
@@ -138,9 +138,9 @@ template<typename RandomAccessIterator, typename _DifferenceTp>
     equally_split(sd->starts[iam + 1] - sd->starts[iam], 
                   num_samples + 1, es);
 
-    for (difference_type i = 0; i < num_samples; i++)
-      ::new(&(sd->samples[iam * num_samples + i])) value_type(
-          sd->source[sd->starts[iam] + es[i + 1]]);
+    for (difference_type i = 0; i < num_samples; ++i)
+      ::new(&(sd->samples[iam * num_samples + i]))
+         value_type(sd->source[sd->starts[iam] + es[i + 1]]);
 
     delete[] es;
   }
@@ -150,7 +150,7 @@ template<typename RandomAccessIterator, typename _DifferenceTp>
   *  @param comp Comparator.
   */
 template<typename RandomAccessIterator, typename Comparator>
-  inline void 
+  void 
   parallel_sort_mwms_pu(PMWMSSortingData<RandomAccessIterator>* sd,
                         Comparator& comp)
   {
@@ -209,7 +209,7 @@ template<typename RandomAccessIterator, typename Comparator>
 
 #       pragma omp barrier
 
-        for (int s = 0; s < sd->num_threads; s++)
+        for (int s = 0; s < sd->num_threads; ++s)
           {
             // For each sequence.
               if (num_samples * iam > 0)
@@ -243,7 +243,7 @@ template<typename RandomAccessIterator, typename Comparator>
 
         std::vector<std::pair<SortingPlacesIterator, SortingPlacesIterator> >
             seqs(sd->num_threads);
-        for (int s = 0; s < sd->num_threads; s++)
+        for (int s = 0; s < sd->num_threads; ++s)
           seqs[s] = std::make_pair(sd->sorting_places[s],
                                    sd->sorting_places[s]
                                        + (sd->starts[s + 1] - sd->starts[s]));
@@ -255,20 +255,20 @@ template<typename RandomAccessIterator, typename Comparator>
           multiseq_partition(seqs.begin(), seqs.end(),
                              sd->starts[iam + 1], offsets.begin(), comp);
 
-        for (int seq = 0; seq < sd->num_threads; seq++)
+        for (int seq = 0; seq < sd->num_threads; ++seq)
           {
             // for each sequence
             if (iam < (sd->num_threads - 1))
               sd->pieces[iam][seq].end = offsets[seq] - seqs[seq].first;
             else
               // very end of this sequence
-              sd->pieces[iam][seq].end =
-                  sd->starts[seq + 1] - sd->starts[seq];
+              sd->pieces[iam][seq].end = (sd->starts[seq + 1]
+                                         - sd->starts[seq]);
           }
 
 #       pragma omp barrier
 
-        for (int seq = 0; seq < sd->num_threads; seq++)
+        for (int seq = 0; seq < sd->num_threads; ++seq)
           {
             // For each sequence.
             if (iam > 0)
@@ -281,7 +281,7 @@ template<typename RandomAccessIterator, typename Comparator>
 
     // Offset from target begin, length after merging.
     difference_type offset = 0, length_am = 0;
-    for (int s = 0; s < sd->num_threads; s++)
+    for (int s = 0; s < sd->num_threads; ++s)
       {
         length_am += sd->pieces[iam][s].end - sd->pieces[iam][s].begin;
         offset += sd->pieces[iam][s].begin;
@@ -293,8 +293,8 @@ template<typename RandomAccessIterator, typename Comparator>
     // instead of the assignment operator.
     // XXX incorrect (de)construction
     sd->merging_places[iam] = sd->temporaries[iam] =
-        static_cast<value_type*>(
-        ::operator new(sizeof(value_type) * length_am));
+        static_cast<value_type*>(::operator new(sizeof(value_type)
+                                               * length_am));
 #else
     // Merge directly to target.
     sd->merging_places[iam] = sd->source + offset;
@@ -302,11 +302,11 @@ template<typename RandomAccessIterator, typename Comparator>
     std::vector<std::pair<SortingPlacesIterator, SortingPlacesIterator> >
         seqs(sd->num_threads);
 
-    for (int s = 0; s < sd->num_threads; s++)
+    for (int s = 0; s < sd->num_threads; ++s)
       {
         seqs[s] =
-            std::make_pair(sd->sorting_places[s] + sd->pieces[iam][s].begin,
-                           sd->sorting_places[s] + sd->pieces[iam][s].end);
+         std::make_pair(sd->sorting_places[s] + sd->pieces[iam][s].begin,
+                        sd->sorting_places[s] + sd->pieces[iam][s].end);
       }
 
     multiway_merge(seqs.begin(), seqs.end(), sd->merging_places[iam], comp,
@@ -333,13 +333,11 @@ template<typename RandomAccessIterator, typename Comparator>
   *  @param stable Stable sorting.
   */
 template<typename RandomAccessIterator, typename Comparator>
-  inline void
+  void
   parallel_sort_mwms(RandomAccessIterator begin, RandomAccessIterator end,
-                     Comparator comp, 
-                     typename std::iterator_traits<RandomAccessIterator>
-                        ::difference_type n,
-                     int num_threads,
-                     bool stable)
+                     Comparator comp, typename
+                    std::iterator_traits<RandomAccessIterator>::
+                    difference_type n, int num_threads, bool stable)
   {
     _GLIBCXX_CALL(n)
 
@@ -382,14 +380,14 @@ template<typename RandomAccessIterator, typename Comparator>
                     (Settings::sort_mwms_oversampling * num_threads - 1)
                         * num_threads;
                 sd.samples = static_cast<value_type*>(
-                    ::operator new(size * sizeof(value_type)));
+                 ::operator new(size * sizeof(value_type)));
               }
             else
               sd.samples = NULL;
 
             sd.offsets = new difference_type[num_threads - 1];
             sd.pieces = new std::vector<Piece<difference_type> >[num_threads];
-            for (int s = 0; s < num_threads; s++)
+            for (int s = 0; s < num_threads; ++s)
               sd.pieces[s].resize(num_threads);
             starts = sd.starts = new difference_type[num_threads + 1];
             sd.stable = stable;
@@ -397,7 +395,7 @@ template<typename RandomAccessIterator, typename Comparator>
             difference_type chunk_length = n / num_threads;
             difference_type split = n % num_threads;
             difference_type pos = 0;
-            for (int i = 0; i < num_threads; i++)
+            for (int i = 0; i < num_threads; ++i)
               {
                 starts[i] = pos;
                 pos += (i < split) ? (chunk_length + 1) : chunk_length;
index 21b8eea..ccbdeee 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -58,387 +58,449 @@ namespace __parallel
 {
   // Sequential fallback.
   template<typename InputIterator, typename T>
-  inline T
-  accumulate(InputIterator begin, InputIterator end, T init, 
-            __gnu_parallel::sequential_tag)
-  { return _GLIBCXX_STD_P::accumulate(begin, end, init); }
+    inline T
+    accumulate(InputIterator begin, InputIterator end, T init, 
+              __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::accumulate(begin, end, init); }
 
   template<typename InputIterator, typename T, typename BinaryOperation>
-  inline T
-  accumulate(InputIterator begin, InputIterator end, T init,
-            BinaryOperation binary_op, __gnu_parallel::sequential_tag)
-  { return _GLIBCXX_STD_P::accumulate(begin, end, init, binary_op); }
+    inline T
+    accumulate(InputIterator begin, InputIterator end, T init,
+              BinaryOperation binary_op, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::accumulate(begin, end, init, binary_op); }
 
   // Sequential fallback for input iterator case.
   template<typename InputIterator, typename T, typename IteratorTag>
-  inline T
-  accumulate_switch(InputIterator begin, InputIterator end, T init, IteratorTag)  { return accumulate(begin, end, init, __gnu_parallel::sequential_tag()); }
-
-  template<typename InputIterator, typename T, typename BinaryOperation, typename IteratorTag>
-  T
-  accumulate_switch(InputIterator begin, InputIterator end, T init, 
-                   BinaryOperation binary_op, IteratorTag)
-  {
-    return accumulate(begin, end, init, binary_op, 
-                     __gnu_parallel::sequential_tag());
-  }
+    inline T
+    accumulate_switch(InputIterator begin, InputIterator end,
+                     T init, IteratorTag) 
+    { return accumulate(begin, end, init, __gnu_parallel::sequential_tag()); }
+
+  template<typename InputIterator, typename T, typename BinaryOperation,
+          typename IteratorTag>
+    T
+    accumulate_switch(InputIterator begin, InputIterator end, T init, 
+                     BinaryOperation binary_op, IteratorTag)
+    { return accumulate(begin, end, init, binary_op, 
+                       __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators.
-  template<typename _RandomAccessIterator, typename T, typename BinaryOperation>
-  T
-  accumulate_switch(_RandomAccessIterator begin, _RandomAccessIterator end, 
-                   T init, BinaryOperation binary_op, 
-                   random_access_iterator_tag, 
-                   __gnu_parallel::parallelism parallelism_tag  
-                   = __gnu_parallel::parallel_unbalanced)
-  {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::accumulate_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
-      {
-       T res = init;
-       __gnu_parallel::accumulate_selector<_RandomAccessIterator> my_selector;
-       __gnu_parallel::for_each_template_random_access(begin, end, __gnu_parallel::nothing(), my_selector, __gnu_parallel::accumulate_binop_reduct<BinaryOperation>(binary_op), res, res, -1, parallelism_tag);
-       return res;
-      }
-    else
-      return accumulate(begin, end, init, binary_op, 
-                       __gnu_parallel::sequential_tag());
-  }
+  template<typename _RandomAccessIterator, typename T,
+          typename BinaryOperation>
+    T
+    accumulate_switch(_RandomAccessIterator begin, _RandomAccessIterator end, 
+                     T init, BinaryOperation binary_op, 
+                     random_access_iterator_tag, 
+                     __gnu_parallel::parallelism parallelism_tag  
+                     = __gnu_parallel::parallel_unbalanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::accumulate_minimal_n
+           && __gnu_parallel::is_parallel(parallelism_tag)))
+       {
+         T res = init;
+         __gnu_parallel::accumulate_selector<_RandomAccessIterator>
+           my_selector;
+         __gnu_parallel::
+           for_each_template_random_access(begin, end,
+                                           __gnu_parallel::nothing(),
+                                           my_selector,
+                                           __gnu_parallel::
+                                           accumulate_binop_reduct
+                                           <BinaryOperation>(binary_op),
+                                           res, res, -1, parallelism_tag);
+         return res;
+       }
+      else
+       return accumulate(begin, end, init, binary_op, 
+                         __gnu_parallel::sequential_tag());
+    }
 
   // Public interface.
   template<typename InputIterator, typename T>
-  inline T
-  accumulate(InputIterator begin, InputIterator end, T init, 
-            __gnu_parallel::parallelism parallelism_tag)
-  {
-    typedef std::iterator_traits<InputIterator> iterator_traits;
-    typedef typename iterator_traits::value_type value_type;
-    typedef typename iterator_traits::iterator_category iterator_category;
-
-    return accumulate_switch(begin, end, init, __gnu_parallel::plus<T, value_type>(),
-                            iterator_category(), parallelism_tag);
-  }
+    inline T
+    accumulate(InputIterator begin, InputIterator end, T init, 
+              __gnu_parallel::parallelism parallelism_tag)
+    {
+      typedef std::iterator_traits<InputIterator> iterator_traits;
+      typedef typename iterator_traits::value_type value_type;
+      typedef typename iterator_traits::iterator_category iterator_category;
+
+      return accumulate_switch(begin, end, init,
+                              __gnu_parallel::plus<T, value_type>(),
+                              iterator_category(), parallelism_tag);
+    }
 
   template<typename InputIterator, typename T>
-  inline T
-  accumulate(InputIterator begin, InputIterator end, T init)
-  {
-    typedef std::iterator_traits<InputIterator> iterator_traits;
-    typedef typename iterator_traits::value_type value_type;
-    typedef typename iterator_traits::iterator_category iterator_category;
-
-    return accumulate_switch(begin, end, init, __gnu_parallel::plus<T, value_type>(),
-                            iterator_category());
-  }
+    inline T
+    accumulate(InputIterator begin, InputIterator end, T init)
+    {
+      typedef std::iterator_traits<InputIterator> iterator_traits;
+      typedef typename iterator_traits::value_type value_type;
+      typedef typename iterator_traits::iterator_category iterator_category;
+
+      return accumulate_switch(begin, end, init,
+                              __gnu_parallel::plus<T, value_type>(),
+                              iterator_category());
+    }
 
   template<typename InputIterator, typename T, typename BinaryOperation>
-  inline T
-  accumulate(InputIterator begin, InputIterator end, T init, 
-            BinaryOperation binary_op, 
-            __gnu_parallel::parallelism parallelism_tag)
-  {
-    typedef iterator_traits<InputIterator> iterator_traits;
-    typedef typename iterator_traits::iterator_category iterator_category;
-    return accumulate_switch(begin, end, init, binary_op, 
-                            iterator_category(), parallelism_tag);
-  }
+    inline T
+    accumulate(InputIterator begin, InputIterator end, T init, 
+              BinaryOperation binary_op, 
+              __gnu_parallel::parallelism parallelism_tag)
+    {
+      typedef iterator_traits<InputIterator> iterator_traits;
+      typedef typename iterator_traits::iterator_category iterator_category;
+      return accumulate_switch(begin, end, init, binary_op, 
+                              iterator_category(), parallelism_tag);
+    }
 
   template<typename InputIterator, typename T, typename BinaryOperation>
-  inline T
-  accumulate(InputIterator begin, InputIterator end, T init, 
-            BinaryOperation binary_op) 
-  {
-    typedef iterator_traits<InputIterator> iterator_traits;
-    typedef typename iterator_traits::iterator_category iterator_category;
-    return accumulate_switch(begin, end, init, binary_op, 
-                            iterator_category());
-  }
+    inline T
+    accumulate(InputIterator begin, InputIterator end, T init, 
+              BinaryOperation binary_op) 
+    {
+      typedef iterator_traits<InputIterator> iterator_traits;
+      typedef typename iterator_traits::iterator_category iterator_category;
+      return accumulate_switch(begin, end, init, binary_op, 
+                              iterator_category());
+    }
 
 
   // Sequential fallback.
   template<typename InputIterator1, typename InputIterator2, typename T>
-  inline T
-  inner_product(InputIterator1 first1, InputIterator1 last1, 
-               InputIterator2 first2, T init, __gnu_parallel::sequential_tag)
-  { return _GLIBCXX_STD_P::inner_product(first1, last1, first2, init); }
-
-  template<typename InputIterator1, typename InputIterator2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  inline T
-  inner_product(InputIterator1 first1, InputIterator1 last1, 
-               InputIterator2 first2, T init, BinaryFunction1 binary_op1, 
-               BinaryFunction2 binary_op2, __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::inner_product(first1, last1, first2, init, 
-                                        binary_op1, binary_op2);
-  }
+    inline T
+    inner_product(InputIterator1 first1, InputIterator1 last1, 
+                 InputIterator2 first2, T init,
+                 __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::inner_product(first1, last1, first2, init); }
+
+  template<typename InputIterator1, typename InputIterator2, typename T,
+          typename BinaryFunction1, typename BinaryFunction2>
+    inline T
+    inner_product(InputIterator1 first1, InputIterator1 last1, 
+                 InputIterator2 first2, T init, BinaryFunction1 binary_op1, 
+                 BinaryFunction2 binary_op2, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::inner_product(first1, last1, first2, init, 
+                                          binary_op1, binary_op2); }
 
   // Parallel algorithm for random access iterators.
-  template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  T
-  inner_product_switch(RandomAccessIterator1 first1, RandomAccessIterator1 last1, RandomAccessIterator2 first2, T init, BinaryFunction1 binary_op1, BinaryFunction2 binary_op2, random_access_iterator_tag, random_access_iterator_tag, __gnu_parallel::parallelism parallelism_tag = __gnu_parallel::parallel_unbalanced)
-  {
-    if (_GLIBCXX_PARALLEL_CONDITION((last1 - first1) >= __gnu_parallel::Settings::accumulate_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
-      {
-       T res = init;
-       __gnu_parallel::inner_product_selector<RandomAccessIterator1, RandomAccessIterator2, T> my_selector(first1, first2);
-       __gnu_parallel::for_each_template_random_access(first1, last1, binary_op2, my_selector, binary_op1, res, res, -1, parallelism_tag);
-       return res;
-      }
-    else
-      return inner_product(first1, last1, first2, init, 
-                          __gnu_parallel::sequential_tag());
-  }
+  template<typename RandomAccessIterator1, typename RandomAccessIterator2,
+          typename T, typename BinaryFunction1, typename BinaryFunction2>
+    T
+    inner_product_switch(RandomAccessIterator1 first1,
+                        RandomAccessIterator1 last1,
+                        RandomAccessIterator2 first2, T init,
+                        BinaryFunction1 binary_op1,
+                        BinaryFunction2 binary_op2,
+                        random_access_iterator_tag,
+                        random_access_iterator_tag,
+                        __gnu_parallel::parallelism parallelism_tag
+                        = __gnu_parallel::parallel_unbalanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION((last1 - first1)
+                                     >= __gnu_parallel::Settings::
+                                     accumulate_minimal_n
+                                     && __gnu_parallel::
+                                     is_parallel(parallelism_tag)))
+       {
+         T res = init;
+         __gnu_parallel::
+           inner_product_selector<RandomAccessIterator1,
+           RandomAccessIterator2, T> my_selector(first1, first2);
+         __gnu_parallel::
+           for_each_template_random_access(first1, last1, binary_op2,
+                                           my_selector, binary_op1,
+                                           res, res, -1, parallelism_tag);
+         return res;
+       }
+      else
+       return inner_product(first1, last1, first2, init, 
+                            __gnu_parallel::sequential_tag());
+    }
 
   // No parallelism for input iterators.
-  template<typename InputIterator1, typename InputIterator2, typename T, typename BinaryFunction1, typename BinaryFunction2, typename IteratorTag1, typename IteratorTag2>
-  inline T
-  inner_product_switch(InputIterator1 first1, InputIterator1 last1, 
-                      InputIterator2 first2, T init, 
-                      BinaryFunction1 binary_op1, BinaryFunction2 binary_op2, 
-                      IteratorTag1, IteratorTag2)
-  {
-    return inner_product(first1, last1, first2, init, binary_op1, binary_op2,
-                        __gnu_parallel::sequential_tag());
-  }
-
-  template<typename InputIterator1, typename InputIterator2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  inline T
-  inner_product(InputIterator1 first1, InputIterator1 last1, 
-               InputIterator2 first2, T init, BinaryFunction1 binary_op1, 
-               BinaryFunction2 binary_op2, 
-               __gnu_parallel::parallelism parallelism_tag)
-  {
-    typedef iterator_traits<InputIterator1> traits1_type;
-    typedef typename traits1_type::iterator_category iterator1_category;
-
-    typedef iterator_traits<InputIterator2> traits2_type;
-    typedef typename traits2_type::iterator_category iterator2_category;
-
-    return inner_product_switch(first1, last1, first2, init, binary_op1, 
-                               binary_op2, iterator1_category(), 
-                               iterator2_category(), parallelism_tag);
-  }
-
-  template<typename InputIterator1, typename InputIterator2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  inline T
-  inner_product(InputIterator1 first1, InputIterator1 last1, 
-               InputIterator2 first2, T init, BinaryFunction1 binary_op1, 
-               BinaryFunction2 binary_op2)
-  {
-    typedef iterator_traits<InputIterator1> traits1_type;
-    typedef typename traits1_type::iterator_category iterator1_category;
-
-    typedef iterator_traits<InputIterator2> traits2_type;
-    typedef typename traits2_type::iterator_category iterator2_category;
-
-    return inner_product_switch(first1, last1, first2, init, binary_op1, 
-                               binary_op2, iterator1_category(),
-                               iterator2_category());
-  }
+  template<typename InputIterator1, typename InputIterator2, typename T,
+          typename BinaryFunction1, typename BinaryFunction2,
+          typename IteratorTag1, typename IteratorTag2>
+    inline T
+    inner_product_switch(InputIterator1 first1, InputIterator1 last1, 
+                        InputIterator2 first2, T init, 
+                        BinaryFunction1 binary_op1,
+                        BinaryFunction2 binary_op2, 
+                        IteratorTag1, IteratorTag2)
+    { return inner_product(first1, last1, first2, init,
+                          binary_op1, binary_op2,
+                          __gnu_parallel::sequential_tag()); }
+
+  template<typename InputIterator1, typename InputIterator2, typename T,
+          typename BinaryFunction1, typename BinaryFunction2>
+    inline T
+    inner_product(InputIterator1 first1, InputIterator1 last1, 
+                 InputIterator2 first2, T init, BinaryFunction1 binary_op1, 
+                 BinaryFunction2 binary_op2, 
+                 __gnu_parallel::parallelism parallelism_tag)
+    {
+      typedef iterator_traits<InputIterator1> traits1_type;
+      typedef typename traits1_type::iterator_category iterator1_category;
+
+      typedef iterator_traits<InputIterator2> traits2_type;
+      typedef typename traits2_type::iterator_category iterator2_category;
+
+      return inner_product_switch(first1, last1, first2, init, binary_op1, 
+                                 binary_op2, iterator1_category(), 
+                                 iterator2_category(), parallelism_tag);
+    }
+
+  template<typename InputIterator1, typename InputIterator2, typename T,
+          typename BinaryFunction1, typename BinaryFunction2>
+    inline T
+    inner_product(InputIterator1 first1, InputIterator1 last1, 
+                 InputIterator2 first2, T init, BinaryFunction1 binary_op1, 
+                 BinaryFunction2 binary_op2)
+    {
+      typedef iterator_traits<InputIterator1> traits1_type;
+      typedef typename traits1_type::iterator_category iterator1_category;
+
+      typedef iterator_traits<InputIterator2> traits2_type;
+      typedef typename traits2_type::iterator_category iterator2_category;
+
+      return inner_product_switch(first1, last1, first2, init, binary_op1, 
+                                 binary_op2, iterator1_category(),
+                                 iterator2_category());
+    }
 
   template<typename InputIterator1, typename InputIterator2, typename T>
-  inline T
-  inner_product(InputIterator1 first1, InputIterator1 last1, 
-               InputIterator2 first2, T init, 
-               __gnu_parallel::parallelism parallelism_tag)
-  {
-    typedef iterator_traits<InputIterator1> traits_type1;
-    typedef typename traits_type1::value_type value_type1;
-    typedef iterator_traits<InputIterator2> traits_type2;
-    typedef typename traits_type2::value_type value_type2;
-
-    typedef typename __gnu_parallel::multiplies<value_type1, value_type2>::result
+    inline T
+    inner_product(InputIterator1 first1, InputIterator1 last1, 
+                 InputIterator2 first2, T init, 
+                 __gnu_parallel::parallelism parallelism_tag)
+    {
+      typedef iterator_traits<InputIterator1> traits_type1;
+      typedef typename traits_type1::value_type value_type1;
+      typedef iterator_traits<InputIterator2> traits_type2;
+      typedef typename traits_type2::value_type value_type2;
+
+      typedef typename
+       __gnu_parallel::multiplies<value_type1, value_type2>::result
         multiplies_result_type;
-    return inner_product(first1, last1, first2, init,
+      return inner_product(first1, last1, first2, init,
                            __gnu_parallel::plus<T, multiplies_result_type>(),
-                           __gnu_parallel::multiplies<value_type1, value_type2>(),
+                           __gnu_parallel::
+                          multiplies<value_type1, value_type2>(),
                            parallelism_tag);
-  }
+    }
 
   template<typename InputIterator1, typename InputIterator2, typename T>
-  inline T
-  inner_product(InputIterator1 first1, InputIterator1 last1, 
-               InputIterator2 first2, T init)
-  {
-    typedef iterator_traits<InputIterator1> traits_type1;
-    typedef typename traits_type1::value_type value_type1;
-    typedef iterator_traits<InputIterator2> traits_type2;
-    typedef typename traits_type2::value_type value_type2;
-
-    typedef typename __gnu_parallel::multiplies<value_type1, value_type2>::result
+    inline T
+    inner_product(InputIterator1 first1, InputIterator1 last1, 
+                 InputIterator2 first2, T init)
+    {
+      typedef iterator_traits<InputIterator1> traits_type1;
+      typedef typename traits_type1::value_type value_type1;
+      typedef iterator_traits<InputIterator2> traits_type2;
+      typedef typename traits_type2::value_type value_type2;
+
+      typedef typename
+       __gnu_parallel::multiplies<value_type1, value_type2>::result
         multiplies_result_type;
-    return inner_product(first1, last1, first2, init,
+      return inner_product(first1, last1, first2, init,
                            __gnu_parallel::plus<T, multiplies_result_type>(),
-                           __gnu_parallel::multiplies<value_type1, value_type2>());
-  }
+                           __gnu_parallel::
+                          multiplies<value_type1, value_type2>());
+    }
 
   // Sequential fallback.
   template<typename InputIterator, typename OutputIterator>
-  inline OutputIterator
-  partial_sum(InputIterator begin, InputIterator end, OutputIterator result,
-             __gnu_parallel::sequential_tag)
-  { return _GLIBCXX_STD_P::partial_sum(begin, end, result); }
+    inline OutputIterator
+    partial_sum(InputIterator begin, InputIterator end, OutputIterator result,
+               __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::partial_sum(begin, end, result); }
 
   // Sequential fallback.
-  template<typename InputIterator, typename OutputIterator, typename BinaryOperation>
-  inline OutputIterator
-  partial_sum(InputIterator begin, InputIterator end, OutputIterator result,
-             BinaryOperation bin_op, __gnu_parallel::sequential_tag)
-  { return _GLIBCXX_STD_P::partial_sum(begin, end, result, bin_op); }
+  template<typename InputIterator, typename OutputIterator,
+          typename BinaryOperation>
+    inline OutputIterator
+    partial_sum(InputIterator begin, InputIterator end, OutputIterator result,
+               BinaryOperation bin_op, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::partial_sum(begin, end, result, bin_op); }
 
   // Sequential fallback for input iterator case.
-  template<typename InputIterator, typename OutputIterator, typename BinaryOperation, typename IteratorTag1, typename IteratorTag2>
-  inline OutputIterator
-  partial_sum_switch(InputIterator begin, InputIterator end, OutputIterator result, BinaryOperation bin_op, IteratorTag1, IteratorTag2)
-  {
-    return _GLIBCXX_STD_P::partial_sum(begin, end, result, bin_op);
-  }
+  template<typename InputIterator, typename OutputIterator,
+          typename BinaryOperation, typename IteratorTag1,
+          typename IteratorTag2>
+    inline OutputIterator
+    partial_sum_switch(InputIterator begin, InputIterator end,
+                      OutputIterator result, BinaryOperation bin_op,
+                      IteratorTag1, IteratorTag2)
+    { return _GLIBCXX_STD_P::partial_sum(begin, end, result, bin_op); }
 
   // Parallel algorithm for random access iterators.
-  template<typename InputIterator, typename OutputIterator, typename BinaryOperation>
-  OutputIterator
-  partial_sum_switch(InputIterator begin, InputIterator end,
-                    OutputIterator result, BinaryOperation bin_op,
-                    random_access_iterator_tag, random_access_iterator_tag)
-  {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::partial_sum_minimal_n))
-      return __gnu_parallel::parallel_partial_sum(begin, end, result, bin_op);
-    else
-      return partial_sum(begin, end, result, bin_op, __gnu_parallel::sequential_tag());
-  }
+  template<typename InputIterator, typename OutputIterator,
+          typename BinaryOperation>
+    OutputIterator
+    partial_sum_switch(InputIterator begin, InputIterator end,
+                      OutputIterator result, BinaryOperation bin_op,
+                      random_access_iterator_tag, random_access_iterator_tag)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::
+                                     sequence_index_t>(end - begin)
+                                     >= __gnu_parallel::Settings::
+                                     partial_sum_minimal_n))
+       return __gnu_parallel::parallel_partial_sum(begin, end,
+                                                   result, bin_op);
+      else
+       return partial_sum(begin, end, result, bin_op,
+                          __gnu_parallel::sequential_tag());
+    }
 
   // Public interface.
   template<typename InputIterator, typename OutputIterator>
-  inline OutputIterator
-  partial_sum(InputIterator begin, InputIterator end, OutputIterator result)
-  {
-    typedef typename iterator_traits<InputIterator>::value_type value_type;
-    return partial_sum(begin, end, result, std::plus<value_type>());
-  }
+    inline OutputIterator
+    partial_sum(InputIterator begin, InputIterator end, OutputIterator result)
+    {
+      typedef typename iterator_traits<InputIterator>::value_type value_type;
+      return partial_sum(begin, end, result, std::plus<value_type>());
+    }
 
   // Public interface
-  template<typename InputIterator, typename OutputIterator, typename BinaryOperation>
-  inline OutputIterator
-  partial_sum(InputIterator begin, InputIterator end, OutputIterator result,
-             BinaryOperation binary_op)
-  {
-    typedef iterator_traits<InputIterator> traitsi_type;
-    typedef typename traitsi_type::iterator_category iteratori_category;
-
-    typedef iterator_traits<OutputIterator> traitso_type;
-    typedef typename traitso_type::iterator_category iteratoro_category;
-
-    return partial_sum_switch(begin, end, result, binary_op,
-                                  iteratori_category(), iteratoro_category());
-  }
+  template<typename InputIterator, typename OutputIterator,
+          typename BinaryOperation>
+    inline OutputIterator
+    partial_sum(InputIterator begin, InputIterator end, OutputIterator result,
+               BinaryOperation binary_op)
+    {
+      typedef iterator_traits<InputIterator> traitsi_type;
+      typedef typename traitsi_type::iterator_category iteratori_category;
+
+      typedef iterator_traits<OutputIterator> traitso_type;
+      typedef typename traitso_type::iterator_category iteratoro_category;
+
+      return partial_sum_switch(begin, end, result, binary_op,
+                               iteratori_category(), iteratoro_category());
+    }
 
   // Sequential fallback.
   template<typename InputIterator, typename OutputIterator>
-  inline OutputIterator
-  adjacent_difference(InputIterator begin, InputIterator end,
-                     OutputIterator result, __gnu_parallel::sequential_tag)
-  { return _GLIBCXX_STD_P::adjacent_difference(begin, end, result); }
+    inline OutputIterator
+    adjacent_difference(InputIterator begin, InputIterator end,
+                       OutputIterator result, __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::adjacent_difference(begin, end, result); }
 
   // Sequential fallback.
-  template<typename InputIterator, typename OutputIterator, typename BinaryOperation>
-  inline OutputIterator
-  adjacent_difference(InputIterator begin, InputIterator end,
-                     OutputIterator result, BinaryOperation bin_op,
-                     __gnu_parallel::sequential_tag)
-  {
-    return _GLIBCXX_STD_P::adjacent_difference(begin, end, result, bin_op);
-  }
+  template<typename InputIterator, typename OutputIterator,
+          typename BinaryOperation>
+    inline OutputIterator
+    adjacent_difference(InputIterator begin, InputIterator end,
+                       OutputIterator result, BinaryOperation bin_op,
+                       __gnu_parallel::sequential_tag)
+    { return _GLIBCXX_STD_P::adjacent_difference(begin, end, result, bin_op); }
 
   // Sequential fallback for input iterator case.
-  template<typename InputIterator, typename OutputIterator, typename BinaryOperation, typename IteratorTag1, typename IteratorTag2>
-  inline OutputIterator
-  adjacent_difference_switch(InputIterator begin, InputIterator end,
-                            OutputIterator result, BinaryOperation bin_op,
+  template<typename InputIterator, typename OutputIterator,
+          typename BinaryOperation, typename IteratorTag1,
+          typename IteratorTag2>
+    inline OutputIterator
+    adjacent_difference_switch(InputIterator begin, InputIterator end,
+                              OutputIterator result, BinaryOperation bin_op,
                             IteratorTag1, IteratorTag2)
-  { 
-    return adjacent_difference(begin, end, result, bin_op,  
-                              __gnu_parallel::sequential_tag()); 
-  }
+    { return adjacent_difference(begin, end, result, bin_op,  
+                                __gnu_parallel::sequential_tag()); }
 
   // Parallel algorithm for random access iterators.
-  template<typename InputIterator, typename OutputIterator, typename BinaryOperation>
-  OutputIterator
-  adjacent_difference_switch(InputIterator begin, InputIterator end,
-                            OutputIterator result, BinaryOperation bin_op,
-                            random_access_iterator_tag, 
-                            random_access_iterator_tag,
-                            __gnu_parallel::parallelism parallelism_tag
-                            = __gnu_parallel::parallel_balanced)
-  {
-    if (_GLIBCXX_PARALLEL_CONDITION(static_cast<__gnu_parallel::sequence_index_t>(end - begin) >= __gnu_parallel::Settings::adjacent_difference_minimal_n && __gnu_parallel::is_parallel(parallelism_tag)))
-      {
-       bool dummy = true;
-       typedef __gnu_parallel::iterator_pair<InputIterator, OutputIterator, random_access_iterator_tag> ip;
-       *result = *begin;
-       ip begin_pair(begin + 1, result + 1), end_pair(end, result + (end - begin));
-       __gnu_parallel::adjacent_difference_selector<ip> functionality;
-       __gnu_parallel::for_each_template_random_access(begin_pair, end_pair, bin_op, functionality, __gnu_parallel::dummy_reduct(), dummy, dummy, -1, parallelism_tag);
-       return functionality.finish_iterator;
-      }
-    else
-      return adjacent_difference(begin, end, result, bin_op, 
-                                __gnu_parallel::sequential_tag());
-  }
+  template<typename InputIterator, typename OutputIterator,
+          typename BinaryOperation>
+    OutputIterator
+    adjacent_difference_switch(InputIterator begin, InputIterator end,
+                              OutputIterator result, BinaryOperation bin_op,
+                              random_access_iterator_tag, 
+                              random_access_iterator_tag,
+                              __gnu_parallel::parallelism parallelism_tag
+                              = __gnu_parallel::parallel_balanced)
+    {
+      if (_GLIBCXX_PARALLEL_CONDITION(
+           static_cast<__gnu_parallel::sequence_index_t>(end - begin)
+           >= __gnu_parallel::Settings::adjacent_difference_minimal_n
+           && __gnu_parallel::is_parallel(parallelism_tag)))
+       {
+         bool dummy = true;
+         typedef __gnu_parallel::iterator_pair<InputIterator, OutputIterator,
+           random_access_iterator_tag> ip;
+         *result = *begin;
+         ip begin_pair(begin + 1, result + 1),
+           end_pair(end, result + (end - begin));
+         __gnu_parallel::adjacent_difference_selector<ip> functionality;
+         __gnu_parallel::
+           for_each_template_random_access(begin_pair, end_pair, bin_op,
+                                           functionality,
+                                           __gnu_parallel::dummy_reduct(),
+                                           dummy, dummy, -1, parallelism_tag);
+         return functionality.finish_iterator;
+       }
+      else
+       return adjacent_difference(begin, end, result, bin_op, 
+                                  __gnu_parallel::sequential_tag());
+    }
 
   // Public interface.
   template<typename InputIterator, typename OutputIterator>
-  inline OutputIterator
-  adjacent_difference(InputIterator begin, InputIterator end,
-                     OutputIterator result,
-                     __gnu_parallel::parallelism parallelism_tag)
-  {
-    typedef iterator_traits<InputIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    return adjacent_difference(begin, end, result, std::minus<value_type>(), 
-                              parallelism_tag);
-  }
+    inline OutputIterator
+    adjacent_difference(InputIterator begin, InputIterator end,
+                       OutputIterator result,
+                       __gnu_parallel::parallelism parallelism_tag)
+    {
+      typedef iterator_traits<InputIterator> traits_type;
+      typedef typename traits_type::value_type value_type;
+      return adjacent_difference(begin, end, result, std::minus<value_type>(),
+                                parallelism_tag);
+    }
 
   template<typename InputIterator, typename OutputIterator>
-  inline OutputIterator
-  adjacent_difference(InputIterator begin, InputIterator end,
-                     OutputIterator result)
-  {
-    typedef iterator_traits<InputIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    return adjacent_difference(begin, end, result, std::minus<value_type>());
-  }
-
-  template<typename InputIterator, typename OutputIterator, typename BinaryOperation>
-  inline OutputIterator
-  adjacent_difference(InputIterator begin, InputIterator end,
-                     OutputIterator result, BinaryOperation binary_op,
-                     __gnu_parallel::parallelism parallelism_tag)
-  {
-    typedef iterator_traits<InputIterator> traitsi_type;
-    typedef typename traitsi_type::iterator_category iteratori_category;
-
-    typedef iterator_traits<OutputIterator> traitso_type;
-    typedef typename traitso_type::iterator_category iteratoro_category;
-
-    return adjacent_difference_switch(begin, end, result, binary_op,
-                                     iteratori_category(), 
-                                     iteratoro_category(), parallelism_tag);
-  }
-
-  template<typename InputIterator, typename OutputIterator, typename BinaryOperation>
-  inline OutputIterator
-  adjacent_difference(InputIterator begin, InputIterator end,
-                     OutputIterator result, BinaryOperation binary_op)
-  {
-    typedef iterator_traits<InputIterator> traitsi_type;
-    typedef typename traitsi_type::iterator_category iteratori_category;
-
-    typedef iterator_traits<OutputIterator> traitso_type;
-    typedef typename traitso_type::iterator_category iteratoro_category;
-
-    return adjacent_difference_switch(begin, end, result, binary_op,
-                                     iteratori_category(), 
-                                     iteratoro_category());
-  }
+    inline OutputIterator
+    adjacent_difference(InputIterator begin, InputIterator end,
+                       OutputIterator result)
+    {
+      typedef iterator_traits<InputIterator> traits_type;
+      typedef typename traits_type::value_type value_type;
+      return adjacent_difference(begin, end, result, std::minus<value_type>());
+    }
+
+  template<typename InputIterator, typename OutputIterator,
+          typename BinaryOperation>
+    inline OutputIterator
+    adjacent_difference(InputIterator begin, InputIterator end,
+                       OutputIterator result, BinaryOperation binary_op,
+                       __gnu_parallel::parallelism parallelism_tag)
+    {
+      typedef iterator_traits<InputIterator> traitsi_type;
+      typedef typename traitsi_type::iterator_category iteratori_category;
+
+      typedef iterator_traits<OutputIterator> traitso_type;
+      typedef typename traitso_type::iterator_category iteratoro_category;
+
+      return adjacent_difference_switch(begin, end, result, binary_op,
+                                       iteratori_category(), 
+                                       iteratoro_category(), parallelism_tag);
+    }
+
+  template<typename InputIterator, typename OutputIterator,
+          typename BinaryOperation>
+    inline OutputIterator
+    adjacent_difference(InputIterator begin, InputIterator end,
+                       OutputIterator result, BinaryOperation binary_op)
+    {
+      typedef iterator_traits<InputIterator> traitsi_type;
+      typedef typename traitsi_type::iterator_category iteratori_category;
+
+      typedef iterator_traits<OutputIterator> traitso_type;
+      typedef typename traitso_type::iterator_category iteratoro_category;
+
+      return adjacent_difference_switch(begin, end, result, binary_op,
+                                       iteratori_category(), 
+                                       iteratoro_category());
+    }
 } // end namespace
 } // end namespace
 
index 4181132..f693a60 100644 (file)
@@ -1,6 +1,6 @@
 // <numeric> parallel extensions -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -44,146 +44,162 @@ namespace std
 {
 namespace __parallel
 {
-  template<typename _IIter, typename T>
-  inline T
-  accumulate(_IIter, _IIter, T);
-
-  template<typename _IIter, typename T>
-  inline T
-  accumulate(_IIter, _IIter, T, __gnu_parallel::sequential_tag);
-
-  template<typename _IIter, typename T>
-  inline T
-  accumulate(_IIter, _IIter, T, __gnu_parallel::parallelism parallelism_tag);
-
-  template<typename _IIter, typename T, typename _Tag>
-  inline T
-  accumulate_switch(_IIter, _IIter, T, _Tag);
-
-  template<typename _IIter, typename T, typename _BinaryOper>
-  inline T
-  accumulate(_IIter, _IIter, T, _BinaryOper);
-
-  template<typename _IIter, typename T, typename _BinaryOper>
-  inline T
-  accumulate(_IIter, _IIter, T, _BinaryOper, __gnu_parallel::sequential_tag);
-
-  template<typename _IIter, typename T, typename _BinaryOper>
-  inline T
-  accumulate(_IIter, _IIter, T, _BinaryOper, 
-            __gnu_parallel::parallelism parallelism_tag);
-
-  template<typename _IIter, typename T, typename _BinaryOper, typename _Tag>
-  T
-  accumulate_switch(_IIter, _IIter, T, _BinaryOper, _Tag);
-
-  template<typename _RAIter, typename T, typename _BinaryOper>
-  T
-  accumulate_switch(_RAIter, _RAIter, T, _BinaryOper, 
-                   random_access_iterator_tag, __gnu_parallel::parallelism);
-
+  template<typename _IIter, typename _Tp>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp);
+
+  template<typename _IIter, typename _Tp>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _Tp>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, __gnu_parallel::parallelism);
+
+  template<typename _IIter, typename _Tp, typename _Tag>
+    _Tp
+    accumulate_switch(_IIter, _IIter, _Tp, _Tag);
+
+  template<typename _IIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, _BinaryOper);
+
+  template<typename _IIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, _BinaryOper,
+              __gnu_parallel::sequential_tag);
+
+  template<typename _IIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    accumulate(_IIter, _IIter, _Tp, _BinaryOper,
+              __gnu_parallel::parallelism);
+
+  template<typename _IIter, typename _Tp, typename _BinaryOper,
+          typename _Tag>
+    _Tp
+    accumulate_switch(_IIter, _IIter, _Tp, _BinaryOper, _Tag);
+
+  template<typename _RAIter, typename _Tp, typename _BinaryOper>
+    _Tp
+    accumulate_switch(_RAIter, _RAIter, _Tp, _BinaryOper,
+                     random_access_iterator_tag,
+                     __gnu_parallel::parallelism);
 
- template<typename _IIter, typename _OIter>
-  inline _OIter
-  adjacent_difference(_IIter, _IIter, _OIter);
 template<typename _IIter, typename _OIter>
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  inline _OIter
-  adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper);
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper);
 
   template<typename _IIter, typename _OIter>
-  inline _OIter
-  adjacent_difference(_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag);
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter,
+                       __gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  inline _OIter
-  adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper, 
-                     __gnu_parallel::sequential_tag);
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper, 
+                       __gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter>
-  inline _OIter
-  adjacent_difference(_IIter, _IIter, _OIter, __gnu_parallel::parallelism);
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter,
+                       __gnu_parallel::parallelism);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  inline _OIter
-  adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper, 
-                     __gnu_parallel::parallelism);
+    _OIter
+    adjacent_difference(_IIter, _IIter, _OIter, _BinaryOper, 
+                       __gnu_parallel::parallelism);
 
-  template<typename _IIter, typename _OIter, typename _BinaryOper, typename _Tag1, typename _Tag2>
-  inline _OIter
-  adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2);
+  template<typename _IIter, typename _OIter, typename _BinaryOper,
+          typename _Tag1, typename _Tag2>
+    _OIter
+    adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper,
+                              _Tag1, _Tag2);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  _OIter
-  adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, 
-                            random_access_iterator_tag, 
-                            random_access_iterator_tag, 
-                            __gnu_parallel::parallelism);
-
-
-  template<typename _IIter1, typename _IIter2, typename T>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T);
-
-  template<typename _IIter1, typename _IIter2, typename T>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T, __gnu_parallel::sequential_tag);
-
-  template<typename _IIter1, typename _IIter2, typename T>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T, __gnu_parallel::parallelism);
-
-
-  template<typename _IIter1, typename _IIter2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T, BinaryFunction1, BinaryFunction2);
-
-  template<typename _IIter1, typename _IIter2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T, BinaryFunction1, BinaryFunction2,
-               __gnu_parallel::sequential_tag);
-
-  template<typename _IIter1, typename _IIter2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  inline T
-  inner_product(_IIter1, _IIter1, _IIter2, T, BinaryFunction1, BinaryFunction2,
-               __gnu_parallel::parallelism);
-
-  template<typename _RAIter1, typename _RAIter2, typename T, typename BinaryFunction1, typename BinaryFunction2>
-  T
-  inner_product_switch(_RAIter1, _RAIter1, _RAIter2, T, BinaryFunction1, 
-                      BinaryFunction2, random_access_iterator_tag, 
-                      random_access_iterator_tag, 
-                      __gnu_parallel::parallelism);
-
-  template<typename _IIter1, typename _IIter2, typename T, typename BinaryFunction1, typename BinaryFunction2, typename _Tag1, typename _Tag2>
-  inline T
-  inner_product_switch(_IIter1, _IIter1, _IIter2, T, BinaryFunction1, 
-                      BinaryFunction2, _Tag1, _Tag2);
+    _OIter
+    adjacent_difference_switch(_IIter, _IIter, _OIter, _BinaryOper, 
+                              random_access_iterator_tag, 
+                              random_access_iterator_tag, 
+                              __gnu_parallel::parallelism);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp,
+                 __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp,
+                 __gnu_parallel::parallelism);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+          typename _BinaryFunction1, typename _BinaryFunction2>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp,
+                 _BinaryFunction1, _BinaryFunction2);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+          typename _BinaryFunction1, typename _BinaryFunction2>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1,
+                 _BinaryFunction2, __gnu_parallel::sequential_tag);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+          typename BinaryFunction1, typename BinaryFunction2>
+    _Tp
+    inner_product(_IIter1, _IIter1, _IIter2, _Tp, BinaryFunction1,
+                 BinaryFunction2, __gnu_parallel::parallelism);
+
+  template<typename _RAIter1, typename _RAIter2, typename _Tp,
+          typename BinaryFunction1, typename BinaryFunction2>
+    _Tp
+    inner_product_switch(_RAIter1, _RAIter1, _RAIter2, _Tp, BinaryFunction1, 
+                        BinaryFunction2, random_access_iterator_tag, 
+                        random_access_iterator_tag, 
+                        __gnu_parallel::parallelism);
+
+  template<typename _IIter1, typename _IIter2, typename _Tp,
+          typename _BinaryFunction1, typename _BinaryFunction2,
+          typename _Tag1, typename _Tag2>
+    _Tp
+    inner_product_switch(_IIter1, _IIter1, _IIter2, _Tp, _BinaryFunction1, 
+                        _BinaryFunction2, _Tag1, _Tag2);
 
 
   template<typename _IIter, typename _OIter>
-  inline _OIter
-  partial_sum(_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag);
+    _OIter
+    partial_sum(_IIter, _IIter, _OIter, __gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  inline _OIter
-  partial_sum(_IIter, _IIter, _OIter, _BinaryOper, __gnu_parallel::sequential_tag);
+    _OIter
+    partial_sum(_IIter, _IIter, _OIter, _BinaryOper,
+               __gnu_parallel::sequential_tag);
 
   template<typename _IIter, typename _OIter>
-  inline _OIter
-  partial_sum(_IIter, _IIter, _OIter result);
+    _OIter
+    partial_sum(_IIter, _IIter, _OIter result);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  inline _OIter
-  partial_sum(_IIter, _IIter, _OIter, _BinaryOper);
+    _OIter
+    partial_sum(_IIter, _IIter, _OIter, _BinaryOper);
 
-  template<typename _IIter, typename _OIter, typename _BinaryOper, typename _Tag1, typename _Tag2>
-  inline _OIter
-  partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2);
+  template<typename _IIter, typename _OIter, typename _BinaryOper,
+          typename _Tag1, typename _Tag2>
+    _OIter
+    partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, _Tag1, _Tag2);
 
   template<typename _IIter, typename _OIter, typename _BinaryOper>
-  _OIter
-  partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper, random_access_iterator_tag, random_access_iterator_tag);
+    _OIter
+    partial_sum_switch(_IIter, _IIter, _OIter, _BinaryOper,
+                      random_access_iterator_tag, random_access_iterator_tag);
 } // end namespace
 } // end namespace
 
index 0a992b0..97660c1 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -65,17 +65,18 @@ namespace __gnu_parallel
   *  @return User-supplied functor (that may contain a part of the result).
   */
 template<typename RandomAccessIterator,
-            typename Op,
-            typename Fu,
-            typename Red,
-            typename Result>
+        typename Op,
+        typename Fu,
+        typename Red,
+        typename Result>
   Op
-  for_each_template_random_access_omp_loop(
-             RandomAccessIterator begin,
-             RandomAccessIterator end,
-             Op o, Fu& f, Red r, Result base, Result& output,
-             typename std::iterator_traits<RandomAccessIterator>::
-                 difference_type bound)
+  for_each_template_random_access_omp_loop(RandomAccessIterator begin,
+                                          RandomAccessIterator end,
+                                          Op o, Fu& f, Red r, Result base,
+                                          Result& output,
+                                          typename std::iterator_traits
+                                          <RandomAccessIterator>::
+                                          difference_type bound)
   {
     typedef typename
         std::iterator_traits<RandomAccessIterator>::difference_type
@@ -83,7 +84,7 @@ template<typename RandomAccessIterator,
 
     difference_type length = end - begin;
     thread_index_t num_threads =
-        __gnu_parallel::min<difference_type>(get_max_threads(), length);
+      __gnu_parallel::min<difference_type>(get_max_threads(), length);
 
     Result *thread_results;
 
@@ -94,19 +95,19 @@ template<typename RandomAccessIterator,
             num_threads = omp_get_num_threads();
             thread_results = new Result[num_threads];
 
-            for (thread_index_t i = 0; i < num_threads; i++)
+            for (thread_index_t i = 0; i < num_threads; ++i)
               thread_results[i] = Result();
           }
 
         thread_index_t iam = omp_get_thread_num();
 
 #       pragma omp for schedule(dynamic, Settings::workstealing_chunk_size)
-        for (difference_type pos = 0; pos < length; pos++)
+        for (difference_type pos = 0; pos < length; ++pos)
           thread_results[iam] =
               r(thread_results[iam], f(o, begin+pos));
       } //parallel
 
-    for (thread_index_t i = 0; i < num_threads; i++)
+    for (thread_index_t i = 0; i < num_threads; ++i)
         output = r(output, thread_results[i]);
 
     delete [] thread_results;
index df2c3b5..2546bb2 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -65,25 +65,26 @@ namespace __gnu_parallel
    *  @return User-supplied functor (that may contain a part of the result).
    */
 template<typename RandomAccessIterator,
-          typename Op,
-          typename Fu,
-          typename Red,
-          typename Result>
+        typename Op,
+        typename Fu,
+        typename Red,
+        typename Result>
   Op
-  for_each_template_random_access_omp_loop_static(
-              RandomAccessIterator begin,
-              RandomAccessIterator end,
-              Op o, Fu& f, Red r, Result base, Result& output,
-              typename std::iterator_traits<RandomAccessIterator>::
-                  difference_type bound)
+  for_each_template_random_access_omp_loop_static(RandomAccessIterator begin,
+                                                 RandomAccessIterator end,
+                                                 Op o, Fu& f, Red r,
+                                                 Result base, Result& output,
+                                                 typename std::iterator_traits
+                                                 <RandomAccessIterator>::
+                                                 difference_type bound)
   {
     typedef typename
-        std::iterator_traits<RandomAccessIterator>::difference_type
-        difference_type;
+      std::iterator_traits<RandomAccessIterator>::difference_type
+      difference_type;
 
     difference_type length = end - begin;
     thread_index_t num_threads =
-        std::min<difference_type>(get_max_threads(), length);
+      std::min<difference_type>(get_max_threads(), length);
 
     Result *thread_results;
 
@@ -94,20 +95,19 @@ template<typename RandomAccessIterator,
             num_threads = omp_get_num_threads();
             thread_results = new Result[num_threads];
 
-            for (thread_index_t i = 0; i < num_threads; i++)
+            for (thread_index_t i = 0; i < num_threads; ++i)
               thread_results[i] = Result();
           }
 
         thread_index_t iam = omp_get_thread_num();
 
 #       pragma omp for schedule(static, Settings::workstealing_chunk_size)
-        for (difference_type pos = 0; pos < length; pos++)
-          thread_results[iam] =
-              r(thread_results[iam], f(o, begin+pos));
+        for (difference_type pos = 0; pos < length; ++pos)
+          thread_results[iam] = r(thread_results[iam], f(o, begin+pos));
       } //parallel
 
-    for (thread_index_t i = 0; i < num_threads; i++)
-        output = r(output, thread_results[i]);
+    for (thread_index_t i = 0; i < num_threads; ++i)
+      output = r(output, thread_results[i]);
 
     delete [] thread_results;
 
index 6954e74..9e6c2ea 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -64,19 +64,19 @@ namespace __gnu_parallel
   *  std::count_n()).
   *  @return User-supplied functor (that may contain a part of the result).
   */
-template<
-    typename RandomAccessIterator,
-    typename Op,
-    typename Fu,
-    typename Red,
-    typename Result>
+template<typename RandomAccessIterator,
+        typename Op,
+        typename Fu,
+        typename Red,
+        typename Result>
   Op
-  for_each_template_random_access_ed(
-              RandomAccessIterator begin,
-              RandomAccessIterator end,
-              Op o, Fu& f, Red r, Result base, Result& output,
-              typename std::iterator_traits<RandomAccessIterator>::
-                  difference_type bound)
+  for_each_template_random_access_ed(RandomAccessIterator begin,
+                                    RandomAccessIterator end,
+                                    Op o, Fu& f, Red r, Result base,
+                                    Result& output,
+                                    typename std::iterator_traits
+                                    <RandomAccessIterator>::
+                                    difference_type bound)
   {
     typedef std::iterator_traits<RandomAccessIterator> traits_type;
     typedef typename traits_type::difference_type difference_type;
@@ -85,7 +85,7 @@ template<
     Result *thread_results;
 
     thread_index_t num_threads =
-        __gnu_parallel::min<difference_type>(get_max_threads(), length);
+      __gnu_parallel::min<difference_type>(get_max_threads(), length);
 
 #   pragma omp parallel num_threads(num_threads)
       {
@@ -116,7 +116,7 @@ template<
         thread_results[iam] = reduct;
       } //parallel
 
-    for (thread_index_t i = 0; i < num_threads; i++)
+    for (thread_index_t i = 0; i < num_threads; ++i)
       output = r(output, thread_results[i]);
 
     // Points to last element processed (needed as return value for
index c165729..f7ca754 100644 (file)
@@ -57,15 +57,14 @@ namespace __gnu_parallel
   *  @param value Start value. Must be passed since the neutral
   *  element is unknown in general.
   *  @return End iterator of output sequence. */
-template<
-    typename InputIterator,
-    typename OutputIterator,
-    typename BinaryOperation>
-  inline OutputIterator
-  parallel_partial_sum_basecase(
-            InputIterator begin, InputIterator end,
-            OutputIterator result, BinaryOperation bin_op,
-            typename std::iterator_traits<InputIterator>::value_type value)
+template<typename InputIterator,
+        typename OutputIterator,
+        typename BinaryOperation>
+  OutputIterator
+  parallel_partial_sum_basecase(InputIterator begin, InputIterator end,
+                               OutputIterator result, BinaryOperation bin_op,
+                               typename std::iterator_traits
+                               <InputIterator>::value_type value)
   {
     if (begin == end)
       return result;
@@ -90,15 +89,14 @@ template<
     *  @param num_threads Number of threads to use.
     *  @return End iterator of output sequence.
     */
-template<
-    typename InputIterator,
-    typename OutputIterator,
-    typename BinaryOperation>
+template<typename InputIterator,
+        typename OutputIterator,
+        typename BinaryOperation>
   OutputIterator
-  parallel_partial_sum_linear(
-            InputIterator begin, InputIterator end,
-            OutputIterator result, BinaryOperation bin_op,
-            typename std::iterator_traits<InputIterator>::difference_type n)
+  parallel_partial_sum_linear(InputIterator begin, InputIterator end,
+                             OutputIterator result, BinaryOperation bin_op,
+                             typename std::iterator_traits
+                             <InputIterator>::difference_type n)
   {
     typedef std::iterator_traits<InputIterator> traits_type;
     typedef typename traits_type::value_type value_type;
@@ -133,9 +131,10 @@ template<
             else
               {
                 difference_type chunk_length =
-                    ((double)n /
-                    ((double)num_threads + Settings::partial_sum_dilatation)),
-                    borderstart = n - num_threads * chunk_length;
+                    ((double)n
+                    / ((double)num_threads
+                       + Settings::partial_sum_dilatation)),
+                 borderstart = n - num_threads * chunk_length;
                 borders[0] = 0;
                 for (int i = 1; i < (num_threads + 1); ++i)
                   {
@@ -145,8 +144,8 @@ template<
                 borders[num_threads + 1] = n;
               }
 
-            sums = static_cast<value_type*>(
-                ::operator new(sizeof(value_type) * num_threads));
+            sums = static_cast<value_type*>(::operator new(sizeof(value_type)
+                                                          * num_threads));
             OutputIterator target_end;
           } //single
 
@@ -155,16 +154,17 @@ template<
           {
             *result = *begin;
             parallel_partial_sum_basecase(begin + 1, begin + borders[1],
-                          result + 1, bin_op, *begin);
+                                         result + 1, bin_op, *begin);
             ::new(&(sums[iam])) value_type(*(result + borders[1] - 1));
           }
         else
           {
-            ::new(&(sums[iam])) value_type(
-                                std::accumulate(begin + borders[iam] + 1,
-                                begin + borders[iam + 1],
-                                *(begin + borders[iam]),
-                                bin_op, __gnu_parallel::sequential_tag()));
+            ::new(&(sums[iam]))
+             value_type(std::accumulate(begin + borders[iam] + 1,
+                                        begin + borders[iam + 1],
+                                        *(begin + borders[iam]),
+                                        bin_op,
+                                        __gnu_parallel::sequential_tag()));
           }
 
 #       pragma omp barrier
@@ -177,9 +177,9 @@ template<
 
         // Still same team.
         parallel_partial_sum_basecase(begin + borders[iam + 1],
-                      begin + borders[iam + 2],
-                      result + borders[iam + 1], bin_op,
-                      sums[iam]);
+                                     begin + borders[iam + 2],
+                                     result + borders[iam + 1], bin_op,
+                                     sums[iam]);
       } //parallel
 
     ::operator delete(sums);
@@ -194,10 +194,9 @@ template<
   *  @param result Begin iterator of output sequence.
   *  @param bin_op Associative binary function.
   *  @return End iterator of output sequence. */
-template<
-    typename InputIterator,
-    typename OutputIterator,
-    typename BinaryOperation>
+template<typename InputIterator,
+        typename OutputIterator,
+        typename BinaryOperation>
   OutputIterator
   parallel_partial_sum(InputIterator begin, InputIterator end,
                        OutputIterator result, BinaryOperation bin_op)
index d6dac37..9dfcaad 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -92,10 +92,11 @@ template<typename RandomAccessIterator, typename Predicate>
             reserved_right = new bool[num_threads];
 
             if (Settings::partition_chunk_share > 0.0)
-              chunk_size = std::max<difference_type>(
-                  Settings::partition_chunk_size,
-                  (double)n * Settings::partition_chunk_share /
-                        (double)num_threads);
+              chunk_size = std::max<difference_type>(Settings::
+                                                    partition_chunk_size,
+                                                    (double)n * Settings::
+                                                    partition_chunk_share
+                                                    / (double)num_threads);
             else
               chunk_size = Settings::partition_chunk_size;
           }
@@ -106,7 +107,7 @@ template<typename RandomAccessIterator, typename Predicate>
               {
                 difference_type num_chunks = (right - left + 1) / chunk_size;
 
-                for (int r = 0; r < num_threads; r++)
+                for (int r = 0; r < num_threads; ++r)
                   {
                     reserved_left[r] = false;
                     reserved_right[r] = false;
@@ -164,10 +165,10 @@ template<typename RandomAccessIterator, typename Predicate>
                   {
                     while (pred(begin[thread_left])
                             && thread_left <= thread_left_border)
-                      thread_left++;
+                      ++thread_left;
                     while (!pred(begin[thread_right])
                             && thread_right >= thread_right_border)
-                      thread_right--;
+                      --thread_right;
 
                     if (thread_left > thread_left_border
                         || thread_right < thread_right_border)
@@ -175,18 +176,18 @@ template<typename RandomAccessIterator, typename Predicate>
                       break;
 
                     std::swap(begin[thread_left], begin[thread_right]);
-                    thread_left++;
-                    thread_right--;
+                    ++thread_left;
+                    --thread_right;
                   }
               }
 
             // Now swap the leftover chunks to the right places.
             if (thread_left <= thread_left_border)
 #             pragma omp atomic
-              leftover_left++;
+              ++leftover_left;
             if (thread_right >= thread_right_border)
 #             pragma omp atomic
-              leftover_right++;
+              ++leftover_right;
 
 #           pragma omp barrier
 
@@ -212,9 +213,8 @@ template<typename RandomAccessIterator, typename Predicate>
                 && thread_right_border <= rightnew)
               {
                 // Chunk already in place, reserve spot.
-                reserved_right
-                    [((thread_right_border - 1) - right) / chunk_size]
-                    = true;
+                reserved_right[((thread_right_border - 1) - right)
+                              / chunk_size] = true;
               }
 
 #           pragma omp barrier
@@ -225,7 +225,7 @@ template<typename RandomAccessIterator, typename Predicate>
                 // Find spot and swap.
                 difference_type swapstart = -1;
                 omp_set_lock(&result_lock);
-                for (int r = 0; r < leftover_left; r++)
+                for (int r = 0; r < leftover_left; ++r)
                   if (!reserved_left[r])
                     {
                       reserved_left[r] = true;
@@ -238,10 +238,10 @@ template<typename RandomAccessIterator, typename Predicate>
                 _GLIBCXX_PARALLEL_ASSERT(swapstart != -1);
 #endif
 
-                std::swap_ranges(
-                    begin + thread_left_border - (chunk_size - 1),
-                    begin + thread_left_border + 1,
-                    begin + swapstart);
+                std::swap_ranges(begin + thread_left_border
+                                - (chunk_size - 1),
+                                begin + thread_left_border + 1,
+                                begin + swapstart);
               }
 
             if (thread_right >= thread_right_border
@@ -250,7 +250,7 @@ template<typename RandomAccessIterator, typename Predicate>
                 // Find spot and swap
                 difference_type swapstart = -1;
                 omp_set_lock(&result_lock);
-                for (int r = 0; r < leftover_right; r++)
+                for (int r = 0; r < leftover_right; ++r)
                   if (!reserved_right[r])
                     {
                       reserved_right[r] = true;
@@ -264,17 +264,17 @@ template<typename RandomAccessIterator, typename Predicate>
 #endif
 
                 std::swap_ranges(begin + thread_right_border,
-                                begin + thread_right_border + chunk_size,
-                                begin + swapstart);
+                                begin + thread_right_border + chunk_size,
+                                begin + swapstart);
               }
 #if _GLIBCXX_ASSERTIONS
 #             pragma omp barrier
 
 #             pragma omp single
                 {
-                  for (int r = 0; r < leftover_left; r++)
+                  for (int r = 0; r < leftover_left; ++r)
                     _GLIBCXX_PARALLEL_ASSERT(reserved_left[r]);
-                  for (int r = 0; r < leftover_right; r++)
+                  for (int r = 0; r < leftover_right; ++r)
                     _GLIBCXX_PARALLEL_ASSERT(reserved_right[r]);
                 }
 
@@ -295,17 +295,17 @@ template<typename RandomAccessIterator, typename Predicate>
       {
         // Go right until key is geq than pivot.
         while (pred(begin[final_left]) && final_left < final_right)
-          final_left++;
+          ++final_left;
 
         // Go left until key is less than pivot.
         while (!pred(begin[final_right]) && final_left < final_right)
-          final_right--;
+          --final_right;
 
         if (final_left == final_right)
           break;
         std::swap(begin[final_left], begin[final_right]);
-        final_left++;
-        final_right--;
+        ++final_left;
+        --final_right;
       }
 
     // All elements on the left side are < piv, all elements on the
@@ -345,7 +345,8 @@ template<typename RandomAccessIterator, typename Comparator>
     RandomAccessIterator split;
     random_number rng;
 
-    difference_type minimum_length = std::max<difference_type>(2, Settings::partition_minimal_n);
+    difference_type minimum_length =
+      std::max<difference_type>(2, Settings::partition_minimal_n);
 
     // Break if input range to small.
     while (static_cast<sequence_index_t>(end - begin) >= minimum_length)
@@ -359,15 +360,19 @@ template<typename RandomAccessIterator, typename Comparator>
           std::swap(*pivot_pos, *(end - 1));
         pivot_pos = end - 1;
 
-        // XXX Comparator must have first_value_type, second_value_type, result_type
-        // Comparator == __gnu_parallel::lexicographic<S, int, __gnu_parallel::less<S, S> >
+        // XXX Comparator must have first_value_type, second_value_type,
+       // result_type
+        // Comparator == __gnu_parallel::lexicographic<S, int,
+       // __gnu_parallel::less<S, S> >
         // pivot_pos == std::pair<S, int>*
         // XXX binder2nd only for RandomAccessIterators??
-        __gnu_parallel::binder2nd<Comparator, value_type, value_type, bool> pred(comp, *pivot_pos);
+        __gnu_parallel::binder2nd<Comparator, value_type, value_type, bool>
+         pred(comp, *pivot_pos);
 
         // Divide, leave pivot unchanged in last place.
         RandomAccessIterator split_pos1, split_pos2;
-        split_pos1 = begin + parallel_partition(begin, end - 1, pred, get_max_threads());
+        split_pos1 = begin + parallel_partition(begin, end - 1, pred,
+                                               get_max_threads());
 
         // Left side: < pivot_pos; right side: >= pivot_pos
 
@@ -377,14 +382,19 @@ template<typename RandomAccessIterator, typename Comparator>
         pivot_pos = split_pos1;
 
         // In case all elements are equal, split_pos1 == 0
-        if ((split_pos1 + 1 - begin) < (n >> 7) || (end - split_pos1) < (n >> 7))
+        if ((split_pos1 + 1 - begin) < (n >> 7)
+           || (end - split_pos1) < (n >> 7))
           {
             // Very unequal split, one part smaller than one 128th
             // elements not stricly larger than the pivot.
-            __gnu_parallel::unary_negate<__gnu_parallel::binder1st<Comparator, value_type, value_type, bool>, value_type> pred(__gnu_parallel::binder1st<Comparator, value_type, value_type, bool>(comp, *pivot_pos));
+            __gnu_parallel::unary_negate<__gnu_parallel::
+             binder1st<Comparator, value_type, value_type, bool>, value_type>
+             pred(__gnu_parallel::binder1st<Comparator, value_type,
+                  value_type, bool>(comp, *pivot_pos));
 
             // Find other end of pivot-equal range.
-            split_pos2 = __gnu_sequential::partition(split_pos1 + 1, end, pred);
+            split_pos2 = __gnu_sequential::partition(split_pos1 + 1,
+                                                    end, pred);
           }
         else
           // Only skip the pivot.
@@ -410,7 +420,9 @@ template<typename RandomAccessIterator, typename Comparator>
 *  @param comp Comparator. */
 template<typename RandomAccessIterator, typename Comparator>
   void
-  parallel_partial_sort(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end, Comparator comp)
+  parallel_partial_sort(RandomAccessIterator begin,
+                       RandomAccessIterator middle,
+                       RandomAccessIterator end, Comparator comp)
   {
     parallel_nth_element(begin, middle, end, comp);
     std::sort(begin, middle, comp);
index 9d2143b..27a26f3 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -55,96 +55,98 @@ namespace __gnu_parallel
    *  Calling them would not make sense in a concurrent setting.
    *  @param T Contained element type. */
   template<typename T>
-  class RestrictedBoundedConcurrentQueue
-  {
-  private:
-    /** @brief Array of elements, seen as cyclic buffer. */
-    T* base;
-
-    /** @brief Maximal number of elements contained at the same time. */
-    sequence_index_t max_size;
-
-    /** @brief Cyclic begin and end pointers contained in one
-       atomically changeable value. */
-    _GLIBCXX_VOLATILE lcas_t borders;
-
-  public:
-    /** @brief Constructor. Not to be called concurrent, of course.
-     *  @param max_size Maximal number of elements to be contained. */
-    RestrictedBoundedConcurrentQueue(sequence_index_t max_size)
+    class RestrictedBoundedConcurrentQueue
     {
-      this->max_size = max_size;
-      base = new T[max_size];
-      borders = encode2(0, 0);
+    private:
+      /** @brief Array of elements, seen as cyclic buffer. */
+      T* base;
+
+      /** @brief Maximal number of elements contained at the same time. */
+      sequence_index_t max_size;
+
+      /** @brief Cyclic begin and end pointers contained in one
+         atomically changeable value. */
+      _GLIBCXX_VOLATILE lcas_t borders;
+
+    public:
+      /** @brief Constructor. Not to be called concurrent, of course.
+       *  @param max_size Maximal number of elements to be contained. */
+      RestrictedBoundedConcurrentQueue(sequence_index_t max_size)
+      {
+       this->max_size = max_size;
+       base = new T[max_size];
+       borders = encode2(0, 0);
 #pragma omp flush
-    }
-
-    /** @brief Destructor. Not to be called concurrent, of course. */
-    ~RestrictedBoundedConcurrentQueue()
-    {
-      delete[] base;
-    }
-
-    /** @brief Pushes one element into the queue at the front end.
-     *  Must not be called concurrently with pop_front(). */
-    void push_front(const T& t)
-    {
-      lcas_t former_borders = borders;
-      int former_front, former_back;
-      decode2(former_borders, former_front, former_back);
-      *(base + former_front % max_size) = t;
+      }
+
+      /** @brief Destructor. Not to be called concurrent, of course. */
+      ~RestrictedBoundedConcurrentQueue()
+      { delete[] base; }
+
+      /** @brief Pushes one element into the queue at the front end.
+       *  Must not be called concurrently with pop_front(). */
+      void
+      push_front(const T& t)
+      {
+       lcas_t former_borders = borders;
+       int former_front, former_back;
+       decode2(former_borders, former_front, former_back);
+       *(base + former_front % max_size) = t;
 #if _GLIBCXX_ASSERTIONS
-      // Otherwise: front - back > max_size eventually.
-      _GLIBCXX_PARALLEL_ASSERT(((former_front + 1) - former_back) <= max_size);
+       // Otherwise: front - back > max_size eventually.
+       _GLIBCXX_PARALLEL_ASSERT(((former_front + 1) - former_back)
+                                <= max_size);
 #endif
-      fetch_and_add(&borders, encode2(1, 0));
-    }
-
-    /** @brief Pops one element from the queue at the front end.
-     *  Must not be called concurrently with pop_front(). */
-    bool pop_front(T& t)
-    {
-      int former_front, former_back;
+       fetch_and_add(&borders, encode2(1, 0));
+      }
+
+      /** @brief Pops one element from the queue at the front end.
+       *  Must not be called concurrently with pop_front(). */
+      bool
+      pop_front(T& t)
+      {
+       int former_front, former_back;
 #pragma omp flush
-      decode2(borders, former_front, former_back);
-      while (former_front > former_back)
-       {
-         // Chance.
-         lcas_t former_borders = encode2(former_front, former_back);
-         lcas_t new_borders = encode2(former_front - 1, former_back);
-         if (compare_and_swap(&borders, former_borders, new_borders))
-           {
-             t = *(base + (former_front - 1) % max_size);
-             return true;
-           }
+       decode2(borders, former_front, former_back);
+       while (former_front > former_back)
+         {
+           // Chance.
+           lcas_t former_borders = encode2(former_front, former_back);
+           lcas_t new_borders = encode2(former_front - 1, former_back);
+           if (compare_and_swap(&borders, former_borders, new_borders))
+             {
+               t = *(base + (former_front - 1) % max_size);
+               return true;
+             }
 #pragma omp flush
-         decode2(borders, former_front, former_back);
-       }
-      return false;
-    }
-
-    /** @brief Pops one element from the queue at the front end.
-     *  Must not be called concurrently with pop_front(). */
-    bool pop_back(T& t)        //queue behavior
-    {
-      int former_front, former_back;
+           decode2(borders, former_front, former_back);
+         }
+       return false;
+      }
+
+      /** @brief Pops one element from the queue at the front end.
+       *  Must not be called concurrently with pop_front(). */
+      bool
+      pop_back(T& t)   //queue behavior
+      {
+       int former_front, former_back;
 #pragma omp flush
-      decode2(borders, former_front, former_back);
-      while (former_front > former_back)
-       {
-         // Chance.
-         lcas_t former_borders = encode2(former_front, former_back);
-         lcas_t new_borders = encode2(former_front, former_back + 1);
-         if (compare_and_swap(&borders, former_borders, new_borders))
-           {
-             t = *(base + former_back % max_size);
-             return true;
-           }
+       decode2(borders, former_front, former_back);
+       while (former_front > former_back)
+         {
+           // Chance.
+           lcas_t former_borders = encode2(former_front, former_back);
+           lcas_t new_borders = encode2(former_front, former_back + 1);
+           if (compare_and_swap(&borders, former_borders, new_borders))
+             {
+               t = *(base + former_back % max_size);
+               return true;
+             }
 #pragma omp flush
-         decode2(borders, former_front, former_back);
-       }
-      return false;
-    }
+           decode2(borders, former_front, former_back);
+         }
+       return false;
+      }
   };
 }      //namespace __gnu_parallel
 
index 9228647..5b5a62f 100644 (file)
@@ -53,48 +53,46 @@ namespace __gnu_parallel
    *  this part.
    */
   template<typename RandomAccessIterator, typename Comparator>
-  inline
-  typename std::iterator_traits<RandomAccessIterator>::difference_type
-  parallel_sort_qs_divide(
-      RandomAccessIterator begin,
-      RandomAccessIterator end,
-      Comparator comp,
-      typename std::iterator_traits<RandomAccessIterator>::difference_type
-          pivot_rank,
-      typename std::iterator_traits<RandomAccessIterator>::difference_type
-          num_samples,
-      thread_index_t num_threads)
-  {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
-
-    difference_type n = end - begin;
-    num_samples = std::min(num_samples, n);
-
-    // Allocate uninitialized, to avoid default constructor.
-    value_type* samples = static_cast<value_type*>(
-      ::operator new(num_samples * sizeof(value_type)));
-
-    for (difference_type s = 0; s < num_samples; ++s)
-      {
-        const unsigned long long index = static_cast<unsigned long long>(s)
-                        * n / num_samples;
-        ::new(&(samples[s])) value_type(begin[index]);
-      }
+    typename std::iterator_traits<RandomAccessIterator>::difference_type
+    parallel_sort_qs_divide(RandomAccessIterator begin,
+                           RandomAccessIterator end,
+                           Comparator comp, typename std::iterator_traits
+                           <RandomAccessIterator>::difference_type pivot_rank,
+                           typename std::iterator_traits
+                           <RandomAccessIterator>::difference_type
+                           num_samples, thread_index_t num_threads)
+    {
+      typedef std::iterator_traits<RandomAccessIterator> traits_type;
+      typedef typename traits_type::value_type value_type;
+      typedef typename traits_type::difference_type difference_type;
+
+      difference_type n = end - begin;
+      num_samples = std::min(num_samples, n);
+
+      // Allocate uninitialized, to avoid default constructor.
+      value_type* samples =
+       static_cast<value_type*>(::operator new(num_samples
+                                               * sizeof(value_type)));
+
+      for (difference_type s = 0; s < num_samples; ++s)
+       {
+         const unsigned long long index = static_cast<unsigned long long>(s)
+           * n / num_samples;
+         ::new(&(samples[s])) value_type(begin[index]);
+       }
 
-    __gnu_sequential::sort(samples, samples + num_samples, comp);
+      __gnu_sequential::sort(samples, samples + num_samples, comp);
 
-    value_type& pivot = samples[pivot_rank * num_samples / n];
+      value_type& pivot = samples[pivot_rank * num_samples / n];
 
-    __gnu_parallel::binder2nd<Comparator, value_type, value_type, bool>
+      __gnu_parallel::binder2nd<Comparator, value_type, value_type, bool>
         pred(comp, pivot);
-    difference_type split = parallel_partition(begin, end, pred, num_threads);
+      difference_type split = parallel_partition(begin, end, pred, num_threads);
 
-    ::operator delete(samples);
+      ::operator delete(samples);
 
-    return split;
-  }
+      return split;
+    }
 
   /** @brief Unbalanced quicksort conquer step.
    *  @param begin Begin iterator of subsequence.
@@ -104,50 +102,51 @@ namespace __gnu_parallel
    *  this part.
    */
   template<typename RandomAccessIterator, typename Comparator>
-  inline void
-  parallel_sort_qs_conquer(RandomAccessIterator begin,
-                           RandomAccessIterator end,
-                           Comparator comp,
-                           thread_index_t num_threads)
-  {
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
-
-    if (num_threads <= 1)
-      {
-        __gnu_sequential::sort(begin, end, comp);
-        return;
-      }
+    void
+    parallel_sort_qs_conquer(RandomAccessIterator begin,
+                            RandomAccessIterator end,
+                            Comparator comp,
+                            thread_index_t num_threads)
+    {
+      typedef std::iterator_traits<RandomAccessIterator> traits_type;
+      typedef typename traits_type::value_type value_type;
+      typedef typename traits_type::difference_type difference_type;
+
+      if (num_threads <= 1)
+       {
+         __gnu_sequential::sort(begin, end, comp);
+         return;
+       }
 
-    difference_type n = end - begin, pivot_rank;
+      difference_type n = end - begin, pivot_rank;
 
-    if (n <= 1)
-      return;
+      if (n <= 1)
+       return;
 
-    thread_index_t num_threads_left;
+      thread_index_t num_threads_left;
 
-    if ((num_threads % 2) == 1)
-      num_threads_left = num_threads / 2 + 1;
-    else
-      num_threads_left = num_threads / 2;
+      if ((num_threads % 2) == 1)
+       num_threads_left = num_threads / 2 + 1;
+      else
+       num_threads_left = num_threads / 2;
 
-    pivot_rank = n * num_threads_left / num_threads;
+      pivot_rank = n * num_threads_left / num_threads;
 
-    difference_type split = parallel_sort_qs_divide(
-        begin, end, comp, pivot_rank,
-        Settings::sort_qs_num_samples_preset, num_threads);
+      difference_type split =
+       parallel_sort_qs_divide(begin, end, comp, pivot_rank,
+                               Settings::sort_qs_num_samples_preset,
+                               num_threads);
 
 #pragma omp parallel sections
-    {
+      {
 #pragma omp section
-      parallel_sort_qs_conquer(begin, begin + split,
-                               comp, num_threads_left);
+       parallel_sort_qs_conquer(begin, begin + split,
+                                comp, num_threads_left);
 #pragma omp section
-      parallel_sort_qs_conquer(begin + split, end,
-                               comp, num_threads - num_threads_left);
+       parallel_sort_qs_conquer(begin + split, end,
+                                comp, num_threads - num_threads_left);
+      }
     }
-  }
 
 
 
@@ -160,34 +159,33 @@ namespace __gnu_parallel
    *  this part.
    */
   template<typename RandomAccessIterator, typename Comparator>
-  inline void
-  parallel_sort_qs(
-      RandomAccessIterator begin,
-      RandomAccessIterator end,
-      Comparator comp,
-      typename std::iterator_traits<RandomAccessIterator>::difference_type n,
-      int num_threads)
-  {
-    _GLIBCXX_CALL(n)
-
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
-
-    if (n == 0)
-      return;
-
-    // At least one element per processor.
-    if (num_threads > n)
-      num_threads = static_cast<thread_index_t>(n);
-
-    Settings::sort_qs_num_samples_preset = 100;
-
-    // Hard to avoid.
-    omp_set_num_threads(num_threads);
-
-    parallel_sort_qs_conquer(begin, begin + n, comp, num_threads);
-  }
+    void
+    parallel_sort_qs(RandomAccessIterator begin,
+                    RandomAccessIterator end,
+                    Comparator comp, typename std::iterator_traits
+                    <RandomAccessIterator>::difference_type n,
+                    int num_threads)
+    {
+      _GLIBCXX_CALL(n)
+
+      typedef std::iterator_traits<RandomAccessIterator> traits_type;
+      typedef typename traits_type::value_type value_type;
+      typedef typename traits_type::difference_type difference_type;
+
+      if (n == 0)
+       return;
+
+      // At least one element per processor.
+      if (num_threads > n)
+       num_threads = static_cast<thread_index_t>(n);
+
+      Settings::sort_qs_num_samples_preset = 100;
+
+      // Hard to avoid.
+      omp_set_num_threads(num_threads);
+
+      parallel_sort_qs_conquer(begin, begin + n, comp, num_threads);
+    }
 
 } //namespace __gnu_parallel
 
index 266ed0a..ae52372 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -46,229 +46,288 @@ namespace __gnu_parallel
   // http://www.math.keio.ac.jp/matumoto/emt.html
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  class mersenne_twister
-  {
-  public:
-    typedef UIntType result_type;
-    static const int word_size = w;
-    static const int state_size = n;
-    static const int shift_size = m;
-    static const int mask_bits = r;
-    static const UIntType parameter_a = a;
-    static const int output_u = u;
-    static const int output_s = s;
-    static const UIntType output_b = b;
-    static const int output_t = t;
-    static const UIntType output_c = c;
-    static const int output_l = l;
-
-    static const bool has_fixed_range = false;
-
-    mersenne_twister() { seed(); }
+    class mersenne_twister
+    {
+    public:
+      typedef UIntType result_type;
+      static const int word_size = w;
+      static const int state_size = n;
+      static const int shift_size = m;
+      static const int mask_bits = r;
+      static const UIntType parameter_a = a;
+      static const int output_u = u;
+      static const int output_s = s;
+      static const UIntType output_b = b;
+      static const int output_t = t;
+      static const UIntType output_c = c;
+      static const int output_l = l;
+
+      static const bool has_fixed_range = false;
+
+      mersenne_twister() { seed(); }
 
 #if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x520)
-    // Work around overload resolution problem (Gennadiy E. Rozental)
-    explicit mersenne_twister(const UIntType& value)
+      // Work around overload resolution problem (Gennadiy E. Rozental)
+      explicit
+      mersenne_twister(const UIntType& value)
 #else
-      explicit mersenne_twister(UIntType value)
+      explicit
+      mersenne_twister(UIntType value)
 #endif
-    { seed(value); }
-    template<typename It> mersenne_twister(It& first, It last) { seed(first,last); }
+      { seed(value); }
 
-    template<typename Generator>
-    explicit mersenne_twister(Generator & gen) { seed(gen); }
+      template<typename It>
+        mersenne_twister(It& first, It last)
+       { seed(first,last); }
 
-    // compiler-generated copy ctor and assignment operator are fine
+      template<typename Generator>
+        explicit
+        mersenne_twister(Generator & gen)
+       { seed(gen); }
 
-    void seed() { seed(UIntType(5489)); }
+      // compiler-generated copy ctor and assignment operator are fine
+
+      void
+      seed()
+      { seed(UIntType(5489)); }
 
 #if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x520)
-    // Work around overload resolution problem (Gennadiy E. Rozental)
-    void seed(const UIntType& value)
+      // Work around overload resolution problem (Gennadiy E. Rozental)
+      void
+      seed(const UIntType& value)
 #else
-      void seed(UIntType value)
+      void
+      seed(UIntType value)
 #endif
-    {
-      // New seeding algorithm from
+      {
+       // New seeding algorithm from
       // http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html
-      // In the previous versions, MSBs of the seed affected only MSBs of the
-      // state x[].
-      const UIntType mask = ~0u;
-      x[0] = value & mask;
-      for (i = 1; i < n; i++) {
-       // See Knuth "The Art of Computer Programming" Vol. 2, 3rd ed., page 106
-       x[i] = (1812433253UL * (x[i-1] ^ (x[i-1] >> (w-2))) + i) & mask;
+       // In the previous versions, MSBs of the seed affected only MSBs of the
+       // state x[].
+       const UIntType mask = ~0u;
+       x[0] = value & mask;
+       for (i = 1; i < n; ++i)
+         {
+           // See Knuth "The Art of Computer Programming" Vol. 2,
+           // 3rd ed., page 106
+           x[i] = (1812433253UL * (x[i-1] ^ (x[i-1] >> (w-2))) + i) & mask;
+         }
       }
-    }
 
-    // For GCC, moving this function out-of-line prevents inlining, which may
-    // reduce overall object code size.  However, MSVC does not grok
-    // out-of-line definitions of member function templates.
-    template<typename Generator>
-    void seed(Generator & gen)
-    {
-      // I could have used std::generate_n, but it takes "gen" by value
-      for (int j = 0; j < n; j++)
-       x[j] = gen();
-      i = n;
-    }
+      // For GCC, moving this function out-of-line prevents inlining, which may
+      // reduce overall object code size.  However, MSVC does not grok
+      // out-of-line definitions of member function templates.
+      template<typename Generator>
+        void
+        seed(Generator & gen)
+       {
+         // I could have used std::generate_n, but it takes "gen" by value
+         for (int j = 0; j < n; ++j)
+           x[j] = gen();
+         i = n;
+       }
 
-    template<typename It>
-    void seed(It& first, It last)
-    {
-      int j;
-      for (j = 0; j < n && first != last; ++j, ++first)
-       x[j] = *first;
-      i = n;
-      /*    if (first == last && j < n)
-           throw std::invalid_argument("mersenne_twister::seed");*/
-    }
+      template<typename It>
+        void
+        seed(It& first, It last)
+       {
+         int j;
+         for (j = 0; j < n && first != last; ++j, ++first)
+           x[j] = *first;
+         i = n;
+         /*    if (first == last && j < n)
+               throw std::invalid_argument("mersenne_twister::seed");*/
+       }
 
-    result_type min() const { return 0; }
-    result_type max() const
-    {
-      // avoid "left shift count >= with of type" warning
-      result_type res = 0;
-      for (int i = 0; i < w; ++i)
-       res |= (1u << i);
-      return res;
-    }
+      result_type
+      min() const
+      { return 0; }
+      
+      result_type
+      max() const
+      {
+       // avoid "left shift count >= with of type" warning
+       result_type res = 0;
+       for (int i = 0; i < w; ++i)
+         res |= (1u << i);
+       return res;
+      }
 
-    result_type operator()();
-    static bool validation(result_type v) { return val == v; }
+      result_type
+      operator()();
+      
+      static bool
+      validation(result_type v)
+      { return val == v; }
 
 #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
 
-    friend bool operator==(const mersenne_twister& x, const mersenne_twister& y)
-    {
-      for (int j = 0; j < state_size; ++j)
-       if (x.compute(j) != y.compute(j))
-         return false;
-      return true;
-    }
+      friend bool
+      operator==(const mersenne_twister& x, const mersenne_twister& y)
+      {
+       for (int j = 0; j < state_size; ++j)
+         if (x.compute(j) != y.compute(j))
+           return false;
+       return true;
+      }
 
-    friend bool operator!=(const mersenne_twister& x, const mersenne_twister& y)
-    { return !(x == y); }
+      friend bool
+      operator!=(const mersenne_twister& x, const mersenne_twister& y)
+      { return !(x == y); }
 #else
-    // Use a member function; Streamable concept not supported.
-    bool operator==(const mersenne_twister& rhs) const
-    {
-      for (int j = 0; j < state_size; ++j)
-       if (compute(j) != rhs.compute(j))
-         return false;
-      return true;
-    }
+      // Use a member function; Streamable concept not supported.
+      bool
+      operator==(const mersenne_twister& rhs) const
+      {
+       for (int j = 0; j < state_size; ++j)
+         if (compute(j) != rhs.compute(j))
+           return false;
+       return true;
+      }
 
-    bool operator!=(const mersenne_twister& rhs) const
-    { return !(*this == rhs); }
+      bool
+      operator!=(const mersenne_twister& rhs) const
+      { return !(*this == rhs); }
 #endif
 
-  private:
-    // returns x(i-n+index), where index is in 0..n-1
-    UIntType compute(unsigned int index) const
-    {
-      // equivalent to (i-n+index) % 2n, but doesn't produce negative numbers
-      return x[ (i + n + index) % (2*n) ];
-    }
-    void twist(int block);
+    private:
+      // returns x(i-n+index), where index is in 0..n-1
+      UIntType
+      compute(unsigned int index) const
+      {
+       // equivalent to (i-n+index) % 2n, but doesn't produce negative numbers
+       return x[ (i + n + index) % (2*n) ];
+      }
+
+      void
+      twist(int block);
 
-    // state representation: next output is o(x(i))
-    //   x[0]  ... x[k] x[k+1] ... x[n-1]     x[n]     ... x[2*n-1]   represents
-    //  x(i-k) ... x(i) x(i+1) ... x(i-k+n-1) x(i-k-n) ... x[i(i-k-1)]
-    // The goal is to always have x(i-n) ... x(i-1) available for
-    // operator== and save/restore.
+      // state representation: next output is o(x(i))
+      //  x[0]  ... x[k] x[k+1] ... x[n-1]     x[n]     ... x[2*n-1] represents
+      //  x(i-k) ... x(i) x(i+1) ... x(i-k+n-1) x(i-k-n) ... x[i(i-k-1)]
+      // The goal is to always have x(i-n) ... x(i-1) available for
+      // operator== and save/restore.
 
-    UIntType x[2*n];
-    int i;
+      UIntType x[2*n];
+      int i;
   };
 
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
   //  A definition is required even for integral static constants
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  const bool mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::has_fixed_range;
+    const bool
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::has_fixed_range;
+
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::state_size;
+    const int
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::state_size;
+
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::shift_size;
+    const int
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::shift_size;
+  
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::mask_bits;
+    const int
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::mask_bits;
+  
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  const UIntType mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::parameter_a;
+    const UIntType
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::parameter_a;
+  
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_u;
+    const int
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_u;
+  
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_s;
+    const int
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_s;
+  
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  const UIntType mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_b;
+    const UIntType
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_b;
+  
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_t;
+    const int
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_t;
+  
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  const UIntType mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_c;
+    const UIntType
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_c;
+  
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_l;
+    const int
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_l;
 #endif
 
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  void mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::twist(int block)
+  void
+  mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::twist(int block)
   {
     const UIntType upper_mask = (~0u) << r;
     const UIntType lower_mask = ~upper_mask;
 
-    if (block == 0) {
-      for (int j = n; j < 2*n; j++) {
-       UIntType y = (x[j-n] & upper_mask) | (x[j-(n-1)] & lower_mask);
-       x[j] = x[j-(n-m)] ^ (y >> 1) ^ (y&1 ? a : 0);
+    if (block == 0)
+      {
+       for (int j = n; j < 2*n; ++j)
+         {
+           UIntType y = (x[j-n] & upper_mask) | (x[j-(n-1)] & lower_mask);
+           x[j] = x[j-(n-m)] ^ (y >> 1) ^ (y&1 ? a : 0);
+         }
       }
-    } else if (block == 1) {
-      // split loop to avoid costly modulo operations
-      {  // extra scope for MSVC brokenness w.r.t. for scope
-       for (int j = 0; j < n-m; j++) {
-         UIntType y = (x[j+n] & upper_mask) | (x[j+n+1] & lower_mask);
-         x[j] = x[j+n+m] ^ (y >> 1) ^ (y&1 ? a : 0);
+    else if (block == 1)
+      {
+       // split loop to avoid costly modulo operations
+       {  // extra scope for MSVC brokenness w.r.t. for scope
+         for (int j = 0; j < n-m; ++j)
+           {
+             UIntType y = (x[j+n] & upper_mask) | (x[j+n+1] & lower_mask);
+             x[j] = x[j+n+m] ^ (y >> 1) ^ (y&1 ? a : 0);
+           }
        }
+       
+       for (int j = n-m; j < n-1; ++j)
+         {
+           UIntType y = (x[j+n] & upper_mask) | (x[j+n+1] & lower_mask);
+           x[j] = x[j-(n-m)] ^ (y >> 1) ^ (y&1 ? a : 0);
+         }
+       // last iteration
+       UIntType y = (x[2*n-1] & upper_mask) | (x[0] & lower_mask);
+       x[n-1] = x[m-1] ^ (y >> 1) ^ (y&1 ? a : 0);
+       i = 0;
       }
-
-      for (int j = n-m; j < n-1; j++) {
-       UIntType y = (x[j+n] & upper_mask) | (x[j+n+1] & lower_mask);
-       x[j] = x[j-(n-m)] ^ (y >> 1) ^ (y&1 ? a : 0);
-      }
-      // last iteration
-      UIntType y = (x[2*n-1] & upper_mask) | (x[0] & lower_mask);
-      x[n-1] = x[m-1] ^ (y >> 1) ^ (y&1 ? a : 0);
-      i = 0;
-    }
   }
 
   template<typename UIntType, int w, int n, int m, int r, UIntType a, int u,
           int s, UIntType b, int t, UIntType c, int l, UIntType val>
-  inline typename mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::result_type
-  mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::operator()()
-  {
-    if (i == n)
-      twist(0);
-    else if (i >= 2*n)
-      twist(1);
-    // Step 4
-    UIntType z = x[i];
-    ++i;
-    z ^= (z >> u);
-    z ^= ((z << s) & b);
-    z ^= ((z << t) & c);
-    z ^= (z >> l);
-    return z;
-  }
+    inline
+    typename mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::result_type
+    mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::operator()()
+    {
+      if (i == n)
+       twist(0);
+      else if (i >= 2*n)
+       twist(1);
+      // Step 4
+      UIntType z = x[i];
+      ++i;
+      z ^= (z >> u);
+      z ^= ((z << s) & b);
+      z ^= ((z << t) & c);
+      z ^= (z >> l);
+      return z;
+    }
 
 
   typedef mersenne_twister<uint32,32,351,175,19,0xccab8ee7,11,
@@ -286,14 +345,15 @@ namespace __gnu_parallel
     uint64 supremum, RAND_SUP;
     double supremum_reciprocal, RAND_SUP_REC;
 
-    uint64 cache;      /* assumed to be twice as long as the usual random number */
-    int bits_left;     /* bit results */
+    uint64 cache;  /* assumed to be twice as long as the usual random number */
+    int bits_left; /* bit results */
 
-    static inline uint32 scale_down(uint64 x,
+    static uint32
+    scale_down(uint64 x,
 #if _GLIBCXX_SCALE_DOWN_FPU
-                                   uint64 /*supremum*/, double supremum_reciprocal)
+              uint64 /*supremum*/, double supremum_reciprocal)
 #else
-      uint64 supremum, double /*supremum_reciprocal*/)
+               uint64 supremum, double /*supremum_reciprocal*/)
 #endif
        {
 #if _GLIBCXX_SCALE_DOWN_FPU
@@ -303,82 +363,81 @@ namespace __gnu_parallel
 #endif
        }
 
-public:
-  /** @brief Default constructor. Seed with 0. */
-  random_number() :
-    mt(0),
-    supremum(0x100000000ULL),
-    RAND_SUP(1ULL << (sizeof(uint32) * 8)),
-    supremum_reciprocal((double)supremum / (double)RAND_SUP),
-    RAND_SUP_REC(1.0 / (double)RAND_SUP),
-    cache(0), bits_left(0)
-  {
-  }
-
-  /** @brief Constructor.
-   *  @param seed Random seed.
-   *  @param supremum Generate integer random numbers in the interval @c [0,supremum). */
-  random_number(uint32 seed, uint64 supremum = 0x100000000ULL) :
-    mt(seed),
-    supremum(supremum),
-    RAND_SUP(1ULL << (sizeof(uint32) * 8)),
-    supremum_reciprocal((double)supremum / (double)RAND_SUP),
-    RAND_SUP_REC(1.0 / (double)RAND_SUP),
-    cache(0), bits_left(0)
-  {
-  }
-
-  /** @brief Generate unsigned random 32-bit integer. */
-  inline uint32 operator()()
-  {
-    return scale_down(mt(), supremum, supremum_reciprocal);
-  }
-
-  /** @brief Generate unsigned random 32-bit integer in the interval @c [0,local_supremum). */
-  inline uint32 operator()(uint64 local_supremum)
-  {
-    return scale_down(mt(), local_supremum, (double)local_supremum * RAND_SUP_REC);
-  }
-
-  /** @brief Set the random seed.
-   *  @param seed to set. */
-  inline void set_seed(uint32 seed)
-  {
-    mt.seed(seed);
-    cache = mt();
-    bits_left = 32;
-  }
+  public:
+    /** @brief Default constructor. Seed with 0. */
+    random_number()
+    : mt(0), supremum(0x100000000ULL),
+      RAND_SUP(1ULL << (sizeof(uint32) * 8)),
+      supremum_reciprocal((double)supremum / (double)RAND_SUP),
+      RAND_SUP_REC(1.0 / (double)RAND_SUP),
+      cache(0), bits_left(0) { }
+
+    /** @brief Constructor.
+     *  @param seed Random seed.
+     *  @param supremum Generate integer random numbers in the
+     *                  interval @c [0,supremum). */
+    random_number(uint32 seed, uint64 supremum = 0x100000000ULL)
+    : mt(seed), supremum(supremum),
+      RAND_SUP(1ULL << (sizeof(uint32) * 8)),
+      supremum_reciprocal((double)supremum / (double)RAND_SUP),
+      RAND_SUP_REC(1.0 / (double)RAND_SUP),
+      cache(0), bits_left(0) { }
+
+    /** @brief Generate unsigned random 32-bit integer. */
+    uint32
+    operator()()
+    { return scale_down(mt(), supremum, supremum_reciprocal); }
+
+    /** @brief Generate unsigned random 32-bit integer in the
+       interval @c [0,local_supremum). */
+    uint32
+    operator()(uint64 local_supremum)
+    {
+      return scale_down(mt(), local_supremum,
+                       (double)local_supremum * RAND_SUP_REC);
+    }
 
-  /** @brief Generate a number of random bits, compile-time parameter. */
-  template<int bits>
-  inline unsigned long genrand_bits()
-  {
-    unsigned long res = cache & ((1 << bits) - 1);
-    cache = cache >> bits;
-    bits_left -= bits;
-    if (bits_left < 32)
-      {
-       cache |= (((uint64)mt()) << bits_left);
-       bits_left += 32;
-      }
-    return res;
-  }
+    /** @brief Set the random seed.
+     *  @param seed to set. */
+    void
+    set_seed(uint32 seed)
+    {
+      mt.seed(seed);
+      cache = mt();
+      bits_left = 32;
+    }
 
-  /** @brief Generate a number of random bits, run-time parameter.
-   *  @param bits Number of bits to generate. */
-  inline unsigned long genrand_bits(int bits)
-  {
-    unsigned long res = cache & ((1 << bits) - 1);
-    cache = cache >> bits;
-    bits_left -= bits;
-    if (bits_left < 32)
+    /** @brief Generate a number of random bits, compile-time parameter. */
+    template<int bits>
+      unsigned long
+      genrand_bits()
       {
-       cache |= (((uint64)mt()) << bits_left);
-       bits_left += 32;
+       unsigned long res = cache & ((1 << bits) - 1);
+       cache = cache >> bits;
+       bits_left -= bits;
+       if (bits_left < 32)
+         {
+           cache |= (((uint64)mt()) << bits_left);
+           bits_left += 32;
+         }
+       return res;
       }
-    return res;
-  }
 
+    /** @brief Generate a number of random bits, run-time parameter.
+     *  @param bits Number of bits to generate. */
+    unsigned long
+    genrand_bits(int bits)
+    {
+      unsigned long res = cache & ((1 << bits) - 1);
+      cache = cache >> bits;
+      bits_left -= bits;
+      if (bits_left < 32)
+       {
+         cache |= (((uint64)mt()) << bits_left);
+         bits_left += 32;
+       }
+      return res;
+    }
 };
 
 } // namespace __gnu_parallel
index dd086ba..348a3a3 100644 (file)
@@ -124,7 +124,7 @@ template<typename RandomNumberGenerator>
 /** @brief Random shuffle code executed by each thread.
   *  @param pus Array of thread-local data records. */
 template<typename RandomAccessIterator, typename RandomNumberGenerator>
-  inline void 
+  void 
   parallel_random_shuffle_drs_pu(DRSSorterPU<RandomAccessIterator,
                                  RandomNumberGenerator>* pus)
   {
@@ -213,8 +213,8 @@ template<typename RandomAccessIterator, typename RandomNumberGenerator>
         thread_index_t target_p = bin_proc[target_bin];
 
         // Last column [d->num_threads] stays unchanged.
-        ::new(&(temporaries[target_p][dist[target_bin + 1]++])) value_type(
-              *(source + i + start));
+        ::new(&(temporaries[target_p][dist[target_bin + 1]++]))
+           value_type(*(source + i + start));
       }
 
     delete[] oracles;
@@ -260,13 +260,13 @@ template<typename T>
   *  @param rng Random number generator to use.
   */
 template<typename RandomAccessIterator, typename RandomNumberGenerator>
-  inline void
-  parallel_random_shuffle_drs(
-      RandomAccessIterator begin,
-      RandomAccessIterator end,
-      typename std::iterator_traits<RandomAccessIterator>::difference_type n,
-      thread_index_t num_threads,
-      RandomNumberGenerator& rng)
+  void
+  parallel_random_shuffle_drs(RandomAccessIterator begin,
+                             RandomAccessIterator end,
+                             typename std::iterator_traits
+                             <RandomAccessIterator>::difference_type n,
+                             thread_index_t num_threads,
+                             RandomNumberGenerator& rng)
   {
     typedef std::iterator_traits<RandomAccessIterator> traits_type;
     typedef typename traits_type::value_type value_type;
@@ -393,7 +393,7 @@ template<typename RandomAccessIterator, typename RandomNumberGenerator>
  *  @param rng Random number generator to use.
  */
 template<typename RandomAccessIterator, typename RandomNumberGenerator>
-  inline void
+  void
   sequential_random_shuffle(RandomAccessIterator begin, 
                             RandomAccessIterator end,
                             RandomNumberGenerator& rng)
index d917b12..86bd2b8 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -81,10 +81,9 @@ template<typename RandomAccessIterator, typename _DifferenceTp>
    *  @param end2 End iterator of second sequence.
    *  @param pred Find predicate.
    *  @return Place of finding in first sequences. */
-template<
-    typename _RandomAccessIterator1,
-    typename _RandomAccessIterator2,
-    typename Pred>
+template<typename _RandomAccessIterator1,
+        typename _RandomAccessIterator2,
+        typename Pred>
   _RandomAccessIterator1
   search_template(_RandomAccessIterator1 begin1, _RandomAccessIterator1 end1,
                   _RandomAccessIterator2 begin2, _RandomAccessIterator2 end2,
index 7be3127..50c28d4 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -48,7 +48,7 @@
 namespace __gnu_parallel
 {
 template<typename InputIterator, typename OutputIterator>
-  inline OutputIterator
+  OutputIterator
   copy_tail(std::pair<InputIterator, InputIterator> b,
             std::pair<InputIterator, InputIterator> e, OutputIterator r)
   {
@@ -68,10 +68,9 @@ template<typename InputIterator, typename OutputIterator>
     return r;
   }
 
-template<
-    typename InputIterator,
-    typename OutputIterator,
-    typename Comparator>
+template<typename InputIterator,
+        typename OutputIterator,
+        typename Comparator>
   struct symmetric_difference_func
   {
     typedef std::iterator_traits<InputIterator> traits_type;
@@ -82,9 +81,10 @@ template<
 
     Comparator comp;
 
-    inline OutputIterator invoke(InputIterator a, InputIterator b,
-                                  InputIterator c, InputIterator d,
-                                  OutputIterator r) const
+    OutputIterator
+    invoke(InputIterator a, InputIterator b,
+          InputIterator c, InputIterator d,
+          OutputIterator r) const
     {
       while (a != b && c != d)
         {
@@ -109,9 +109,9 @@ template<
       return std::copy(c, d, std::copy(a, b, r));
     }
 
-    inline difference_type
-    count(InputIterator a, InputIterator b, InputIterator c, InputIterator d)
-        const
+    difference_type
+    count(InputIterator a, InputIterator b,
+         InputIterator c, InputIterator d) const
     {
       difference_type counter = 0;
 
@@ -137,21 +137,19 @@ template<
       return counter + (b - a) + (d - c);
     }
 
-    inline OutputIterator
+    OutputIterator
     first_empty(InputIterator c, InputIterator d, OutputIterator out) const
     { return std::copy(c, d, out); }
 
-    inline OutputIterator
+    OutputIterator
     second_empty(InputIterator a, InputIterator b, OutputIterator out) const
     { return std::copy(a, b, out); }
-
   };
 
 
-template<
-    typename InputIterator,
-    typename OutputIterator,
-    typename Comparator>
+template<typename InputIterator,
+        typename OutputIterator,
+        typename Comparator>
   struct difference_func
   {
     typedef std::iterator_traits<InputIterator> traits_type;
@@ -162,7 +160,7 @@ template<
 
     Comparator comp;
 
-    inline OutputIterator
+    OutputIterator
     invoke(InputIterator a, InputIterator b, InputIterator c, InputIterator d,
           OutputIterator r) const
     {
@@ -185,9 +183,9 @@ template<
       return std::copy(a, b, r);
     }
 
-    inline difference_type
-    count(InputIterator a, InputIterator b, InputIterator c, InputIterator d)
-        const
+    difference_type
+    count(InputIterator a, InputIterator b,
+         InputIterator c, InputIterator d) const
     {
       difference_type counter = 0;
 
@@ -217,10 +215,9 @@ template<
   };
 
 
-template<
-    typename InputIterator,
-    typename OutputIterator,
-    typename Comparator>
+template<typename InputIterator,
+        typename OutputIterator,
+        typename Comparator>
   struct intersection_func
   {
     typedef std::iterator_traits<InputIterator> traits_type;
@@ -231,7 +228,7 @@ template<
 
     Comparator comp;
 
-    inline OutputIterator
+    OutputIterator
     invoke(InputIterator a, InputIterator b, InputIterator c, InputIterator d,
           OutputIterator r) const
     {
@@ -253,9 +250,9 @@ template<
       return r;
     }
 
-    inline difference_type
-    count(InputIterator a, InputIterator b, InputIterator c, InputIterator d)
-        const
+    difference_type
+    count(InputIterator a, InputIterator b,
+         InputIterator c, InputIterator d) const
     {
       difference_type counter = 0;
 
@@ -289,13 +286,13 @@ template<class InputIterator, class OutputIterator, class Comparator>
   struct union_func
   {
     typedef typename std::iterator_traits<InputIterator>::difference_type
-        difference_type;
+    difference_type;
 
     union_func(Comparator c) : comp(c) {}
 
     Comparator comp;
 
-    inline OutputIterator
+    OutputIterator
     invoke(InputIterator a, const InputIterator b, InputIterator c,
           const InputIterator d, OutputIterator r) const
     {
@@ -322,9 +319,9 @@ template<class InputIterator, class OutputIterator, class Comparator>
       return std::copy(c, d, std::copy(a, b, r));
     }
 
-    inline difference_type
-    count(InputIterator a, InputIterator b, InputIterator c, InputIterator d)
-        const
+    difference_type
+    count(InputIterator a, InputIterator b,
+         InputIterator c, InputIterator d) const
     {
       difference_type counter = 0;
 
@@ -356,10 +353,9 @@ template<class InputIterator, class OutputIterator, class Comparator>
     { return std::copy(a, b, out); }
   };
 
-template<
-    typename InputIterator,
-    typename OutputIterator,
-    typename Operation>
+template<typename InputIterator,
+        typename OutputIterator,
+        typename Operation>
   OutputIterator
   parallel_set_operation(InputIterator begin1, InputIterator end1,
                          InputIterator begin2, InputIterator end2,
@@ -480,11 +476,10 @@ template<
   }
 
 
-template<
-    typename InputIterator,
-    typename OutputIterator,
-    typename Comparator>
-  OutputIterator
+template<typename InputIterator,
+        typename OutputIterator,
+        typename Comparator>
+  inline OutputIterator
   parallel_set_union(InputIterator begin1, InputIterator end1,
                      InputIterator begin2, InputIterator end2,
                      OutputIterator result, Comparator comp)
@@ -493,11 +488,10 @@ template<
         union_func< InputIterator, OutputIterator, Comparator>(comp));
   }
 
-template<
-    typename InputIterator,
-    typename OutputIterator,
-    typename Comparator>
-  OutputIterator
+template<typename InputIterator,
+        typename OutputIterator,
+        typename Comparator>
+  inline OutputIterator
   parallel_set_intersection(InputIterator begin1, InputIterator end1,
                             InputIterator begin2, InputIterator end2,
                             OutputIterator result, Comparator comp)
@@ -508,7 +502,7 @@ template<
 
 
 template<typename InputIterator, typename OutputIterator>
-  OutputIterator
+  inline OutputIterator
   set_intersection(InputIterator begin1, InputIterator end1,
                    InputIterator begin2, InputIterator end2,
                    OutputIterator result)
@@ -517,14 +511,13 @@ template<typename InputIterator, typename OutputIterator>
     typedef typename traits_type::value_type value_type;
 
     return set_intersection(begin1, end1, begin2, end2, result,
-                  std::less<value_type>());
+                           std::less<value_type>());
   }
 
-template<
-    typename InputIterator,
-    typename OutputIterator,
-    typename Comparator>
-  OutputIterator
+template<typename InputIterator,
+        typename OutputIterator,
+        typename Comparator>
+  inline OutputIterator
   parallel_set_difference(InputIterator begin1, InputIterator end1,
                           InputIterator begin2, InputIterator end2,
                           OutputIterator result, Comparator comp)
@@ -533,11 +526,10 @@ template<
         difference_func<InputIterator, OutputIterator, Comparator>(comp));
   }
 
-template<
-    typename InputIterator,
-    typename OutputIterator,
-    typename Comparator>
-  OutputIterator
+template<typename InputIterator,
+        typename OutputIterator,
+        typename Comparator>
+  inline OutputIterator
   parallel_set_symmetric_difference(InputIterator begin1, InputIterator end1,
                                     InputIterator begin2, InputIterator end2,
                                     OutputIterator result, Comparator comp)
index 5cfc6a0..a06227b 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -33,7 +33,8 @@
  *  whether to use parallelized algorithms.
  *  This file is a GNU parallel extension to the Standard C++ Library.
  *
- *  @section parallelization_decision  The decision whether to run an algorithm in parallel.
+ *  @section parallelization_decision  The decision whether to run
+ *                                     an algorithm in parallel.
  *
  *  There are several ways the user can switch on and off the 
  *  parallel execution of an algorithm, both at compile- and 
   * __gnu_parallel::Settings::force_parallel, i. e. usually a decision based on
   * the input size.
   */
-#define _GLIBCXX_PARALLEL_CONDITION(c) (!(__gnu_parallel::Settings::force_sequential) && ((__gnu_parallel::get_max_threads() > 1 && (c)) || __gnu_parallel::Settings::force_parallel))
+#define _GLIBCXX_PARALLEL_CONDITION(c) \
+(!(__gnu_parallel::Settings::force_sequential) \
+ && ((__gnu_parallel::get_max_threads() > 1 \
+      && (c)) || __gnu_parallel::Settings::force_parallel))
 
 namespace __gnu_parallel
 {
@@ -131,7 +135,8 @@ namespace
     /** @brief Different merging algorithms: bubblesort-alike,
        loser-tree variants, enum sentinel */
     enum MultiwayMergeAlgorithm
-    { BUBBLE, LOSER_TREE_EXPLICIT, LOSER_TREE, LOSER_TREE_COMBINED, LOSER_TREE_SENTINEL, MWM_ALGORITHM_LAST };
+    { BUBBLE, LOSER_TREE_EXPLICIT, LOSER_TREE, LOSER_TREE_COMBINED,
+      LOSER_TREE_SENTINEL, MWM_ALGORITHM_LAST };
 
     /** @brief Different splitting strategies for sorting/merging:
        by sampling, exact */
@@ -340,7 +345,8 @@ namespace
   volatile sequence_index_t Settings::partition_chunk_size = 1000;
   volatile double Settings::partition_chunk_share = 0.0;
   volatile unsigned int Settings::adjacent_difference_minimal_n = 1000;
-  volatile  Settings::PartialSumAlgorithm Settings::partial_sum_algorithm = Settings::LINEAR;
+  volatile  Settings::PartialSumAlgorithm Settings::
+  partial_sum_algorithm = Settings::LINEAR;
   volatile unsigned int Settings::partial_sum_minimal_n = 1000;
   volatile float Settings::partial_sum_dilatation = 1.0f;
   volatile unsigned int Settings::random_shuffle_minimal_n = 1000;
@@ -352,10 +358,13 @@ namespace
 
   // unique copy
   volatile sequence_index_t Settings::unique_copy_minimal_n = 10000;
-  volatile  Settings::MultiwayMergeAlgorithm Settings::multiway_merge_algorithm = Settings::LOSER_TREE;
-  volatile  Settings::Splitting Settings::multiway_merge_splitting = Settings::EXACT;
+  volatile  Settings::MultiwayMergeAlgorithm Settings::
+  multiway_merge_algorithm = Settings::LOSER_TREE;
+  volatile  Settings::Splitting Settings::multiway_merge_splitting =
+    Settings::EXACT;
   volatile unsigned int Settings::multiway_merge_oversampling = 10;
-  volatile  Settings::FindDistribution Settings::find_distribution = Settings::CONSTANT_SIZE_BLOCKS;
+  volatile  Settings::FindDistribution Settings::find_distribution =
+    Settings::CONSTANT_SIZE_BLOCKS;
   volatile sequence_index_t Settings::find_sequential_search_size = 256;
   volatile sequence_index_t Settings::find_initial_block_size = 256;
   volatile sequence_index_t Settings::find_maximum_block_size = 8192;
@@ -375,7 +384,8 @@ namespace
   volatile sequence_index_t Settings::set_union_minimal_n = 1000;
   volatile sequence_index_t Settings::set_intersection_minimal_n = 1000;
   volatile sequence_index_t Settings::set_difference_minimal_n = 1000;
-  volatile sequence_index_t Settings::set_symmetric_difference_minimal_n = 1000;
+  volatile sequence_index_t Settings::set_symmetric_difference_minimal_n =
+    1000;
   volatile unsigned long long Settings::L1_cache_size = 16 << 10;
   volatile unsigned long long Settings::L2_cache_size = 256 << 10;
   volatile unsigned int Settings::TLB_size = 128;
index 6b20edd..5dc3470 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -69,36 +69,37 @@ namespace __gnu_parallel
    *  @callgraph 
    */
   template<typename RandomAccessIterator, typename Comparator>
-  inline void
-  parallel_sort(RandomAccessIterator begin, RandomAccessIterator end,
-               Comparator comp, bool stable)
-  {
-    _GLIBCXX_CALL(end - begin)
-    typedef std::iterator_traits<RandomAccessIterator> traits_type;
-    typedef typename traits_type::value_type value_type;
-    typedef typename traits_type::difference_type difference_type;
-
-    if (begin != end)
-      {
-       difference_type n = end - begin;
-
-       if (false) ;
+    inline void
+    parallel_sort(RandomAccessIterator begin, RandomAccessIterator end,
+                 Comparator comp, bool stable)
+    {
+      _GLIBCXX_CALL(end - begin)
+      typedef std::iterator_traits<RandomAccessIterator> traits_type;
+      typedef typename traits_type::value_type value_type;
+      typedef typename traits_type::difference_type difference_type;
+
+      if (begin != end)
+       {
+         difference_type n = end - begin;
+
+         if (false) ;
 #if _GLIBCXX_MERGESORT
-       else if (Settings::sort_algorithm == Settings::MWMS || stable)
-         parallel_sort_mwms(begin, end, comp, n, get_max_threads(), stable);
+         else if (Settings::sort_algorithm == Settings::MWMS || stable)
+           parallel_sort_mwms(begin, end, comp, n, get_max_threads(), stable);
 #endif
 #if _GLIBCXX_QUICKSORT
-       else if (Settings::sort_algorithm == Settings::QS && !stable)
-         parallel_sort_qs(begin, end, comp, n, get_max_threads());
+         else if (Settings::sort_algorithm == Settings::QS && !stable)
+           parallel_sort_qs(begin, end, comp, n, get_max_threads());
 #endif
 #if _GLIBCXX_BAL_QUICKSORT
-       else if (Settings::sort_algorithm == Settings::QS_BALANCED && !stable)
-         parallel_sort_qsb(begin, end, comp, n, get_max_threads());
+         else if (Settings::sort_algorithm == Settings::QS_BALANCED
+                  && !stable)
+           parallel_sort_qsb(begin, end, comp, n, get_max_threads());
 #endif
-       else
-         __gnu_sequential::sort(begin, end, comp);
-      }
-  }
+         else
+           __gnu_sequential::sort(begin, end, comp);
+       }
+    }
 } // end namespace __gnu_parallel
 
 #endif
index eed0b92..52589b8 100644 (file)
@@ -77,11 +77,11 @@ namespace __gnu_parallel
       component, if present. Set kind component.
    *  @param T Simple type, nothing to unconst */
   template<typename T>
-  struct unconst_first_component
-  {
-    /** @brief New type after removing the const */
-    typedef T type;
-  };
+    struct unconst_first_component
+    {
+      /** @brief New type after removing the const */
+      typedef T type;
+    };
 
   /** @brief Helper class: remove the const modifier from the first
       component, if present. Map kind component
@@ -89,11 +89,11 @@ namespace __gnu_parallel
    *  @param Load Second component
    *  @sa unconst_first_component */
   template<typename Key, typename Load>
-  struct unconst_first_component<std::pair<const Key, Load> >
-  {
-    /** @brief New type after removing the const */
-    typedef std::pair<Key, Load> type;
-  };
+    struct unconst_first_component<std::pair<const Key, Load> >
+    {
+      /** @brief New type after removing the const */
+      typedef std::pair<Key, Load> type;
+    };
 
   /** @brief Helper class: set the appropriate comparator to deal with
    * repetitions. Comparator for unique dictionaries.
@@ -103,24 +103,23 @@ namespace __gnu_parallel
    *  @param _Key Keys to compare
    *  @param _Compare Comparator equal to conceptual < */
   template<typename _Key, typename _Compare>
-  struct StrictlyLess : public std::binary_function<_Key, _Key, bool>
-  {
-    /** @brief Comparator equal to conceptual < */
-    _Compare c;
+    struct StrictlyLess : public std::binary_function<_Key, _Key, bool>
+    {
+      /** @brief Comparator equal to conceptual < */
+      _Compare c;
 
-    /** @brief Constructor given a Comparator */
-    StrictlyLess(const _Compare& _c) : c(_c) { }
+      /** @brief Constructor given a Comparator */
+      StrictlyLess(const _Compare& _c) : c(_c) { }
 
-    /** @brief Copy constructor */
-    StrictlyLess(const StrictlyLess<_Key, _Compare>& strictly_less)
-    : c(strictly_less.c) { }
+      /** @brief Copy constructor */
+      StrictlyLess(const StrictlyLess<_Key, _Compare>& strictly_less)
+      : c(strictly_less.c) { }
 
-    /** @brief Operator() */
-    bool operator()(const _Key& k1, const _Key& k2) const
-    {
-      return c(k1, k2);
-    }
-  };
+      /** @brief Operator() */
+      bool
+      operator()(const _Key& k1, const _Key& k2) const
+      { return c(k1, k2); }
+    };
 
   /** @brief Helper class: set the appropriate comparator to deal with
    * repetitions. Comparator for non-unique dictionaries.
@@ -130,22 +129,23 @@ namespace __gnu_parallel
    *  @param _Key Keys to compare
    *  @param _Compare Comparator equal to conceptual <= */
   template<typename _Key, typename _Compare>
-  struct LessEqual : public std::binary_function<_Key, _Key, bool>
-  {
-    /** @brief Comparator equal to conceptual < */
-    _Compare c;
+    struct LessEqual : public std::binary_function<_Key, _Key, bool>
+    {
+      /** @brief Comparator equal to conceptual < */
+      _Compare c;
 
-    /** @brief Constructor given a Comparator */
-    LessEqual(const _Compare& _c) : c(_c) { }
+      /** @brief Constructor given a Comparator */
+      LessEqual(const _Compare& _c) : c(_c) { }
 
-    /** @brief Copy constructor */
-    LessEqual(const LessEqual<_Key, _Compare>& less_equal)
-    : c(less_equal.c) { }
+      /** @brief Copy constructor */
+      LessEqual(const LessEqual<_Key, _Compare>& less_equal)
+      : c(less_equal.c) { }
 
-    /** @brief Operator() */
-    bool operator()(const _Key& k1, const _Key& k2) const
-    { return !c(k2, k1); }
-  };
+      /** @brief Operator() */
+      bool
+      operator()(const _Key& k1, const _Key& k2) const
+      { return !c(k2, k1); }
+    };
 
 
   /** @brief Parallel red-black tree.
@@ -240,28 +240,28 @@ namespace __gnu_parallel
      * @param __last Last element of the input
      */
     template<typename _InputIterator>
-    void
-    _M_insert_unique(_InputIterator __first, _InputIterator __last)
-    {
-      if (__first==__last) return;
-      if (_GLIBCXX_PARALLEL_CONDITION(true))
-       if (base_type::_M_impl._M_node_count == 0)
-         {
-           _M_bulk_insertion_construction(__first, __last, true, 
-                                          strictly_less);
-           _GLIBCXX_PARALLEL_ASSERT(rb_verify());
-         }
+      void
+      _M_insert_unique(_InputIterator __first, _InputIterator __last)
+      {
+       if (__first == __last)
+         return;
+       
+       if (_GLIBCXX_PARALLEL_CONDITION(true))
+         if (base_type::_M_impl._M_node_count == 0)
+           {
+             _M_bulk_insertion_construction(__first, __last, true, 
+                                            strictly_less);
+             _GLIBCXX_PARALLEL_ASSERT(rb_verify());
+           }
+         else
+           {
+             _M_bulk_insertion_construction(__first, __last, false, 
+                                            strictly_less);
+             _GLIBCXX_PARALLEL_ASSERT(rb_verify());
+           }
        else
-         {
-           _M_bulk_insertion_construction(__first, __last, false, 
-                                          strictly_less);
-           _GLIBCXX_PARALLEL_ASSERT(rb_verify());
-         }
-      else
-       {
          base_type::_M_insert_unique(__first, __last);
-       }
-    }
+      }
 
     /** @brief Parallel replacement of the sequential
      * std::_Rb_tree::_M_insert_equal()
@@ -272,19 +272,21 @@ namespace __gnu_parallel
      * @param __first First element of the input
      * @param __last Last element of the input         */
     template<typename _InputIterator>
-    void
-    _M_insert_equal(_InputIterator __first, _InputIterator __last)
-    {
-      if (__first==__last) return;
-      if (_GLIBCXX_PARALLEL_CONDITION(true))
-       if (base_type::_M_impl._M_node_count == 0)
-         _M_bulk_insertion_construction(__first, __last, true, less_equal);
+      void
+      _M_insert_equal(_InputIterator __first, _InputIterator __last)
+      {
+       if (__first == __last)
+         return;
+      
+       if (_GLIBCXX_PARALLEL_CONDITION(true))
+         if (base_type::_M_impl._M_node_count == 0)
+           _M_bulk_insertion_construction(__first, __last, true, less_equal);
+         else
+           _M_bulk_insertion_construction(__first, __last, false, less_equal);
        else
-         _M_bulk_insertion_construction(__first, __last, false, less_equal);
-      else
-       base_type::_M_insert_equal(__first, __last);
-      _GLIBCXX_PARALLEL_ASSERT(rb_verify());
-    }
+         base_type::_M_insert_equal(__first, __last);
+       _GLIBCXX_PARALLEL_ASSERT(rb_verify());
+      }
 
   private:
 
@@ -295,274 +297,273 @@ namespace __gnu_parallel
      * @param ranker Calculates the position of a node in an array of nodes
      */
     template<typename ranker>
-    class nodes_initializer
-    {
-      /** @brief Renaming of tree size_type */
+      class nodes_initializer
+      {
+       /** @brief Renaming of tree size_type */
       
-      typedef _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc> tree_type;
-      typedef typename tree_type::size_type size_type;
-    public:
+       typedef _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc> tree_type;
+       typedef typename tree_type::size_type size_type;
+      public:
 
-      /** @brief mask[%i]= 0..01..1, where the number of 1s is %i+1 */
-      size_type mask[sizeof(size_type)*8];
+       /** @brief mask[%i]= 0..01..1, where the number of 1s is %i+1 */
+       size_type mask[sizeof(size_type)*8];
 
-      /** @brief Array of nodes (initial address)       */
-      const _Rb_tree_node_ptr* r_init;
+       /** @brief Array of nodes (initial address)      */
+       const _Rb_tree_node_ptr* r_init;
 
-      /** @brief Total number of (used) nodes */
-      size_type n;
+       /** @brief Total number of (used) nodes */
+       size_type n;
 
-      /** @brief Rank of the last tree node that can be calculated
-         taking into account a complete tree
-      */
-      size_type splitting_point;
+       /** @brief Rank of the last tree node that can be calculated
+           taking into account a complete tree
+       */
+       size_type splitting_point;
 
-      /** @brief Rank of the tree root */
-      size_type rank_root;
+       /** @brief Rank of the tree root */
+       size_type rank_root;
 
-      /** @brief Height of the tree */
-      int height;
+       /** @brief Height of the tree */
+       int height;
 
-      /** @brief Number of threads into which divide the work */
-      const thread_index_t num_threads;
+       /** @brief Number of threads into which divide the work */
+       const thread_index_t num_threads;
 
-      /** @brief Helper object to mind potential gaps in r_init */
-      const ranker& rank;
+       /** @brief Helper object to mind potential gaps in r_init */
+       const ranker& rank;
 
-      /** @brief Constructor
-       * @param r Array of nodes
-       * @param _n Total number of (used) nodes
-       * @param _num_threads Number of threads into which divide the work
-       * @param _rank Helper object to mind potential gaps in @c r_init */
-      nodes_initializer(const _Rb_tree_node_ptr* r, const size_type _n, 
-                       const thread_index_t _num_threads, const ranker& _rank):
-       r_init(r),
-       n(_n),
-       num_threads(_num_threads),
-       rank(_rank)
-      {
-       height = log2(n);
-       splitting_point = 2 * (n - ((1 << height) - 1)) -1;
+       /** @brief Constructor
+        * @param r Array of nodes
+        * @param _n Total number of (used) nodes
+        * @param _num_threads Number of threads into which divide the work
+        * @param _rank Helper object to mind potential gaps in @c r_init */
+       nodes_initializer(const _Rb_tree_node_ptr* r, const size_type _n, 
+                         const thread_index_t _num_threads,
+                         const ranker& _rank)
+       : r_init(r), n(_n), num_threads(_num_threads), rank(_rank)
+       {
+         height = log2(n);
+         splitting_point = 2 * (n - ((1 << height) - 1)) -1;
 
-       // Rank root.
-       size_type max = 1 << (height + 1);
-       rank_root= (max-2) >> 1;
-       if (rank_root > splitting_point)
-         rank_root = complete_to_original(rank_root);
+         // Rank root.
+         size_type max = 1 << (height + 1);
+         rank_root= (max-2) >> 1;
+         if (rank_root > splitting_point)
+           rank_root = complete_to_original(rank_root);
 
-       mask[0] = 0x1;
-       for (unsigned int i = 1; i < sizeof(size_type)*8; ++i)
-         {
+         mask[0] = 0x1;
+         for (unsigned int i = 1; i < sizeof(size_type)*8; ++i)
            mask[i] = (mask[i-1] << 1) + 1;
-         }
-      }
+       }
 
-      /** @brief Query for tree height
-       * @return Tree height */
-      int 
-      get_height() const
-      { return height; }
+       /** @brief Query for tree height
+        * @return Tree height */
+       int
+       get_height() const
+       { return height; }
 
-      /** @brief Query for the splitting point
-       * @return Splitting point */
-      size_type 
-      get_shifted_splitting_point() const
-      { return rank.get_shifted_rank(splitting_point, 0); }
+       /** @brief Query for the splitting point
+        * @return Splitting point */
+       size_type
+       get_shifted_splitting_point() const
+       { return rank.get_shifted_rank(splitting_point, 0); }
 
-      /** @brief Query for the tree root node
-       * @return Tree root node */
-      _Rb_tree_node_ptr 
-      get_root() const
-      { return  r_init[rank.get_shifted_rank(rank_root,num_threads/2)]; }
+       /** @brief Query for the tree root node
+        * @return Tree root node */
+       _Rb_tree_node_ptr 
+       get_root() const
+       { return  r_init[rank.get_shifted_rank(rank_root,num_threads/2)]; }
 
-      /** @brief Calculation of the parent position in the array of nodes
-       * @hideinitializer */
+       /** @brief Calculation of the parent position in the array of nodes
+        * @hideinitializer */
 #define CALCULATE_PARENT                                               \
-      if (p_s> splitting_point)                                                \
-       p_s = complete_to_original(p_s);                                \
-           int s_r = rank.get_shifted_rank(p_s,iam);                   \
-           r->_M_parent = r_init[s_r];                                 \
+       if (p_s> splitting_point)                                       \
+         p_s = complete_to_original(p_s);                              \
+       int s_r = rank.get_shifted_rank(p_s,iam);                       \
+       r->_M_parent = r_init[s_r];                                     \
                                                                        \
-      /** @brief Link a node with its parent and children taking into
-         account that its rank (without gaps) is different to that in
-         a complete tree
-       * @param r Pointer to the node
-       * @param iam Partition of the array in which the node is, where
-       * iam is in [0..num_threads)
-       * @sa link_complete */
-      void 
-      link_incomplete(const _Rb_tree_node_ptr& r, const int iam) const
-      {
-       size_type real_pos = rank.get_real_rank(&r-r_init, iam);
-       size_type l_s, r_s, p_s;
-       int mod_pos= original_to_complete(real_pos);
-       int zero= first_0_right(mod_pos);
-
-       // 1. Convert n to n', where n' will be its rank if the tree
-       //    was complete
-       // 2. Calculate neighbours for n'
-       // 3. Convert the neighbors n1', n2' and n3' to their
-       //    appropriate values n1, n2, n3. Note that it must be
-       //    checked that these neighbors actually exist.
-       calculate_shifts_pos_level(mod_pos, zero, l_s, r_s, p_s);
-       if (l_s > splitting_point)
-         {
-           _GLIBCXX_PARALLEL_ASSERT(r_s > splitting_point);
-           if (zero == 1)
-             {
-               r->_M_left = 0;
+       /** @brief Link a node with its parent and children taking into
+           account that its rank (without gaps) is different to that in
+           a complete tree
+           * @param r Pointer to the node
+           * @param iam Partition of the array in which the node is, where
+           * iam is in [0..num_threads)
+           * @sa link_complete */
+       void
+       link_incomplete(const _Rb_tree_node_ptr& r, const int iam) const
+       {
+         size_type real_pos = rank.get_real_rank(&r-r_init, iam);
+         size_type l_s, r_s, p_s;
+         int mod_pos= original_to_complete(real_pos);
+         int zero= first_0_right(mod_pos);
+
+         // 1. Convert n to n', where n' will be its rank if the tree
+         //    was complete
+         // 2. Calculate neighbours for n'
+         // 3. Convert the neighbors n1', n2' and n3' to their
+         //    appropriate values n1, n2, n3. Note that it must be
+         //    checked that these neighbors actually exist.
+         calculate_shifts_pos_level(mod_pos, zero, l_s, r_s, p_s);
+         if (l_s > splitting_point)
+           {
+             _GLIBCXX_PARALLEL_ASSERT(r_s > splitting_point);
+             if (zero == 1)
+               {
+                 r->_M_left = 0;
+                 r->_M_right = 0;
+               }
+             else
+               {
+                 r->_M_left =
+                   r_init[rank.get_shifted_rank(complete_to_original(l_s),
+                                                iam)];
+                 r->_M_right =
+                   r_init[rank.get_shifted_rank(complete_to_original(r_s),
+                                                iam)];
+               }
+           }
+         else
+           {
+             r->_M_left= r_init[rank.get_shifted_rank(l_s,iam)];
+             if (zero != 1)
+               r->_M_right
+                 = r_init[rank.get_shifted_rank(complete_to_original(r_s),
+                                                iam)];
+             else
                r->_M_right = 0;
-             }
-           else
-             {
-               r->_M_left= r_init[rank.get_shifted_rank(complete_to_original(l_s),iam)];
-               r->_M_right= r_init[rank.get_shifted_rank(complete_to_original(r_s),iam)];
-             }
-
-         }
-       else{
-         r->_M_left= r_init[rank.get_shifted_rank(l_s,iam)];
-         if (zero != 1)
+           }
+         r->_M_color = std::_S_black;
+         CALCULATE_PARENT;
+       }
+
+       /** @brief Link a node with its parent and children taking into
+           account that its rank (without gaps) is the same as that in
+           a complete tree
+           * @param r Pointer to the node
+           * @param iam Partition of the array in which the node is, where
+           * iam is in [0..@c num_threads)
+           * @sa link_incomplete
+           */
+       void
+       link_complete(const _Rb_tree_node_ptr& r, const int iam) const
+       {
+         size_type real_pos = rank.get_real_rank(&r-r_init, iam);
+         size_type p_s;
+
+         // Test if it is a leaf on the last not necessarily full level
+         if ((real_pos & mask[0]) == 0)
            {
-             r->_M_right= r_init[rank.get_shifted_rank(complete_to_original(r_s),iam)];
+             if ((real_pos & 0x2) == 0)
+               p_s = real_pos + 1;
+             else
+               p_s = real_pos - 1;
+             r->_M_color = std::_S_red;
+             r->_M_left = 0;
+           r->_M_right = 0;
            }
          else
            {
-             r->_M_right = 0;
+             size_type l_s, r_s;
+             int zero = first_0_right(real_pos);
+             calculate_shifts_pos_level(real_pos, zero, l_s, r_s, p_s);
+             r->_M_color = std::_S_black;
+
+             r->_M_left = r_init[rank.get_shifted_rank(l_s,iam)];
+             if (r_s > splitting_point)
+               r_s = complete_to_original(r_s);
+             r->_M_right = r_init[rank.get_shifted_rank(r_s,iam)];
            }
+         CALCULATE_PARENT;
        }
-       r->_M_color = std::_S_black;
-       CALCULATE_PARENT;
-      }
-
-      /** @brief Link a node with its parent and children taking into
-         account that its rank (without gaps) is the same as that in
-         a complete tree
-       * @param r Pointer to the node
-       * @param iam Partition of the array in which the node is, where
-       * iam is in [0..@c num_threads)
-       * @sa link_incomplete
-       */
-      void 
-      link_complete(const _Rb_tree_node_ptr& r, const int iam) const
-      {
-       size_type real_pos = rank.get_real_rank(&r-r_init, iam);
-       size_type p_s;
-
-       // Test if it is a leaf on the last not necessarily full level
-       if ((real_pos & mask[0]) == 0)
-         {
-           if ((real_pos & 0x2) == 0)
-             p_s = real_pos + 1;
-           else
-             p_s = real_pos - 1;
-           r->_M_color = std::_S_red;
-           r->_M_left = 0;
-           r->_M_right = 0;
-         }
-       else
-         {
-           size_type l_s, r_s;
-           int zero = first_0_right(real_pos);
-           calculate_shifts_pos_level(real_pos, zero, l_s, r_s, p_s);
-           r->_M_color = std::_S_black;
-
-           r->_M_left = r_init[rank.get_shifted_rank(l_s,iam)];
-           if (r_s > splitting_point)
-             r_s = complete_to_original(r_s);
-           r->_M_right = r_init[rank.get_shifted_rank(r_s,iam)];
-         }
-       CALCULATE_PARENT;
-      }
 
 #undef CALCULATE_PARENT
 
-    private:
-      /** @brief Change of "base": Convert the rank in the actual tree
-         into the corresponding rank if the tree was complete
-       * @param pos Rank in the actual incomplete tree
-       * @return Rank in the corresponding complete tree
-       * @sa complete_to_original  */
-      int 
-      original_to_complete(const int pos) const
-      { return (pos << 1) - splitting_point; }
-
-      /** @brief Change of "base": Convert the rank if the tree was
-         complete into the corresponding rank in the actual tree
-       * @param pos Rank in the complete tree
-       * @return Rank in the actual incomplete tree
-       * @sa original_to_complete */
-      int 
-      complete_to_original(const int pos) const
-      { return (pos + splitting_point) >> 1; }
-
-
-      /** @brief Calculate the rank in the complete tree of the parent
-         and children of a node
-       * @param pos Rank in the complete tree of the node whose parent
-       * and children rank must be calculated
-       * @param level Tree level in which the node at pos is in
-       * (starting to count at leaves). @pre @c level > 1
-       * @param left_shift Rank in the complete tree of the left child
-       * of pos (out parameter)
-       * @param right_shift Rank in the complete tree of the right
-       * child of pos (out parameter)
-       * @param parent_shift Rank in the complete tree of the parent
-       * of pos (out parameter)
-       */
-      void 
-      calculate_shifts_pos_level(const size_type pos, const int level, 
-                                size_type& left_shift, size_type& right_shift,
-                                size_type& parent_shift) const
-      {
-       int stride =  1 << (level -1);
-       left_shift = pos - stride;
-       right_shift = pos + stride;
-       if (((pos >> (level + 1)) & 0x1) == 0)
-         parent_shift = pos + 2*stride;
-       else
-         parent_shift = pos - 2*stride;
-      }
-
-      /** @brief Search for the first 0 bit (growing the weight)
-       * @param x Binary number (corresponding to a rank in the tree)
-       * whose first 0 bit must be calculated
-       * @return Position of the first 0 bit in @c x (starting to
-       * count with 1)
-       */
-      int 
-      first_0_right(const size_type x) const
-      {
-       if ((x & 0x2) == 0)
-         return 1;
-       else
-         return first_0_right_bs(x);
-      }
+      private:
+       /** @brief Change of "base": Convert the rank in the actual tree
+           into the corresponding rank if the tree was complete
+           * @param pos Rank in the actual incomplete tree
+           * @return Rank in the corresponding complete tree
+           * @sa complete_to_original  */
+       int
+       original_to_complete(const int pos) const
+       { return (pos << 1) - splitting_point; }
+
+       /** @brief Change of "base": Convert the rank if the tree was
+           complete into the corresponding rank in the actual tree
+           * @param pos Rank in the complete tree
+           * @return Rank in the actual incomplete tree
+           * @sa original_to_complete */
+       int
+       complete_to_original(const int pos) const
+       { return (pos + splitting_point) >> 1; }
+
+
+       /** @brief Calculate the rank in the complete tree of the parent
+           and children of a node
+           * @param pos Rank in the complete tree of the node whose parent
+           * and children rank must be calculated
+           * @param level Tree level in which the node at pos is in
+           * (starting to count at leaves). @pre @c level > 1
+           * @param left_shift Rank in the complete tree of the left child
+           * of pos (out parameter)
+           * @param right_shift Rank in the complete tree of the right
+           * child of pos (out parameter)
+           * @param parent_shift Rank in the complete tree of the parent
+           * of pos (out parameter)
+           */
+       void
+       calculate_shifts_pos_level(const size_type pos, const int level, 
+                                  size_type& left_shift,
+                                  size_type& right_shift,
+                                  size_type& parent_shift) const
+       {
+         int stride =  1 << (level -1);
+         left_shift = pos - stride;
+         right_shift = pos + stride;
+         if (((pos >> (level + 1)) & 0x1) == 0)
+           parent_shift = pos + 2*stride;
+         else
+           parent_shift = pos - 2*stride;
+       }
 
-      /** @brief Search for the first 0 bit (growing the weight) using
-       * binary search
-       *
-       * Binary search can be used instead of a naive loop using the
-       * masks in mask array
-       * @param x Binary number (corresponding to a rank in the tree)
-       * whose first 0 bit must be calculated
-       * @param k_beg Position in which to start searching. By default is 2.
-       * @return Position of the first 0 bit in x (starting to count with 1) */
-      int 
-      first_0_right_bs(const size_type x, int k_beg=2) const
-      {
-       int k_end = sizeof(size_type)*8;
-       size_type not_x = x ^ mask[k_end-1];
-       while ((k_end-k_beg) > 1)
-         {
-           int k = k_beg + (k_end-k_beg)/2;
-           if ((not_x & mask[k-1]) != 0)
-             k_end = k;
-           else
-             k_beg = k;
-         }
-       return k_beg;
-      }
+       /** @brief Search for the first 0 bit (growing the weight)
+        * @param x Binary number (corresponding to a rank in the tree)
+        * whose first 0 bit must be calculated
+        * @return Position of the first 0 bit in @c x (starting to
+        * count with 1)
+        */
+       int
+       first_0_right(const size_type x) const
+       {
+         if ((x & 0x2) == 0)
+           return 1;
+         else
+           return first_0_right_bs(x);
+       }
+
+       /** @brief Search for the first 0 bit (growing the weight) using
+        * binary search
+        *
+        * Binary search can be used instead of a naive loop using the
+        * masks in mask array
+        * @param x Binary number (corresponding to a rank in the tree)
+        * whose first 0 bit must be calculated
+        * @param k_beg Position in which to start searching. By default is 2.
+        * @return Position of the first 0 bit in x (starting to count with 1) */
+       int
+       first_0_right_bs(const size_type x, int k_beg=2) const
+       {
+         int k_end = sizeof(size_type)*8;
+         size_type not_x = x ^ mask[k_end-1];
+         while ((k_end-k_beg) > 1)
+           {
+             int k = k_beg + (k_end-k_beg)/2;
+             if ((not_x & mask[k-1]) != 0)
+               k_end = k;
+             else
+               k_beg = k;
+           }
+         return k_beg;
+       }
     };
 
     /***** Dealing with repetitions (EFFICIENCY ISSUE) *****/
@@ -605,18 +606,17 @@ namespace __gnu_parallel
        * @param _num_threads Number of partitions (and threads that
        * work on it) */
       ranker_gaps(const size_type* size_p, const size_type* shift_r, 
-                 const thread_index_t _num_threads) :
-       beg_shift_partition(size_p),
-       rank_shift(shift_r),
+                 const thread_index_t _num_threads)
+      : beg_shift_partition(size_p), rank_shift(shift_r),
        num_threads(_num_threads)
       {
        beg_partition = new size_type[num_threads+1];
        beg_partition[0] = 0;
        for (int i = 1; i <= num_threads; ++i)
-         {
-           beg_partition[i] = beg_partition[i-1] + (beg_shift_partition[i] - beg_shift_partition[i-1]) - (rank_shift[i] - rank_shift[i-1]);
-
-         }
+         beg_partition[i] = (beg_partition[i-1]
+                             + (beg_shift_partition[i]
+                                - beg_shift_partition[i-1])
+                             - (rank_shift[i] - rank_shift[i-1]));
 
        // Ghost element, strictly larger than any index requested.
        ++beg_partition[num_threads];
@@ -728,156 +728,163 @@ namespace __gnu_parallel
      * @param _Comp Comparator to invert
      * @param _Iterator Iterator to the elements to compare */
     template<typename _Comp, typename _Iterator>
-    class gr_or_eq
-    {
-      /** @brief Renaming value_type of _Iterator */
-      typedef typename std::iterator_traits<_Iterator>::value_type value_type;
-
-      /** @brief Comparator to be inverted */
-      const _Comp comp;
-
-    public:
-      /** @brief Constructor
-       * @param c Comparator */
-      gr_or_eq(const _Comp& c) : comp(c) { }
-
-      /** @brief Operator()
-       * @param a First value to compare
-       * @param b Second value to compare */
-      bool operator()(const value_type& a, const value_type& b) const
+      class gr_or_eq
       {
-       if (not (comp(_KeyOfValue()(a), _KeyOfValue()(b))))
-         return true;
-       return false;
-      }
-    };
+       /** @brief Renaming value_type of _Iterator */
+       typedef typename std::iterator_traits<_Iterator>::value_type
+       value_type;
+
+       /** @brief Comparator to be inverted */
+       const _Comp comp;
+
+      public:
+       /** @brief Constructor
+        * @param c Comparator */
+       gr_or_eq(const _Comp& c) : comp(c) { }
+
+       /** @brief Operator()
+        * @param a First value to compare
+        * @param b Second value to compare */
+       bool
+       operator()(const value_type& a, const value_type& b) const
+       {
+         if (not (comp(_KeyOfValue()(a), _KeyOfValue()(b))))
+           return true;
+         return false;
+       }
+      };
 
     /** @brief Helper comparator class: Passed as a parameter of
        list_partition to check that a sequence is sorted
      * @param _InputIterator Iterator to the elements to compare
      * @param _CompIsSorted  Comparator to check for sortednesss */
     template<typename _InputIterator, typename _CompIsSorted>
-    class is_sorted_functor
-    {
-      /** @brief Element to compare with (first parameter of comp) */
-      _InputIterator prev;
-
-      /** @brief Comparator to check for sortednesss */
-      const _CompIsSorted comp;
-
-      /** @brief Sum up the history of the operator() of this
-       * comparator class Its value is true if all calls to comp from
-       * this class have returned true. It is false otherwise */
-      bool sorted;
-
-    public:
-      /** @brief Constructor
-       *
-       * Sorted is set to true
-       * @param first Element to compare with the first time the
-       * operator() is called
-       * @param c  Comparator to check for sortedness */
-      is_sorted_functor(const _InputIterator first, const _CompIsSorted c)
-      : prev(first), comp(c), sorted(true) { }
-
-      /** @brief Operator() with only one explicit parameter. Updates
-         the class member @c prev and sorted.
-       * @param it Iterator to the element which must be compared to
-       * the element pointed by the the class member @c prev */
-      void operator()(const _InputIterator it)
+      class is_sorted_functor
       {
-       if (sorted and it != prev and comp(_KeyOfValue()(*it),
-                                          _KeyOfValue()(*prev)))
-         sorted = false;
-       prev = it;
-      }
+       /** @brief Element to compare with (first parameter of comp) */
+       _InputIterator prev;
+
+       /** @brief Comparator to check for sortednesss */
+       const _CompIsSorted comp;
+
+       /** @brief Sum up the history of the operator() of this
+        * comparator class Its value is true if all calls to comp from
+        * this class have returned true. It is false otherwise */
+       bool sorted;
+
+      public:
+       /** @brief Constructor
+        *
+        * Sorted is set to true
+        * @param first Element to compare with the first time the
+        * operator() is called
+        * @param c  Comparator to check for sortedness */
+       is_sorted_functor(const _InputIterator first, const _CompIsSorted c)
+       : prev(first), comp(c), sorted(true) { }
+
+       /** @brief Operator() with only one explicit parameter. Updates
+           the class member @c prev and sorted.
+           * @param it Iterator to the element which must be compared to
+           * the element pointed by the the class member @c prev */
+       void
+       operator()(const _InputIterator it)
+       {
+         if (sorted and it != prev and comp(_KeyOfValue()(*it),
+                                            _KeyOfValue()(*prev)))
+           sorted = false;
+         prev = it;
+       }
 
-      /** @brief Query method for sorted
-       * @return Current value of sorted */
-      bool is_sorted() const
-      {
-       return sorted;
-      }
-    };
+       /** @brief Query method for sorted
+        * @return Current value of sorted */
+       bool
+       is_sorted() const
+       { return sorted; }
+      };
 
     /** @brief Helper functor: sort the input based upon elements
        instead of keys
      * @param KeyComparator Comparator for the key of values */
     template<typename KeyComparator>
-    class ValueCompare
-    : public std::binary_function<value_type, value_type, bool>
-    {
-      /** @brief Comparator for the key of values */
-      const KeyComparator comp;
-
-    public:
-      /** @brief Constructor
-       * @param c Comparator for the key of values */
-      ValueCompare(const KeyComparator& c): comp(c)  { }
-
-      /** @brief Operator(): Analogous to comp but for values and not keys
-       * @param v1 First value to compare
-       * @param v2 Second value to compare
-       * @return Result of the comparison */
-      bool operator()(const value_type& v1, const value_type& v2) const
-      { return comp(_KeyOfValue()(v1),_KeyOfValue()(v2)); }
-    };
+      class ValueCompare
+      : public std::binary_function<value_type, value_type, bool>
+      {
+       /** @brief Comparator for the key of values */
+       const KeyComparator comp;
+
+      public:
+       /** @brief Constructor
+        * @param c Comparator for the key of values */
+       ValueCompare(const KeyComparator& c): comp(c)  { }
+
+       /** @brief Operator(): Analogous to comp but for values and not keys
+        * @param v1 First value to compare
+        * @param v2 Second value to compare
+        * @return Result of the comparison */
+       bool
+       operator()(const value_type& v1, const value_type& v2) const
+       { return comp(_KeyOfValue()(v1),_KeyOfValue()(v2)); }
+      };
 
     /** @brief Helper comparator: compare a key with the key in a node
      * @param _Comparator Comparator for keys */
     template<typename _Comparator>
-    struct compare_node_key
-    {
-      /** @brief Comparator for keys */
-      const _Comparator& c;
-
-      /** @brief Constructor
-       * @param _c Comparator for keys */
-      compare_node_key(const _Comparator& _c) : c(_c) { }
-
-      /** @brief Operator() with the first parameter being a node
-       * @param r Node whose key is to be compared
-       * @param k Key to be compared
-       * @return Result of the comparison */
-      bool operator()(const _Rb_tree_node_ptr r, const key_type& k) const
-      { return c(base_type::_S_key(r),k); }
-
-      /** @brief Operator() with the second parameter being a node
-       * @param k Key to be compared
-       * @param r Node whose key is to be compared
-       * @return Result of the comparison */
-      bool operator()(const key_type& k, const _Rb_tree_node_ptr r) const
-      { return c(k, base_type::_S_key(r)); }
-    };
+      struct compare_node_key
+      {
+       /** @brief Comparator for keys */
+       const _Comparator& c;
+
+       /** @brief Constructor
+        * @param _c Comparator for keys */
+       compare_node_key(const _Comparator& _c) : c(_c) { }
+
+       /** @brief Operator() with the first parameter being a node
+        * @param r Node whose key is to be compared
+        * @param k Key to be compared
+        * @return Result of the comparison */
+       bool
+       operator()(const _Rb_tree_node_ptr r, const key_type& k) const
+       { return c(base_type::_S_key(r),k); }
+
+       /** @brief Operator() with the second parameter being a node
+        * @param k Key to be compared
+        * @param r Node whose key is to be compared
+        * @return Result of the comparison */
+       bool
+       operator()(const key_type& k, const _Rb_tree_node_ptr r) const
+       { return c(k, base_type::_S_key(r)); }
+      };
 
     /** @brief Helper comparator: compare a key with the key of a
        value pointed by an iterator
      * @param _Comparator Comparator for keys 
      */
     template<typename _Iterator, typename _Comparator>
-    struct compare_value_key
-    {
-      /** @brief Comparator for keys */
-      const _Comparator& c;
-
-      /** @brief Constructor
-       * @param _c Comparator for keys */
-      compare_value_key(const _Comparator& _c) : c(_c){ }
-
-      /** @brief Operator() with the first parameter being an iterator
-       * @param v Iterator to the value whose key is to be compared
-       * @param k Key to be compared
-       * @return Result of the comparison */
-      bool operator()(const _Iterator& v, const key_type& k) const
-      { return c(_KeyOfValue()(*v),k); }
-
-      /** @brief Operator() with the second parameter being an iterator
-       * @param k Key to be compared
-       * @param v Iterator to the value whose key is to be compared
-       * @return Result of the comparison */
-      bool operator()(const key_type& k, const _Iterator& v) const
-      { return c(k, _KeyOfValue()(*v)); }
-    };
+      struct compare_value_key
+      {
+       /** @brief Comparator for keys */
+       const _Comparator& c;
+
+       /** @brief Constructor
+        * @param _c Comparator for keys */
+       compare_value_key(const _Comparator& _c) : c(_c){ }
+
+       /** @brief Operator() with the first parameter being an iterator
+        * @param v Iterator to the value whose key is to be compared
+        * @param k Key to be compared
+        * @return Result of the comparison */
+       bool
+       operator()(const _Iterator& v, const key_type& k) const
+       { return c(_KeyOfValue()(*v),k); }
+
+       /** @brief Operator() with the second parameter being an iterator
+        * @param k Key to be compared
+        * @param v Iterator to the value whose key is to be compared
+        * @return Result of the comparison */
+       bool
+       operator()(const key_type& k, const _Iterator& v) const
+       { return c(k, _KeyOfValue()(*v)); }
+      };
 
     /** @brief Helper class of _Rb_tree to avoid some symmetric code
        in tree operations */
@@ -886,13 +893,15 @@ namespace __gnu_parallel
       /** @brief Obtain the conceptual left child of a node
        * @param parent Node whose child must be obtained
        * @return Reference to the child node */
-      static _Rb_tree_node_base*& left(_Rb_tree_node_base* parent)
+      static _Rb_tree_node_base*&
+      left(_Rb_tree_node_base* parent)
       { return parent->_M_left; }
 
       /** @brief Obtain the conceptual right child of a node
        * @param parent Node whose child must be obtained
        * @return Reference to the child node */
-      static _Rb_tree_node_base*& right(_Rb_tree_node_base* parent)
+      static _Rb_tree_node_base*&
+      right(_Rb_tree_node_base* parent)
       { return parent->_M_right; }
     };
 
@@ -901,22 +910,24 @@ namespace __gnu_parallel
      * @param S Symmetry to inverse
      * @sa LeftRight */
     template<typename S>
-    struct Opposite
-    {
-      /** @brief Obtain the conceptual left child of a node, inverting
-         the symmetry
-       * @param parent Node whose child must be obtained
-       * @return Reference to the child node */
-      static _Rb_tree_node_base*& left(_Rb_tree_node_base* parent)
-      { return S::right(parent);}
-
-      /** @brief Obtain the conceptual right child of a node,
-         inverting the symmetry
-       * @param parent Node whose child must be obtained
-       * @return Reference to the child node */
-      static _Rb_tree_node_base*& right(_Rb_tree_node_base* parent)
-      { return S::left(parent);}
-    };
+      struct Opposite
+      {
+       /** @brief Obtain the conceptual left child of a node, inverting
+           the symmetry
+           * @param parent Node whose child must be obtained
+           * @return Reference to the child node */
+       static _Rb_tree_node_base*&
+       left(_Rb_tree_node_base* parent)
+       { return S::right(parent);}
+
+       /** @brief Obtain the conceptual right child of a node,
+           inverting the symmetry
+           * @param parent Node whose child must be obtained
+           * @return Reference to the child node */
+       static _Rb_tree_node_base*&
+       right(_Rb_tree_node_base* parent)
+        { return S::left(parent);}
+      };
 
     /** @brief Inverse symmetry of LeftRight */
     typedef Opposite<LeftRight> RightLeft;
@@ -926,148 +937,153 @@ namespace __gnu_parallel
      * @param Comparator Comparator for values
      * @param _ValuePtr Pointer to values */
     template<typename Comparator, typename _ValuePtr>
-    class PtrComparator 
-    : public std::binary_function<_ValuePtr, _ValuePtr, bool>
-    {
-      /** @brief Comparator for values */
-      Comparator comp;
-
-    public:
-      /** @brief Constructor
-       * @param comp Comparator for values */
-      PtrComparator(Comparator comp) : comp(comp)  { }
-
-      /** @brief Operator(): compare the values instead of the pointers
-       * @param v1 Pointer to the first element to compare
-       * @param v2 Pointer to the second element to compare */
-      bool operator()(const _ValuePtr& v1, const _ValuePtr& v2) const
-      { return comp(*v1,*v2); }
-    };
+      class PtrComparator 
+      : public std::binary_function<_ValuePtr, _ValuePtr, bool>
+      {
+       /** @brief Comparator for values */
+       Comparator comp;
+
+      public:
+       /** @brief Constructor
+        * @param comp Comparator for values */
+       PtrComparator(Comparator comp) : comp(comp)  { }
+
+       /** @brief Operator(): compare the values instead of the pointers
+        * @param v1 Pointer to the first element to compare
+        * @param v2 Pointer to the second element to compare */
+       bool
+       operator()(const _ValuePtr& v1, const _ValuePtr& v2) const
+       { return comp(*v1,*v2); }
+      };
 
     /** @brief Iterator whose elements are pointers
      * @param value_type Type pointed by the pointers */
     template<typename _ValueTp>
-    class PtrIterator
-    {
-    public:
-      /** @brief The iterator category is random access iterator */
-      typedef typename std::random_access_iterator_tag iterator_category;
-      typedef _ValueTp  value_type;
-      typedef size_t difference_type;
-      typedef value_type* ValuePtr;
-      typedef ValuePtr& reference;
-      typedef value_type** pointer;
+      class PtrIterator
+      {
+      public:
+       /** @brief The iterator category is random access iterator */
+       typedef typename std::random_access_iterator_tag iterator_category;
+       typedef _ValueTp  value_type;
+       typedef size_t difference_type;
+       typedef value_type* ValuePtr;
+       typedef ValuePtr& reference;
+       typedef value_type** pointer;
 
-      /** @brief Element accessed by the iterator */
-      value_type** ptr;
+       /** @brief Element accessed by the iterator */
+       value_type** ptr;
 
-      /** @brief Trivial constructor */
-      PtrIterator() { }
+       /** @brief Trivial constructor */
+       PtrIterator() { }
 
-      /** @brief Constructor from an element */
-      PtrIterator(const ValuePtr& __i) : ptr(&__i) { }
+       /** @brief Constructor from an element */
+       PtrIterator(const ValuePtr& __i) : ptr(&__i) { }
 
-      /** @brief Constructor from a pointer */
-      PtrIterator(const pointer& __i) : ptr(__i) { }
+       /** @brief Constructor from a pointer */
+       PtrIterator(const pointer& __i) : ptr(__i) { }
 
-      /** @brief Copy constructor */
-      PtrIterator(const PtrIterator<value_type>& __i) : ptr(__i.ptr) { }
+       /** @brief Copy constructor */
+       PtrIterator(const PtrIterator<value_type>& __i) : ptr(__i.ptr) { }
 
-      reference
-      operator*() const
-      { return **ptr; }
+       reference
+       operator*() const
+       { return **ptr; }
 
-      ValuePtr
-      operator->() const
-      { return *ptr; }
+       ValuePtr
+       operator->() const
+       { return *ptr; }
 
-      /** @brief Bidirectional iterator requirement */
-      PtrIterator&
-      operator++()
-      {
-       ++ptr;
-       return *this;
-      }
+       /** @brief Bidirectional iterator requirement */
+       PtrIterator&
+       operator++()
+       {
+         ++ptr;
+         return *this;
+       }
 
-      /** @brief Bidirectional iterator requirement */
-      PtrIterator
-      operator++(int)
-      { return PtrIterator(ptr++); }
+       /** @brief Bidirectional iterator requirement */
+       PtrIterator
+       operator++(int)
+       { return PtrIterator(ptr++); }
 
-      /** @brief Bidirectional iterator requirement */
-      PtrIterator&
-      operator--()
-      {
-       --ptr;
-       return *this;
-      }
+       /** @brief Bidirectional iterator requirement */
+       PtrIterator&
+       operator--()
+       {
+         --ptr;
+         return *this;
+       }
 
-      /** @brief Bidirectional iterator requirement */
-      PtrIterator
-      operator--(int)
-      { return PtrIterator(ptr--); }
+       /** @brief Bidirectional iterator requirement */
+       PtrIterator
+       operator--(int)
+       { return PtrIterator(ptr--); }
 
-      /** @brief Random access iterator requirement */
-      reference
-      operator[](const difference_type& __n) const
-      { return *ptr[__n]; }
+       /** @brief Random access iterator requirement */
+       reference
+       operator[](const difference_type& __n) const
+       { return *ptr[__n]; }
 
-      /** @brief Random access iterator requirement */
-      PtrIterator&
-      operator+=(const difference_type& __n)
-      {
-       ptr += __n;
-       return *this;
-      }
+       /** @brief Random access iterator requirement */
+       PtrIterator&
+       operator+=(const difference_type& __n)
+        {
+         ptr += __n;
+         return *this;
+       }
 
-      /** @brief Random access iterator requirement */
-      PtrIterator
-      operator+(const difference_type& __n) const
-      { return PtrIterator(ptr + __n); }
+       /** @brief Random access iterator requirement */
+       PtrIterator
+       operator+(const difference_type& __n) const
+       { return PtrIterator(ptr + __n); }
 
-      /** @brief Random access iterator requirement */
-      PtrIterator&
-      operator-=(const difference_type& __n)
-      {
-       ptr -= __n;
-       return *this;
-      }
+       /** @brief Random access iterator requirement */
+       PtrIterator&
+       operator-=(const difference_type& __n)
+       {
+         ptr -= __n;
+         return *this;
+       }
 
-      /** @brief Random access iterator requirement */
-      PtrIterator
-      operator-(const difference_type& __n) const
-      { return PtrIterator(ptr - __n); }
+       /** @brief Random access iterator requirement */
+       PtrIterator
+       operator-(const difference_type& __n) const
+       { return PtrIterator(ptr - __n); }
 
-      /** @brief Random access iterator requirement */
-      difference_type
-      operator-(const PtrIterator<value_type>& iter) const
-      { return ptr - iter.ptr; }
+       /** @brief Random access iterator requirement */
+       difference_type
+       operator-(const PtrIterator<value_type>& iter) const
+       { return ptr - iter.ptr; }
 
-      /** @brief Random access iterator requirement */
-      difference_type
-      operator+(const PtrIterator<value_type>& iter) const
-      { return ptr + iter.ptr; }
+       /** @brief Random access iterator requirement */
+       difference_type
+       operator+(const PtrIterator<value_type>& iter) const
+       { return ptr + iter.ptr; }
 
-      /** @brief Allow assignment of an element ValuePtr to the iterator */
-      PtrIterator<value_type>& operator=(const ValuePtr sptr)
-      {
-       ptr = &sptr;
-       return *this;
-      }
+       /** @brief Allow assignment of an element ValuePtr to the iterator */
+       PtrIterator<value_type>&
+       operator=(const ValuePtr sptr)
+       {
+         ptr = &sptr;
+         return *this;
+       }
 
-      PtrIterator<value_type>& operator=(const PtrIterator<value_type>& piter)
-      {
-       ptr = piter.ptr;
-       return *this;
-      }
+       PtrIterator<value_type>&
+       operator=(const PtrIterator<value_type>& piter)
+       {
+         ptr = piter.ptr;
+         return *this;
+       }
 
-      bool operator==(const PtrIterator<value_type>& piter)
-      { return ptr == piter.ptr; }
+       bool
+       operator==(const PtrIterator<value_type>& piter)
+       { return ptr == piter.ptr; }
 
-      bool operator!=(const PtrIterator<value_type>& piter)
-      { return ptr != piter.ptr; }
+       bool
+       operator!=(const PtrIterator<value_type>& piter)
+       { return ptr != piter.ptr; }
 
-    };
+      };
 
 
     /** @brief Bulk insertion helper: synchronization and construction
@@ -1207,47 +1223,55 @@ namespace __gnu_parallel
      * saved so that afterwards the sequence can be processed
      * effectively in parallel. */
     template<typename _InputIterator, typename StrictlyLessOrLessEqual>
-    void
-    _M_bulk_insertion_construction(const _InputIterator __first, const _InputIterator __last, const bool is_construction, StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      thread_index_t num_threads = get_max_threads();
-      size_type n;
-      size_type beg_partition[num_threads+1];
-      _InputIterator access[num_threads+1];
-      beg_partition[0] = 0;
-      bool is_sorted= is_sorted_distance_accessors(__first, __last, access, beg_partition,n, num_threads, std::__iterator_category(__first));
-
-      if (not is_sorted)
-       {
-         _M_not_sorted_bulk_insertion_construction(access, beg_partition, n, num_threads, is_construction, strictly_less_or_less_equal);
-       }
-      else
-       {
-         // The vector must be moved... all ranges must have at least
-         // one element, or make just sequential???
-         if (static_cast<size_type>(num_threads) > n)
-           {
-             int j = 1;
-             for (int i = 1; i <= num_threads; ++i)
-               {
-                 if (beg_partition[j-1] != beg_partition[i])
-                   {
-                     beg_partition[j] = beg_partition[i];
-                     access[j] = access[i];
-                     ++j;
-                   }
-               }
-             num_threads = static_cast<thread_index_t>(n);
-           }
+      void
+      _M_bulk_insertion_construction(const _InputIterator __first,
+                                    const _InputIterator __last,
+                                    const bool is_construction,
+                                    StrictlyLessOrLessEqual
+                                    strictly_less_or_less_equal)
+      {
+       thread_index_t num_threads = get_max_threads();
+       size_type n;
+       size_type beg_partition[num_threads+1];
+       _InputIterator access[num_threads+1];
+       beg_partition[0] = 0;
+       bool is_sorted =
+         is_sorted_distance_accessors(__first, __last, access,
+                                      beg_partition, n, num_threads,
+                                      std::__iterator_category(__first));
+
+       if (not is_sorted)
+         _M_not_sorted_bulk_insertion_construction(
+           access, beg_partition, n, num_threads,
+           is_construction, strictly_less_or_less_equal);
+       else
+         {
+           // The vector must be moved... all ranges must have at least
+           // one element, or make just sequential???
+           if (static_cast<size_type>(num_threads) > n)
+             {
+               int j = 1;
+               for (int i = 1; i <= num_threads; ++i)
+                 {
+                   if (beg_partition[j-1] != beg_partition[i])
+                     {
+                       beg_partition[j] = beg_partition[i];
+                       access[j] = access[i];
+                       ++j;
+                     }
+                 }
+               num_threads = static_cast<thread_index_t>(n);
+             }
 
-         if (is_construction)
-           _M_sorted_bulk_construction(access, beg_partition, n, num_threads, 
-                                       strictly_less_or_less_equal);
-         else
-           _M_sorted_bulk_insertion(access, beg_partition, n, num_threads, 
-                                    strictly_less_or_less_equal);
-       }
-    }
+           if (is_construction)
+             _M_sorted_bulk_construction(access, beg_partition, n,
+                                         num_threads, 
+                                         strictly_less_or_less_equal);
+           else
+             _M_sorted_bulk_insertion(access, beg_partition, n, num_threads, 
+                                      strictly_less_or_less_equal);
+         }
+      }
 
     /** @brief Bulk construction and insertion helper method on an
      * input sequence which is not sorted
@@ -1273,39 +1297,54 @@ namespace __gnu_parallel
      * of the wrapping container 
      */
     template<typename _InputIterator, typename StrictlyLessOrLessEqual>
-    void
-    _M_not_sorted_bulk_insertion_construction(_InputIterator* access,
-                                             size_type* beg_partition,
-                                             const size_type n,
-                                             const thread_index_t num_threads,
-                                             const bool is_construction,
-                          StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      // Copy entire elements. In the case of a map, we would be
-      // copying the pair. Therefore, the copy should be reconsidered
-      // when objects are big. Essentially two cases:
-      // - The key is small: make that the pair, is a pointer to data
-      //   instead of a copy to it
-      // - The key is big: we simply have a pointer to the iterator
+      void
+      _M_not_sorted_bulk_insertion_construction(_InputIterator* access,
+                                               size_type* beg_partition,
+                                               const size_type n,
+                                               const thread_index_t
+                                               num_threads,
+                                               const bool is_construction,
+                                               StrictlyLessOrLessEqual
+                                               strictly_less_or_less_equal)
+      {
+       // Copy entire elements. In the case of a map, we would be
+       // copying the pair. Therefore, the copy should be reconsidered
+       // when objects are big. Essentially two cases:
+       // - The key is small: make that the pair, is a pointer to data
+       //   instead of a copy to it
+       // - The key is big: we simply have a pointer to the iterator
 #if _GLIBCXX_TREE_FULL_COPY
-      nc_value_type* v = static_cast<nc_value_type*> (::operator new(sizeof(nc_value_type)*(n+1)));
-
-      uninitialized_copy_from_accessors(access, beg_partition, v, num_threads);
-
-      _M_not_sorted_bulk_insertion_construction<nc_value_type, nc_value_type*, ValueCompare<_Compare> >
-       (beg_partition, v, ValueCompare<_Compare>(base_type::_M_impl._M_key_compare), n, num_threads, is_construction, strictly_less_or_less_equal);
+       nc_value_type* v = 
+         static_cast<nc_value_type*>(::operator new(sizeof(nc_value_type)
+                                                    * (n+1)));
+
+       uninitialized_copy_from_accessors(access, beg_partition,
+                                         v, num_threads);
+
+       _M_not_sorted_bulk_insertion_construction<nc_value_type,
+         nc_value_type*, ValueCompare<_Compare> >
+         (beg_partition, v, ValueCompare<_Compare>(base_type::
+                                                   _M_impl._M_key_compare),
+          n, num_threads, is_construction, strictly_less_or_less_equal);
 #else
-      // For sorting, we cannot use the new PtrIterator because we
-      // want the pointers to be exchanged and not the elements.
-      typedef PtrComparator<ValueCompare<_Compare>, nc_value_type*>  this_ptr_comparator;
-      nc_value_type** v = static_cast<nc_value_type**> (::operator new(sizeof(nc_value_type*)*(n+1)));
-
-      uninitialized_ptr_copy_from_accessors(access, beg_partition, v, num_threads);
-
-      _M_not_sorted_bulk_insertion_construction<nc_value_type*, PtrIterator<nc_value_type>, this_ptr_comparator>
-       (beg_partition, v, this_ptr_comparator(ValueCompare<_Compare>(base_type::_M_impl._M_key_compare)), n, num_threads, is_construction, strictly_less_or_less_equal);
+       // For sorting, we cannot use the new PtrIterator because we
+       // want the pointers to be exchanged and not the elements.
+       typedef PtrComparator<ValueCompare<_Compare>, nc_value_type*>
+         this_ptr_comparator;
+       nc_value_type** v = 
+         static_cast<nc_value_type**>(::operator new(sizeof(nc_value_type*)
+                                                     * (n+1)));
+
+       uninitialized_ptr_copy_from_accessors(access, beg_partition,
+                                             v, num_threads);
+
+       _M_not_sorted_bulk_insertion_construction<nc_value_type*,
+         PtrIterator<nc_value_type>, this_ptr_comparator>
+         (beg_partition, v, this_ptr_comparator(
+           ValueCompare<_Compare>(base_type::_M_impl._M_key_compare)),
+          n, num_threads, is_construction, strictly_less_or_less_equal);
 #endif
-    }
+      }
 
     /** @brief Bulk construction and insertion helper method on an
      * input sequence which is not sorted
@@ -1327,25 +1366,40 @@ namespace __gnu_parallel
      * transparently with repetitions with respect to the uniqueness
      * of the wrapping container
      */
-    template<typename ElementsToSort, typename IteratorSortedElements, typename Comparator, typename StrictlyLessOrLessEqual>
-    void
-    _M_not_sorted_bulk_insertion_construction(size_type* beg_partition, ElementsToSort* v, Comparator comp, const size_type n, thread_index_t num_threads, const bool is_construction, StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      // The accessors have been calculated for the non sorted.
-      num_threads = static_cast<thread_index_t>(std::min<size_type>(num_threads, n));
-
-      std::stable_sort(v, v+n, comp);
-
-      IteratorSortedElements sorted_access[num_threads+1];
-      range_accessors(IteratorSortedElements(v), IteratorSortedElements(v+n), sorted_access, beg_partition, n, num_threads, std::__iterator_category(v));
-
-      // Partial template specialization not available.
-      if (is_construction)
-       _M_sorted_bulk_construction(sorted_access, beg_partition, n, num_threads, strictly_less_or_less_equal);
-      else
-       _M_sorted_bulk_insertion(sorted_access, beg_partition, n, num_threads, strictly_less_or_less_equal);
-      ::operator delete(v);
-    }
+    template<typename ElementsToSort, typename IteratorSortedElements,
+            typename Comparator, typename StrictlyLessOrLessEqual>
+       void
+       _M_not_sorted_bulk_insertion_construction(size_type* beg_partition,
+                                                ElementsToSort* v,
+                                                Comparator comp,
+                                                const size_type n,
+                                                thread_index_t num_threads,
+                                                const bool is_construction,
+                                                StrictlyLessOrLessEqual
+                                                strictly_less_or_less_equal)
+      {
+       // The accessors have been calculated for the non sorted.
+       num_threads =
+         static_cast<thread_index_t>(std::min<size_type>(num_threads, n));
+
+       std::stable_sort(v, v+n, comp);
+
+       IteratorSortedElements sorted_access[num_threads+1];
+       range_accessors(IteratorSortedElements(v),
+                       IteratorSortedElements(v + n),
+                       sorted_access, beg_partition, n, num_threads,
+                       std::__iterator_category(v));
+
+       // Partial template specialization not available.
+       if (is_construction)
+         _M_sorted_bulk_construction(sorted_access, beg_partition, n,
+                                     num_threads,
+                                     strictly_less_or_less_equal);
+       else
+         _M_sorted_bulk_insertion(sorted_access, beg_partition, n,
+                                  num_threads, strictly_less_or_less_equal);
+       ::operator delete(v);
+      }
 
     /** @brief Construct a tree sequentially using the parallel routine
      * @param r_array Array of nodes from which to take the nodes to
@@ -1414,31 +1468,37 @@ namespace __gnu_parallel
      * going to be shared
      */
     template<typename _Iterator>
-    _Rb_tree_node_ptr* 
-    _M_unsorted_bulk_allocation_and_initialization(const _Iterator* access, const size_type* beg_partition, const size_type n, const thread_index_t num_threads)
-    {
-      _Rb_tree_node_ptr* r = static_cast<_Rb_tree_node_ptr*> (::operator new (sizeof(_Rb_tree_node_ptr)*(n+1)));
+      _Rb_tree_node_ptr* 
+      _M_unsorted_bulk_allocation_and_initialization(const _Iterator* access,
+                                                    const size_type*
+                                                    beg_partition,
+                                                    const size_type n,
+                                                    const thread_index_t
+                                                    num_threads)
+      {
+       _Rb_tree_node_ptr* r = static_cast<_Rb_tree_node_ptr*>(
+         ::operator new (sizeof(_Rb_tree_node_ptr) * (n + 1)));
 
-      // Allocate and initialize the nodes (don't check for uniqueness
-      // because the sequence is not necessarily sorted.
+       // Allocate and initialize the nodes (don't check for uniqueness
+       // because the sequence is not necessarily sorted.
 #pragma omp parallel num_threads(num_threads)
-      {
+       {
 #if USE_PAPI
-       PAPI_register_thread();
+         PAPI_register_thread();
 #endif
 
-       int iam = omp_get_thread_num();
-       _Iterator it = access[iam];
-       size_type i = beg_partition[iam];
-       while (it!= access[iam+1])
-         {
-           r[i] = base_type::_M_create_node(*it);
-           ++i;
-           ++it;
-         }
+         int iam = omp_get_thread_num();
+         _Iterator it = access[iam];
+         size_type i = beg_partition[iam];
+         while (it!= access[iam+1])
+           {
+             r[i] = base_type::_M_create_node(*it);
+             ++i;
+             ++it;
+           }
+       }
+       return r;
       }
-      return r;
-    }
 
 
     /** @brief Allocation of an array of nodes and initialization of
@@ -1470,104 +1530,123 @@ namespace __gnu_parallel
      * of the wrapping container
      */
     template<typename _Iterator, typename StrictlyLessOrLessEqual>
-    _Rb_tree_node_ptr* 
-    _M_sorted_bulk_allocation_and_initialization(_Iterator* access, size_type*  beg_partition, size_type* rank_shift, const size_type n, thread_index_t& num_threads, StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      // Ghost node at the end to avoid extra comparisons in nodes_initializer.
-      _Rb_tree_node_ptr* r = static_cast<_Rb_tree_node_ptr*> (::operator new (sizeof(_Rb_tree_node_ptr)*(n+1)));
-      r[n] = NULL;
-
-      // Dealing with repetitions (EFFICIENCY ISSUE).
-      _Iterator access_copy[num_threads+1];
-      for (int i = 0; i <= num_threads; ++i)
-       access_copy[i] = access[i];
-      // Allocate and initialize the nodes
-#pragma omp parallel num_threads(num_threads)
+      _Rb_tree_node_ptr* 
+      _M_sorted_bulk_allocation_and_initialization(_Iterator* access,
+                                                  size_type* beg_partition,
+                                                  size_type* rank_shift,
+                                                  const size_type n,
+                                                  thread_index_t& num_threads,
+                                                  StrictlyLessOrLessEqual
+                                                  strictly_less_or_less_equal)
       {
+       // Ghost node at the end to avoid extra comparisons
+       // in nodes_initializer.
+       _Rb_tree_node_ptr* r = static_cast<_Rb_tree_node_ptr*>(
+         ::operator new(sizeof(_Rb_tree_node_ptr) * (n + 1)));
+       r[n] = NULL;
+
+       // Dealing with repetitions (EFFICIENCY ISSUE).
+       _Iterator access_copy[num_threads+1];
+       for (int i = 0; i <= num_threads; ++i)
+         access_copy[i] = access[i];
+       // Allocate and initialize the nodes
+#pragma omp parallel num_threads(num_threads)
+       {
 #if USE_PAPI
-       PAPI_register_thread();
+         PAPI_register_thread();
 #endif
-       thread_index_t iam = omp_get_thread_num();
-       _Iterator prev = access[iam];
-       size_type i = beg_partition[iam];
-       _Iterator it = prev;
-       if (iam != 0)
-         {
-           --prev;
-           // Dealing with repetitions (CORRECTNESS ISSUE).
-           while (it!= access_copy[iam+1] and not strictly_less_or_less_equal(_KeyOfValue()(*prev), _KeyOfValue()(*it)))
-             {
-               _GLIBCXX_PARALLEL_ASSERT(not base_type::_M_impl._M_key_compare(_KeyOfValue()(*it),_KeyOfValue()(*prev)));
+         thread_index_t iam = omp_get_thread_num();
+         _Iterator prev = access[iam];
+         size_type i = beg_partition[iam];
+         _Iterator it = prev;
+         if (iam != 0)
+           {
+             --prev;
+             // Dealing with repetitions (CORRECTNESS ISSUE).
+             while (it!= access_copy[iam+1]
+                    and not strictly_less_or_less_equal(_KeyOfValue()(*prev),
+                                                        _KeyOfValue()(*it)))
+               {
+                 _GLIBCXX_PARALLEL_ASSERT(not base_type::
+                                          _M_impl._M_key_compare
+                                          (_KeyOfValue()(*it),
+                                           _KeyOfValue()(*prev)));
+                 ++it;
+               }
+             access[iam] = it;
+             if (it != access_copy[iam+1]){
+               r[i] = base_type::_M_create_node(*it);
+               ++i;
+               prev=it;
                ++it;
              }
-           access[iam] = it;
-           if (it != access_copy[iam+1]){
-             r[i] = base_type::_M_create_node(*it);
+             //}
+           }
+         else
+           {
+             r[i] = base_type::_M_create_node(*prev);
              ++i;
-             prev=it;
              ++it;
            }
-           //}
-         }
-       else
-         {
-           r[i] = base_type::_M_create_node(*prev);
-           ++i;
-           ++it;
-         }
-       while (it!= access_copy[iam+1])
-         {
+         while (it != access_copy[iam+1])
+           {
            /*****      Dealing with repetitions (CORRECTNESS ISSUE) *****/
-           if (strictly_less_or_less_equal(_KeyOfValue()(*prev),_KeyOfValue()(*it)))
+           if (strictly_less_or_less_equal(_KeyOfValue()(*prev),
+                                           _KeyOfValue()(*it)))
              {
                r[i] = base_type::_M_create_node(*it);
                ++i;
                prev=it;
              }
-           else{
-             _GLIBCXX_PARALLEL_ASSERT(not base_type::_M_impl._M_key_compare(_KeyOfValue()(*it),_KeyOfValue()(*prev)));
-           }
+           else
+             _GLIBCXX_PARALLEL_ASSERT(not base_type::
+                                      _M_impl._M_key_compare
+                                      (_KeyOfValue()(*it),
+                                       _KeyOfValue()(*prev)));
            ++it;
          }
-       /*****  Dealing with repetitions (EFFICIENCY ISSUE) *****/
-       rank_shift[iam+1] =  beg_partition[iam+1] - i;
-      }
-      /*****   Dealing with repetitions (EFFICIENCY ISSUE) *****/
-      rank_shift[0] = 0;
-      /* Guarantee that there are no empty intervals.
-      - If an empty interval is found, is joined with the previous one
-        (the rank_shift of the previous is augmented with all the new
-        repetitions)
-      */
-      thread_index_t i = 1;
-      while (i <= num_threads and rank_shift[i] != (beg_partition[i] - beg_partition[i-1]))
-       {
-         rank_shift[i] += rank_shift[i-1];
-         ++i;
+         /*****        Dealing with repetitions (EFFICIENCY ISSUE) *****/
+         rank_shift[iam+1] =  beg_partition[iam+1] - i;
        }
-      if (i <= num_threads)
-       {
-         thread_index_t j = i - 1;
-         while (true)
-           {
-             do
-               {
-                 rank_shift[j] += rank_shift[i];
-                 ++i;
-               } while (i <= num_threads and rank_shift[i] == (beg_partition[i] - beg_partition[i-1]));
-
-             beg_partition[j] = beg_partition[i-1];
-             access[j] = access[i-1];
-             if (i > num_threads) break;
-             ++j;
+       /*****  Dealing with repetitions (EFFICIENCY ISSUE) *****/
+       rank_shift[0] = 0;
+       /* Guarantee that there are no empty intervals.
+          - If an empty interval is found, is joined with the previous one
+          (the rank_shift of the previous is augmented with all the new
+          repetitions)
+       */
+       thread_index_t i = 1;
+       while (i <= num_threads
+              and rank_shift[i] != (beg_partition[i] - beg_partition[i-1]))
+         {
+           rank_shift[i] += rank_shift[i-1];
+           ++i;
+         }
+       if (i <= num_threads)
+         {
+           thread_index_t j = i - 1;
+           while (true)
+             {
+               do
+                 {
+                   rank_shift[j] += rank_shift[i];
+                   ++i;
+                 }
+               while (i <= num_threads
+                      and rank_shift[i] == (beg_partition[i]
+                                            - beg_partition[i-1]));
 
-             // Initialize with the previous.
-             rank_shift[j] = rank_shift[j-1];
-           }
-         num_threads = j;
-       }
-      return r;
+               beg_partition[j] = beg_partition[i-1];
+               access[j] = access[i-1];
+               if (i > num_threads) break;
+               ++j;
 
+               // Initialize with the previous.
+               rank_shift[j] = rank_shift[j-1];
+             }
+           num_threads = j;
+         }
+       return r;
     }
 
     /** @brief Allocation of an array of nodes and initialization of
@@ -1598,42 +1677,45 @@ namespace __gnu_parallel
      * of the wrapping container
      */
     template<typename _Iterator, typename StrictlyLessOrLessEqual>
-    _Rb_tree_node_ptr* 
-    _M_sorted_no_gapped_bulk_allocation_and_initialization(_Iterator* access, size_type* beg_partition, size_type& n, const thread_index_t num_threads, StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      size_type* sums = static_cast<size_type*> (::operator new (sizeof(size_type)*n));
-      // Allocate and initialize the nodes
-      /*               try
-       {*/
-#pragma omp parallel num_threads(num_threads)
+      _Rb_tree_node_ptr* 
+      _M_sorted_no_gapped_bulk_allocation_and_initialization
+      (_Iterator* access, size_type* beg_partition, size_type& n,
+       const thread_index_t num_threads,
+       StrictlyLessOrLessEqual strictly_less_or_less_equal)
       {
+       size_type* sums =
+         static_cast<size_type*>(::operator new (sizeof(size_type) * n));
+       // Allocate and initialize the nodes
+       /*              try
+                       {*/
+#pragma omp parallel num_threads(num_threads)
+       {
 #if USE_PAPI
-       PAPI_register_thread();
+         PAPI_register_thread();
 #endif
-       int iam = omp_get_thread_num();
-       _Iterator prev = access[iam];
-       size_type i = beg_partition[iam];
-       _Iterator it = prev;
-       if (iam !=0)
-         {
-           --prev;
+         int iam = omp_get_thread_num();
+         _Iterator prev = access[iam];
+         size_type i = beg_partition[iam];
+         _Iterator it = prev;
+         if (iam !=0)
+           {
+             --prev;
 
-           // First iteration here, to update accessor in case was
-           // equal to the last element of the previous range
+             // First iteration here, to update accessor in case was
+             // equal to the last element of the previous range
 
-           // Dealing with repetitions (CORRECTNESS ISSUE).
-           if (strictly_less_or_less_equal(_KeyOfValue()(*prev),_KeyOfValue()(*it)))
-             {
-               sums[i] = 0;
-               prev=it;
-             }
-           else
-             {
+             // Dealing with repetitions (CORRECTNESS ISSUE).
+             if (strictly_less_or_less_equal(_KeyOfValue()(*prev),
+                                             _KeyOfValue()(*it)))
+               {
+                 sums[i] = 0;
+                 prev=it;
+               }
+             else
                sums[i] = 1;
-             }
-           ++i;
-           ++it;
-         }
+             ++i;
+             ++it;
+           }
        else
          {
            sums[i] = 0;
@@ -1643,7 +1725,8 @@ namespace __gnu_parallel
        while (it!= access[iam+1])
          {
            // Dealing with repetitions (CORRECTNESS ISSUE).
-           if (strictly_less_or_less_equal(_KeyOfValue()(*prev),_KeyOfValue()(*it)))
+           if (strictly_less_or_less_equal(_KeyOfValue()(*prev),
+                                           _KeyOfValue()(*it)))
              {
                sums[i] = 0;
                prev=it;
@@ -1658,7 +1741,8 @@ namespace __gnu_parallel
       partial_sum(sums,sums + n, sums);
 
       n -= sums[n-1];
-      _Rb_tree_node_ptr* r = static_cast<_Rb_tree_node_ptr*> (::operator new (sizeof(_Rb_tree_node_ptr)*(n+1)));
+      _Rb_tree_node_ptr* r = static_cast<_Rb_tree_node_ptr*>(
+       ::operator new(sizeof(_Rb_tree_node_ptr) * (n + 1)));
       r[n]=0;
 
 #pragma omp parallel num_threads(num_threads)
@@ -1721,70 +1805,79 @@ namespace __gnu_parallel
      * of the wrapping container
      */
     template<typename _Iterator, typename StrictlyLessOrLessEqual>
-    void
-    _M_sorted_bulk_construction(_Iterator* access, size_type* beg_partition, const size_type n, thread_index_t num_threads, StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      // Dealing with repetitions (EFFICIENCY ISSUE).
-      size_type rank_shift[num_threads+1];
-
-      _Rb_tree_node_ptr* r = _M_sorted_bulk_allocation_and_initialization(access, beg_partition, rank_shift, n, num_threads, strictly_less_or_less_equal);
+      void
+      _M_sorted_bulk_construction(_Iterator* access, size_type* beg_partition,
+                                 const size_type n,
+                                 thread_index_t num_threads,
+                                 StrictlyLessOrLessEqual
+                                 strictly_less_or_less_equal)
+      {
+       // Dealing with repetitions (EFFICIENCY ISSUE).
+       size_type rank_shift[num_threads+1];
 
-      // Link the tree appropriately.
-      // Dealing with repetitions (EFFICIENCY ISSUE).
-      ranker_gaps rank(beg_partition, rank_shift, num_threads);
-      nodes_initializer<ranker_gaps> nodes_init(r, n - rank_shift[num_threads], num_threads, rank);
-      size_type split = nodes_init.get_shifted_splitting_point();
+       _Rb_tree_node_ptr* r = _M_sorted_bulk_allocation_and_initialization
+         (access, beg_partition, rank_shift, n, num_threads,
+          strictly_less_or_less_equal);
+       
+       // Link the tree appropriately.
+       // Dealing with repetitions (EFFICIENCY ISSUE).
+       ranker_gaps rank(beg_partition, rank_shift, num_threads);
+       nodes_initializer<ranker_gaps>
+         nodes_init(r, n - rank_shift[num_threads], num_threads, rank);
+       size_type split = nodes_init.get_shifted_splitting_point();
 
 #pragma omp parallel num_threads(num_threads)
-      {
+       {
 #if USE_PAPI
-       PAPI_register_thread();
+         PAPI_register_thread();
 #endif
-       int iam = omp_get_thread_num();
-       size_type beg = beg_partition[iam];
-       // Dealing with repetitions (EFFICIENCY ISSUE).
-       size_type end = beg_partition[iam+1] - (rank_shift[iam+1] - rank_shift[iam]);
-       if (split >= end)
-         {
-           for (size_type i = beg; i < end; ++i)
-             {
+         int iam = omp_get_thread_num();
+         size_type beg = beg_partition[iam];
+         // Dealing with repetitions (EFFICIENCY ISSUE).
+         size_type end = (beg_partition[iam+1]
+                          - (rank_shift[iam+1] - rank_shift[iam]));
+         if (split >= end)
+           {
+             for (size_type i = beg; i < end; ++i)
                nodes_init.link_complete(r[i],iam);
-             }
-         }
-       else
-         {
-           if (split <= beg)
-             {
-               for (size_type i = beg; i < end; ++i)
-                 nodes_init.link_incomplete(r[i],iam);
-             }
-           else
-             {
-               for (size_type i = beg; i < split; ++i)
-                 nodes_init.link_complete(r[i],iam);
-               for (size_type i = split; i < end; ++i)
-                 nodes_init.link_incomplete(r[i],iam);
-             }
-         }
-      }
-      // If the execution reaches this point, there has been no
-      // exception, and so the structure can be initialized.
-
-      // Join the tree laid on the array of ptrs with the header node.
-      // Dealing with repetitions (EFFICIENCY ISSUE).
-      base_type::_M_impl._M_node_count = n - rank_shift[num_threads];
-      base_type::_M_impl._M_header._M_left = r[0];
-      thread_index_t with_element =  num_threads;
-      while ((beg_partition[with_element] - beg_partition[with_element-1]) == (rank_shift[with_element] - rank_shift[with_element-1]))
-       {
-         --with_element;
+           }
+         else
+           {
+             if (split <= beg)
+               {
+                 for (size_type i = beg; i < end; ++i)
+                   nodes_init.link_incomplete(r[i],iam);
+               }
+             else
+               {
+                 for (size_type i = beg; i < split; ++i)
+                   nodes_init.link_complete(r[i],iam);
+                 for (size_type i = split; i < end; ++i)
+                   nodes_init.link_incomplete(r[i],iam);
+               }
+           }
        }
-      base_type::_M_impl._M_header._M_right = r[beg_partition[with_element] - (rank_shift[with_element] - rank_shift[with_element-1]) - 1];
-      base_type::_M_impl._M_header._M_parent = nodes_init.get_root();
-      nodes_init.get_root()->_M_parent= &base_type::_M_impl._M_header;
+       // If the execution reaches this point, there has been no
+       // exception, and so the structure can be initialized.
 
-      ::operator delete(r);
-    }
+       // Join the tree laid on the array of ptrs with the header node.
+       // Dealing with repetitions (EFFICIENCY ISSUE).
+       base_type::_M_impl._M_node_count = n - rank_shift[num_threads];
+       base_type::_M_impl._M_header._M_left = r[0];
+       thread_index_t with_element =  num_threads;
+       while ((beg_partition[with_element]
+               - beg_partition[with_element-1])
+              == (rank_shift[with_element] - rank_shift[with_element-1]))
+         --with_element;
+       
+       base_type::_M_impl._M_header._M_right =
+         r[beg_partition[with_element]
+           - (rank_shift[with_element] - rank_shift[with_element-1]) - 1];
+       base_type::_M_impl._M_header._M_parent = nodes_init.get_root();
+       nodes_init.get_root()->_M_parent= &base_type::_M_impl._M_header;
+
+       ::operator delete(r);
+      }
 
 
     /** @brief Main bulk insertion method: perform the actual
@@ -1807,204 +1900,272 @@ namespace __gnu_parallel
      * of the wrapping container
      */
     template<typename _Iterator, typename StrictlyLessOrLessEqual>
-    void
-    _M_sorted_bulk_insertion(_Iterator* access, size_type* beg_partition, size_type k, thread_index_t num_threads, StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      _GLIBCXX_PARALLEL_ASSERT((size_type)num_threads <= k);
-      // num_thr-1 problems in the upper part of the tree
-      // num_thr problems to further parallelize
-      std::vector<size_type> existing(num_threads,0);
+      void
+      _M_sorted_bulk_insertion(_Iterator* access, size_type* beg_partition,
+                              size_type k, thread_index_t num_threads,
+                              StrictlyLessOrLessEqual
+                              strictly_less_or_less_equal)
+      {
+       _GLIBCXX_PARALLEL_ASSERT((size_type)num_threads <= k);
+       // num_thr-1 problems in the upper part of the tree
+       // num_thr problems to further parallelize
+       std::vector<size_type> existing(num_threads,0);
 #if _GLIBCXX_TREE_INITIAL_SPLITTING
-      /*****   Dealing with repetitions (EFFICIENCY ISSUE) *****/
-      size_type rank_shift[num_threads+1];
+       /*****  Dealing with repetitions (EFFICIENCY ISSUE) *****/
+       size_type rank_shift[num_threads+1];
 
-      // Need to create them dynamically because they are so erased
-      concat_problem* conc[2*num_threads-1];
+       // Need to create them dynamically because they are so erased
+       concat_problem* conc[2*num_threads-1];
 #endif
-      _Rb_tree_node_ptr* r;
-      /*****   Dealing with repetitions (EFFICIENCY ISSUE) *****/
-      if (not strictly_less_or_less_equal(base_type::_S_key(base_type::_M_root()),base_type::_S_key(base_type::_M_root()) ))
-       {
-         // Unique container
-         // Set 1 and 2 could be done in parallel ...
-         // 1. Construct the nodes with their corresponding data
+       _Rb_tree_node_ptr* r;
+       /*****  Dealing with repetitions (EFFICIENCY ISSUE) *****/
+       if (not strictly_less_or_less_equal
+           (base_type::_S_key(base_type::_M_root()),
+            base_type::_S_key(base_type::_M_root()) ))
+         {
+           // Unique container
+           // Set 1 and 2 could be done in parallel ...
+           // 1. Construct the nodes with their corresponding data
 #if _GLIBCXX_TREE_INITIAL_SPLITTING
-         r = _M_sorted_bulk_allocation_and_initialization(access, beg_partition, rank_shift, k, num_threads, strictly_less_or_less_equal);
+           r = _M_sorted_bulk_allocation_and_initialization
+             (access, beg_partition, rank_shift, k, num_threads,
+              strictly_less_or_less_equal);
 #else
-         r = _M_sorted_no_gapped_bulk_allocation_and_initialization(access, beg_partition, k, num_threads, strictly_less_or_less_equal);
+           r = _M_sorted_no_gapped_bulk_allocation_and_initialization
+             (access, beg_partition, k, num_threads,
+              strictly_less_or_less_equal);
 #endif
-       }
-      else
-       {
-         // Not unique container.
-         r = _M_unsorted_bulk_allocation_and_initialization(access, beg_partition, k, num_threads);
+         }
+       else
+         {
+           // Not unique container.
+           r = _M_unsorted_bulk_allocation_and_initialization
+             (access, beg_partition, k, num_threads);
 #if _GLIBCXX_TREE_INITIAL_SPLITTING
-         // Trivial initialization of rank_shift.
-         for (int i=0; i <= num_threads; ++i)
-           rank_shift[i] = 0;
+           // Trivial initialization of rank_shift.
+           for (int i=0; i <= num_threads; ++i)
+             rank_shift[i] = 0;
 #endif
-       }
+         }
 #if _GLIBCXX_TREE_INITIAL_SPLITTING
-      // Calculate position of last element to be inserted: must be
-      // done now, or otherwise becomes messy.
-
-  /***** Dealing with
-      repetitions (EFFICIENCY ISSUE) *****/
-      size_type last = beg_partition[num_threads] - (rank_shift[num_threads] - rank_shift[num_threads - 1]);
-
-      //2. Split the tree according to access in num_threads parts
-      //Initialize upper concat_problems
-      //Allocate them dynamically because they are afterwards so erased
-      for (int i=0; i < (2*num_threads-1); ++i)
-       {
+       // Calculate position of last element to be inserted: must be
+       // done now, or otherwise becomes messy.
+
+       /***** Dealing with
+        repetitions (EFFICIENCY ISSUE) *****/
+       size_type last = (beg_partition[num_threads]
+                         - (rank_shift[num_threads]
+                            - rank_shift[num_threads - 1]));
+
+       //2. Split the tree according to access in num_threads parts
+       //Initialize upper concat_problems
+       //Allocate them dynamically because they are afterwards so erased
+       for (int i=0; i < (2*num_threads-1); ++i)
          conc[i] = new concat_problem ();
-       }
-      concat_problem* root_problem = _M_bulk_insertion_initialize_upper_problems(conc, 0, num_threads, NULL);
-
-      // The first position of access and the last are ignored, so we
-      // have exactly num_threads subtrees.
-      bool before = omp_get_nested();
-      omp_set_nested(true);
-      _M_bulk_insertion_split_tree_by_pivot(static_cast<_Rb_tree_node_ptr>(base_type::_M_root()), r, access, beg_partition, rank_shift, 0, num_threads-1, conc, num_threads, strictly_less_or_less_equal);
-      omp_set_nested(before);
-
-      // Construct upper tree with the first elements of ranges if
-      // they are NULL We cannot do this by default because they could
-      // be repeated and would not be checked.
-      size_type r_s = 0;
-      for (int pos = 1; pos < num_threads; ++pos)
-       {
-         _GLIBCXX_PARALLEL_ASSERT(conc[(pos-1)*2]->t == NULL or conc[pos*2-1]->t == NULL or strictly_less_or_less_equal(base_type::_S_key(base_type::_S_maximum(conc[(pos-1)*2]->t)), base_type::_S_key(conc[pos*2-1]->t)));
-         _GLIBCXX_PARALLEL_ASSERT(conc[pos*2]->t == NULL  or conc[pos*2-1]->t == NULL or strictly_less_or_less_equal( base_type::_S_key(conc[pos*2-1]->t), base_type::_S_key(base_type::_S_minimum(conc[pos*2]->t))));
-         /*****        Dealing with repetitions (CORRECTNESS ISSUE) *****/
+       concat_problem* root_problem =
+         _M_bulk_insertion_initialize_upper_problems(conc, 0,
+                                                     num_threads, NULL);
+
+       // The first position of access and the last are ignored, so we
+       // have exactly num_threads subtrees.
+       bool before = omp_get_nested();
+       omp_set_nested(true);
+
+       _M_bulk_insertion_split_tree_by_pivot(
+         static_cast<_Rb_tree_node_ptr>(base_type::_M_root()), r,
+         access, beg_partition, rank_shift, 0, num_threads - 1, conc,
+         num_threads, strictly_less_or_less_equal);
+
+       omp_set_nested(before);
+
+       // Construct upper tree with the first elements of ranges if
+       // they are NULL We cannot do this by default because they could
+       // be repeated and would not be checked.
+       size_type r_s = 0;
+       for (int pos = 1; pos < num_threads; ++pos)
+         {
+           _GLIBCXX_PARALLEL_ASSERT(
+             conc[(pos-1)*2]->t == NULL or conc[pos*2-1]->t == NULL
+             or strictly_less_or_less_equal
+             (base_type::_S_key(base_type::_S_maximum(conc[(pos-1)*2]->t)),
+              base_type::_S_key(conc[pos*2-1]->t)));
+           _GLIBCXX_PARALLEL_ASSERT(
+             conc[pos*2]->t == NULL or conc[pos*2-1]->t == NULL
+             or strictly_less_or_less_equal(
+               base_type::_S_key(conc[pos*2-1]->t),
+               base_type::_S_key(base_type::_S_minimum(conc[pos*2]->t))));
+           /*****      Dealing with repetitions (CORRECTNESS ISSUE) *****/
 
-         // The first element of the range is the root.
-         if (conc[pos*2-1]->t == NULL or (not(strictly_less_or_less_equal(base_type::_S_key(static_cast<_Rb_tree_node_ptr>(conc[pos*2-1]->t)), _KeyOfValue()(*access[pos])))))
-           {
-             // There was not a candidate element
-             // or
-             // Exists an initialized position in the array which
-             // corresponds to conc[pos*2-1]->t */
-             if (conc[pos*2-1]->t == NULL)
-               {
-                 size_t np = beg_partition[pos];
-                 _GLIBCXX_PARALLEL_ASSERT(conc[(pos-1)*2]->t == NULL or strictly_less_or_less_equal(base_type::_S_key(base_type::_S_maximum(conc[(pos-1)*2]->t)), base_type::_S_key(r[np])));
-                 _GLIBCXX_PARALLEL_ASSERT(conc[pos*2]->t == NULL  or strictly_less_or_less_equal( base_type::_S_key(r[np]), base_type::_S_key(base_type::_S_minimum(conc[pos*2]->t))));
-                 conc[pos*2-1]->t = r[np];
-                 r[np]->_M_color = std::_S_black;
-                 ++base_type::_M_impl._M_node_count;
-               }
-             else
-               {
+           // The first element of the range is the root.
+           if (conc[pos*2-1]->t == NULL
+               or (not(strictly_less_or_less_equal(
+                         base_type::_S_key(static_cast<_Rb_tree_node_ptr>
+                                           (conc[pos*2-1]->t)),
+                         _KeyOfValue()(*access[pos])))))
+             {
+               // There was not a candidate element
+               // or
+               // Exists an initialized position in the array which
+               // corresponds to conc[pos*2-1]->t */
+               if (conc[pos*2-1]->t == NULL)
+                 {
+                   size_t np = beg_partition[pos];
+                   _GLIBCXX_PARALLEL_ASSERT(
+                     conc[(pos-1)*2]->t == NULL
+                     or strictly_less_or_less_equal
+                     (base_type::_S_key(base_type::
+                                        _S_maximum(conc[(pos-1)*2]->t)),
+                      base_type::_S_key(r[np])));
+                   _GLIBCXX_PARALLEL_ASSERT(
+                     conc[pos*2]->t == NULL
+                     or strictly_less_or_less_equal(
+                       base_type::_S_key(r[np]),
+                       base_type::_S_key(base_type::
+                                         _S_minimum(conc[pos*2]->t))));
+                   conc[pos*2-1]->t = r[np];
+                   r[np]->_M_color = std::_S_black;
+                   ++base_type::_M_impl._M_node_count;
+                 }
+               else
                  base_type::_M_destroy_node(r[beg_partition[pos]]);
-               }
-             ++(access[pos]);
-             ++(beg_partition[pos]);
-             ++r_s;
-           }
-         _GLIBCXX_PARALLEL_ASSERT(conc[(pos-1)*2]->t == NULL or conc[(pos-1)*2]->t->_M_color == std::_S_black);
-         /*****        Dealing with repetitions (EFFICIENCY ISSUE) *****/
-         rank_shift[pos] += r_s;
-       }
-      /*****   Dealing with repetitions (EFFICIENCY ISSUE) *****/
-      rank_shift[num_threads] += r_s;
+               ++(access[pos]);
+               ++(beg_partition[pos]);
+               ++r_s;
+             }
+           _GLIBCXX_PARALLEL_ASSERT(
+             conc[(pos-1)*2]->t == NULL
+             or conc[(pos-1)*2]->t->_M_color == std::_S_black);
+           /*****      Dealing with repetitions (EFFICIENCY ISSUE) *****/
+           rank_shift[pos] += r_s;
+         }
+       /*****  Dealing with repetitions (EFFICIENCY ISSUE) *****/
+       rank_shift[num_threads] += r_s;
 #else
-      concat_problem root_problem_on_stack(static_cast<_Rb_tree_node_ptr>(base_type::_M_root()), black_height(static_cast<_Rb_tree_node_ptr>(base_type::_M_root())), NULL);
-      concat_problem * root_problem = &root_problem_on_stack;
-      size_type last = k;
+       concat_problem root_problem_on_stack(
+         static_cast<_Rb_tree_node_ptr>(base_type::_M_root()),
+         black_height(static_cast<_Rb_tree_node_ptr>(base_type::_M_root())),
+         NULL);
+       concat_problem * root_problem = &root_problem_on_stack;
+       size_type last = k;
 #endif
 
-      // 3. Split the range according to tree and create
-      // 3. insertion/concatenation problems to be solved in parallel
+       // 3. Split the range according to tree and create
+       // 3. insertion/concatenation problems to be solved in parallel
 #if _GLIBCXX_TREE_DYNAMIC_BALANCING
-      size_type min_problem = (k/num_threads) / (log2(k/num_threads + 1)+1);
+       size_type min_problem = (k/num_threads) / (log2(k/num_threads + 1)+1);
 #else
-      size_type min_problem = base_type::size() + k;
+       size_type min_problem = base_type::size() + k;
 #endif
 
-      RestrictedBoundedConcurrentQueue<insertion_problem>* ins_problems[num_threads];
+       RestrictedBoundedConcurrentQueue<insertion_problem>* 
+         ins_problems[num_threads];
 
 #pragma omp parallel num_threads(num_threads)
-      {
-       int num_thread = omp_get_thread_num();
-       ins_problems[num_thread] = new RestrictedBoundedConcurrentQueue<insertion_problem>(2*(log2(base_type::size())+1));
+       {
+         int num_thread = omp_get_thread_num();
+         ins_problems[num_thread] =
+           new RestrictedBoundedConcurrentQueue<insertion_problem>
+           (2 * (log2(base_type::size()) + 1));
 #if _GLIBCXX_TREE_INITIAL_SPLITTING
-       /*****  Dealing with repetitions (EFFICIENCY ISSUE) *****/
-       size_type end_k_thread = beg_partition[num_thread+1]  - (rank_shift[num_thread+1] - rank_shift[num_thread]);
-       ins_problems[num_thread]->push_front(insertion_problem(beg_partition[num_thread], end_k_thread, num_thread, conc[num_thread*2]));
+         /*****        Dealing with repetitions (EFFICIENCY ISSUE) *****/
+         size_type end_k_thread = (beg_partition[num_thread+1]
+                                   - (rank_shift[num_thread+1]
+                                      - rank_shift[num_thread]));
+         ins_problems[num_thread]->push_front(
+           insertion_problem(beg_partition[num_thread], end_k_thread,
+                             num_thread, conc[num_thread*2]));
 #else
-       // size_type end_k_thread = beg_partition[num_thread+1];
+         // size_type end_k_thread = beg_partition[num_thread+1];
 #endif
-       insertion_problem ip_to_solve;
-       bool change;
+         insertion_problem ip_to_solve;
+         bool change;
 
 #if _GLIBCXX_TREE_INITIAL_SPLITTING
 #pragma omp barrier
 #else
 #pragma omp single
-       ins_problems[num_thread]->push_front(insertion_problem(0, k, num_thread, root_problem));
+         ins_problems[num_thread]->push_front(insertion_problem(
+                                                0, k, num_thread,
+                                                root_problem));
 #endif
 
-       do
-         {
-           // First do own work.
-           while (ins_problems[num_thread]->pop_front(ip_to_solve))
-             {
-               _GLIBCXX_PARALLEL_ASSERT(ip_to_solve.pos_beg <= ip_to_solve.pos_end);
-               _M_bulk_insertion_split_sequence(r, ins_problems[num_thread], ip_to_solve, existing[num_thread], min_problem, strictly_less_or_less_equal);
-
-             }
-           yield();
-           change = false;
+         do
+           {
+             // First do own work.
+             while (ins_problems[num_thread]->pop_front(ip_to_solve))
+               {
+                 _GLIBCXX_PARALLEL_ASSERT(ip_to_solve.pos_beg
+                                          <= ip_to_solve.pos_end);
+                 _M_bulk_insertion_split_sequence(
+                   r, ins_problems[num_thread], ip_to_solve,
+                   existing[num_thread], min_problem,
+                   strictly_less_or_less_equal);
 
-           //Then, try to steal from others (and become own).
-           for (int i=1; i<num_threads; ++i)
-             {
-               if (ins_problems[(num_thread+i)%num_threads]->pop_back(ip_to_solve))
-                 {
-                   change = true;
-                   _M_bulk_insertion_split_sequence(r, ins_problems[num_thread], ip_to_solve, existing[num_thread], min_problem, strictly_less_or_less_equal);
-                   break;
-                 }
-             }
-         } while (change);
-      }
+               }
+             yield();
+             change = false;
 
-      // Update root and sizes.
-      base_type::_M_root() = root_problem->t;
-      root_problem->t->_M_parent = &(base_type::_M_impl._M_header);
-      /*****   Dealing with repetitions (EFFICIENCY ISSUE) *****/
+             //Then, try to steal from others (and become own).
+             for (int i=1; i<num_threads; ++i)
+               {
+                 if (ins_problems[(num_thread + i)
+                                  % num_threads]->pop_back(ip_to_solve))
+                   {
+                     change = true;
+                     _M_bulk_insertion_split_sequence(
+                       r, ins_problems[num_thread], ip_to_solve,
+                       existing[num_thread], min_problem,
+                       strictly_less_or_less_equal);
+                     break;
+                   }
+               }
+           } while (change);
+       }
 
-      // Add the k elements that wanted to be inserted, minus the ones
-      // that were repeated.
+       // Update root and sizes.
+       base_type::_M_root() = root_problem->t;
+       root_problem->t->_M_parent = &(base_type::_M_impl._M_header);
+       /*****  Dealing with repetitions (EFFICIENCY ISSUE) *****/
+       
+       // Add the k elements that wanted to be inserted, minus the ones
+       // that were repeated.
 #if _GLIBCXX_TREE_INITIAL_SPLITTING
-      base_type::_M_impl._M_node_count += (k - (rank_shift[num_threads]));
+       base_type::_M_impl._M_node_count += (k - (rank_shift[num_threads]));
 #else
-      base_type::_M_impl._M_node_count += k;
+       base_type::_M_impl._M_node_count += k;
 #endif
-      // Also then, take out the ones that were already existing in the tree.
-      for (int i = 0; i< num_threads; ++i)
-       {
+       // Also then, take out the ones that were already existing in the tree.
+       for (int i = 0; i< num_threads; ++i)
          base_type::_M_impl._M_node_count -= existing[i];
-       }
-      // Update leftmost and rightmost.
-      /*****   Dealing with repetitions (EFFICIENCY ISSUE) *****/
-      if (not strictly_less_or_less_equal(base_type::_S_key(base_type::_M_root()), base_type::_S_key(base_type::_M_root()))){
-       // Unique container.
-       if (base_type::_M_impl._M_key_compare(_KeyOfValue()(*(access[0])), base_type::_S_key(base_type::_M_leftmost())))
-         base_type::_M_leftmost() = r[0];
-       if (base_type::_M_impl._M_key_compare(base_type::_S_key(base_type::_M_rightmost()), _KeyOfValue()(*(--access[num_threads]))))
-         base_type::_M_rightmost() = r[last - 1];
-      }
-      else{
-       if (strictly_less_or_less_equal(_KeyOfValue()(*(access[0])), base_type::_S_key(base_type::_M_leftmost())))
-         base_type::_M_leftmost() = base_type::_S_minimum(base_type::_M_root());
-       if (strictly_less_or_less_equal(base_type::_S_key(base_type::_M_rightmost()), _KeyOfValue()(*(--access[num_threads]))))
-         base_type::_M_rightmost() =  base_type::_S_maximum(base_type::_M_root());
-      }
-
-
-
+       // Update leftmost and rightmost.
+       /*****  Dealing with repetitions (EFFICIENCY ISSUE) *****/
+       if (not strictly_less_or_less_equal(
+             base_type::_S_key(base_type::_M_root()),
+             base_type::_S_key(base_type::_M_root())))
+         {
+           // Unique container.
+           if (base_type::_M_impl._M_key_compare(
+                 _KeyOfValue()(*(access[0])),
+                 base_type::_S_key(base_type::_M_leftmost())))
+             base_type::_M_leftmost() = r[0];
+           if (base_type::_M_impl._M_key_compare(
+                 base_type::_S_key(base_type::_M_rightmost()),
+                 _KeyOfValue()(*(--access[num_threads]))))
+             base_type::_M_rightmost() = r[last - 1];
+         }
+       else
+         {
+           if (strictly_less_or_less_equal(_KeyOfValue()(*(access[0])),
+                                           base_type::_S_key(base_type::
+                                                             _M_leftmost())))
+             base_type::_M_leftmost() =
+               base_type::_S_minimum(base_type::_M_root());
+           if (strictly_less_or_less_equal(
+                 base_type::_S_key(base_type::_M_rightmost()),
+                 _KeyOfValue()(*(--access[num_threads]))))
+             base_type::_M_rightmost() = 
+               base_type::_S_maximum(base_type::_M_root());
+         }
 
 #if _GLIBCXX_TREE_INITIAL_SPLITTING
       // Delete root problem
@@ -2013,9 +2174,7 @@ namespace __gnu_parallel
 
       // Delete queues
       for (int pos = 0; pos < num_threads; ++pos)
-       {
-         delete ins_problems[pos];
-       }
+       delete ins_problems[pos];
 
       // Delete array of pointers
       ::operator delete(r);
@@ -2056,101 +2215,136 @@ namespace __gnu_parallel
      * of the wrapping container
      */
     template<typename _Iterator, typename StrictlyLessOrLessEqual>
-    void
-    _M_bulk_insertion_split_tree_by_pivot(_Rb_tree_node_ptr t, _Rb_tree_node_ptr* r, _Iterator* access,  size_type* beg_partition, size_type* rank_shift, const size_type pos_beg, const size_type pos_end, concat_problem** conc, const thread_index_t num_threads, StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      if (pos_beg == pos_end)
-       {
-         //Elements are in [pos_beg, pos_end]
-         conc[pos_beg*2]->t = t;
-         conc[pos_beg*2]->black_h = black_height(t);
-         force_black_root (conc[pos_beg*2]->t, conc[pos_beg*2]->black_h);
-         return;
-       }
-      if (t == 0)
-       {
-         for (size_type i = pos_beg; i < pos_end; ++i)
-           {
-             conc[i*2]->t = NULL;
-             conc[i*2]->black_h = 0;
-             conc[i*2+1]->t = NULL;
-           }
-         conc[pos_end*2]->t = NULL;
-         conc[pos_end*2]->black_h = 0;
-         return;
-       }
+      void
+      _M_bulk_insertion_split_tree_by_pivot(_Rb_tree_node_ptr t,
+                                           _Rb_tree_node_ptr* r,
+                                           _Iterator* access,
+                                           size_type* beg_partition,
+                                           size_type* rank_shift,
+                                           const size_type pos_beg,
+                                           const size_type pos_end,
+                                           concat_problem** conc,
+                                           const thread_index_t num_threads,
+                                           StrictlyLessOrLessEqual
+                                           strictly_less_or_less_equal)
+      {
+       if (pos_beg == pos_end)
+         {
+           //Elements are in [pos_beg, pos_end]
+           conc[pos_beg*2]->t = t;
+           conc[pos_beg*2]->black_h = black_height(t);
+           force_black_root (conc[pos_beg*2]->t, conc[pos_beg*2]->black_h);
+           return;
+         }
+       if (t == 0)
+         {
+           for (size_type i = pos_beg; i < pos_end; ++i)
+             {
+               conc[i*2]->t = NULL;
+               conc[i*2]->black_h = 0;
+               conc[i*2+1]->t = NULL;
+             }
+           conc[pos_end*2]->t = NULL;
+           conc[pos_end*2]->black_h = 0;
+           return;
+         }
 
-      // Return the last pos, in which key >= (pos-1).
-      // Search in the range [pos_beg, pos_end]
-      size_type pos = std::upper_bound(access + pos_beg, access + pos_end + 1, base_type::_S_key(t), compare_value_key<_Iterator, _Compare>(base_type::_M_impl._M_key_compare)) - access;
-      if (pos != pos_beg)
-       {
+       // Return the last pos, in which key >= (pos-1).
+       // Search in the range [pos_beg, pos_end]
+       size_type pos = (std::upper_bound(access + pos_beg,
+                                        access + pos_end + 1,
+                                        base_type::_S_key(t),
+                                        compare_value_key<_Iterator,
+                                        _Compare>(base_type::
+                                                  _M_impl._M_key_compare))
+                        - access);
+       if (pos != pos_beg)
          --pos;
-       }
-      _GLIBCXX_PARALLEL_ASSERT(pos == 0 or not base_type::_M_impl._M_key_compare(base_type::_S_key(t), _KeyOfValue()(*access[pos])));
-
-
-      _Rb_tree_node_ptr ll, lr;
-      int black_h_ll, black_h_lr;
-      _Rb_tree_node_ptr rl, rr;
-      int black_h_rl, black_h_rr;
-
-      if (pos != pos_beg)
-       {
-         _Rb_tree_node_ptr prev = r[beg_partition[pos] - 1 - (rank_shift[pos] - rank_shift[pos - 1])];
-
-         _GLIBCXX_PARALLEL_ASSERT(strictly_less_or_less_equal(base_type::_S_key(prev), _KeyOfValue()(*access[pos])));
 
-         split(static_cast<_Rb_tree_node_ptr>(t->_M_left),
-               static_cast<const key_type&>(_KeyOfValue()(*access[pos])),
-               static_cast<const key_type&>(base_type::_S_key(prev)),
-               conc[pos*2-1]->t, ll, lr, black_h_ll, black_h_lr,
-               strictly_less_or_less_equal);
+       _GLIBCXX_PARALLEL_ASSERT(
+         pos == 0
+         or not base_type::_M_impl._M_key_compare(
+           base_type::_S_key(t), _KeyOfValue()(*access[pos])));
 
-         _M_bulk_insertion_split_tree_by_pivot(ll, r, access, beg_partition, rank_shift, pos_beg, pos-1, conc,num_threads, strictly_less_or_less_equal);
-       }
-      else
-       {
-         lr = static_cast<_Rb_tree_node_ptr>(t->_M_left);
-         black_h_lr = black_height (lr);
-         force_black_root (lr, black_h_lr);
-       }
-
-      if (pos != pos_end)
-       {
-         _Rb_tree_node_ptr prev = r[beg_partition[pos+1] - 1 - (rank_shift[pos+1] - rank_shift[pos])];
+       
+       _Rb_tree_node_ptr ll, lr;
+       int black_h_ll, black_h_lr;
+       _Rb_tree_node_ptr rl, rr;
+       int black_h_rl, black_h_rr;
 
-         _GLIBCXX_PARALLEL_ASSERT(not base_type::_M_impl._M_key_compare(_KeyOfValue()(*access[pos+1]), base_type::_S_key(prev)));
-         _GLIBCXX_PARALLEL_ASSERT(strictly_less_or_less_equal(base_type::_S_key(prev), _KeyOfValue()(*access[pos+1])));
-
-         split(static_cast<_Rb_tree_node_ptr>(t->_M_right),
-               static_cast<const key_type&>(_KeyOfValue()(*access[pos+1])),
-               static_cast<const key_type&>(base_type::_S_key(prev)),
-               conc[pos*2+1]->t, rl, rr, black_h_rl, black_h_rr,
-               strictly_less_or_less_equal);
+       if (pos != pos_beg)
+         {
+           _Rb_tree_node_ptr prev = (r[beg_partition[pos] - 1
+                                       - (rank_shift[pos]
+                                          - rank_shift[pos - 1])]);
+
+           _GLIBCXX_PARALLEL_ASSERT(
+             strictly_less_or_less_equal(base_type::_S_key(prev),
+                                         _KeyOfValue()(*access[pos])));
+
+           split(static_cast<_Rb_tree_node_ptr>(t->_M_left),
+                 static_cast<const key_type&>(_KeyOfValue()(*access[pos])),
+                 static_cast<const key_type&>(base_type::_S_key(prev)),
+                 conc[pos*2-1]->t, ll, lr, black_h_ll, black_h_lr,
+                 strictly_less_or_less_equal);
+
+           _M_bulk_insertion_split_tree_by_pivot(
+             ll, r, access, beg_partition, rank_shift, pos_beg, pos-1,
+             conc, num_threads, strictly_less_or_less_equal);
+         }
+       else
+         {
+           lr = static_cast<_Rb_tree_node_ptr>(t->_M_left);
+           black_h_lr = black_height (lr);
+           force_black_root (lr, black_h_lr);
+         }
 
-         _M_bulk_insertion_split_tree_by_pivot(rr, r, access, beg_partition, rank_shift, pos+1, pos_end, conc,num_threads, strictly_less_or_less_equal);
-       }
-      else
-       {
-         rl = static_cast<_Rb_tree_node_ptr>(t->_M_right);
-         black_h_rl = black_height (rl);
-         force_black_root (rl, black_h_rl);
-       }
+       if (pos != pos_end)
+         {
+           _Rb_tree_node_ptr prev = (r[beg_partition[pos+1] - 1
+                                       - (rank_shift[pos+1]
+                                          - rank_shift[pos])]);
+
+           _GLIBCXX_PARALLEL_ASSERT(
+             not base_type::_M_impl._M_key_compare(
+               _KeyOfValue()(*access[pos+1]), base_type::_S_key(prev)));
+           _GLIBCXX_PARALLEL_ASSERT(
+             strictly_less_or_less_equal(base_type::_S_key(prev),
+                                         _KeyOfValue()(*access[pos+1])));
+
+           split(static_cast<_Rb_tree_node_ptr>(t->_M_right),
+                 static_cast<const key_type&>(_KeyOfValue()(*access[pos+1])),
+                 static_cast<const key_type&>(base_type::_S_key(prev)),
+                 conc[pos*2+1]->t, rl, rr, black_h_rl, black_h_rr,
+                 strictly_less_or_less_equal);
+
+           _M_bulk_insertion_split_tree_by_pivot(
+             rr, r, access, beg_partition, rank_shift, pos+1, pos_end,
+             conc,num_threads, strictly_less_or_less_equal);
+         }
+       else
+         {
+           rl = static_cast<_Rb_tree_node_ptr>(t->_M_right);
+           black_h_rl = black_height (rl);
+           force_black_root (rl, black_h_rl);
+         }
 
-      // When key(t) is equal to key(access[pos]) and no other key in
-      // the left tree satisfies the criteria to be conc[pos*2-1]->t,
-      // key(t) must be assigned to it to avoid repetitions.
-      // Therefore, we do not have a root parameter for the
-      // concatenate function and a new concatenate function must be
-      // provided.
-      if (pos != pos_beg and conc[pos*2-1]->t == NULL and not strictly_less_or_less_equal(_KeyOfValue()(*access[pos]), base_type::_S_key(t)))
-       {
-         conc[pos*2-1]->t = t;
-         t = NULL;
-       }
-      concatenate(t, lr, rl, black_h_lr, black_h_rl, conc[pos*2]->t, conc[pos*2]->black_h);
-    }
+       // When key(t) is equal to key(access[pos]) and no other key in
+       // the left tree satisfies the criteria to be conc[pos*2-1]->t,
+       // key(t) must be assigned to it to avoid repetitions.
+       // Therefore, we do not have a root parameter for the
+       // concatenate function and a new concatenate function must be
+       // provided.
+       if (pos != pos_beg and conc[pos*2-1]->t == NULL
+           and not strictly_less_or_less_equal(_KeyOfValue()(*access[pos]),
+                                               base_type::_S_key(t)))
+         {
+           conc[pos*2-1]->t = t;
+           t = NULL;
+         }
+       concatenate(t, lr, rl, black_h_lr, black_h_rl,
+                   conc[pos*2]->t, conc[pos*2]->black_h);
+      }
 
     /** @brief Divide the insertion problem until a leaf is reached or
      * the problem is small.
@@ -2174,41 +2368,52 @@ namespace __gnu_parallel
      * of the wrapping container
      */
     template<typename StrictlyLessOrLessEqual>
-    void
-    _M_bulk_insertion_split_sequence(_Rb_tree_node_ptr* r, RestrictedBoundedConcurrentQueue<insertion_problem>* ins_problems,  insertion_problem& ip, size_type& existing, const size_type min_problem, StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      _GLIBCXX_PARALLEL_ASSERT(ip.t == ip.conc->t);
-      if (ip.t == NULL or (ip.pos_end- ip.pos_beg) <= min_problem)
-       {
-         // SOLVE PROBLEM SEQUENTIALLY
-         // Start solving the problem.
-         _GLIBCXX_PARALLEL_ASSERT(ip.pos_beg <= ip.pos_end);
-         _M_bulk_insertion_merge_concatenate(r, ip, existing, strictly_less_or_less_equal);
-         return;
-       }
+      void
+      _M_bulk_insertion_split_sequence(
+       _Rb_tree_node_ptr* r,
+       RestrictedBoundedConcurrentQueue<insertion_problem>* ins_problems,
+       insertion_problem& ip, size_type& existing,
+       const size_type min_problem,
+       StrictlyLessOrLessEqual strictly_less_or_less_equal)
+      {
+       _GLIBCXX_PARALLEL_ASSERT(ip.t == ip.conc->t);
+       if (ip.t == NULL or (ip.pos_end- ip.pos_beg) <= min_problem)
+         {
+           // SOLVE PROBLEM SEQUENTIALLY
+           // Start solving the problem.
+           _GLIBCXX_PARALLEL_ASSERT(ip.pos_beg <= ip.pos_end);
+           _M_bulk_insertion_merge_concatenate(r, ip, existing,
+                                               strictly_less_or_less_equal);
+           return;
+         }
 
-      size_type pos_beg_right;
-      size_type pos_end_left = divide(r, ip.pos_beg, ip.pos_end, base_type::_S_key(ip.t), pos_beg_right, existing, strictly_less_or_less_equal);
+       size_type pos_beg_right;
+       size_type pos_end_left = divide(r, ip.pos_beg, ip.pos_end,
+                                       base_type::_S_key(ip.t), pos_beg_right,
+                                       existing, strictly_less_or_less_equal);
 
-      int black_h_l, black_h_r;
-      if (ip.t->_M_color == std::_S_black)
-       {
+       int black_h_l, black_h_r;
+       if (ip.t->_M_color == std::_S_black)
          black_h_l = black_h_r = ip.conc->black_h - 1;
-       }
-      else
-       {
+       else
          black_h_l = black_h_r = ip.conc->black_h;
-       }
 
       // Right problem into the queue.
-      ip.conc->right_problem = new concat_problem(static_cast<_Rb_tree_node_ptr>(ip.t->_M_right), black_h_r, ip.conc);
-      ip.conc->left_problem = new concat_problem(static_cast<_Rb_tree_node_ptr>(ip.t->_M_left), black_h_l, ip.conc);
+      ip.conc->right_problem = new concat_problem(
+       static_cast<_Rb_tree_node_ptr>(ip.t->_M_right), black_h_r, ip.conc);
+      ip.conc->left_problem = new concat_problem(
+       static_cast<_Rb_tree_node_ptr>(ip.t->_M_left), black_h_l, ip.conc);
 
-      ins_problems->push_front(insertion_problem(pos_beg_right, ip.pos_end, ip.array_partition, ip.conc->right_problem));
+      ins_problems->push_front(insertion_problem(pos_beg_right, ip.pos_end,
+                                                ip.array_partition,
+                                                ip.conc->right_problem));
 
       // Solve left problem.
-      insertion_problem ip_left(ip.pos_beg, pos_end_left, ip.array_partition, ip.conc->left_problem);
-      _M_bulk_insertion_split_sequence(r, ins_problems, ip_left, existing, min_problem, strictly_less_or_less_equal);
+      insertion_problem ip_left(ip.pos_beg, pos_end_left, ip.array_partition,
+                               ip.conc->left_problem);
+      _M_bulk_insertion_split_sequence(r, ins_problems, ip_left, existing,
+                                      min_problem,
+                                      strictly_less_or_less_equal);
     }
 
 
@@ -2237,60 +2442,70 @@ namespace __gnu_parallel
      *  @return Resulting tree after the elements have been inserted
      */
     template<typename StrictlyLessOrLessEqual>
-    _Rb_tree_node_ptr 
-    _M_bulk_insertion_merge(_Rb_tree_node_ptr* r_array, _Rb_tree_node_ptr t, const size_type pos_beg, const size_type pos_end,  size_type& existing, int& black_h, StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
+      _Rb_tree_node_ptr 
+      _M_bulk_insertion_merge(_Rb_tree_node_ptr* r_array, _Rb_tree_node_ptr t,
+                             const size_type pos_beg,
+                             const size_type pos_end,
+                             size_type& existing, int& black_h,
+                             StrictlyLessOrLessEqual
+                             strictly_less_or_less_equal)
+      {
 #ifndef NDEBUG
-      int count;
+       int count;
 #endif
-      _GLIBCXX_PARALLEL_ASSERT(pos_beg<=pos_end);
+       _GLIBCXX_PARALLEL_ASSERT(pos_beg<=pos_end);
 
-      // Leaf: a tree with the range must be constructed. Returns its
-      // height in black nodes and its root (in ip.t) If there is
-      // nothing to insert, we still need the height for balancing.
-      if (t == NULL)
-       {
-         if (pos_end == pos_beg) return NULL;
-         t = simple_tree_construct(r_array,pos_beg, pos_end, black_h);
-         _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(t,count));
-         return t;
-       }
-      if (pos_end == pos_beg)
-       return t;
-      if ((pos_end - pos_beg) <= (size_type)(black_h))
-       {
-         // Exponential size tree with respect the number of elements
-         // to be inserted.
-         for (size_type p = pos_beg; p < pos_end; ++p)
-           {
-             t = _M_insert_local(t, r_array[p], existing, black_h, strictly_less_or_less_equal);
-           }
-         _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(t,count));
+       // Leaf: a tree with the range must be constructed. Returns its
+       // height in black nodes and its root (in ip.t) If there is
+       // nothing to insert, we still need the height for balancing.
+       if (t == NULL)
+         {
+           if (pos_end == pos_beg)
+             return NULL;
+           t = simple_tree_construct(r_array,pos_beg, pos_end, black_h);
+           _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(t,count));
+           return t;
+         }
+       if (pos_end == pos_beg)
          return t;
-       }
-
-      size_type pos_beg_right;
-      size_type pos_end_left = divide(r_array, pos_beg, pos_end, base_type::_S_key(t), pos_beg_right, existing, strictly_less_or_less_equal);
+       if ((pos_end - pos_beg) <= (size_type)(black_h))
+         {
+           // Exponential size tree with respect the number of elements
+           // to be inserted.
+           for (size_type p = pos_beg; p < pos_end; ++p)
+             t = _M_insert_local(t, r_array[p], existing, black_h,
+                                 strictly_less_or_less_equal);
+           _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(t,count));
+           return t;
+         }
 
+       size_type pos_beg_right;
+       size_type pos_end_left = divide(r_array, pos_beg, pos_end,
+                                       base_type::_S_key(t), pos_beg_right,
+                                       existing, strictly_less_or_less_equal);
 
-      int black_h_l, black_h_r;
-      if (t->_M_color == std::_S_black)
-       {
+       int black_h_l, black_h_r;
+       if (t->_M_color == std::_S_black)
          black_h_l = black_h_r = black_h - 1;
-       }
-      else
-       {
+       else
          black_h_l = black_h_r = black_h;
-       }
-      force_black_root(t->_M_left, black_h_l);
-      _Rb_tree_node_ptr l = _M_bulk_insertion_merge(r_array, static_cast<_Rb_tree_node_ptr>(t->_M_left), pos_beg, pos_end_left, existing, black_h_l, strictly_less_or_less_equal);
-      force_black_root(t->_M_right, black_h_r);
-      _Rb_tree_node_ptr r = _M_bulk_insertion_merge(r_array, static_cast<_Rb_tree_node_ptr>(t->_M_right), pos_beg_right, pos_end, existing, black_h_r, strictly_less_or_less_equal);
+       
+       force_black_root(t->_M_left, black_h_l);
 
-      concatenate(t, l, r, black_h_l,  black_h_r, t, black_h);
+       _Rb_tree_node_ptr l = _M_bulk_insertion_merge(
+         r_array, static_cast<_Rb_tree_node_ptr>(t->_M_left), pos_beg,
+         pos_end_left, existing, black_h_l, strictly_less_or_less_equal);
 
-      return t;
-    }
+       force_black_root(t->_M_right, black_h_r);
+
+       _Rb_tree_node_ptr r = _M_bulk_insertion_merge(
+         r_array, static_cast<_Rb_tree_node_ptr>(t->_M_right), pos_beg_right,
+         pos_end, existing, black_h_r, strictly_less_or_less_equal);
+
+       concatenate(t, l, r, black_h_l,  black_h_r, t, black_h);
+
+       return t;
+      }
 
     /** @brief Solve a given insertion problem and all the parent
      * concatenation problem that are ready to be solved.
@@ -2311,35 +2526,50 @@ namespace __gnu_parallel
      *  of the wrapping container
      */
     template<typename StrictlyLessOrLessEqual>
-    void 
-    _M_bulk_insertion_merge_concatenate(_Rb_tree_node_ptr* r, insertion_problem& ip, size_type& existing, StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      concat_problem* conc = ip.conc;
-      _GLIBCXX_PARALLEL_ASSERT(ip.pos_beg <= ip.pos_end);
+      void
+      _M_bulk_insertion_merge_concatenate(_Rb_tree_node_ptr* r,
+                                         insertion_problem& ip,
+                                         size_type& existing,
+                                         StrictlyLessOrLessEqual
+                                         strictly_less_or_less_equal)
+      {
+       concat_problem* conc = ip.conc;
+       _GLIBCXX_PARALLEL_ASSERT(ip.pos_beg <= ip.pos_end);
 
-      conc->t = _M_bulk_insertion_merge(r, ip.t, ip.pos_beg, ip.pos_end, existing, conc->black_h, strictly_less_or_less_equal);
-      _GLIBCXX_PARALLEL_ASSERT(conc->t == NULL or conc->t->_M_color == std::_S_black);
+       conc->t = _M_bulk_insertion_merge(r, ip.t, ip.pos_beg, ip.pos_end,
+                                         existing, conc->black_h,
+                                         strictly_less_or_less_equal);
+       _GLIBCXX_PARALLEL_ASSERT(conc->t == NULL
+                                or conc->t->_M_color == std::_S_black);
 
-      bool is_ready = true;
-      while (conc->par_problem != NULL and is_ready)
-       {
-         // Pre: exists left and right problem, so there is not a deadlock
-         if (compare_and_swap(&conc->par_problem->is_ready, concat_problem::READY_NO,  concat_problem::READY_YES))
-           is_ready = false;
+       bool is_ready = true;
+       while (conc->par_problem != NULL and is_ready)
+         {
+           // Pre: exists left and right problem, so there is not a deadlock
+           if (compare_and_swap(&conc->par_problem->is_ready,
+                                concat_problem::READY_NO,
+                                concat_problem::READY_YES))
+             is_ready = false;
 
-         if (is_ready)
-           {
-             conc = conc->par_problem;
-             _GLIBCXX_PARALLEL_ASSERT(conc->left_problem!=NULL and conc->right_problem!=NULL);
-             _GLIBCXX_PARALLEL_ASSERT (conc->left_problem->black_h >=0 and conc->right_problem->black_h>=0);
-             // Finished working with the problems.
-             concatenate(conc->t, conc->left_problem->t, conc->right_problem->t, conc->left_problem->black_h,  conc->right_problem->black_h, conc->t, conc->black_h);
-
-             delete conc->left_problem;
-             delete conc->right_problem;
-           }
-       }
-    }
+           if (is_ready)
+             {
+               conc = conc->par_problem;
+               _GLIBCXX_PARALLEL_ASSERT(conc->left_problem!=NULL
+                                        and conc->right_problem!=NULL);
+               _GLIBCXX_PARALLEL_ASSERT(conc->left_problem->black_h >=0
+                                        and conc->right_problem->black_h>=0);
+               // Finished working with the problems.
+               concatenate(conc->t, conc->left_problem->t,
+                           conc->right_problem->t,
+                           conc->left_problem->black_h, 
+                           conc->right_problem->black_h,
+                           conc->t, conc->black_h);
+
+               delete conc->left_problem;
+               delete conc->right_problem;
+             }
+         }
+      }
 
     // Begin of sorting, searching and related comparison-based helper methods.
 
@@ -2351,52 +2581,59 @@ namespace __gnu_parallel
      *  @param dist Size of the sequence (out)
      *  @return sequence is sorted. */
     template<typename _RandomAccessIterator>
-    bool
-    is_sorted_distance(const _RandomAccessIterator __first, const _RandomAccessIterator __last, size_type& dist, std::random_access_iterator_tag) const
-    {
-      gr_or_eq<_Compare, _RandomAccessIterator> geq(base_type::_M_impl._M_key_compare);
-      dist = __last - __first;
+      bool
+      is_sorted_distance(const _RandomAccessIterator __first,
+                        const _RandomAccessIterator __last,
+                        size_type& dist,
+                        std::random_access_iterator_tag) const
+      {
+       gr_or_eq<_Compare, _RandomAccessIterator>
+         geq(base_type::_M_impl._M_key_compare);
+       dist = __last - __first;
 
-      // In parallel.
-      return equal(__first + 1, __last, __first, geq);
-    }
+       // In parallel.
+       return equal(__first + 1, __last, __first, geq);
+      }
 
-    /** @brief Check whether an input sequence is sorted, and
-     * calculate its size.
-     *
-     *  The list partitioning tool is used so that all the work is
-     *  done in only one traversal.
-     *  @param __first Begin iterator of sequence.
-     *  @param __last End iterator of sequence.
-     *  @param dist Size of the sequence (out)
-     *  @return sequence is sorted. */
-    template<typename _InputIterator>
-    bool
-    is_sorted_distance(const _InputIterator __first, const _InputIterator __last, size_type& dist, std::input_iterator_tag) const
-    {
-      dist = 1;
-      bool is_sorted = true;
-      _InputIterator it = __first;
-      _InputIterator prev = it++;
-      while (it != __last)
-       {
-         ++dist;
-         if (base_type::_M_impl._M_key_compare(_KeyOfValue()(*it),_KeyOfValue()(*prev)))
-           {
-             is_sorted = false;
-             ++it;
-             break;
-           }
-         prev = it;
-         ++it;
-       }
-      while (it != __last)
-       {
-         ++dist;
-         ++it;
-       }
-      return is_sorted;
-    }
+    /** @brief Check whether an input sequence is sorted, and
+     * calculate its size.
+     *
+     *  The list partitioning tool is used so that all the work is
+     *  done in only one traversal.
+     *  @param __first Begin iterator of sequence.
+     *  @param __last End iterator of sequence.
+     *  @param dist Size of the sequence (out)
+     *  @return sequence is sorted. */
+    template<typename _InputIterator>
+      bool
+      is_sorted_distance(const _InputIterator __first,
+                        const _InputIterator __last, size_type& dist,
+                        std::input_iterator_tag) const
+      {
+       dist = 1;
+       bool is_sorted = true;
+       _InputIterator it = __first;
+       _InputIterator prev = it++;
+       while (it != __last)
+         {
+           ++dist;
+           if (base_type::_M_impl._M_key_compare(_KeyOfValue()(*it),
+                                                 _KeyOfValue()(*prev)))
+             {
+               is_sorted = false;
+               ++it;
+               break;
+             }
+           prev = it;
+           ++it;
+         }
+       while (it != __last)
+         {
+           ++dist;
+           ++it;
+         }
+       return is_sorted;
+      }
 
     /** @brief Check whether a random-access sequence is sorted,
      * calculate its size, and obtain intermediate accessors to the
@@ -2416,17 +2653,24 @@ namespace __gnu_parallel
      *  @param num_pieces Number of pieces to generate.
      *  @return Sequence is sorted. */
     template<typename _RandomAccessIterator>
-    bool
-    is_sorted_distance_accessors(const _RandomAccessIterator __first, const _RandomAccessIterator __last,  _RandomAccessIterator* access, size_type* beg_partition, size_type& dist, thread_index_t& num_pieces, std::random_access_iterator_tag) const
-    {
-      bool is_sorted = is_sorted_distance(__first, __last, dist,std::__iterator_category(__first));
-      if (dist < (unsigned int) num_pieces)
-       num_pieces = dist;
-
-      // Do it opposite way to use accessors in equal function???
-      range_accessors(__first,__last, access, beg_partition, dist, num_pieces, std::__iterator_category(__first));
-      return is_sorted;
-    }
+      bool
+      is_sorted_distance_accessors(const _RandomAccessIterator __first,
+                                  const _RandomAccessIterator __last,
+                                  _RandomAccessIterator* access,
+                                  size_type* beg_partition, size_type& dist,
+                                  thread_index_t& num_pieces,
+                                  std::random_access_iterator_tag) const
+      {
+       bool is_sorted = is_sorted_distance(__first, __last, dist,
+                                           std::__iterator_category(__first));
+       if (dist < (unsigned int) num_pieces)
+         num_pieces = dist;
+
+       // Do it opposite way to use accessors in equal function???
+       range_accessors(__first,__last, access, beg_partition, dist,
+                       num_pieces, std::__iterator_category(__first));
+       return is_sorted;
+      }
 
     /** @brief Check whether an input sequence is sorted, calculate
      * its size, and obtain intermediate accessors to the sequence to
@@ -2448,23 +2692,28 @@ namespace __gnu_parallel
      *  @param num_pieces Number of pieces to generate.
      *  @return Sequence is sorted. */
     template<typename _InputIterator>
-    bool
-    is_sorted_distance_accessors(const _InputIterator __first, const _InputIterator __last, _InputIterator* access,  size_type* beg_partition, size_type& dist, thread_index_t& num_pieces, std::input_iterator_tag) const
-    {
-      is_sorted_functor<_InputIterator, _Compare> sorted(__first, base_type::_M_impl._M_key_compare);
-      dist = list_partition(__first, __last, access,  (beg_partition+1),  num_pieces, sorted,  0);
-
-      // Calculate the rank of the beginning each partition from the
-      // sequence sizes (what is stored at this point in beg_partition
-      // array).
-      beg_partition[0] = 0;
-      for (int i = 0; i < num_pieces; ++i)
-       {
+      bool
+      is_sorted_distance_accessors(const _InputIterator __first,
+                                  const _InputIterator __last,
+                                  _InputIterator* access,
+                                  size_type* beg_partition, size_type& dist,
+                                  thread_index_t& num_pieces,
+                                  std::input_iterator_tag) const
+      {
+       is_sorted_functor<_InputIterator, _Compare>
+         sorted(__first, base_type::_M_impl._M_key_compare);
+       dist = list_partition(__first, __last, access, (beg_partition+1),
+                             num_pieces, sorted,  0);
+
+       // Calculate the rank of the beginning each partition from the
+       // sequence sizes (what is stored at this point in beg_partition
+       // array).
+       beg_partition[0] = 0;
+       for (int i = 0; i < num_pieces; ++i)
          beg_partition[i+1] += beg_partition[i];
-       }
 
-      return sorted.is_sorted();
-    }
+       return sorted.is_sorted();
+      }
 
     /** @brief Make a full copy of the elements of a sequence
      *
@@ -2481,15 +2730,19 @@ namespace __gnu_parallel
      *  @param out Begin iterator of output sequence.
      *  @param num_threads Number of threads to use. */
     template<typename _InputIterator, typename _OutputIterator>
-    static void
-    uninitialized_copy_from_accessors(_InputIterator* access, size_type* beg_partition, _OutputIterator out, const thread_index_t num_threads)
-    {
-#pragma omp parallel num_threads(num_threads)
+      static void
+      uninitialized_copy_from_accessors(_InputIterator* access,
+                                       size_type* beg_partition,
+                                       _OutputIterator out,
+                                       const thread_index_t num_threads)
       {
-       int iam = omp_get_thread_num();
-       uninitialized_copy(access[iam], access[iam+1], out+beg_partition[iam]);
+#pragma omp parallel num_threads(num_threads)
+       {
+         int iam = omp_get_thread_num();
+         uninitialized_copy(access[iam], access[iam + 1],
+                            out + beg_partition[iam]);
+       }
       }
-    }
 
     /** @brief Make a copy of the pointers of the elements of a sequence
      *  @param access Array of size @c num_threads + 1 that defines @c
@@ -2502,20 +2755,23 @@ namespace __gnu_parallel
      *  @param out Begin iterator of output sequence.
      *  @param num_threads Number of threads to use. */
     template<typename _InputIterator, typename _OutputIterator>
-    static void
-    uninitialized_ptr_copy_from_accessors(_InputIterator* access, size_type* beg_partition, _OutputIterator out, const thread_index_t num_threads)
-    {
-#pragma omp parallel num_threads(num_threads)
+      static void
+      uninitialized_ptr_copy_from_accessors(_InputIterator* access,
+                                           size_type* beg_partition,
+                                           _OutputIterator out,
+                                           const thread_index_t num_threads)
       {
-       int iam = omp_get_thread_num();
-       _OutputIterator itout = out + beg_partition[iam];
-       for (_InputIterator it = access[iam]; it != access[iam+1]; ++it)
-         {
-           *itout = &(*it);
-           ++itout;
-         }
+#pragma omp parallel num_threads(num_threads)
+       {
+         int iam = omp_get_thread_num();
+         _OutputIterator itout = out + beg_partition[iam];
+         for (_InputIterator it = access[iam]; it != access[iam+1]; ++it)
+           {
+             *itout = &(*it);
+             ++itout;
+           }
+       }
       }
-    }
 
     /** @brief Split a sorted node array in two parts according to a key.
      *
@@ -2540,28 +2796,44 @@ namespace __gnu_parallel
      *  resulting left partition (out)
      */
     template<typename StrictlyLessOrLessEqual>
-    size_type
-    divide(_Rb_tree_node_ptr* r, const size_type pos_beg, const size_type pos_end, const key_type& key, size_type& pos_beg_right, size_type& existing, StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      pos_beg_right = std::lower_bound(r + pos_beg, r + pos_end, key, compare_node_key<_Compare>(base_type::_M_impl._M_key_compare)) - r;
-
-      //Check if the element exists.
-      size_type pos_end_left = pos_beg_right;
-
-      // If r[pos_beg_right] is equal to key, must be erased
-      /*****   Dealing with repetitions (CORRECTNESS ISSUE) *****/
-      _GLIBCXX_PARALLEL_ASSERT((pos_beg_right == pos_end) or not base_type::_M_impl._M_key_compare(base_type::_S_key(r[pos_beg_right]),key));
-      _GLIBCXX_PARALLEL_ASSERT((pos_beg_right + 1 >= pos_end) or strictly_less_or_less_equal(key, base_type::_S_key(r[pos_beg_right + 1])));
-      if (pos_beg_right != pos_end and not strictly_less_or_less_equal(key, base_type::_S_key(r[pos_beg_right])))
-       {
-         _M_destroy_node(r[pos_beg_right]);
-         r[pos_beg_right] = NULL;
-         ++pos_beg_right;
-         ++existing;
-       }
-      _GLIBCXX_PARALLEL_ASSERT(pos_end_left <= pos_beg_right and pos_beg_right <= pos_end and pos_end_left >= pos_beg);
-      return pos_end_left;
-    }
+      size_type
+      divide(_Rb_tree_node_ptr* r, const size_type pos_beg,
+            const size_type pos_end, const key_type& key,
+            size_type& pos_beg_right, size_type& existing,
+            StrictlyLessOrLessEqual strictly_less_or_less_equal)
+      {
+       pos_beg_right = std::lower_bound(
+         r + pos_beg, r + pos_end, key, compare_node_key<_Compare>(
+           base_type::_M_impl._M_key_compare)) - r;
+
+       //Check if the element exists.
+       size_type pos_end_left = pos_beg_right;
+
+       // If r[pos_beg_right] is equal to key, must be erased
+       /*****  Dealing with repetitions (CORRECTNESS ISSUE) *****/
+       _GLIBCXX_PARALLEL_ASSERT(
+         (pos_beg_right == pos_end)
+         or not base_type::_M_impl._M_key_compare(
+           base_type::_S_key(r[pos_beg_right]),key));
+       _GLIBCXX_PARALLEL_ASSERT(
+         (pos_beg_right + 1 >= pos_end)
+         or strictly_less_or_less_equal(
+           key, base_type::_S_key(r[pos_beg_right + 1])));
+
+       if (pos_beg_right != pos_end
+           and not strictly_less_or_less_equal(
+             key, base_type::_S_key(r[pos_beg_right])))
+         {
+           _M_destroy_node(r[pos_beg_right]);
+           r[pos_beg_right] = NULL;
+           ++pos_beg_right;
+           ++existing;
+         }
+       _GLIBCXX_PARALLEL_ASSERT(pos_end_left <= pos_beg_right
+                                and pos_beg_right <= pos_end
+                                and pos_end_left >= pos_beg);
+       return pos_end_left;
+      }
 
 
     /** @brief Parallelization helper method: Given a random-access
@@ -2579,18 +2851,26 @@ namespace __gnu_parallel
      *  @param n Sequence size
      *  @param num_pieces Number of pieces. */
     template<typename _RandomAccessIterator>
-    static void
-    range_accessors(const _RandomAccessIterator __first, const _RandomAccessIterator __last,  _RandomAccessIterator* access, size_type* beg_partition, const size_type n, const thread_index_t num_pieces, std::random_access_iterator_tag)
-    {
-      access[0] = __first;
-      for (int i=1; i< num_pieces; ++i)
-       {
-         access[i] = access[i-1] + (__last-__first)/num_pieces;
-         beg_partition[i]= beg_partition[i-1]+ (__last-__first)/num_pieces;
-       }
-      beg_partition[num_pieces] = __last - access[num_pieces-1] +  beg_partition[num_pieces-1];
-      access[num_pieces]= __last;
-    }
+      static void
+      range_accessors(const _RandomAccessIterator __first,
+                     const _RandomAccessIterator __last,
+                     _RandomAccessIterator* access,
+                     size_type* beg_partition,
+                     const size_type n,
+                     const thread_index_t num_pieces,
+                     std::random_access_iterator_tag)
+      {
+       access[0] = __first;
+       for (int i = 1; i< num_pieces; ++i)
+         {
+           access[i] = access[i-1] + (__last-__first)/num_pieces;
+           beg_partition[i] = (beg_partition[i - 1]
+                               + (__last - __first) / num_pieces);
+         }
+       beg_partition[num_pieces] = (__last - access[num_pieces - 1]
+                                    +  beg_partition[num_pieces - 1]);
+       access[num_pieces]= __last;
+      }
 
     /** @brief Parallelization helper method: Given an input-access
        sequence of known size, divide it into pieces of almost the
@@ -2607,21 +2887,26 @@ namespace __gnu_parallel
      *  @param n Sequence size
      *  @param num_pieces Number of pieces. */
     template<typename _InputIterator>
-    static void
-    range_accessors(const _InputIterator __first, const _InputIterator __last, _InputIterator* access,  size_type* beg_partition, const size_type n, const thread_index_t num_pieces, std::input_iterator_tag)
-    {
-      access[0] = __first;
-      _InputIterator it= __first;
-      for (int i=1; i< num_pieces; ++i)
-       {
-         for (int j=0; j< n/num_pieces; ++j)
+      static void
+      range_accessors(const _InputIterator __first,
+                     const _InputIterator __last, _InputIterator* access,
+                     size_type* beg_partition, const size_type n,
+                     const thread_index_t num_pieces, std::input_iterator_tag)
+      {
+       access[0] = __first;
+       _InputIterator it= __first;
+       for (int i = 1; i < num_pieces; ++i)
+         {
+           for (int j=0; j< n/num_pieces; ++j)
            ++it;
-         access[i] = it;
-         beg_partition[i]= n/num_pieces + beg_partition[i-1];
+           access[i] = it;
+           beg_partition[i]= n / num_pieces + beg_partition[i - 1];
        }
-      access[num_pieces] = __last;
-      beg_partition[num_pieces] = n - (num_pieces-1)*(n/num_pieces) + beg_partition[num_pieces-1];
-    }
+       access[num_pieces] = __last;
+       beg_partition[num_pieces] = (n - (num_pieces - 1)
+                                    * (n / num_pieces)
+                                    + beg_partition[num_pieces - 1]);
+      }
 
     /** @brief Initialize an array of concatenation problems for bulk
        insertion. They are linked as a tree with (end - beg) leaves.
@@ -2631,21 +2916,27 @@ namespace __gnu_parallel
      *  @param parent Pointer to the parent concatenation problem.
      */
     static concat_problem*
-    _M_bulk_insertion_initialize_upper_problems(concat_problem** conc, const int beg, const int end, concat_problem* parent)
-    {
-      if (beg + 1 == end)
-       {
-         conc[2*beg]->par_problem = parent;
-         return conc[2*beg];
-       }
+    _M_bulk_insertion_initialize_upper_problems(concat_problem** conc,
+                                               const int beg, const int end,
+                                               concat_problem* parent)
+      {
+       if (beg + 1 == end)
+         {
+           conc[2*beg]->par_problem = parent;
+           return conc[2*beg];
+         }
 
-      int size = end - beg;
-      int mid = beg + size/2;
-      conc[2*mid-1]->par_problem = parent;
-      conc[2*mid-1]->left_problem = _M_bulk_insertion_initialize_upper_problems(conc, beg, mid, conc[2*mid-1]);
-      conc[2*mid-1]->right_problem = _M_bulk_insertion_initialize_upper_problems(conc, mid, end, conc[2*mid-1]);
-      return conc[2*mid-1];
-    }
+       int size = end - beg;
+       int mid = beg + size/2;
+       conc[2*mid-1]->par_problem = parent;
+       conc[2*mid-1]->left_problem =
+         _M_bulk_insertion_initialize_upper_problems(conc, beg, mid,
+                                                     conc[2*mid-1]);
+       conc[2*mid-1]->right_problem =
+         _M_bulk_insertion_initialize_upper_problems(conc, mid, end,
+                                                     conc[2*mid-1]);
+       return conc[2*mid-1];
+      }
 
 
     /** @brief Determine black height of a node recursively.
@@ -2656,7 +2947,7 @@ namespace __gnu_parallel
     {
       if (t == NULL) 
        return 0;
-      int bh = black_height (static_cast<const _Rb_tree_node_ptr> (t->_M_left));
+      int bh = black_height(static_cast<const _Rb_tree_node_ptr>(t->_M_left));
       if (t->_M_color == std::_S_black)
        ++bh;
       return bh;
@@ -2735,8 +3026,10 @@ namespace __gnu_parallel
       _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(l, count1));
       _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(r, count2));
 
-      _GLIBCXX_PARALLEL_ASSERT(l != NULL ? l->_M_color != std::_S_red and black_h_l > 0 : black_h_l == 0);
-      _GLIBCXX_PARALLEL_ASSERT(r != NULL ? r->_M_color != std::_S_red and black_h_r > 0 : black_h_r == 0);
+      _GLIBCXX_PARALLEL_ASSERT(l != NULL ? l->_M_color != std::_S_red
+                              and black_h_l > 0 : black_h_l == 0);
+      _GLIBCXX_PARALLEL_ASSERT(r != NULL ? r->_M_color != std::_S_red
+                              and black_h_r > 0 : black_h_r == 0);
 
       if (black_h_l > black_h_r)
        if (root != NULL)
@@ -2751,13 +3044,16 @@ namespace __gnu_parallel
            else
              {
                // XXX SHOULD BE the same as extract_min but slower.
-               /*
-                  root = static_cast<_Rb_tree_node_ptr>(_Rb_tree_node_base::_S_minimum(r));
-                  split(r, _S_key(_Rb_tree_increment(root)), _S_key(root), root, t, r, black_h, black_h_r);
+               /* root = static_cast<_Rb_tree_node_ptr>(
+                  _Rb_tree_node_base::_S_minimum(r));
+
+                  split(r, _S_key(_Rb_tree_increment(root)),
+                  _S_key(root), root, t, r, black_h, black_h_r);
                */
                extract_min(r, root, r, black_h_r);
                _GLIBCXX_PARALLEL_ASSERT(root != NULL);
-               concatenate<LeftRight>(root, l, r, black_h_l, black_h_r, t, black_h);
+               concatenate<LeftRight>(root, l, r, black_h_l,
+                                      black_h_r, t, black_h);
              }
          }
       else
@@ -2774,12 +3070,16 @@ namespace __gnu_parallel
              {
                // XXX SHOULD BE the same as extract_max but slower
                /*
-                  root = static_cast<_Rb_tree_node_ptr>(_Rb_tree_node_base::_S_maximum(l));
-                  split(l, _S_key(root), _S_key(_Rb_tree_decrement(root)), root, l, t, black_h_l, black_h);
+                  root = static_cast<_Rb_tree_node_ptr>(
+                  _Rb_tree_node_base::_S_maximum(l));
+
+                  split(l, _S_key(root), _S_key(_Rb_tree_decrement(root)),
+                  root, l, t, black_h_l, black_h);
                */
                extract_max(l, root, l, black_h_l);
                _GLIBCXX_PARALLEL_ASSERT(root != NULL);
-               concatenate<RightLeft>(root, r, l, black_h_r, black_h_l, t, black_h);
+               concatenate<RightLeft>(root, r, l, black_h_r,
+                                      black_h_l, t, black_h);
              }
          }
 #ifndef NDEBUG
@@ -2808,47 +3108,55 @@ namespace __gnu_parallel
      *  @post @c t is correct red-black tree with height @c black_h.
      */
     template<typename S>
-    static void
-    concatenate(const _Rb_tree_node_ptr rt, _Rb_tree_node_ptr l, 
-               _Rb_tree_node_ptr r, int black_h_l, int black_h_r, 
-               _Rb_tree_node_ptr& t, int& black_h)
-    {
-      _Rb_tree_node_base* root = l;
-      _Rb_tree_node_ptr parent = NULL;
-      black_h = black_h_l;
-      _GLIBCXX_PARALLEL_ASSERT(black_h_l >= black_h_r);
-      while (black_h_l != black_h_r)
-       {
-         if (l->_M_color == std::_S_black)
-           --black_h_l;
-         parent = l;
-         l = static_cast<_Rb_tree_node_ptr>(S::right(l));
-         _GLIBCXX_PARALLEL_ASSERT((black_h_l == 0 and (l == NULL or l->_M_color == std::_S_red)) or (black_h_l != 0 and l != NULL));
-         _GLIBCXX_PARALLEL_ASSERT((black_h_r == 0 and (r == NULL or r->_M_color == std::_S_red)) or (black_h_r != 0 and r != NULL));
-       }
-      if (l != NULL and l->_M_color == std::_S_red)
-       {
-         //the root needs to be black
-         parent = l;
-         l = static_cast<_Rb_tree_node_ptr>(S::right(l));
-       }
-      _GLIBCXX_PARALLEL_ASSERT(l != NULL ? l->_M_color == std::_S_black : true);
-      _GLIBCXX_PARALLEL_ASSERT(r != NULL ? r->_M_color == std::_S_black : true);
-      t = plant<S>(rt, l, r);
-      t->_M_parent = parent;
-      if (parent != NULL)
-       {
-         S::right(parent) = t;
-         black_h += _Rb_tree_rebalance(t, root);
-         t = static_cast<_Rb_tree_node_ptr> (root);
-       }
-      else
-       {
-         ++black_h;
-         t->_M_color = std::_S_black;
-       }
-      _GLIBCXX_PARALLEL_ASSERT(t->_M_color == std::_S_black);
-    }
+      static void
+      concatenate(const _Rb_tree_node_ptr rt, _Rb_tree_node_ptr l, 
+                 _Rb_tree_node_ptr r, int black_h_l, int black_h_r, 
+                 _Rb_tree_node_ptr& t, int& black_h)
+      {
+       _Rb_tree_node_base* root = l;
+       _Rb_tree_node_ptr parent = NULL;
+       black_h = black_h_l;
+       _GLIBCXX_PARALLEL_ASSERT(black_h_l >= black_h_r);
+       while (black_h_l != black_h_r)
+         {
+           if (l->_M_color == std::_S_black)
+             --black_h_l;
+           parent = l;
+           l = static_cast<_Rb_tree_node_ptr>(S::right(l));
+           _GLIBCXX_PARALLEL_ASSERT(
+             (black_h_l == 0 and (l == NULL or l->_M_color == std::_S_red))
+             or (black_h_l != 0 and l != NULL));
+           _GLIBCXX_PARALLEL_ASSERT(
+             (black_h_r == 0 and (r == NULL or r->_M_color == std::_S_red))
+             or (black_h_r != 0 and r != NULL));
+         }
+       if (l != NULL and l->_M_color == std::_S_red)
+         {
+           //the root needs to be black
+           parent = l;
+           l = static_cast<_Rb_tree_node_ptr>(S::right(l));
+         }
+
+       _GLIBCXX_PARALLEL_ASSERT(
+         l != NULL ? l->_M_color == std::_S_black : true);
+       _GLIBCXX_PARALLEL_ASSERT(
+         r != NULL ? r->_M_color == std::_S_black : true);
+
+       t = plant<S>(rt, l, r);
+       t->_M_parent = parent;
+       if (parent != NULL)
+         {
+           S::right(parent) = t;
+           black_h += _Rb_tree_rebalance(t, root);
+           t = static_cast<_Rb_tree_node_ptr> (root);
+         }
+       else
+         {
+           ++black_h;
+           t->_M_color = std::_S_black;
+         }
+       _GLIBCXX_PARALLEL_ASSERT(t->_M_color == std::_S_black);
+      }
 
     /** @brief Split a tree according to key in three parts: a left
      *  child, a right child and an intermediate node.
@@ -2872,36 +3180,48 @@ namespace __gnu_parallel
      *  of the wrapping container
      *  @return Black height of t */
     template<typename StrictlyLessOrEqual>
-    int
-    split(_Rb_tree_node_ptr t, const key_type& key, const key_type& prev_k, 
-         _Rb_tree_node_ptr& root, _Rb_tree_node_ptr& l, _Rb_tree_node_ptr& r, 
-         int& black_h_l, int& black_h_r, 
-         StrictlyLessOrEqual strictly_less_or_less_equal) const
-    {
-      if (t != NULL)
-       {
-         // Must be initialized, in case we never go left!!!
-         root = NULL;
-         int h = split_not_null(t, key, prev_k, root, l, r, black_h_l, black_h_r, strictly_less_or_less_equal);
+      int
+      split(_Rb_tree_node_ptr t, const key_type& key, const key_type& prev_k, 
+           _Rb_tree_node_ptr& root, _Rb_tree_node_ptr& l,
+           _Rb_tree_node_ptr& r, int& black_h_l, int& black_h_r, 
+           StrictlyLessOrEqual strictly_less_or_less_equal)
+      {
+       if (t != NULL)
+         {
+           // Must be initialized, in case we never go left!!!
+           root = NULL;
+           int h = split_not_null(t, key, prev_k, root, l, r, black_h_l,
+                                  black_h_r, strictly_less_or_less_equal);
 #ifndef NDEBUG
-         _GLIBCXX_PARALLEL_ASSERT(l == NULL or base_type::_M_impl._M_key_compare(base_type::_S_key(base_type::_S_maximum(l)),key));
-         _GLIBCXX_PARALLEL_ASSERT(r == NULL or not base_type::_M_impl._M_key_compare(base_type::_S_key(base_type::_S_minimum(r)),key));
-         int count1, count2;
-         _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(l, count1));
-         _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(r, count2));
-         _GLIBCXX_PARALLEL_ASSERT(root == NULL or base_type::_M_impl._M_key_compare(prev_k, base_type::_S_key(root)) and not base_type::_M_impl._M_key_compare(key, base_type::_S_key(root)));
-         _GLIBCXX_PARALLEL_ASSERT(root != NULL or l==NULL or  not base_type::_M_impl._M_key_compare(prev_k, base_type::_S_key(base_type::_S_maximum(l))));
+           _GLIBCXX_PARALLEL_ASSERT(
+             l == NULL or base_type::_M_impl._M_key_compare(
+               base_type::_S_key(base_type::_S_maximum(l)),key));
+           _GLIBCXX_PARALLEL_ASSERT(
+             r == NULL or not base_type::_M_impl._M_key_compare(
+               base_type::_S_key(base_type::_S_minimum(r)),key));
+           int count1, count2;
+           _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(l, count1));
+           _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(r, count2));
+           _GLIBCXX_PARALLEL_ASSERT(
+             root == NULL or base_type::_M_impl._M_key_compare(
+               prev_k, base_type::_S_key(root))
+             and not base_type::_M_impl._M_key_compare(
+               key, base_type::_S_key(root)));
+           _GLIBCXX_PARALLEL_ASSERT(
+             root != NULL or l==NULL
+             or not base_type::_M_impl._M_key_compare(
+               prev_k, base_type::_S_key(base_type::_S_maximum(l))));
 #endif
-         return h;
-       }
+           return h;
+         }
 
-      r = NULL;
-      root = NULL;
-      l = NULL;
-      black_h_r = 0;
-      black_h_l = 0;
-      return 0;
-    }
+       r = NULL;
+       root = NULL;
+       l = NULL;
+       black_h_r = 0;
+       black_h_l = 0;
+       return 0;
+      }
 
     /** @brief Split a tree according to key in three parts: a left
      * child, a right child and an intermediate node.
@@ -2923,98 +3243,119 @@ namespace __gnu_parallel
      *  @pre t != NULL
      *  @return Black height of t */
     template<typename StrictlyLessOrEqual>
-    int
-    split_not_null(const _Rb_tree_node_ptr t, const key_type& key, 
-                  const key_type& prev_k, _Rb_tree_node_ptr& root, 
-                  _Rb_tree_node_ptr& l, _Rb_tree_node_ptr& r, int& black_h_l, 
-                  int& black_h_r, 
-                  StrictlyLessOrEqual strictly_less_or_equal) const
-    {
-      _GLIBCXX_PARALLEL_ASSERT (t != NULL);
-      int black_h, b_h;
-      int black_node = 0;
-      if (t->_M_color == std::_S_black)
-       ++black_node;
-      if (strictly_less_or_equal(key, base_type::_S_key(t)))
-       {
-         if (t->_M_left != NULL )
-           {
-             // t->M_right is at most one node
-             // go to the left
-             b_h = black_h = split_not_null( static_cast<_Rb_tree_node_ptr>(t->_M_left), key, prev_k, root, l, r, black_h_l, black_h_r, strictly_less_or_equal);
-             // Moin root and right subtree to already existing right
-             // half, leave left subtree.
-             force_black_root(t->_M_right, b_h);
-             concatenate(t, r, static_cast<_Rb_tree_node_ptr>(t->_M_right), black_h_r, b_h, r, black_h_r);
-           }
-         else
-           {
-             // t->M_right is at most one node
-             r = t;
-             black_h_r = black_node;
-             force_black_root(r, black_h_r);
-
-             black_h = 0;
-             l = NULL;
-             black_h_l = 0;
-           }
-         _GLIBCXX_PARALLEL_ASSERT(l == NULL or base_type::_M_impl._M_key_compare(base_type::_S_key(base_type::_S_maximum(l)),key));
-         _GLIBCXX_PARALLEL_ASSERT(r == NULL or not base_type::_M_impl._M_key_compare(base_type::_S_key(base_type::_S_minimum(r)),key));
-       }
-      else
-       {
-         if (t->_M_right != NULL )
-           {
-             // Go to the right.
-             if (strictly_less_or_equal(prev_k, base_type::_S_key(t)))
-               root = t;
-             b_h = black_h = split_not_null(static_cast<_Rb_tree_node_ptr>(t->_M_right), key, prev_k, root, l, r, black_h_l, black_h_r, strictly_less_or_equal);
-             // Join root and left subtree to already existing left
-             // half, leave right subtree.
-             force_black_root(t->_M_left, b_h);
-             if (root != t)
-               {
-                 // There was another point where we went right.
-                 concatenate(t, static_cast<_Rb_tree_node_ptr>(t->_M_left), l, b_h, black_h_l, l, black_h_l);
-               }
-             else
-               {
-                 l = static_cast<_Rb_tree_node_ptr>(t->_M_left);
-                 black_h_l = b_h;
-               }
-             _GLIBCXX_PARALLEL_ASSERT(l == NULL or base_type::_M_impl._M_key_compare(base_type::_S_key(base_type::_S_maximum(l)),key));
-             _GLIBCXX_PARALLEL_ASSERT(r == NULL or not base_type::_M_impl._M_key_compare(base_type::_S_key(base_type::_S_minimum(r)),key));
-           }
-         else
-           {
-             if (strictly_less_or_equal(prev_k, base_type::_S_key(t)))
-               {
+      int
+      split_not_null(const _Rb_tree_node_ptr t, const key_type& key, 
+                    const key_type& prev_k, _Rb_tree_node_ptr& root, 
+                    _Rb_tree_node_ptr& l, _Rb_tree_node_ptr& r,
+                    int& black_h_l, int& black_h_r, 
+                    StrictlyLessOrEqual strictly_less_or_equal)
+      {
+       _GLIBCXX_PARALLEL_ASSERT (t != NULL);
+       int black_h, b_h;
+       int black_node = 0;
+       if (t->_M_color == std::_S_black)
+         ++black_node;
+       if (strictly_less_or_equal(key, base_type::_S_key(t)))
+         {
+           if (t->_M_left != NULL )
+             {
+               // t->M_right is at most one node
+               // go to the left
+               b_h = black_h = split_not_null(
+                 static_cast<_Rb_tree_node_ptr>(t->_M_left), key, prev_k,
+                 root, l, r, black_h_l, black_h_r,
+                 strictly_less_or_equal);
+               // Moin root and right subtree to already existing right
+               // half, leave left subtree.
+               force_black_root(t->_M_right, b_h);
+               concatenate(t, r, static_cast<_Rb_tree_node_ptr>(t->_M_right),
+                           black_h_r, b_h, r, black_h_r);
+             }
+           else
+             {
+               // t->M_right is at most one node
+               r = t;
+               black_h_r = black_node;
+               force_black_root(r, black_h_r);
+
+               black_h = 0;
+               l = NULL;
+               black_h_l = 0;
+             }
+           _GLIBCXX_PARALLEL_ASSERT(
+             l == NULL or base_type::_M_impl._M_key_compare(
+               base_type::_S_key(base_type::_S_maximum(l)),key));
+           _GLIBCXX_PARALLEL_ASSERT(
+             r == NULL or not base_type::_M_impl._M_key_compare(
+               base_type::_S_key(base_type::_S_minimum(r)),key));
+         }
+       else
+         {
+           if (t->_M_right != NULL )
+             {
+               // Go to the right.
+               if (strictly_less_or_equal(prev_k, base_type::_S_key(t)))
                  root = t;
-                 l= static_cast<_Rb_tree_node_ptr>(t->_M_left);
-                 make_black_leaf(l, black_h_l);
-                 _GLIBCXX_PARALLEL_ASSERT(l == NULL or base_type::_M_impl._M_key_compare(base_type::_S_key(base_type::_S_maximum(l)),key));
-               }
-             else
-               {
-                 l= t;
-                 black_h_l = black_node;
-                 force_black_root(l, black_h_l);
-                 _GLIBCXX_PARALLEL_ASSERT(l == NULL or base_type::_M_impl._M_key_compare(base_type::_S_key(base_type::_S_maximum(l)),key));
-               }
+               b_h = black_h = split_not_null(
+                 static_cast<_Rb_tree_node_ptr>(t->_M_right), key, prev_k,
+                 root, l, r, black_h_l, black_h_r, strictly_less_or_equal);
+               // Join root and left subtree to already existing left
+               // half, leave right subtree.
+               force_black_root(t->_M_left, b_h);
+               if (root != t)
+                 {
+                   // There was another point where we went right.
+                   concatenate(t, static_cast<_Rb_tree_node_ptr>(
+                                 t->_M_left), l, b_h, black_h_l,
+                               l, black_h_l);
+                 }
+               else
+                 {
+                   l = static_cast<_Rb_tree_node_ptr>(t->_M_left);
+                   black_h_l = b_h;
+                 }
+               _GLIBCXX_PARALLEL_ASSERT(
+                 l == NULL or base_type::_M_impl._M_key_compare(
+                   base_type::_S_key(base_type::_S_maximum(l)),key));
+               _GLIBCXX_PARALLEL_ASSERT(
+                 r == NULL or not base_type::_M_impl._M_key_compare(
+                   base_type::_S_key(base_type::_S_minimum(r)),key));
+             }
+           else
+             {
+               if (strictly_less_or_equal(prev_k, base_type::_S_key(t)))
+                 {
+                   root = t;
+                   l= static_cast<_Rb_tree_node_ptr>(t->_M_left);
+                   make_black_leaf(l, black_h_l);
+                   _GLIBCXX_PARALLEL_ASSERT(
+                     l == NULL or base_type::_M_impl._M_key_compare(
+                       base_type::_S_key(base_type::_S_maximum(l)),key));
+                 }
+               else
+                 {
+                   l= t;
+                   black_h_l = black_node;
+                   force_black_root(l, black_h_l);
+                   _GLIBCXX_PARALLEL_ASSERT(
+                     l == NULL or base_type::_M_impl._M_key_compare(
+                       base_type::_S_key(base_type::_S_maximum(l)),key));
+                 }
 
-             r = NULL;
-             black_h = 0;
-             black_h_r = 0;
-           }
-       }
-      return black_h + black_node;
-    }
+               r = NULL;
+               black_h = 0;
+               black_h_r = 0;
+             }
+         }
+       return black_h + black_node;
+      }
 
     /** @brief Color the root black and update the black height accordingly.
      *
      * @param t Root of the tree.
      * @param black_h Black height of the tree @c t (out) */
-    static void force_black_root(_Rb_tree_node_base* t, int& black_h)
+    static void
+    force_black_root(_Rb_tree_node_base* t, int& black_h)
     {
       if (t != NULL and t->_M_color == std::_S_red)
        {
@@ -3032,7 +3373,7 @@ namespace __gnu_parallel
      *  @return Black height of the original tree  */
     int
     extract_min(const _Rb_tree_node_ptr t, _Rb_tree_node_ptr& root, 
-               _Rb_tree_node_ptr& r, int& black_h_r) const
+               _Rb_tree_node_ptr& r, int& black_h_r)
     {
       _GLIBCXX_PARALLEL_ASSERT (t != NULL);
       int black_h, b_h;
@@ -3044,12 +3385,14 @@ namespace __gnu_parallel
        {
          // t->M_right is at most one node
          // go to the left
-         b_h = black_h = extract_min( static_cast<_Rb_tree_node_ptr>(t->_M_left), root, r, black_h_r);
+         b_h = black_h = extract_min(
+           static_cast<_Rb_tree_node_ptr>(t->_M_left), root, r, black_h_r);
 
          // Join root and right subtree to already existing right
          // half, leave left subtree
          force_black_root(t->_M_right, b_h);
-         concatenate(t, r, static_cast<_Rb_tree_node_ptr>(t->_M_right), black_h_r, b_h, r, black_h_r);
+         concatenate(t, r, static_cast<_Rb_tree_node_ptr>(t->_M_right),
+                     black_h_r, b_h, r, black_h_r);
        }
       else
        {
@@ -3091,13 +3434,15 @@ namespace __gnu_parallel
 
       if (t->_M_right != NULL )
        {
-         b_h = black_h = extract_max(static_cast<_Rb_tree_node_ptr>(t->_M_right), root, l,  black_h_l);
+         b_h = black_h = extract_max(
+           static_cast<_Rb_tree_node_ptr>(t->_M_right), root, l,  black_h_l);
 
          // Join root and left subtree to already existing left half,
          // leave right subtree.
          force_black_root(t->_M_left, b_h);
 
-         concatenate(t, static_cast<_Rb_tree_node_ptr>(t->_M_left), l, b_h, black_h_l, l, black_h_l);
+         concatenate(t, static_cast<_Rb_tree_node_ptr>(
+                       t->_M_left), l, b_h, black_h_l, l, black_h_l);
        }
       else
        {
@@ -3142,25 +3487,32 @@ namespace __gnu_parallel
          int black_node = 0;
          if (t->_M_color == std::_S_black)
            ++black_node;
-         if (not (base_type::_M_impl._M_key_compare(base_type::_S_key(t), key)))
+         if (not (base_type::_M_impl._M_key_compare(base_type::_S_key(t),
+                                                    key)))
            {
              // Go to the left.
-             b_h = black_h = split( static_cast<_Rb_tree_node_ptr>(t->_M_left), key, l, r, black_h_l, black_h_r);
+             b_h = black_h = split(
+               static_cast<_Rb_tree_node_ptr>(t->_M_left), key, l, r,
+               black_h_l, black_h_r);
 
              // Join root and right subtree to already existing right
              // half, leave left subtree.
              force_black_root(t->_M_right, b_h);
-             concatenate(t, r, static_cast<_Rb_tree_node_ptr>(t->_M_right), black_h_r, b_h, r, black_h_r);
+             concatenate(t, r, static_cast<_Rb_tree_node_ptr>(
+                           t->_M_right), black_h_r, b_h, r, black_h_r);
            }
          else
            {
              // Go to the right.
-             b_h = black_h = split(static_cast<_Rb_tree_node_ptr>(t->_M_right), key, l, r, black_h_l, black_h_r);
+             b_h = black_h = split(static_cast<_Rb_tree_node_ptr>(
+                                     t->_M_right), key, l, r,
+                                   black_h_l, black_h_r);
 
              // Join root and left subtree to already existing left
              // half, leave right subtree.
              force_black_root(t->_M_left, b_h);
-             concatenate(t, static_cast<_Rb_tree_node_ptr>(t->_M_left), l, b_h, black_h_l, l, black_h_l);
+             concatenate(t, static_cast<_Rb_tree_node_ptr>(
+                           t->_M_left), l, b_h, black_h_l, l, black_h_l);
            }
          return black_h + black_node;
        }
@@ -3192,19 +3544,20 @@ namespace __gnu_parallel
      *  of the wrapping container
      *  @return Resulting tree after insertion */
     template<typename StrictlyLessOrLessEqual>
-    _Rb_tree_node_ptr
-    _M_insert_local(_Rb_tree_node_base* t, const _Rb_tree_node_ptr new_t, 
-                   size_type& existing, int& black_h, 
-                   StrictlyLessOrLessEqual strictly_less_or_less_equal)
-    {
-      _GLIBCXX_PARALLEL_ASSERT(t != NULL);
-      if (_M_insert_local_top_down(t, new_t, NULL, NULL, true, strictly_less_or_less_equal))
-       {
-         t->_M_parent = NULL;
-         black_h += _Rb_tree_rebalance(new_t, t);
-         _GLIBCXX_PARALLEL_ASSERT(t->_M_color == std::_S_black);
-         return static_cast<_Rb_tree_node_ptr>(t);
-       }
+      _Rb_tree_node_ptr
+      _M_insert_local(_Rb_tree_node_base* t, const _Rb_tree_node_ptr new_t, 
+                     size_type& existing, int& black_h, 
+                     StrictlyLessOrLessEqual strictly_less_or_less_equal)
+      {
+       _GLIBCXX_PARALLEL_ASSERT(t != NULL);
+       if (_M_insert_local_top_down(t, new_t, NULL, NULL,
+                                    true, strictly_less_or_less_equal))
+         {
+           t->_M_parent = NULL;
+           black_h += _Rb_tree_rebalance(new_t, t);
+           _GLIBCXX_PARALLEL_ASSERT(t->_M_color == std::_S_black);
+           return static_cast<_Rb_tree_node_ptr>(t);
+         }
       else
        {
          base_type::_M_destroy_node(new_t);
@@ -3230,50 +3583,47 @@ namespace __gnu_parallel
      *  @return Success of the insertion 
      */
     template<typename StrictlyLessOrLessEqual>
-    bool
-    _M_insert_local_top_down(_Rb_tree_node_base* t, 
-                            const _Rb_tree_node_ptr new_t, 
-                            _Rb_tree_node_base* eq_t, 
-                            _Rb_tree_node_base* parent, const bool is_left, 
-                   StrictlyLessOrLessEqual strictly_less_or_less_equal) const
-    {
-      if (t != NULL)
-       {
-         if (strictly_less_or_less_equal(_S_key(new_t), _S_key(static_cast<_Rb_tree_node_ptr>(t))))
-           {
-             return _M_insert_local_top_down(t->_M_left, new_t, eq_t, t, true, strictly_less_or_less_equal);
-           }
-         else
-           {
-             return _M_insert_local_top_down(t->_M_right, new_t, t, t, false, strictly_less_or_less_equal);
-           }
-       }
+      bool
+      _M_insert_local_top_down(_Rb_tree_node_base* t, 
+                              const _Rb_tree_node_ptr new_t, 
+                              _Rb_tree_node_base* eq_t, 
+                              _Rb_tree_node_base* parent, const bool is_left, 
+                              StrictlyLessOrLessEqual
+                              strictly_less_or_less_equal) const
+      {
+       if (t != NULL)
+         {
+           if (strictly_less_or_less_equal(
+                 _S_key(new_t), _S_key(static_cast<_Rb_tree_node_ptr>(t))))
+             return _M_insert_local_top_down(t->_M_left, new_t, eq_t, t, true,
+                                             strictly_less_or_less_equal);
+           else
+             return _M_insert_local_top_down(t->_M_right, new_t, t, t, false,
+                                             strictly_less_or_less_equal);
+         }
 
-      _GLIBCXX_PARALLEL_ASSERT(parent != NULL);
+       _GLIBCXX_PARALLEL_ASSERT(parent != NULL);
 
-      // Base case.
-      if (eq_t == NULL or strictly_less_or_less_equal(_S_key(static_cast<_Rb_tree_node_ptr>(eq_t)), _S_key(new_t)))
-       {
-         // The element to be inserted did not existed.
-         if (is_left)
-           {
+       // Base case.
+       if (eq_t == NULL or strictly_less_or_less_equal(
+             _S_key(static_cast<_Rb_tree_node_ptr>(eq_t)), _S_key(new_t)))
+         {
+           // The element to be inserted did not existed.
+           if (is_left)
              parent->_M_left = new_t;
-           }
-         else
-           {
+           else
              parent->_M_right = new_t;
-           }
 
-         new_t->_M_parent = parent;
-         new_t->_M_left = NULL;
-         new_t->_M_right = NULL;
-         new_t->_M_color = std::_S_red;
+           new_t->_M_parent = parent;
+           new_t->_M_left = NULL;
+           new_t->_M_right = NULL;
+           new_t->_M_color = std::_S_red;
 
-         return true;
-       }
-      else
-       return false;
-    }
+           return true;
+         }
+       else
+         return false;
+      }
 
     /** @brief Rebalance a tree locally.
      *
@@ -3343,10 +3693,14 @@ namespace __gnu_parallel
       if (__root->_M_color == std::_S_red)
        {
          __root->_M_color = std::_S_black;
-         _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(static_cast<typename base_type::_Const_Link_type>(__root)));
+         _GLIBCXX_PARALLEL_ASSERT(
+           rb_verify_tree(static_cast<typename base_type::
+                          _Const_Link_type>(__root)));
          return 1;
        }
-      _GLIBCXX_PARALLEL_ASSERT(rb_verify_tree(static_cast<typename base_type::_Const_Link_type>(__root)));
+      _GLIBCXX_PARALLEL_ASSERT(
+       rb_verify_tree(static_cast<typename base_type::
+                      _Const_Link_type>(__root)));
       return 0;
     }
 
@@ -3356,7 +3710,8 @@ namespace __gnu_parallel
      *  @return Tree correct. 
      */
     bool
-    rb_verify_tree(const typename base_type::_Const_Link_type __x, int& count) const
+    rb_verify_tree(const typename base_type::_Const_Link_type __x,
+                  int& count) const
     {
       int bh;
       return rb_verify_tree_node(__x) and rb_verify_tree(__x, count, bh);
@@ -3374,9 +3729,9 @@ namespace __gnu_parallel
        return true;
       else
        {
-         return rb_verify_node(__x) and
-           rb_verify_tree_node(base_type::_S_left(__x)) and
-           rb_verify_tree_node( base_type::_S_right(__x));
+         return rb_verify_node(__x)
+           and rb_verify_tree_node(base_type::_S_left(__x))
+           and rb_verify_tree_node( base_type::_S_right(__x));
        }
     }
 
@@ -3432,25 +3787,24 @@ namespace __gnu_parallel
       if (__x->_M_color == std::_S_red)
        if ((__L && __L->_M_color == std::_S_red)
            || (__R && __R->_M_color == std::_S_red))
-         {
-           return false;
-         }
+         return false;
+      
       if (__L != NULL)
        {
-         __L = static_cast<typename base_type::_Const_Link_type>(base_type::_S_maximum(__L));
-         if (base_type::_M_impl._M_key_compare(base_type::_S_key(__x), base_type::_S_key(__L)))
-           {
-             return false;
-           }
+         __L = static_cast<typename base_type::_Const_Link_type>(
+           base_type::_S_maximum(__L));
+         if (base_type::_M_impl._M_key_compare(base_type::_S_key(__x),
+                                               base_type::_S_key(__L)))
+           return false;
        }
 
       if (__R != NULL)
        {
-         __R = static_cast<typename base_type::_Const_Link_type>(base_type::_S_minimum(__R));
-         if (base_type::_M_impl._M_key_compare(base_type::_S_key(__R), base_type::_S_key(__x)))
-           {
-             return false;
-           }
+         __R = static_cast<typename base_type::_Const_Link_type>(
+           base_type::_S_minimum(__R));
+         if (base_type::_M_impl._M_key_compare(base_type::_S_key(__R),
+                                               base_type::_S_key(__x)))
+           return false;
        }
 
       return true;
@@ -3532,21 +3886,27 @@ namespace __gnu_parallel
     bool
     rb_verify()
     {
-      if (base_type::_M_impl._M_node_count == 0 || base_type::begin() == base_type::end())
+      if (base_type::_M_impl._M_node_count == 0
+         || base_type::begin() == base_type::end())
        {
-         bool res = base_type::_M_impl._M_node_count == 0 && base_type::begin() == base_type::end()
+         bool res = base_type::_M_impl._M_node_count == 0
+           && base_type::begin() == base_type::end()
            && base_type::_M_impl._M_header._M_left ==base_type::_M_end()
            && base_type::_M_impl._M_header._M_right == base_type::_M_end();
          _GLIBCXX_PARALLEL_ASSERT(res);
          return res;
        }
       size_type i=0;
-      unsigned int __len = _Rb_tree_black_count(base_type::_M_leftmost(), base_type::_M_root());
-      for (typename base_type::const_iterator __it =base_type::begin(); __it != base_type::end(); ++__it)
+      unsigned int __len = _Rb_tree_black_count(base_type::_M_leftmost(),
+                                               base_type::_M_root());
+      for (typename base_type::const_iterator __it =base_type::begin();
+          __it != base_type::end(); ++__it)
        {
-         typename base_type::_Const_Link_type __x = static_cast<typename base_type::_Const_Link_type>(__it._M_node);
+         typename base_type::_Const_Link_type __x =
+           static_cast<typename base_type::_Const_Link_type>(__it._M_node);
          if (not rb_verify_node(__x)) return false;
-         if (!base_type::_S_left(__x)&& !base_type::_S_right(__x) && _Rb_tree_black_count(__x,base_type::_M_root()) != __len)
+         if (!base_type::_S_left(__x)&& !base_type::_S_right(__x)
+             && _Rb_tree_black_count(__x,base_type::_M_root()) != __len)
            {
              _GLIBCXX_PARALLEL_ASSERT(false);
              return false;
@@ -3557,12 +3917,14 @@ namespace __gnu_parallel
       if (i != base_type::_M_impl._M_node_count)
        printf("%ld != %ld\n", i, base_type::_M_impl._M_node_count);
 
-      if (base_type::_M_leftmost() != std::_Rb_tree_node_base::_S_minimum(base_type::_M_root()))
+      if (base_type::_M_leftmost()
+         != std::_Rb_tree_node_base::_S_minimum(base_type::_M_root()))
        {
          _GLIBCXX_PARALLEL_ASSERT(false);
          return false;
        }
-      if (base_type::_M_rightmost() != std::_Rb_tree_node_base::_S_maximum(base_type::_M_root()))
+      if (base_type::_M_rightmost()
+         != std::_Rb_tree_node_base::_S_maximum(base_type::_M_root()))
        {
          _GLIBCXX_PARALLEL_ASSERT(false);
          return false;
index e3599b4..01bd107 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -50,11 +50,10 @@ namespace __gnu_parallel
   *  @param result Begin iterator of result sequence.
   *  @param binary_pred Equality predicate.
   *  @return End iterator of result sequence. */
-template<
-    typename InputIterator,
-    class OutputIterator,
-    class BinaryPredicate>
-  inline OutputIterator
+template<typename InputIterator,
+        class OutputIterator,
+        class BinaryPredicate>
+  OutputIterator
   parallel_unique_copy(InputIterator first, InputIterator last,
                        OutputIterator result, BinaryPredicate binary_pred)
   {
@@ -79,10 +78,10 @@ template<
       {
 #       pragma omp single
           {
-                num_threads = omp_get_num_threads();
-                borders = new difference_type[num_threads + 2];
-                equally_split(size, num_threads + 1, borders);
-                counter = new difference_type[num_threads + 1];
+           num_threads = omp_get_num_threads();
+           borders = new difference_type[num_threads + 2];
+           equally_split(size, num_threads + 1, borders);
+           counter = new difference_type[num_threads + 1];
           }
 
         thread_index_t iam = omp_get_thread_num();
@@ -99,14 +98,14 @@ template<
           begin = borders[0] + 1;      // == 1
           end = borders[iam + 1];
 
-          i++;
+          ++i;
           *out++ = *first;
 
           for (InputIterator iter = first + begin; iter < first + end; ++iter)
             {
               if (!binary_pred(*iter, *(iter-1)))
                 {
-                  i++;
+                  ++i;
                   *out++ = *iter;
                 }
             }
@@ -118,11 +117,9 @@ template<
 
           for (InputIterator iter = first + begin; iter < first + end; ++iter)
             {
-              if (!binary_pred(*iter, *(iter-1)))
-                {
-                  i++;
-                }
-            }
+              if (!binary_pred(*iter, *(iter - 1)))
+               ++i;
+           }
         }
       counter[iam] = i;
 
@@ -136,7 +133,7 @@ template<
 
       if (iam == 0)
         {
-          for (int t = 0; t < num_threads; t++)
+          for (int t = 0; t < num_threads; ++t)
             begin_output += counter[t];
 
           i = 0;
@@ -148,9 +145,9 @@ template<
 
           for (InputIterator iter = first + begin; iter < first + end; ++iter)
             {
-              if (iter == first || !binary_pred(*iter, *(iter-1)))
+              if (iter == first || !binary_pred(*iter, *(iter - 1)))
                 {
-                  i++;
+                  ++i;
                   *iter_out++ = *iter;
                 }
             }
@@ -166,10 +163,8 @@ template<
           for (InputIterator iter = first + begin; iter < first + end; ++iter)
             {
               if (!binary_pred(*iter, *(iter-1)))
-                {
-                  *iter_out++ = *iter;
-                }
-            }
+               *iter_out++ = *iter;
+           }
         }
     }
 
@@ -193,8 +188,8 @@ template<typename InputIterator, class OutputIterator>
                        OutputIterator result)
   {
     typedef typename std::iterator_traits<InputIterator>::value_type value_type;
-
-    return parallel_unique_copy(first, last, result, std::equal_to<value_type>());
+    return parallel_unique_copy(first, last, result,
+                               std::equal_to<value_type>());
   }
 
 }//namespace __gnu_parallel
index 60c8739..4f0c748 100644 (file)
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2007 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the terms
@@ -96,20 +96,19 @@ template<typename _DifferenceTp>
   *  std::count_n()).
   *  @return User-supplied functor (that may contain a part of the result).
   */
-template<
-    typename RandomAccessIterator,
-    typename Op,
-    typename Fu,
-    typename Red,
-    typename Result>
+template<typename RandomAccessIterator,
+        typename Op,
+        typename Fu,
+        typename Red,
+        typename Result>
   Op
-  for_each_template_random_access_workstealing(
-      RandomAccessIterator begin,
-      RandomAccessIterator end,
-      Op op, Fu& f, Red r,
-      Result base, Result& output,
-      typename std::iterator_traits<RandomAccessIterator>::difference_type
-          bound)
+  for_each_template_random_access_workstealing(RandomAccessIterator begin,
+                                              RandomAccessIterator end,
+                                              Op op, Fu& f, Red r,
+                                              Result base, Result& output,
+                                              typename std::iterator_traits
+                                              <RandomAccessIterator>::
+                                              difference_type bound)
   {
     _GLIBCXX_CALL(end - begin)
 
@@ -180,7 +179,7 @@ template<
 
         // This thread is currently working.
 #       pragma omp atomic
-          busy++;
+          ++busy;
 
         iam_working = true;
 
@@ -198,8 +197,8 @@ template<
             // Cannot use volatile variable directly.
             difference_type my_first = my_job.first;
             result = f(op, begin + my_first);
-            my_job.first++;
-            my_job.load--;
+            ++my_job.first;
+            --my_job.load;
           }
 
         RandomAccessIterator current;
@@ -226,11 +225,11 @@ template<
                 my_job.load = my_job.last - my_job.first + 1;
                 for (difference_type job_counter = 0;
                      job_counter < chunk_size && current_job <= my_job.last;
-                     job_counter++)
+                     ++job_counter)
                   {
                     // Yes: process it!
                     current = begin + current_job;
-                    current_job++;
+                    ++current_job;
 
                     // Do actual work.
                     result = r(result, f(op, current));
@@ -244,7 +243,7 @@ template<
               {
                 // This thread no longer has work.
 #               pragma omp atomic
-                busy--;
+                --busy;
 
                 iam_working = false;
               }
@@ -286,7 +285,7 @@ template<
 
                 // Has potential work again.
 #               pragma omp atomic
-                  busy++;
+                  ++busy;
                 iam_working = true;
 
 #               pragma omp flush(busy)