compress copy 5 (jfalcou#1671)

Author: DenisYaroshevskiy

examples/algorithms/writing_new/collect_indexes__complicated_real_example.cpp

@@ -6,8 +6,6 @@
 */
 //==================================================================================================
 
-//
-// NOTE: another way of writing the same example can be found in: algorithms/writing_new/collect_indexes__writing_custom_loop.cpp
 //
 // In this example we will have a look at a problem from this blog post:
 //   https://maxdemarzi.com/2021/08/30/lets-build-something-outrageous-part-13-finding-things-faster/
@@ -55,7 +53,7 @@ void collect_indexes(R&& r, P p, std::vector<IdxType, Alloc>& res)
   // Prepare the output in case it was not empty.
   res.clear();
 
-  // Over allocating to always use `compress_store[unsafe]`.
+  // Over allocating to always use `compress_copy[unsafe]`.
   // eve won't go beyound eve::expected_cardinal_v<IdxType> per wide here.
   res.resize((r.end() - r.begin()) + eve::expected_cardinal_v<IdxType>);
   IdxType* out = res.data();
@@ -81,26 +79,28 @@ void collect_indexes(R&& r, P p, std::vector<IdxType, Alloc>& res)
       r_with_idx,
       [&](eve::algo::iterator auto r_idx_it, eve::relative_conditional_expr auto ignore) mutable
       {
+        auto [elems_it, idxs_it] = r_idx_it;
+
         // load an element and an index for each element.
         // The values in the `ignored` part are garbage.
-        auto [elems, idxs] = eve::load[ignore](r_idx_it);
+        auto elems = eve::load[ignore](elems_it);
 
         // Apply the predicate
         auto test = p(elems);
 
-        // We don't know what was the result of applying a predicate to garbage, we need to mask it.
-        test = eve::replace_ignored(test, ignore, eve::false_);
-
-        // compress_store[unsafe] - write elements marked as true to the output.
+        // compress_copy[unsafe] - copies elements marked as true to the output.
         // the elements are packed together to the left.
         // unsafe means we can write up to the register width of extra stuff.
-        // returns pointer behind last written element
+        // sparse means we expect few elements (within test) to be true
+        // first ignore means that 'true' for garbage element should still not be written.
+        // second 'ignore_none' means we have enough space in the output to write 4 elements.
+        // returns pointer behind last written element.
         //
         //  idxs    : [ 1 2 3 4 ]
         //  test    : [ f t f t ]
         //  written : [ 2 4 x x ]
         //  returns : out + 2
-        out  = eve::compress_store[eve::unsafe](idxs, test, out);
+        out  = eve::compress_copy[eve::unsafe][eve::sparse][ignore][eve::ignore_none](idxs_it, test, out);
       });
 
   res.resize(out - res.data());

examples/algorithms/writing_new/collect_indexes__writing_custom_loop.cpp

@@ -31,8 +31,9 @@ namespace eve::algo
       EVE_FORCEINLINE bool step(auto it, eve::relative_conditional_expr auto ignore, auto /*idx*/)
       {
         auto loaded = eve::load[ignore](it);
-        auto mask   = !p(loaded);  // we decied that ! can be optimized well enough
-        out = compress_store[unsafe][ignore](loaded, mask, out);
+        auto mask   = !p(loaded); // we decied that ! can be optimized well enough
+        auto density   = density_for_compress_copy<typename TraitsSupport::traits_type>();
+        out            = compress_copy[unsafe][density][ignore](it, loaded, mask, out);
         return false;
       }
 

include/eve/module/algo/algo/remove.hpp

@@ -257,7 +257,8 @@ namespace detail
         auto v2 = eve::load(f2);
 
         auto matches = eve::has_equal_in(v1, v2, equal);
-        o            = eve::compress_store[eve::unsafe](v1, matches, o);
+        auto density = density_for_compress_copy<decltype(modified_traits())>();
+        o            = eve::compress_copy[eve::unsafe][density](f1, v1, matches, o);
 
         // maybe benefictial to move up but we will hope for a compiler
         //
@@ -361,12 +362,17 @@ template<typename TraitsSupport> struct set_intersection_ : TraitsSupport
 //!
 //!  @brief SIMD variation on std::set_intersection that HAS A SLIGHTLY DIFFERENT SEMANTICS.
 //!
