Add loop unrolling to partition point

Author: igaztanaga

include/boost/container/experimental/segmented_partition_point.hpp

@@ -21,6 +21,7 @@
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
 #include <boost/container/experimental/segmented_iterator_traits.hpp>
+#include <boost/container/detail/iterators.hpp>
 
 namespace boost {
 namespace container {
@@ -30,21 +31,71 @@ FwdIt segmented_partition_point(FwdIt first, Sent last, Predicate pred);
 
 namespace detail_algo {
 
-template <class FwdIt, class Sent, class Predicate, class Tag>
+#if defined(BOOST_CONTAINER_SEGMENTED_LOOP_UNROLLING)
+
+template <class RAIter, class Predicate>
+RAIter segmented_partition_point_dispatch
+   (RAIter first, RAIter last, Predicate pred, const non_segmented_iterator_tag &, const std::random_access_iterator_tag &)
+{
+   typedef typename iterator_traits<RAIter>::difference_type difference_type;
+
+   difference_type n = last - first;
+   while(n >= difference_type(4)) {
+      if(!pred(*first))
+         goto final_result;
+      ++first;
+      if(!pred(*first))
+         goto final_result;
+      ++first;
+      if(!pred(*first))
+         goto final_result;
+      ++first;
+      if(!pred(*first))
+         goto final_result;
+      ++first;
+      n -= 4;
+   }
+
+   switch (n % 4) {
+      case 3:
+         if(!pred(*first))
+            break;
+         ++first;
+      BOOST_FALLTHROUGH;
+      case 2:
+         if(!pred(*first))
+            break;
+         ++first;
+      BOOST_FALLTHROUGH;
+      case 1:
+         if(!pred(*first))
+            break;
+         ++first;
+      BOOST_FALLTHROUGH;
+      default:
+         break;
+   }
+   final_result:
+   return first;
+}
+
+#endif   //BOOST_CONTAINER_SEGMENTED_LOOP_UNROLLING
+
+template <class FwdIt, class Sent, class Predicate, class Tag, class Cat>
 typename algo_enable_if_c<
    !Tag::value || is_sentinel<Sent, FwdIt>::value, FwdIt>::type
 segmented_partition_point_dispatch
-   (FwdIt first, Sent last, Predicate pred, Tag)
+   (FwdIt first, Sent last, Predicate pred, Tag, Cat)
 {
    for(; first != last; ++first)
       if(!pred(*first))
          return first;
    return last;
 }
 
-template <class SegIter, class Predicate>
+template <class SegIter, class Predicate, class Cat>
 SegIter segmented_partition_point_dispatch
-   (SegIter first, SegIter last, Predicate pred, segmented_iterator_tag)
+   (SegIter first, SegIter last, Predicate pred, segmented_iterator_tag, Cat)
 {
    typedef segmented_iterator_traits<SegIter>   traits;
    typedef typename traits::local_iterator      local_iterator;
@@ -57,24 +108,24 @@ SegIter segmented_partition_point_dispatch
 
    if(scur == slast) {
       return traits::compose(scur, 
-         (segmented_partition_point_dispatch)(traits::local(first), traits::local(last), pred, is_local_seg_t()));
+         (segmented_partition_point_dispatch)(traits::local(first), traits::local(last), pred, is_local_seg_t(), Cat()));
    }
    else {
       {
          local_iterator lcur =
-            (segmented_partition_point_dispatch)(traits::local(first), traits::end(scur), pred, is_local_seg_t());
+            (segmented_partition_point_dispatch)(traits::local(first), traits::end(scur), pred, is_local_seg_t(), Cat());
          if (lcur != traits::end(scur))
             return traits::compose(scur, lcur);
       }
 
       for(++scur; scur != slast; ++scur) {
          local_iterator lcur =
-            (segmented_partition_point_dispatch)(traits::begin(scur), traits::end(scur), pred, is_local_seg_t());
+            (segmented_partition_point_dispatch)(traits::begin(scur), traits::end(scur), pred, is_local_seg_t(), Cat());
          if(lcur != traits::end(scur))
             return traits::compose(scur, lcur);
       }
       return traits::compose(slast, 
-         (segmented_partition_point_dispatch)(traits::begin(scur), traits::local(last), pred, is_local_seg_t()));
+         (segmented_partition_point_dispatch)(traits::begin(scur), traits::local(last), pred, is_local_seg_t(), Cat()));
    }
    return last;
 }
@@ -92,7 +143,7 @@ FwdIt segmented_partition_point(FwdIt first, Sent last, Predicate pred)
 {
    typedef segmented_iterator_traits<FwdIt> traits;
    return detail_algo::segmented_partition_point_dispatch
-      (first, last, pred, typename traits::is_segmented_iterator());
+      (first, last, pred, typename traits::is_segmented_iterator(), typename iterator_traits<FwdIt>::iterator_category());
 }
 
 } // namespace container