Added fused iteration to reduce virtual dispatches (#9)

* Added fused iteration to reduce virtual dispatches

* Optimization does not use a "caching iterator"

Author: patrickroberts

include/beman/any_view/detail/any_iterator.hpp

@@ -4,6 +4,7 @@
 #define BEMAN_ANY_VIEW_DETAIL_ANY_ITERATOR_HPP
 
 #include <beman/any_view/concepts.hpp>
+#include <beman/any_view/config.hpp>
 #include <beman/any_view/detail/intrusive_small_ptr.hpp>
 #include <beman/any_view/detail/iterator_adaptor.hpp>
 
@@ -16,23 +17,41 @@ class any_iterator {
     using pointer          = std::add_pointer_t<RefT>;
 
     using interface_type = iterator_interface<ElementT, RefT, RValueRefT, DiffT>;
+    using cache_type =
+        std::conditional_t<std::derived_from<IterConceptT, std::forward_iterator_tag>, iter_cache_t<RefT>, no_cache>;
+
+    static constexpr bool cached = not std::same_as<cache_type, no_cache>;
+
     // inplace storage sufficient for a vtable pointer and two pointers
     intrusive_small_ptr<interface_type, 3 * sizeof(void*)> iterator_ptr;
+    BEMAN_ANY_VIEW_NO_UNIQUE_ADDRESS() cache_type cache;
 
     template <class IteratorT, class SentinelT>
     static consteval auto get_in_place_adaptor_type() {
         return std::in_place_type<
             detail::iterator_adaptor<ElementT, reference, rvalue_reference, DiffT, IteratorT, SentinelT>>;
     }
 
+    template <detail::any_compatible_iterator<any_iterator> IteratorT, std::sentinel_for<IteratorT> SentinelT>
+    constexpr any_iterator(IteratorT&& iterator, SentinelT&& sentinel, cache_type&& cache)
+        : iterator_ptr(get_in_place_adaptor_type<IteratorT, SentinelT>(), std::move(iterator), std::move(sentinel)),
+          cache(std::move(cache)) {}
+
   public:
     using iterator_concept = IterConceptT;
     using element_type     = ElementT;
     using difference_type  = DiffT;
 
     template <detail::any_compatible_iterator<any_iterator> IteratorT, std::sentinel_for<IteratorT> SentinelT>
     constexpr any_iterator(IteratorT iterator, SentinelT sentinel)
-        : iterator_ptr(get_in_place_adaptor_type<IteratorT, SentinelT>(), std::move(iterator), std::move(sentinel)) {}
+        : any_iterator(std::move(iterator), std::move(sentinel), cache_type()) {}
+
+    template <detail::any_compatible_iterator<any_iterator> IteratorT, std::sentinel_for<IteratorT> SentinelT>
+    constexpr any_iterator(IteratorT iterator, SentinelT sentinel)
+        requires(cached)
+        : any_iterator(std::move(iterator),
+                       std::move(sentinel),
+                       iterator != sentinel ? iter_cache<RefT>::make(*iterator) : iter_cache_t<RefT>{}) {}
 
     constexpr any_iterator() noexcept
         requires std::derived_from<IterConceptT, std::forward_iterator_tag>
@@ -50,7 +69,13 @@ class any_iterator {
 
     constexpr any_iterator& operator=(any_iterator&&) noexcept = default;
 
-    [[nodiscard]] constexpr reference operator*() const { return **iterator_ptr; }
+    [[nodiscard]] constexpr reference operator*() const {
+        if constexpr (cached) {
+            return *cache;
+        } else {
+            return **iterator_ptr;
+        }
+    }
 
     [[nodiscard]] friend constexpr rvalue_reference iter_move(const any_iterator& other) {
         return other.iterator_ptr->iter_move();
@@ -59,11 +84,19 @@ class any_iterator {
     [[nodiscard]] constexpr pointer operator->() const
         requires std::derived_from<IterConceptT, std::contiguous_iterator_tag>
     {
-        return std::to_address(*iterator_ptr);
+        if constexpr (cached) {
+            return cache;
+        } else {
+            return std::to_address(*iterator_ptr);
+        }
     }
 
     constexpr any_iterator& operator++() {
-        ++*iterator_ptr;
+        if constexpr (cached) {
+            cache = iterator_ptr->next();
+        } else {
+            ++*iterator_ptr;
+        }
         return *this;
     }
 
@@ -86,7 +119,11 @@ class any_iterator {
     constexpr any_iterator& operator--()
         requires std::derived_from<IterConceptT, std::bidirectional_iterator_tag>
     {
-        --*iterator_ptr;
+        if constexpr (cached) {
+            cache = iterator_ptr->prev();
+        } else {
+            --*iterator_ptr;
+        }
         return *this;
     }
 
@@ -113,7 +150,11 @@ class any_iterator {
     constexpr any_iterator& operator+=(difference_type offset)
         requires std::derived_from<IterConceptT, std::random_access_iterator_tag>
     {
-        *iterator_ptr += offset;
+        if constexpr (cached) {
+            cache = iterator_ptr->next(offset);
+        } else {
+            *iterator_ptr += offset;
+        }
         return *this;
     }
 
@@ -154,7 +195,11 @@ class any_iterator {
     }
 
     [[nodiscard]] constexpr bool operator==(std::default_sentinel_t sentinel) const {
-        return *iterator_ptr == sentinel;
+        if constexpr (cached) {
+            return cache == iter_cache_t<RefT>{};
+        } else {
+            return *iterator_ptr == sentinel;
+        }
     }
 };
 

include/beman/any_view/detail/iterator_adaptor.hpp

@@ -26,6 +26,8 @@ class iterator_adaptor final : public iterator_interface<ElementT, RefT, RValueR
     using iterator_interface = detail::iterator_interface<ElementT, RefT, RValueRefT, DiffT>;
     using pointer            = std::add_pointer_t<RefT>;
 
+    static constexpr bool cached = not std::same_as<iter_cache_t<RefT>, no_cache>;
+
     static constexpr auto get_noexcept() {
         return std::is_nothrow_move_constructible_v<IteratorT> and std::is_nothrow_move_constructible_v<SentinelT>;
     }
@@ -63,6 +65,30 @@ class iterator_adaptor final : public iterator_interface<ElementT, RefT, RValueR
         }
     }
 
+    [[nodiscard]] constexpr auto next() -> iter_cache_t<RefT> override {
+        if constexpr (std::forward_iterator<IteratorT> and cached) {
+            return ++iterator != sentinel ? iter_cache<RefT>::make(*iterator) : iter_cache_t<RefT>{};
+        }
+
+        unreachable();
+    }
+
+    [[nodiscard]] constexpr auto prev() -> iter_cache_t<RefT> override {
+        if constexpr (std::bidirectional_iterator<IteratorT> and cached) {
+            return --iterator != sentinel ? iter_cache<RefT>::make(*iterator) : iter_cache_t<RefT>{};
+        }
+
+        unreachable();
+    }
+
+    [[nodiscard]] constexpr auto next(DiffT n) -> iter_cache_t<RefT> override {
+        if constexpr (std::random_access_iterator<IteratorT> and cached) {
+            return (iterator += n) != sentinel ? iter_cache<RefT>::make(*iterator) : iter_cache_t<RefT>{};
+        }
+
+        unreachable();
+    }
+
     [[nodiscard]] constexpr auto operator*() const -> RefT override { return *iterator; }
 
     [[nodiscard]] constexpr auto iter_move() const -> RValueRefT override { return std::ranges::iter_move(iterator); }

include/beman/any_view/detail/iterator_interface.hpp

@@ -5,10 +5,36 @@
 
 #include <compare>
 #include <iterator>
+#include <optional>
 #include <type_traits>
 
 namespace beman::any_view::detail {
 
+struct no_cache {};
+
+template <class RefT>
+struct iter_cache {
+    using type = no_cache;
+};
+
+template <class RefT>
+    requires std::is_trivially_copyable_v<RefT>
+struct iter_cache<RefT> {
+    using type = std::optional<RefT>;
+
+    static constexpr auto make(RefT ref) noexcept -> type { return {ref}; }
+};
+
+template <class RefT>
+struct iter_cache<RefT&> {
+    using type = RefT*;
+
+    static constexpr auto make(RefT& ref) noexcept -> type { return std::addressof(ref); }
+};
+
+template <class RefT>
+using iter_cache_t = iter_cache<RefT>::type;
+
 template <class ElementT, class RefT, class RValueRefT, class DiffT>
 class iterator_interface {
     using pointer = std::add_pointer_t<RefT>;
@@ -21,6 +47,13 @@ class iterator_interface {
     // out-of-place construction
     [[nodiscard]] virtual constexpr auto copy() const -> iterator_interface* = 0;
 
+    // fused increment-compare-dereference
+    [[nodiscard]] virtual constexpr auto next() -> iter_cache_t<RefT> = 0;
+
+    [[nodiscard]] virtual constexpr auto prev() -> iter_cache_t<RefT> = 0;
+
+    [[nodiscard]] virtual constexpr auto next(DiffT n) -> iter_cache_t<RefT> = 0;
+
     // iterator methods
     [[nodiscard]] virtual constexpr auto operator*() const -> RefT = 0;
 

tests/beman/any_view/constexpr.test.cpp

@@ -64,3 +64,23 @@ TEST(ConstexprTest, sort_vector) {
 #endif
     EXPECT_TRUE(sort(std::vector{6, 8, 7, 5, 3, 0, 9}));
 }
+
+constexpr auto set_front(any_view<int, forward> view, int value) {
+    // forward iterator of lvalue reference uses cache object to fuse virtual dispatches
+    static_assert(sizeof(std::ranges::iterator_t<any_view<int, forward>>) ==
+                  sizeof(std::ranges::iterator_t<any_view<int, input>>) + sizeof(int*));
+
+    auto& ref = view.front();
+    // even with cache object, lifetime of reference is not tied to lifetime of iterator
+    ref = value;
+
+    return view.front() == value;
+}
+
+TEST(ConstexprTest, reference_lifetime) {
+#ifndef _MSC_VER
+    // error C2131: expression did not evaluate to a constant
+    static_assert(set_front(std::vector{7}, 42));
+#endif
+    EXPECT_TRUE(set_front(std::vector{7}, 42));
+}