Faster glz::validate_json (#1478)

* Optimization JSON validation

* total rework

* JSON specific

* use ctx

* strip iterator type and cleanup

* Update validate.hpp

* More [[unlikely]] and fix for jsonrpc

* use switch case

* More [[unlikely]]

* unicode surrogate pair validation

* Padded and faster padded string validation

* remove validate.hpp

* More optimized match

* reverting test code

Author: stephenberry

include/glaze/json/read.hpp

@@ -2714,7 +2714,7 @@ namespace glz
    {
       context ctx{};
       glz::skip skip_value{};
-      return read<opts{.validate_skipped = true, .validate_trailing_whitespace = true}>(
+      return read<opts{.comments = true, .validate_skipped = true, .validate_trailing_whitespace = true}>(
          skip_value, std::forward<Buffer>(buffer), ctx);
    }
 

include/glaze/json/skip.hpp

@@ -11,6 +11,11 @@ namespace glz::detail
    struct skip_value<JSON>
    {
       template <opts Opts>
+      requires (not Opts.comments)
+      GLZ_ALWAYS_INLINE static void op(is_context auto&& ctx, auto&& it, auto&& end) noexcept;
+      
+      template <opts Opts>
+      requires (bool(Opts.comments))
       GLZ_ALWAYS_INLINE static void op(is_context auto&& ctx, auto&& it, auto&& end) noexcept;
    };
 
@@ -96,10 +101,11 @@ namespace glz::detail
    }
 
    template <opts Opts>
+   requires (not Opts.comments)
    GLZ_ALWAYS_INLINE void skip_value<JSON>::op(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
-      if constexpr (!Opts.validate_skipped) {
-         if constexpr (!has_ws_handled(Opts)) {
+      if constexpr (not Opts.validate_skipped) {
+         if constexpr (not has_ws_handled(Opts)) {
             GLZ_SKIP_WS();
          }
          while (true) {
@@ -123,11 +129,6 @@ namespace glz::detail
                if (bool(ctx.error)) [[unlikely]]
                   return;
                break;
-            case '/':
-               skip_comment(ctx, it, end);
-               if (bool(ctx.error)) [[unlikely]]
-                  return;
-               continue;
             case ',':
             case '}':
             case ']':
@@ -146,7 +147,7 @@ namespace glz::detail
          }
       }
       else {
-         if constexpr (!has_ws_handled(Opts)) {
+         if constexpr (not has_ws_handled(Opts)) {
             GLZ_SKIP_WS();
          }
          switch (*it) {
@@ -187,6 +188,56 @@ namespace glz::detail
          }
       }
    }
+   
+   template <opts Opts>
+   requires (bool(Opts.comments))
+   GLZ_ALWAYS_INLINE void skip_value<JSON>::op(is_context auto&& ctx, auto&& it, auto&& end) noexcept
+   {
+      if constexpr (not has_ws_handled(Opts)) {
+         GLZ_SKIP_WS();
+      }
+      switch (*it) {
+      case '{': {
+         skip_object<Opts>(ctx, it, end);
+         break;
+      }
+      case '[': {
+         skip_array<Opts>(ctx, it, end);
+         break;
+      }
+      case '"': {
+         skip_string<Opts>(ctx, it, end);
+         break;
+      }
+      case '/': {
+         skip_comment(ctx, it, end);
+         if (bool(ctx.error)) [[unlikely]]
+            return;
+      }
+      case 'n': {
+         ++it;
+         match<"ull", Opts>(ctx, it, end);
+         break;
+      }
+      case 'f': {
+         ++it;
+         match<"alse", Opts>(ctx, it, end);
+         break;
+      }
+      case 't': {
+         ++it;
+         match<"rue", Opts>(ctx, it, end);
+         break;
+      }
+      case '\0': {
+         ctx.error = error_code::unexpected_end;
+         break;
+      }
+      default: {
+         skip_number<Opts>(ctx, it, end);
+      }
+      }
+   }
 
    // parse_value is used for JSON pointer reading
    // we want the JSON pointer access to not care about trailing whitespace

include/glaze/util/parse.hpp

@@ -448,7 +448,8 @@ namespace glz::detail
       requires(has_is_padded(Opts) && str.size() <= padding_bytes)
    GLZ_ALWAYS_INLINE void match(is_context auto&& ctx, auto&& it, auto&&) noexcept
    {
-      if (!compare<str.size()>(it, str.value)) [[unlikely]] {
+      static constexpr auto S = str.sv();
+      if (not comparitor<S>(it)) [[unlikely]] {
          ctx.error = error_code::syntax_error;
       }
       else [[likely]] {
@@ -461,7 +462,8 @@ namespace glz::detail
    GLZ_ALWAYS_INLINE void match(is_context auto&& ctx, auto&& it, auto&& end) noexcept
    {
       const auto n = size_t(end - it);
-      if ((n < str.size()) || !compare<str.size()>(it, str.value)) [[unlikely]] {
+      static constexpr auto S = str.sv();
+      if ((n < str.size()) || not comparitor<S>(it)) [[unlikely]] {
          ctx.error = error_code::syntax_error;
       }
       else [[likely]] {

tests/json_performance/json_performance.cpp

@@ -1261,6 +1261,21 @@ auto generic_tester()
    t1 = std::chrono::steady_clock::now();
 
    r.json_read = std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0).count() * 1e-6;
+   
+   // validate performance
+   
+   t0 = std::chrono::steady_clock::now();
+
+   for (size_t i = 0; i < iterations; ++i) {
+      if (glz::validate_json(buffer)) {
+         std::cout << "glaze error!\n";
+         break;
+      }
+   }
+
+   t1 = std::chrono::steady_clock::now();
+   
+   std::cout << "validation time: " << std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0).count() * 1e-6 << '\n';
 
    // beve write performance