performance optimization

Author: Easton97-Jens

src/request_body_processor/json_backend_jsoncons.cc

@@ -413,7 +413,7 @@ class RawJsonTokenCursor {
     std::size_t m_offset{0};
 };
 
-std::string rawNumberFromContext(const std::string &input,
+std::string_view rawNumberFromContext(const std::string &input,
     jsoncons::staj_event_type event_type, const jsoncons::ser_context &context,
     const jsoncons::staj_event &event, std::string_view scanned_token) {
     const std::size_t begin = context.begin_position();
@@ -422,33 +422,27 @@ std::string rawNumberFromContext(const std::string &input,
     if (begin < end && end <= input.size()) {
         std::string_view candidate(input.data() + begin, end - begin);
         if (tokenMatchesNumericEvent(event_type, candidate)) {
-            return std::string(candidate);
+            return candidate;
         }
     }
 
     if (tokenMatchesNumericEvent(event_type, scanned_token)) {
-        return std::string(scanned_token);
+        return scanned_token;
     }
 
     if (isNumericStringEvent(event)) {
         std::error_code error;
         jsoncons::string_view decoded = event.get<jsoncons::string_view>(error);
         if (error) {
-            return "";
+            return std::string_view();
         }
         if (isValidJsonNumber(std::string_view(decoded.data(), decoded.size()))) {
-            return std::string(decoded.data(), decoded.size());
+            return std::string_view(decoded.data(), decoded.size());
         }
-        return "";
+        return std::string_view();
     }
 
-    std::error_code error;
-    std::string fallback = event.get<std::string>(error);
-    if (error) {
-        return "";
-    }
-
-    return fallback;
+    return std::string_view();
 }
 
 JsonParseResult emitEvent(const std::string &input, JsonEventSink *sink,
@@ -508,7 +502,7 @@ JsonParseResult emitEvent(const std::string &input, JsonEventSink *sink,
                 return fromJsonconsError(error, context);
             }
             if (isNumericStringEvent(event)) {
-                std::string raw_number = rawNumberFromContext(input,
+                std::string_view raw_number = rawNumberFromContext(input,
                     jsoncons::staj_event_type::double_value, context, event,
                     raw_token);
                 if (raw_number.empty()) {
@@ -551,7 +545,7 @@ JsonParseResult emitEvent(const std::string &input, JsonEventSink *sink,
         case jsoncons::staj_event_type::uint64_value:
         case jsoncons::staj_event_type::double_value:
         case jsoncons::staj_event_type::half_value: {
-            std::string raw_number = rawNumberFromContext(input,
+            std::string_view raw_number = rawNumberFromContext(input,
                 event.event_type(), context, event, raw_token);
             if (raw_number.empty()) {
                 return makeResult(JsonParseStatus::InternalError,

src/request_body_processor/json_backend_simdjson.cc

@@ -19,8 +19,10 @@
 
 #include "src/request_body_processor/json_backend.h"
 
+#include <algorithm>
 #include <chrono>
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <utility>
 
@@ -87,6 +89,51 @@ JsonParseResult fromSimdjsonError(simdjson::error_code error) {
     }
 }
 
+simdjson::ondemand::parser &getReusableSimdjsonParser() {
+    thread_local std::unique_ptr<simdjson::ondemand::parser> parser;
+    if (parser == nullptr) {
+#ifdef MSC_JSON_AUDIT_INSTRUMENTATION
+        const auto parser_start = std::chrono::steady_clock::now();
+        parser.reset(new simdjson::ondemand::parser());
+        recordSimdjsonParserConstruction(static_cast<std::uint64_t>(
+            std::chrono::duration_cast<std::chrono::nanoseconds>(
+                std::chrono::steady_clock::now() - parser_start).count()));
+#else
+        parser.reset(new simdjson::ondemand::parser());
+#endif
+    }
+    return *parser;
+}
+
+std::size_t clampRequestedMaxDepth(std::size_t input_size,
+    const JsonBackendParseOptions &options) {
+    const std::size_t requested_depth = options.technical_max_depth > 0
+        ? static_cast<std::size_t>(options.technical_max_depth) : 1;
+    const std::size_t max_possible_depth = (input_size / 2) + 1;
+    return std::min(requested_depth, std::max<std::size_t>(1,
+        max_possible_depth));
+}
+
+simdjson::error_code prepareParser(simdjson::ondemand::parser *parser,
+    std::size_t input_size, const JsonBackendParseOptions &options) {
+    if (parser == nullptr) {
+        return simdjson::MEMALLOC;
+    }
+
+    const JsonBackendParseOptions default_options;
+    std::size_t required_max_depth = parser->max_depth();
+    if (options.technical_max_depth != default_options.technical_max_depth) {
+        required_max_depth = clampRequestedMaxDepth(input_size, options);
+    }
+
+    if (parser->capacity() >= input_size
+        && parser->max_depth() == required_max_depth) {
+        return simdjson::SUCCESS;
+    }
+
+    return parser->allocate(input_size, required_max_depth);
+}
+
 template <typename ResultType, typename TargetType>
 JsonParseResult getResult(ResultType &&result, TargetType *target) {
     if (auto error = std::forward<ResultType>(result).get(*target); error) {
@@ -361,26 +408,23 @@ class JsonBackendWalker {
 
 JsonParseResult parseDocumentWithSimdjson(const std::string &input,
     JsonEventSink *sink, const JsonBackendParseOptions &options) {
-    (void) options;
-
     if (sink == nullptr) {
         return makeResult(JsonParseStatus::InternalError,
             JsonSinkStatus::InternalError, "JSON event sink is null.");
     }
 
+    simdjson::ondemand::parser &parser = getReusableSimdjsonParser();
+    if (auto error = prepareParser(&parser, input.size(), options); error) {
+        return fromSimdjsonError(error);
+    }
+
 #ifdef MSC_JSON_AUDIT_INSTRUMENTATION
-    const auto parser_start = std::chrono::steady_clock::now();
-    simdjson::ondemand::parser parser;
-    recordSimdjsonParserConstruction(static_cast<std::uint64_t>(
-        std::chrono::duration_cast<std::chrono::nanoseconds>(
-            std::chrono::steady_clock::now() - parser_start).count()));
     const auto padded_start = std::chrono::steady_clock::now();
     simdjson::padded_string padded(input);
     recordSimdjsonPaddedCopy(input.size(), static_cast<std::uint64_t>(
         std::chrono::duration_cast<std::chrono::nanoseconds>(
             std::chrono::steady_clock::now() - padded_start).count()));
 #else
-    simdjson::ondemand::parser parser;
     simdjson::padded_string padded(input);
 #endif
     simdjson::ondemand::document document;