Faster key comparison (#1464)

* Faster key comparison

* comparitor comments

* fix mustache code

Author: stephenberry

include/glaze/json/read.hpp

@@ -168,7 +168,7 @@ namespace glz
             }
          }
 
-         if (compare<Length>(TargetKey.data(), it)) [[likely]] {
+         if (comparitor<TargetKey>(it)) [[likely]] {
             it += Length;
             if (*it != '"') [[unlikely]] {
                if constexpr (Opts.error_on_unknown_keys) {

include/glaze/mustache/mustache.hpp

@@ -75,7 +75,7 @@ namespace glz
                         [&]<size_t I>() {
                            static constexpr auto TargetKey = get<I>(reflect<T>::keys);
                            static constexpr auto Length = TargetKey.size();
-                           if ((Length == key.size()) && compare<Length>(TargetKey.data(), start)) [[likely]] {
+                           if ((Length == key.size()) && detail::comparitor<TargetKey>(start)) [[likely]] {
                               if constexpr (detail::reflectable<T> && N > 0) {
                                  std::ignore = write<opt_true<Opts, &opts::raw>>(
                                     detail::get_member(value, get<I>(detail::to_tuple(value))), temp, ctx);

include/glaze/mustache/stencilcount.hpp

@@ -111,7 +111,7 @@ namespace glz
                         [&]<size_t I>() {
                            static constexpr auto TargetKey = get<I>(reflect<T>::keys);
                            static constexpr auto Length = TargetKey.size();
-                           if ((Length == key.size()) && compare<Length>(TargetKey.data(), start)) [[likely]] {
+                           if ((Length == key.size()) && detail::comparitor<TargetKey>(start)) [[likely]] {
                               if constexpr (detail::reflectable<T> && N > 0) {
                                  std::ignore = write<opt_true<Opts, &opts::raw>>(
                                     detail::get_member(value, get<I>(detail::to_tuple(value))), temp, ctx);

include/glaze/util/compare.hpp

@@ -8,7 +8,7 @@
 #include <string_view>
 #include <type_traits>
 
-namespace glz
+namespace glz::detail
 {
    template <class Char>
    inline bool compare(const Char* lhs, const Char* rhs, uint64_t count) noexcept
@@ -158,6 +158,124 @@ namespace glz
          return true;
       }
    }
+   
+   template <size_t N>
+   consteval auto bytes_to_unsigned_type() noexcept
+   {
+      if constexpr (N == 1) {
+         return uint8_t{};
+      }
+      else if constexpr (N == 2) {
+         return uint16_t{};
+      }
+      else if constexpr (N == 4) {
+         return uint32_t{};
+      }
+      else if constexpr (N == 8) {
+         return uint64_t{};
+      }
+      else {
+         return;
+      }
+   }
+   
+   template <size_t N>
+   using unsigned_bytes_t = std::decay_t<decltype(bytes_to_unsigned_type<N>())>;
+   
+   template <const std::string_view& Str, size_t N>
+      requires (N <= 8)
+   consteval auto pack()
+   {
+      using T = unsigned_bytes_t<N>;
+      T v{};
+      for (size_t i = 0; i < N; ++i) {
+         v |= (static_cast<T>(uint8_t(Str[i])) << ((i % 8) * 8));
+      }
+      return v;
+   }
+   
+   template <const std::string_view& Str, size_t N>
+      requires(N > 8)
+   consteval auto pack() {
+      constexpr auto chunks = N / 8;
+      std::array<uint64_t, ((chunks > 0) ? chunks + 1 : 1)> v{};
+      for (size_t i = 0; i < N; ++i) {
+         const auto chunk = i / 8;
+         v[chunk] |= (static_cast<uint64_t>(uint8_t(Str[i])) << ((i % 8) * 8));
+      }
+      return v;
+   }
+   
+   template <const std::string_view& Str, size_t N>
+      requires (N <= 8)
+   consteval auto pack_buffered()
+   {
+      using T = unsigned_bytes_t<N>;
+      T v{};
+      for (size_t i = 0; i < Str.size(); ++i) {
+         v |= (static_cast<T>(uint8_t(Str[i])) << ((i % 8) * 8));
+      }
+      return v;
+   }
+   
+   template <const std::string_view& Str, size_t N = Str.size()>
+   GLZ_ALWAYS_INLINE bool comparitor(const auto* other) noexcept
+   {
+      if constexpr (N == 8) {
+         static constexpr auto packed = pack<Str, 8>();
+         uint64_t in;
+         std::memcpy(&in, other, 8);
+         return (in == packed);
+      }
+      else if constexpr (N == 7) {
+         static constexpr auto packed = pack_buffered<Str, 8>();
+         uint64_t in{};
+         std::memcpy(&in, other, 7);
+         return (in == packed);
+      }
+      else if constexpr (N == 6) {
+         static constexpr auto packed = pack_buffered<Str, 8>();
+         uint64_t in{};
+         std::memcpy(&in, other, 6);
+         return (in == packed);
+      }
+      else if constexpr (N == 5) {
+         static constexpr auto packed = pack<Str, 4>();
+         uint32_t in;
+         std::memcpy(&in, other, 4);
+         return (in == packed) & (Str[4] == other[4]);
+      }
+      else if constexpr (N == 4) {
+         static constexpr auto packed = pack<Str, 4>();
+         uint32_t in;
+         std::memcpy(&in, other, 4);
+         return (in == packed);
+      }
+      else if constexpr (N == 3) {
+         static constexpr auto packed = pack<Str, 2>();
+         uint16_t in;
+         std::memcpy(&in, other, 2);
+         return (in == packed) & (Str[2] == other[2]);
+      }
+      else if constexpr (N == 2) {
+         static constexpr auto packed = pack<Str, 2>();
+         uint16_t in;
+         std::memcpy(&in, other, 2);
+         return (in == packed);
+      }
+      else if constexpr (N == 1) {
+         return Str[0] == other[0];
+      }
+      else if constexpr (N == 0) {
+         return true;
+      }
+      else {
+         // Clang and GCC optimize this extremely well for constexpr std::string_view
+         // Packing data can create more binary on GCC
+         // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp
+         return 0 == std::memcmp(Str.data(), other, N);
+      }
+   }
 
    // compare_sv checks sizes
    inline constexpr bool compare_sv(const std::string_view lhs, const std::string_view rhs) noexcept