+//!   **Defined in Header**
+//!
+//!   @code
+//!   #include <eve/module/algo.hpp>
+//!   @endcode
+//!
 //!  The main idea for the algorithm comes from
 //!    "Faster-Than-Native Alternatives for x86 VP2INTERSECT Instructions"
 //!     by Guillermo Diez-Canas.
 //!     Link: https://arxiv.org/abs/2112.06342
 //!
-//!
 //!  Differences:
 //!    * duplicate handling, `eve::algo::set_intersection` does not
 //!      guarantee how many copies of a duplicated element will be in the output.
@@ -394,14 +400,10 @@ template<typename TraitsSupport> struct set_intersection_ : TraitsSupport
 //!    * The provided solution is minimal, eve won't search for beginning of intersection in
 //!      any way. eve also won't do any dispatch based on size.
 //!      If this is something that can be beneficial for your case - consider it.
+//!    * sparse_output/dense_output - controls which eve::algo::compress_copy is used, default is
+//!                                   dense.
 //!    * Basic version does not support aligning/unrolling. `expect_smaller_range` do.
 //!
-//!  **Header**
-//!
-//!  @code
-//!  #include <eve/module/algo.hpp>
-//!  @endcode
-//!
 //!   @groupheader{Callable Signatures}
 //!
 //!   @code

include/eve/module/algo/algo/set_intersection.hpp

@@ -393,8 +393,48 @@ namespace eve::algo
   //============================================================================
   template<std::unsigned_integral T> inline constexpr auto index_type = (index_type_key = std::type_identity<T>{});
 
-  // getters -------------------
+  struct density_key_t : rbr::as_keyword<density_key_t>
+  {
+    template<typename Value> constexpr auto operator=(Value const&) const noexcept
+    {
+      return rbr::option<density_key_t,Value>{};
+    }
+  };
+  inline constexpr density_key_t density_key;
 
+  //============================================================================
+  //! @addtogroup algo_traits
+  //! @{
+  //!   @var sparse_output
+  //!
+  //!   @brief for algorithms that output data based on input (eve::algo::copy_if,
+  //!   eve::algo::remove_if, eve::algo::set_intersection etc),
+  //!   tells the algorithm to optimize for the case where there will be fairly few
+  //!   elements per iteration.
+  //!   eve::algo::dense_output is default since it's better in most cases measured.
+  //!
+  //!   @see eve::algo::dense_output
+  //! @}
+  //============================================================================
+  inline constexpr auto sparse_output = (density_key = eve::sparse);
+
+  //============================================================================
+  //! @addtogroup algo_traits
+  //! @{
+  //!   @var dense_output
+  //!
+  //!   @brief for algorithms that output data based on input (eve::algo::copy_if,
+  //!   eve::algo::remove_if, eve::algo::set_intersection etc),
+  //!   tells the algorithm to optimize for the case where there will be many
+  //!   elements per iteration.
+  //!   eve::algo::dense_output is default since it's better in most cases measured.
+  //!
+  //!   @see eve::algo::sparse_output
+  //! @}
+  //============================================================================
+  inline constexpr auto dense_output = (density_key = eve::dense);
+
+  // getters -------------------
 
   //================================================================================================
   //! @addtogroup algo_traits
@@ -549,6 +589,19 @@ namespace eve::algo
   template <typename Traits>
   constexpr bool has_type_overrides_v = Traits::contains(force_type_key) || Traits::contains(common_with_types_key);
 
+  //================================================================================================
+  //! @addtogroup algo_traits
+  //! @brief returns eve::sparse or eve::dense (default is eve::dense)
+  //! @tparam Traits
+  //================================================================================================
+  template<typename Traits>
+  constexpr auto
+  density_for_compress_copy()
+  {
+    using res_t = rbr::result::fetch_t<(density_key | eve::dense), Traits>;
+    return res_t {};
+  }
+
   //================================================================================================
   //! @addtogroup algo_traits
   //! @brief some traits should just be replaced with a combination of different traits.

include/eve/module/algo/algo/traits.hpp

@@ -73,7 +73,7 @@ template<typename Callable, typename... Settings> struct compress_callable : Cal
     {
       return (*this)[ignore_none][ignore_none](args...);
     }
-    else if constexpr( sizeof...(Settings) == 3 ) { return (*this)[get<3>(settings)](args...); }
+    else if constexpr( sizeof...(Settings) == 3 ) { return (*this)[get<2>(settings)](args...); }
     else
     {
       auto s0 = get<0>(settings);