Upgrade to Pro — share decks privately, control downloads, hide ads and more …

StockholmC++: Cache friendly data + functional + ranges = ❤️

StockholmC++: Cache friendly data + functional + ranges = ❤️

Experience has shown that when working with data in bulk, or when the data sets are small, structs of vectors is the way to go for performance. Working with structs of vectors can be cumbersome, however. Let's have a look at what can be done with the recent additions to the C++ language and standard library.

Björn Fahller

June 13, 2024
Tweet

More Decks by Björn Fahller

Other Decks in Programming

Transcript

  1. position velocity acceleration mass ← obj1 ← obj2 Björn Fahller

    Cache Friendly + Functional + Ranges = ❤️
  2. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 2/172 stop Putin Background https://youtu.be/rX0ItVEVjHc Mike Acton – CppCon Keynote 2014 Data Oriented Design https://youtu.be/OOOEU2FWCg4 Mathieu Ropert – StockholmCpp 2023 Data Storage in Entity Component System
  3. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 3/172 stop Putin struct S { int x; int y; int z; int d }; y x z d y x z d y x z d y x z d y x z d y x z d y x z d
  4. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 4/172 stop Putin struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d
  5. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 5/172 stop Putin struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access
  6. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 6/172 stop Putin struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access access
  7. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 7/172 stop Putin struct S { int x; int y; int z; int d }; read read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access access
  8. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 8/172 stop Putin struct S { int x; int y; int z; int d }; read read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access access access
  9. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 9/172 stop Putin struct S { int x; int y; int z; int d }; read read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access access access access
  10. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 10/172 stop Putin struct S { int x; int y; int z; int d }; read read read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access access access access
  11. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 11/172 stop Putin struct S { int x; int y; int z; int d }; read read read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access access access access access
  12. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 12/172 stop Putin struct S { int x; int y; int z; int d }; read read read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access access access access access access
  13. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 13/172 stop Putin struct S { int x; int y; int z; int d }; read read read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access access access access access access access
  14. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 14/172 stop Putin struct S { int x; int y; int z; int d }; read read read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access access access access access access access access
  15. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 15/172 stop Putin vector of structs / structs of vectors struct S { int x; int y; int z; int d }; y x z d y x z d y x z d y x z d y x z d y x z d y x z d x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d
  16. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 16/172 stop Putin vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d
  17. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 17/172 stop Putin vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d
  18. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 18/172 stop Putin vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access
  19. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 19/172 stop Putin vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access
  20. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 20/172 stop Putin vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access
  21. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 21/172 stop Putin vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access
  22. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 22/172 stop Putin vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access access
  23. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 23/172 stop Putin vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access access access
  24. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 24/172 stop Putin vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access access access access
  25. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 25/172 stop Putin read vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access access access access
  26. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 26/172 stop Putin read vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access access access access access
  27. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 27/172 stop Putin read vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access access access access access access
  28. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 28/172 stop Putin read vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access access access access access access access
  29. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 29/172 stop Putin read vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access access access access access access access
  30. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 30/172 stop Putin read vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access access access access access access access
  31. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 31/172 stop Putin read vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access access access access access access access
  32. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 32/172 stop Putin read vector of structs / structs of vectors struct S { int x; int y; int z; int d }; read y x z d y x z d y x z d y x z d y x z d y x z d y x z d access x x x x x x x x x x x x x x x x x x x x x x x x y y y y y y y y y y y y y y y y y y y y y y y y z z z z z z z z z z z z z z z z z z z z z z z z d d d d d d d d d d d d d d d d d d d d d d d d access access access access access access access access access access
  33. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 33/172 stop Putin Live Demo vector_of_structs vs struct_of_vectors
  34. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 34/172 stop Putin Observations In this exampe, struct of vectors...
  35. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 35/172 stop Putin Observations In this exampe, struct of vectors... … has way fewer memory access
  36. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 36/172 stop Putin Observations In this exampe, struct of vectors... … has way fewer memory access … has way fewer cache misses
  37. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 37/172 stop Putin Observations In this exampe, struct of vectors... … has way fewer memory access … has way fewer cache misses … has slightly fewer instructions
  38. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 38/172 stop Putin Observations In this exampe, struct of vectors... … has way fewer memory access … has way fewer cache misses … has slightly fewer instructions … is faster
  39. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 39/172 stop Putin Observations In this exampe, struct of vectors... … has way fewer memory access … has way fewer cache misses … has slightly fewer instructions … is faster … is horrible code to work with
  40. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 40/172 stop Putin Observations In this exampe, struct of vectors... … has way fewer memory access … has way fewer cache misses … has slightly fewer instructions … is faster … is horrible code to work with Can we make it easier to work with and keep the performance?
  41. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 41/172 stop Putin std::tuple<> is cool! template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; row operator[](size_t i) { auto access = [&]<size_t ... Is>(std::index_sequence<Is...>) { return row{std::get<Is>(data_)[i]...}; }; return std::invoke(access, indexes); } ... private: static constexpr std::index_sequence_for<Ts...> indexes{}; std::tuple<std::vector<Ts>...> data_; };
  42. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 42/172 stop Putin std::tuple<> is cool! template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; row operator[](size_t i) { auto access = [&]<size_t ... Is>(std::index_sequence<Is...>) { return row{std::get<Is>(data_)[i]...}; }; return std::invoke(access, indexes); } ... private: static constexpr std::index_sequence_for<Ts...> indexes{}; std::tuple<std::vector<Ts>...> data_; }; Storage is a tuple of vectors of Ts
  43. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 43/172 stop Putin std::tuple<> is cool! template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; row operator[](size_t i) { auto access = [&]<size_t ... Is>(std::index_sequence<Is...>) { return row{std::get<Is>(data_)[i]...}; }; return std::invoke(access, indexes); } ... private: static constexpr std::index_sequence_for<Ts...> indexes{}; std::tuple<std::vector<Ts>...> data_; }; Access a row as a tuple of references to the elements
  44. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 44/172 stop Putin std::tuple<> is cool! template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; row operator[](size_t i) { auto access = [&]<size_t ... Is>(std::index_sequence<Is...>) { return row{std::get<Is>(data_)[i]...}; }; return std::invoke(access, indexes); } ... private: static constexpr std::index_sequence_for<Ts...> indexes{}; std::tuple<std::vector<Ts>...> data_; }; Build by dereferencing the same offset in each vector in the tuple
  45. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 45/172 stop Putin table<Ts...>
  46. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 46/172 stop Putin template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; void push_back(Ts... ts); void pop_back(); row operator[](size_t i); row back(); void reserve(size_t size); bool empty() const; size_t size() const private: ... }; table<Ts...>
  47. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 47/172 stop Putin template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; void push_back(Ts... ts); void pop_back(); row operator[](size_t i); row back(); void reserve(size_t size); bool empty() const; size_t size() const private: ... }; template <typename Table, typename P> void drop_if(Table& t, P predicate) { size_t i = 0; while (i < t.size()) { if (predicate(t[i])) { t[i] = std::move(v.back()); t.pop_back(); }  else { ++i; } } } table<Ts...>
  48. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 48/172 stop Putin template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; void push_back(Ts... ts); void pop_back(); row operator[](size_t i); row back(); void reserve(size_t size); bool empty() const; size_t size() const private: ... }; template <typename Table, typename P> void drop_if(Table& t, P predicate) { size_t i = 0; while (i < t.size()) { if (predicate(t[i])) { t[i] = std::move(v.back()); t.pop_back(); }  else { ++i; } } } while (!values.empty()) { drop_if(values, [&](auto r) { auto [x,y,z,d] = r; return z < start; });         ++iter;         start += 10;     } } table<Ts...>
  49. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 49/172 stop Putin Live Demo templated
  50. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 50/172 stop Putin Observations In this exampe...
  51. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 51/172 stop Putin Observations In this exampe... … the ergonomics is roughly the same as with vector of structs
  52. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 52/172 stop Putin Observations In this exampe... … the ergonomics is roughly the same as with vector of structs … performance is the same as with struct of vectors
  53. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 53/172 stop Putin Observations In this exampe... … the ergonomics is roughly the same as with vector of structs … performance is the same as with struct of vectors But, we also need…
  54. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 54/172 stop Putin Observations In this exampe... … the ergonomics is roughly the same as with vector of structs … performance is the same as with struct of vectors But, we also need… … a stable row-ID to lookup objects
  55. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 55/172 stop Putin Observations In this exampe... … the ergonomics is roughly the same as with vector of structs … performance is the same as with struct of vectors But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges
  56. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 56/172 stop Putin Observations In this exampe... … the ergonomics is roughly the same as with vector of structs … performance is the same as with struct of vectors But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want...
  57. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 57/172 stop Putin Observations In this exampe... … the ergonomics is roughly the same as with vector of structs … performance is the same as with struct of vectors But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns
  58. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 58/172 stop Putin Observations In this exampe... … the ergonomics is roughly the same as with vector of structs … performance is the same as with struct of vectors But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements
  59. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 59/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c d e f h g A B C D E F H G i I 0 1 2 3 4 5 7 6 8 data index first_free = 9
  60. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 60/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c d e f h g A B C D E F H G i I 0 1 2 3 4 5 7 6 8 data index erase first_free = 9
  61. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 61/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c d e f h g A B C D E F H G i I 0 1 2 3 4 5 7 6 8 data index erase first_free = 9
  62. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 62/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c d e f h g A B C D E F H G 0 1 2 3 4 5 7 6 8 data index erase i I first_free = 9
  63. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 63/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c d e f h g A B C D E F H G 0 1 2 3 4 5 7 6 8 data index erase i I 3 first_free = 9
  64. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 64/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c d e f h g A B C D E F H G 0 1 2 3 4 5 7 6 8 data index erase i I 3 first_free = 9
  65. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 65/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c d e f h g A B C D E F H G 0 1 2 3 4 5 7 6 8 data index erase i I 3 first_free = 9 9
  66. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 66/172 stop Putin first_free = 3 Stable row ID 0 1 2 3 4 5 7 6 8 a b c d e f h g A B C D E F H G 0 1 2 3 4 5 7 6 8 data index erase i I 3 9
  67. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 67/172 stop Putin first_free = 3 Stable row ID 0 1 2 3 4 5 7 6 8 a b c d e f h g A B C D E F H G 0 1 2 3 4 5 7 6 8 data index erase i I 3 Lookup row_id 8 9
  68. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 68/172 stop Putin first_free = 3 Stable row ID 0 1 2 3 4 5 7 6 8 a b c d e f h g A B C D E F H G 0 1 2 3 4 5 7 6 8 data index erase i I 3 Lookup row_id 8 9
  69. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 69/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C I E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index first_free = 3
  70. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 70/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C I E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index find ‘i’ first_free = 3
  71. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 71/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C I E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index find ‘i’ first_free = 3
  72. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 72/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C I E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index find ‘i’ first_free = 3
  73. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 73/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C I E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index find ‘i’ ‘i’ is at row_id 8, which is stored at offset 3 in the columns. first_free = 3
  74. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 74/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C J E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index first_free = 3
  75. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 75/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C J E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index insert ‘k’, ‘K’ first_free = 3
  76. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 76/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C J E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index insert ‘k’, ‘K’ first_free = 3
  77. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 77/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C J E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index insert ‘k’, ‘K’ first_free = 3 k K 3
  78. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 78/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C J E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index insert ‘k’, ‘K’ first_free = 3 k K 3
  79. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 79/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C J E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index insert ‘k’, ‘K’ first_free = 3 k K 3
  80. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 80/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C J E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index insert ‘k’, ‘K’ first_free = 9 k K 3
  81. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 81/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C J E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index insert ‘k’, ‘K’ first_free = 9 k K 3 8
  82. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 82/172 stop Putin Stable row ID 0 1 2 3 4 5 7 6 8 a b c i e f h g A B C J E F H G 0 1 2 9 4 5 7 6 3 data index 0 1 2 8 4 5 7 6 reverse index insert ‘k’, ‘K’ first_free = 9 k K 3 8 Return row_id == 3, which refers to the new element
  83. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 83/172 stop Putin Stable row ID template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; struct row_id { size_t offset; }; row operator[](row_id id) { auto offset = index_[id.offset].offset; auto access = [&]<size_t ... Is>(std::index_sequence<Is...>) { return row{std::get<Is>(data_)[offset]...}; }; return std::invoke(access, indexes); } private: static constexpr auto indexes = std::index_sequence_for<Ts...>{}; std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; row_id first_free_ = {0}; };
  84. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 84/172 stop Putin Stable row ID template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; struct row_id { size_t offset; }; row operator[](row_id id) { auto offset = index_[id.offset].offset; auto access = [&]<size_t ... Is>(std::index_sequence<Is...>) { return row{std::get<Is>(data_)[offset]...}; }; return std::invoke(access, indexes); } private: static constexpr auto indexes = std::index_sequence_for<Ts...>{}; std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; row_id first_free_ = {0}; }; Translate row_id to offset in the vectors
  85. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 85/172 stop Putin Stable row ID template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; struct row_id { size_t offset; }; row operator[](row_id id) { auto offset = index_[id.offset].offset; auto access = [&]<size_t ... Is>(std::index_sequence<Is...>) { return row{std::get<Is>(data_)[offset]...}; }; return std::invoke(access, indexes); } private: static constexpr auto indexes = std::index_sequence_for<Ts...>{}; std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; row_id first_free_ = {0}; }; The rest of the access as before
  86. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 86/172 stop Putin Stable row ID template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; struct row_id { size_t offset; }; row operator[](row_id id) { auto offset = index_[id.offset].offset; auto access = [&]<size_t ... Is>(std::index_sequence<Is...>) { return row{std::get<Is>(data_)[offset]...}; }; return std::invoke(access, indexes); } private: static constexpr auto indexes = std::index_sequence_for<Ts...>{}; std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; row_id first_free_ = {0}; };
  87. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 87/172 stop Putin Stable row ID template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; struct row_id { size_t offset; }; row operator[](row_id id) { auto offset = index_[id.offset].offset; auto access = [&]<size_t ... Is>(std::index_sequence<Is...>) { return row{std::get<Is>(data_)[offset]...}; }; return std::invoke(access, indexes); } private: static constexpr auto indexes = std::index_sequence_for<Ts...>{}; std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; row_id first_free_ = {0}; }; template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; struct row_id { size_t offset; }; row_id push_back(Ts... ts); void pop_back(); row operator[](row_id i); row back(); void erase(row_id i); void reserve(size_t size); bool empty() const; size_t size() const; bool has_row(row_id i) const; private: ... };
  88. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 88/172 stop Putin Stable row ID template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; struct row_id { size_t offset; }; row operator[](row_id id) { auto offset = index_[id.offset].offset; auto access = [&]<size_t ... Is>(std::index_sequence<Is...>) { return row{std::get<Is>(data_)[offset]...}; }; return std::invoke(access, indexes); } private: static constexpr auto indexes = std::index_sequence_for<Ts...>{}; std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; row_id first_free_ = {0}; }; template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; struct row_id { size_t offset; }; row_id push_back(Ts... ts); void pop_back(); row operator[](row_id i); row back(); void erase(row_id i); void reserve(size_t size); bool empty() const; size_t size() const; bool has_row(row_id i) const; private: ... }; table<int,int,int,int> t; auto i1 = t.push_back(1,2,3,4); auto i2 = t.push_back(2,3,4,5); auto i3 = t.push_back(3,4,5,6); auto i4 = t.push_back(4,5,6,7); t.erase(i2); t.erase(i3); assert(t[i1] == std::tuple(1,2,3,4)); assert(t[i4] == std::tuple(4,5,6,7)); assert(! t.has_row(i2)); assert(! t.has_row(i3));
  89. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 89/172 stop Putin Stable row ID template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; struct row_id { size_t offset; }; row operator[](row_id id) { auto offset = index_[id.offset].offset; auto access = [&]<size_t ... Is>(std::index_sequence<Is...>) { return row{std::get<Is>(data_)[offset]...}; }; return std::invoke(access, indexes); } private: static constexpr auto indexes = std::index_sequence_for<Ts...>{}; std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; row_id first_free_ = {0}; }; template <typename ... Ts> class table { public: using row = std::tuple<Ts&...>; struct row_id { size_t offset; }; row_id push_back(Ts... ts); void pop_back(); row operator[](row_id i); row back(); void erase(row_id i); void reserve(size_t size); bool empty() const; size_t size() const; bool has_row(row_id i) const; private: ... }; table<int,int,int,int> t; auto i1 = t.push_back(1,2,3,4); auto i2 = t.push_back(2,3,4,5); auto i3 = t.push_back(3,4,5,6); auto i4 = t.push_back(4,5,6,7); t.erase(i2); t.erase(i3); assert(t[i1] == std::tuple(1,2,3,4)); assert(t[i4] == std::tuple(4,5,6,7)); assert(! t.has_row(i2)); assert(! t.has_row(i3));
  90. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 90/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements
  91. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 91/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements ✔️
  92. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 92/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements ✔️
  93. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 93/172 stop Putin Iterators • Iterating in storage order is fast! • The prefetcher loves predictable access patterns in contiguous memory • Let the value type be a tuple of references to the elements of each column • Like table<Ts...>::operator[] • Compare with ranges::zip_view
  94. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 94/172 stop Putin Iterators struct sentinel {}; struct iterator { using value_type = row; using difference_type = ssize_t; value_type operator*() const { return std::invoke([&]<size_t ... Is>(std::index_sequence<Is...>){ return value_type{std::get<Is>(t->data_)[offset]...}; }, t->indexes); } iterator& operator++() { ++offset; return *this; } iterator operator++(int) { auto copy = *this; ++*this; return copy; } bool operator==(const iterator&) const = default; bool operator==(sentinel) const { return offset == t->size(); } table* t; size_t offset; };
  95. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 95/172 stop Putin Iterators struct sentinel {}; struct iterator { using value_type = row; using difference_type = ssize_t; value_type operator*() const { return std::invoke([&]<size_t ... Is>(std::index_sequence<Is...>){ return value_type{std::get<Is>(t->data_)[offset]...}; }, t->indexes); } iterator& operator++() { ++offset; return *this; } iterator operator++(int) { auto copy = *this; ++*this; return copy; } bool operator==(const iterator&) const = default; bool operator==(sentinel) const { return offset == t->size(); } table* t; size_t offset; }; Instead of one iterator per column, use the table and the column offset.
  96. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 96/172 stop Putin Iterators struct sentinel {}; struct iterator { using value_type = row; using difference_type = ssize_t; value_type operator*() const { return std::invoke([&]<size_t ... Is>(std::index_sequence<Is...>){ return value_type{std::get<Is>(t->data_)[offset]...}; }, t->indexes); } iterator& operator++() { ++offset; return *this; } iterator operator++(int) { auto copy = *this; ++*this; return copy; } bool operator==(const iterator&) const = default; bool operator==(sentinel) const { return offset == t->size(); } table* t; size_t offset; }; Dereferencing becomes the same as the old table::operator[] on offset.
  97. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 97/172 stop Putin Iterators struct sentinel {}; struct iterator { using value_type = row; using difference_type = ssize_t; value_type operator*() const { return std::invoke([&]<size_t ... Is>(std::index_sequence<Is...>){ return value_type{std::get<Is>(t->data_)[offset]...}; }, t->indexes); } iterator& operator++() { ++offset; return *this; } iterator operator++(int) { auto copy = *this; ++*this; return copy; } bool operator==(const iterator&) const = default; bool operator==(sentinel) const { return offset == t->size(); } table* t; size_t offset; }; Comparing with the end-of-range sentinel becomes checking if the one-past-the-end offset of the table has been reached.
  98. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 98/172 stop Putin template <typename ... Ts> class table { public: struct sentinel {}; struct iterator { ... }; friend class iterator; iterator begin() { return { this, 0 }; } sentinel end() const { return {}; }    size_t size() const { return std::get<0>(data_).size(); } private: static constexpr auto indexes = std::index_sequence_for<Ts...>{}; std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; row_id first_free_ = {0}; }; Iterators
  99. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 99/172 stop Putin template <typename ... Ts> class table { public: struct sentinel {}; struct iterator { ... }; friend class iterator; iterator begin() { return { this, 0 }; } sentinel end() const { return {}; }    size_t size() const { return std::get<0>(data_).size(); } private: static constexpr auto indexes = std::index_sequence_for<Ts...>{}; std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; row_id first_free_ = {0}; }; begin() and end() becomes trivially simple. Iterators
  100. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 100/172 stop Putin Live Demo iterators
  101. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 101/172 stop Putin row_id It would be nice to be able to get the row_id from *iterator, but how? std::tuple<types&...> does not naturally lend itself to that.
  102. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 102/172 stop Putin row_id It would be nice to be able to get the row_id from *iterator, but how? std::tuple<types&...> does not naturally lend itself to that. Inheritance as row : std::tuple<types&...> { ... }; could take care of it, but then we’d lose destructuring as auto [a,b,c] = *iterator; or auto [a,b,c] = table[id];
  103. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 103/172 stop Putin row_id It would be nice to be able to get the row_id from *iterator, but how? std::tuple<types&...> does not naturally lend itself to that. Inheritance as row : std::tuple<types&...> { ... }; could take care of it, but then we’d lose destructuring as auto [a,b,c] = *iterator; or auto [a,b,c] = table[id]; The standard offers a way to implement destructuring for your own types by:
  104. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 104/172 stop Putin row_id It would be nice to be able to get the row_id from *iterator, but how? std::tuple<types&...> does not naturally lend itself to that. Inheritance as row : std::tuple<types&...> { ... }; could take care of it, but then we’d lose destructuring as auto [a,b,c] = *iterator; or auto [a,b,c] = table[id]; The standard offers a way to implement destructuring for your own types by: Specializing std::tuple_size<T>
  105. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 105/172 stop Putin row_id It would be nice to be able to get the row_id from *iterator, but how? std::tuple<types&...> does not naturally lend itself to that. Inheritance as row : std::tuple<types&...> { ... }; could take care of it, but then we’d lose destructuring as auto [a,b,c] = *iterator; or auto [a,b,c] = table[id]; The standard offers a way to implement destructuring for your own types by: Specializing std::tuple_size<T> Specializing std::tuple_element<idx, T>
  106. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 106/172 stop Putin row_id It would be nice to be able to get the row_id from *iterator, but how? std::tuple<types&...> does not naturally lend itself to that. Inheritance as row : std::tuple<types&...> { ... }; could take care of it, but then we’d lose destructuring as auto [a,b,c] = *iterator; or auto [a,b,c] = table[id]; The standard offers a way to implement destructuring for your own types by: Specializing std::tuple_size<T> Specializing std::tuple_element<idx, T> Implementing your own get<Idx>(T&&) or T::get<Idx>()
  107. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 107/172 stop Putin Our own row type template <typename ... Ts> class table { public: struct row_id { size_t offset; }; row operator[](row_id id) { return { this, index_[id.offset].offset; } } private: std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; ... }; template <typename ... Ts> struct row; template <typename ... Ts> struct row<table<Ts...>> { template <size_t I> friend Ts...[I]& get(row& r) { return std::get<I>(r.t->data_)[offset]; } row_id id() const { return t->reverse_index_[offset]; } table* t; size_t offset; };
  108. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 108/172 stop Putin Our own row type template <typename ... Ts> class table { public: struct row_id { size_t offset; }; row operator[](row_id id) { return { this, index_[id.offset].offset; } } private: std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; ... }; template <typename ... Ts> struct row; template <typename ... Ts> struct row<table<Ts...>> { template <size_t I> friend Ts...[I]& get(row& r) { return std::get<I>(r.t->data_)[offset]; } row_id id() const { return t->reverse_index_[offset]; } table* t; size_t offset; }; Which row in the table
  109. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 109/172 stop Putin Our own row type template <typename ... Ts> class table { public: struct row_id { size_t offset; }; row operator[](row_id id) { return { this, index_[id.offset].offset; } } private: std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; ... }; template <typename ... Ts> struct row; template <typename ... Ts> struct row<table<Ts...>> { template <size_t I> friend Ts...[I]& get(row& r) { return std::get<I>(r.t->data_)[offset]; } row_id id() const { return t->reverse_index_[offset]; } table* t; size_t offset; }; Get the row offset by lookup in the index
  110. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 110/172 stop Putin Our own row type template <typename ... Ts> class table { public: struct row_id { size_t offset; }; row operator[](row_id id) { return { this, index_[id.offset].offset; } } private: std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; ... }; template <typename ... Ts> struct row; template <typename ... Ts> struct row<table<Ts...>> { template <size_t I> friend Ts...[I]& get(row& r) { return std::get<I>(r.t->data_)[offset]; } row_id id() const { return t->reverse_index_[offset]; } table* t; size_t offset; }; Getting the row_id back is trivial
  111. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 111/172 stop Putin Our own row type template <typename ... Ts> class table { public: struct row_id { size_t offset; }; row operator[](row_id id) { return { this, index_[id.offset].offset; } } private: std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; ... }; template <typename ... Ts> struct row; template <typename ... Ts> struct row<table<Ts...>> { template <size_t I> friend Ts...[I]& get(row& r) { return std::get<I>(r.t->data_)[offset]; } row_id id() const { return t->reverse_index_[offset]; } table* t; size_t offset; }; Reference the desired column with tuple lookup.
  112. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 112/172 stop Putin Our own row type template <typename ... Ts> class table { public: struct row_id { size_t offset; }; row operator[](row_id id) { return { this, index_[id.offset].offset; } } private: std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; ... }; template <typename ... Ts> struct row; template <typename ... Ts> struct row<table<Ts...>> { template <size_t I> friend Ts...[I]& get(row& r) { return std::get<I>(r.t->data_)[offset]; } row_id id() const { return t->reverse_index_[offset]; } table* t; size_t offset; }; C++26 parameter pack indexing magic!
  113. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 113/172 stop Putin Our own row type template <typename ... Ts> class table { public: struct row_id { size_t offset; }; row operator[](row_id id) { return { this, index_[id.offset].offset; } } private: std::tuple<std::vector<Ts>...> data_; std::vector<row_id> reverse_index_; std::vector<row_id> index_; ... }; template <typename ... Ts> struct row; template <typename ... Ts> struct row<table<Ts...>> { template <size_t I> friend Ts...[I]& get(row& r) { return std::get<I>(r.t->data_)[offset]; } row_id id() const { return t->reverse_index_[offset]; } table* t; size_t offset; }; template <size_t I, typename ... Ts> struct std::tuple_element<I, row<Ts...> { using type = Ts...[I]&; }; template <typename ... Ts> struct std::tuple_size<row<Ts...>> : std::integral_constant<size_t, sizeof...(Ts)> {}; Opt in to destructuring
  114. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 114/172 stop Putin Live Demo iterators_row
  115. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 115/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements ✔️
  116. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 116/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements ✔️ ✔️
  117. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 117/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements ✔️ ✔️
  118. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 118/172 stop Putin Selecting columns
  119. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 119/172 stop Putin Selecting columns With the current row type, we can select columns by explicitly using get<I>(row).
  120. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 120/172 stop Putin Selecting columns With the current row type, we can select columns by explicitly using get<I>(row). void func(const table<int, int, float, std::string>& data) { for (auto r : data) { std::println(“{} {}”, get<0>(r), get<3>(r)); } }
  121. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 121/172 stop Putin Selecting columns With the current row type, we can select columns by explicitly using get<I>(row). void func(const table<int, int, float, std::string>& data) { for (auto r : data) { std::println(“{} {}”, get<0>(r), get<3>(r)); } }
  122. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 122/172 stop Putin Selecting columns With the current row type, we can select columns by explicitly using get<I>(row). void func(const table<int, int, float, std::string>& data) { for (auto r : data) { std::println(“{} {}”, get<0>(r), get<3>(r)); } } Not exactly convenient, is it?
  123. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 123/172 stop Putin Different row type template <typename ...> struct table; template <typename, typename> struct row; template <typename ... Ts, size_t ... Cs> struct row<table<Ts...>, std::index_sequence<Cs...>> { using row_id = typename table<Ts...>::row_id; template <size_t I> friend auto& get(const row& r) { static constexpr std::array columns{Cs...}; return std::get<columns[I]>(r.t->data_)[r.offset]; } ... table<Ts...>* t; size_t offset; };
  124. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 124/172 stop Putin Different row type template <typename ...> struct table; template <typename, typename> struct row; template <typename ... Ts, size_t ... Cs> struct row<table<Ts...>, std::index_sequence<Cs...>> { using row_id = typename table<Ts...>::row_id; template <size_t I> friend auto& get(const row& r) { static constexpr std::array columns{Cs...}; return std::get<columns[I]>(r.t->data_)[r.offset]; } ... table<Ts...>* t; size_t offset; }; The columns in the table that are referenced by this row type
  125. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 125/172 stop Putin Different row type template <typename ...> struct table; template <typename, typename> struct row; template <typename ... Ts, size_t ... Cs> struct row<table<Ts...>, std::index_sequence<Cs...>> { using row_id = typename table<Ts...>::row_id; template <size_t I> friend auto& get(const row& r) { static constexpr std::array columns{Cs...}; return std::get<columns[I]>(r.t->data_)[r.offset]; } ... table<Ts...>* t; size_t offset; }; Get the I-th of the columns
  126. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 126/172 stop Putin Different row type template <typename ...> struct table; template <typename, typename> struct row; template <typename ... Ts, size_t ... Cs> struct row<table<Ts...>, std::index_sequence<Cs...>> { using row_id = typename table<Ts...>::row_id; template <size_t I> friend auto& get(const row& r) { static constexpr std::array columns{Cs...}; return std::get<columns[I]>(r.t->data_)[r.offset]; } ... table<Ts...>* t; size_t offset; }; template <typename Table, size_t ... Cs> struct std::tuple_size<row<Table, std::index_sequence<Cs...>>> : std::integral_constant<size_t, sizeof...(Cs)> {}; template <size_t I, typename ... Ts, size_t ... Cs> struct std::tuple_element<I, row<table<Ts...>, std::index_sequence<Cs...>>> {     static constexpr std::array indexes = { Cs... };     using type = Ts...[indexes[I]]&; };
  127. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 127/172 stop Putin Different row type template <typename ...> struct table; template <typename, typename> struct row; template <typename ... Ts, size_t ... Cs> struct row<table<Ts...>, std::index_sequence<Cs...>> { using row_id = typename table<Ts...>::row_id; template <size_t I> friend auto& get(const row& r) { static constexpr std::array columns{Cs...}; return std::get<columns[I]>(r.t->data_)[r.offset]; } ... table<Ts...>* t; size_t offset; }; template <typename Table, size_t ... Cs> struct std::tuple_size<row<Table, std::index_sequence<Cs...>>> : std::integral_constant<size_t, sizeof...(Cs)> {}; template <size_t I, typename ... Ts, size_t ... Cs> struct std::tuple_element<I, row<table<Ts...>, std::index_sequence<Cs...>>> {     static constexpr std::array indexes = { Cs... };     using type = Ts...[indexes[I]]&; }; The size is the number of columns referenced
  128. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 128/172 stop Putin Different row type template <typename ...> struct table; template <typename, typename> struct row; template <typename ... Ts, size_t ... Cs> struct row<table<Ts...>, std::index_sequence<Cs...>> { using row_id = typename table<Ts...>::row_id; template <size_t I> friend auto& get(const row& r) { static constexpr std::array columns{Cs...}; return std::get<columns[I]>(r.t->data_)[r.offset]; } ... table<Ts...>* t; size_t offset; }; template <typename Table, size_t ... Cs> struct std::tuple_size<row<Table, std::index_sequence<Cs...>>> : std::integral_constant<size_t, sizeof...(Cs)> {}; template <size_t I, typename ... Ts, size_t ... Cs> struct std::tuple_element<I, row<table<Ts...>, std::index_sequence<Cs...>>> {     static constexpr std::array indexes = { Cs... };     using type = Ts...[indexes[I]]&; }; The type of the I-th element is the type of the I-th column referenced
  129. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 129/172 stop Putin Select columns in a row template <size_t ... Is, typename Table, size_t ... Cs> auto select(const row<Table, std::index_sequence<Cs...>>& r) {     static constexpr size_t columns[] { Cs... };     return row<Table, std::index_sequence<columns[Is]...>>(r); }
  130. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 130/172 stop Putin Select columns in a row template <size_t ... Is, typename Table, size_t ... Cs> auto select(const row<Table, std::index_sequence<Cs...>>& r) {     static constexpr size_t columns[] { Cs... };     return row<Table, std::index_sequence<columns[Is]...>>(r); } Select a subset of columns to reference
  131. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 131/172 stop Putin Select columns in a row template <size_t ... Is, typename Table, size_t ... Cs> auto select(const row<Table, std::index_sequence<Cs...>>& r) {     static constexpr size_t columns[] { Cs... };     return row<Table, std::index_sequence<columns[Is]...>>(r); } Return a row that references that subset
  132. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 132/172 stop Putin Select columns in a row template <size_t ... Is, typename Table, size_t ... Cs> auto select(const row<Table, std::index_sequence<Cs...>>& r) {     static constexpr size_t columns[] { Cs... };     return row<Table, std::index_sequence<columns[Is]...>>(r); } drop_if(values, [](auto r) { auto [x,z] = select<0,2>(r); return x < z; });
  133. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 133/172 stop Putin Select columns in a row template <size_t ... Is, typename Table, size_t ... Cs> auto select(const row<Table, std::index_sequence<Cs...>>& r) {     static constexpr size_t columns[] { Cs... };     return row<Table, std::index_sequence<columns[Is]...>>(r); } drop_if(values, [](auto r) { auto [x,z] = select<0,2>(r); return x < z; }); Select only the columns we’re interested in for the expression
  134. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 134/172 stop Putin Select columns in a row template <size_t ... Is, typename Table, size_t ... Cs> auto select(const row<Table, std::index_sequence<Cs...>>& r) {     static constexpr size_t columns[] { Cs... };     return row<Table, std::index_sequence<columns[Is]...>>(r); } drop_if(values, [](auto r) { auto [x,z] = select<0,2>(r); return x < z; }); Select only the columns we’re interested in for the expression
  135. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 135/172 stop Putin Select columns in an iteration template <typename R, size_t ... Cs> struct range_selector { using r_iterator = decltype(std::declval<R&>().begin()); struct iterator : r_iterator { using difference_type = ssize_t; using value_type = decltype(select<Cs...>(*std::declval<r_iterator>())); iterator(const r_iterator& i) : r_iterator(i) {} auto operator*() const { const r_iterator& i = *this; return select<Cs...>(*i); } }; iterator begin() { return iterator{ r.begin() }; } auto end() { return r.end(); } R& r; };
  136. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 136/172 stop Putin Select columns in an iteration template <typename R, size_t ... Cs> struct range_selector { using r_iterator = decltype(std::declval<R&>().begin()); struct iterator : r_iterator { using difference_type = ssize_t; using value_type = decltype(select<Cs...>(*std::declval<r_iterator>())); iterator(const r_iterator& i) : r_iterator(i) {} auto operator*() const { const r_iterator& i = *this; return select<Cs...>(*i); } }; iterator begin() { return iterator{ r.begin() }; } auto end() { return r.end(); } R& r; }; range_selector refers to another range which has row<> as its value type. range_selector refers to another range which has row<> as its value type.
  137. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 137/172 stop Putin Select columns in an iteration template <typename R, size_t ... Cs> struct range_selector { using r_iterator = decltype(std::declval<R&>().begin()); struct iterator : r_iterator { using difference_type = ssize_t; using value_type = decltype(select<Cs...>(*std::declval<r_iterator>())); iterator(const r_iterator& i) : r_iterator(i) {} auto operator*() const { const r_iterator& i = *this; return select<Cs...>(*i); } }; iterator begin() { return iterator{ r.begin() }; } auto end() { return r.end(); } R& r; };
  138. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 138/172 stop Putin Select columns in an iteration template <typename R, size_t ... Cs> struct range_selector { using r_iterator = decltype(std::declval<R&>().begin()); struct iterator : r_iterator { using difference_type = ssize_t; using value_type = decltype(select<Cs...>(*std::declval<r_iterator>())); iterator(const r_iterator& i) : r_iterator(i) {} auto operator*() const { const r_iterator& i = *this; return select<Cs...>(*i); } }; iterator begin() { return iterator{ r.begin() }; } auto end() { return r.end(); } R& r; }; Find the iterator type of the referenced range
  139. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 139/172 stop Putin Select columns in an iteration template <typename R, size_t ... Cs> struct range_selector { using r_iterator = decltype(std::declval<R&>().begin()); struct iterator : r_iterator { using difference_type = ssize_t; using value_type = decltype(select<Cs...>(*std::declval<r_iterator>())); iterator(const r_iterator& i) : r_iterator(i) {} auto operator*() const { const r_iterator& i = *this; return select<Cs...>(*i); } }; iterator begin() { return iterator{ r.begin() }; } auto end() { return r.end(); } R& r; }; Create a new iterator type via inheritance
  140. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 140/172 stop Putin Select columns in an iteration template <typename R, size_t ... Cs> struct range_selector { using r_iterator = decltype(std::declval<R&>().begin()); struct iterator : r_iterator { using difference_type = ssize_t; using value_type = decltype(select<Cs...>(*std::declval<r_iterator>())); iterator(const r_iterator& i) : r_iterator(i) {} auto operator*() const { const r_iterator& i = *this; return select<Cs...>(*i); } }; iterator begin() { return iterator{ r.begin() }; } auto end() { return r.end(); } R& r; }; The new value type is the result of select<> on the underlying iterator’s value type
  141. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 141/172 stop Putin Select columns in an iteration template <typename R, size_t ... Cs> struct range_selector { using r_iterator = decltype(std::declval<R&>().begin()); struct iterator : r_iterator { using difference_type = ssize_t; using value_type = decltype(select<Cs...>(*std::declval<r_iterator>())); iterator(const r_iterator& i) : r_iterator(i) {} auto operator*() const { const r_iterator& i = *this; return select<Cs...>(*i); } }; iterator begin() { return iterator{ r.begin() }; } auto end() { return r.end(); } R& r; }; Return a row with the selected columns
  142. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 142/172 stop Putin template <typename R, size_t ... Cs> struct range_selector { using r_iterator = decltype(std::declval<R&>().begin()); struct iterator : r_iterator { using difference_type = ssize_t; using value_type = decltype(select<Cs...>(*std::declval<r_iterator>())); iterator(const r_iterator& i) : r_iterator(i) {} auto operator*() const { const r_iterator& i = *this; return select<Cs...>(*i); } }; iterator begin() { return iterator{ r.begin() }; } auto end() { return r.end(); } R& r; }; Select columns in an iteration template <size_t... Cs> struct range_selector_maker { template <typename R> friend range_selector<R, Cs...> operator|(R& r, range_selector_maker) {     return { r }; } }; template <size_t ... Cs> range_selector_maker<Cs...> select() { return {}; }
  143. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 143/172 stop Putin template <typename R, size_t ... Cs> struct range_selector { using r_iterator = decltype(std::declval<R&>().begin()); struct iterator : r_iterator { using difference_type = ssize_t; using value_type = decltype(select<Cs...>(*std::declval<r_iterator>())); iterator(const r_iterator& i) : r_iterator(i) {} auto operator*() const { const r_iterator& i = *this; return select<Cs...>(*i); } }; iterator begin() { return iterator{ r.begin() }; } auto end() { return r.end(); } R& r; }; Select columns in an iteration template <size_t... Cs> struct range_selector_maker { template <typename R> friend range_selector<R, Cs...> operator|(R& r, range_selector_maker) {     return { r }; } }; template <size_t ... Cs> range_selector_maker<Cs...> select() { return {}; } Create a range_selector<> by piping a range to the result of select<>()
  144. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 144/172 stop Putin template <typename R, size_t ... Cs> struct range_selector { using r_iterator = decltype(std::declval<R&>().begin()); struct iterator : r_iterator { using difference_type = ssize_t; using value_type = decltype(select<Cs...>(*std::declval<r_iterator>())); iterator(const r_iterator& i) : r_iterator(i) {} auto operator*() const { const r_iterator& i = *this; return select<Cs...>(*i); } }; iterator begin() { return iterator{ r.begin() }; } auto end() { return r.end(); } R& r; }; Select columns in an iteration template <size_t... Cs> struct range_selector_maker { template <typename R> friend range_selector<R, Cs...> operator|(R& r, range_selector_maker) {     return { r }; } }; template <size_t ... Cs> range_selector_maker<Cs...> select() { return {}; } for (auto [x,d] : values | select<0,3>()) {     std::println("d={} x={}", d, x); }
  145. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 145/172 stop Putin template <typename R, size_t ... Cs> struct range_selector { using r_iterator = decltype(std::declval<R&>().begin()); struct iterator : r_iterator { using difference_type = ssize_t; using value_type = decltype(select<Cs...>(*std::declval<r_iterator>())); iterator(const r_iterator& i) : r_iterator(i) {} auto operator*() const { const r_iterator& i = *this; return select<Cs...>(*i); } }; iterator begin() { return iterator{ r.begin() }; } auto end() { return r.end(); } R& r; }; Select columns in an iteration template <size_t... Cs> struct range_selector_maker { template <typename R> friend range_selector<R, Cs...> operator|(R& r, range_selector_maker) {     return { r }; } }; template <size_t ... Cs> range_selector_maker<Cs...> select() { return {}; } for (auto [x,d] : values | select<0,3>()) {     std::println("d={} x={}", d, x); }
  146. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 146/172 stop Putin Live Demo row_select
  147. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 147/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements ✔️ ✔️
  148. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 148/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements ✔️ ✔️ ✔️
  149. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 149/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements ✔️ ✔️ ✔️
  150. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 150/172 stop Putin drop_if(values, [](auto r) { auto [x,z] = select<0,2>(r); return x < z; }); Apply functions to selected columns
  151. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 151/172 stop Putin drop_if(values, [](auto r) { auto [x,z] = select<0,2>(r); return x < z; }); Apply functions to selected columns template <size_t ... Cs, typename F> auto select(F&& f) requires (! row_type<std::remove_cvref_t<F>>) { return [f = std::forward<F>(f)]<typename T, typename Is>(row<T, Is> r) { return f(select<Cs...>(r)); }; }
  152. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 152/172 stop Putin drop_if(values, [](auto r) { auto [x,z] = select<0,2>(r); return x < z; }); Apply functions to selected columns template <size_t ... Cs, typename F> auto select(F&& f) requires (! row_type<std::remove_cvref_t<F>>) { return [f = std::forward<F>(f)]<typename T, typename Is>(row<T, Is> r) { return f(select<Cs...>(r)); }; } Conflicts with template <size_t ... Is, typename Table, size_t ... Cs> auto select(const row<Table, std::index_sequence<Cs...>>& r);
  153. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 153/172 stop Putin drop_if(values, [](auto r) { auto [x,z] = select<0,2>(r); return x < z; }); Apply functions to selected columns template <size_t ... Cs, typename F> auto select(F&& f) requires (! row_type<std::remove_cvref_t<F>>) { return [f = std::forward<F>(f)]<typename T, typename Is>(row<T, Is> r) { return f(select<Cs...>(r)); }; } Conflicts with template <size_t ... Is, typename Table, size_t ... Cs> auto select(const row<Table, std::index_sequence<Cs...>>& r);
  154. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 154/172 stop Putin drop_if(values, [](auto r) { auto [x,z] = select<0,2>(r); return x < z; }); Apply functions to selected columns template <size_t ... Cs, typename F> auto select(F&& f) requires (! row_type<std::remove_cvref_t<F>>) { return [f = std::forward<F>(f)]<typename T, typename Is>(row<T, Is> r) { return f(select<Cs...>(r)); }; } template <typename> inline constexpr bool row_type_v = false; template <typename T, typename Cs> inline constexpr bool row_type_v<row<T,Cs>> = true; template <typename T> concept row_type = row_type_v<T>;
  155. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 155/172 stop Putin drop_if(values, [](auto r) { auto [x,z] = select<0,2>(r); return x < z; }); Apply functions to selected columns template <size_t ... Cs, typename F> auto select(F&& f) requires (! row_type<std::remove_cvref_t<F>>) { return [f = std::forward<F>(f)]<typename T, typename Is>(row<T, Is> r) { return f(select<Cs...>(r)); }; } template <typename> inline constexpr bool row_type_v = false; template <typename T, typename Cs> inline constexpr bool row_type_v<row<T,Cs>> = true; template <typename T> concept row_type = row_type_v<T>;
  156. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 156/172 stop Putin drop_if(values, [](auto r) { auto [x,z] = select<0,2>(r); return x < z; }); Apply functions to selected columns template <size_t ... Cs, typename F> auto select(F&& f) requires (! row_type<std::remove_cvref_t<F>>) { return [f = std::forward<F>(f)]<typename T, typename Is>(row<T, Is> r) { return f(select<Cs...>(r)); }; }
  157. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 157/172 stop Putin drop_if(values, [](auto r) { auto [x,z] = select<0,2>(r); return x < z; }); drop_if(values, select<0,2>([](auto r) { auto [x,z] = r; return x < z; })); Apply functions to selected columns template <size_t ... Cs, typename F> auto select(F&& f) requires (! row_type<std::remove_cvref_t<F>>) { return [f = std::forward<F>(f)]<typename T, typename Is>(row<T, Is> r) { return f(select<Cs...>(r)); }; }
  158. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 158/172 stop Putin Apply functions to selected columns drop_if(values, select<0,2>([](auto r) { auto [x,z] = r; return x < z; })); template <typename F> auto apply(F&& f) { return [f = std::forward<F>(f)]<row_type R>(R r) { return std::invoke([&]<size_t ... Cs>(std::index_sequence<Cs...>) { return f(get<Cs>(r)...); }, std::make_index_sequence<std::tuple_size_v<R>>{}); }; }
  159. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 159/172 stop Putin Apply functions to selected columns drop_if(values, select<0,2>([](auto r) { auto [x,z] = r; return x < z; })); template <typename F> auto apply(F&& f) { return [f = std::forward<F>(f)]<row_type R>(R r) { return std::invoke([&]<size_t ... Cs>(std::index_sequence<Cs...>) { return f(get<Cs>(r)...); }, std::make_index_sequence<std::tuple_size_v<R>>{}); }; } apply() takes a function and returns a lambda that takes a row.
  160. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 160/172 stop Putin Apply functions to selected columns drop_if(values, select<0,2>([](auto r) { auto [x,z] = r; return x < z; })); template <typename F> auto apply(F&& f) { return [f = std::forward<F>(f)]<row_type R>(R r) { return std::invoke([&]<size_t ... Cs>(std::index_sequence<Cs...>) { return f(get<Cs>(r)...); }, std::make_index_sequence<std::tuple_size_v<R>>{}); }; } When called, it calls the bound function f with every element in the row.
  161. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 161/172 stop Putin Apply functions to selected columns drop_if(values, select<0,2>([](auto r) { auto [x,z] = r; return x < z; })); drop_if(values, select<0,2>(apply([](auto x, auto z) { return x < z; }))); template <typename F> auto apply(F&& f) { return [f = std::forward<F>(f)]<row_type R>(R r) { return std::invoke([&]<size_t ... Cs>(std::index_sequence<Cs...>) { return f(get<Cs>(r)...); }, std::make_index_sequence<std::tuple_size_v<R>>{}); }; }
  162. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 162/172 stop Putin Apply functions to selected columns drop_if(values, select<0,2>([](auto r) { auto [x,z] = r; return x < z; })); drop_if(values, select<0,2>(apply([](auto x, auto z) { return x < z; }))); template <typename F> auto apply(F&& f) { return [f = std::forward<F>(f)]<row_type R>(R r) { return std::invoke([&]<size_t ... Cs>(std::index_sequence<Cs...>) { return f(get<Cs>(r)...); }, std::make_index_sequence<std::tuple_size_v<R>>{}); }; }
  163. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 163/172 stop Putin Apply functions to selected columns drop_if(values, select<0,2>([](auto r) { auto [x,z] = r; return x < z; })); drop_if(values, select<0,2>(apply([](auto x, auto z) { return x < z; }))); template <typename F> auto apply(F&& f) { return [f = std::forward<F>(f)]<row_type R>(R r) { return std::invoke([&]<size_t ... Cs>(std::index_sequence<Cs...>) { return f(get<Cs>(r)...); }, std::make_index_sequence<std::tuple_size_v<R>>{}); }; } Isn’t there a name for this?
  164. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 164/172 stop Putin Apply functions to selected columns drop_if(values, select<0,2>([](auto r) { auto [x,z] = r; return x < z; })); drop_if(values, select<0,2>(apply([](auto x, auto z) { return x < z; }))); drop_if(values, select<0,2>(apply(std::less{}))); template <typename F> auto apply(F&& f) { return [f = std::forward<F>(f)]<row_type R>(R r) { return std::invoke([&]<size_t ... Cs>(std::index_sequence<Cs...>) { return f(get<Cs>(r)...); }, std::make_index_sequence<std::tuple_size_v<R>>{}); }; }
  165. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 165/172 stop Putin Apply functions to selected columns drop_if(values, select<0,2>([](auto r) { auto [x,z] = r; return x < z; })); drop_if(values, select<0,2>(apply([](auto x, auto z) { return x < z; }))); drop_if(values, select<0,2>(apply(std::less{}))); template <typename F> auto apply(F&& f) { return [f = std::forward<F>(f)]<row_type R>(R r) { return std::invoke([&]<size_t ... Cs>(std::index_sequence<Cs...>) { return f(get<Cs>(r)...); }, std::make_index_sequence<std::tuple_size_v<R>>{}); }; }
  166. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 166/172 stop Putin Live Demo function_select
  167. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 167/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements ✔️ ✔️ ✔️ ✔️
  168. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 168/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements ✔️ ✔️ ✔️ ✔️ ✔️
  169. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 169/172 stop Putin Status But, we also need… … a stable row-ID to lookup objects … an iterator interface to work with ranges And want... … a convenient way to look at only some columns … a convenient way to call functions with selected elements ✔️ ✔️ ✔️ ✔️ ✔️
  170. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 170/172 stop Putin Cache Friendly + Functional + Ranges = ❤️ Give it a go, and please help out if you can https://github.com/rollbear/columnist
  171. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 171/172 stop Putin Cache Friendly + Functional + Ranges = ❤️ Give it a go, and please help out if you can https://github.com/rollbear/columnist https://github.com/rollbear/cache_functional_ranges Source examples from this presentation
  172. Cache Friendly + Functional + Ranges = – StockholmCpp 2024

    © Björn Fahller ❤️ @[email protected] 172/172 stop Putin Björn Fahller [email protected] @[email protected] @rollbear Cache Friendly + Functional + Ranges = ❤️