src: reuse parser between runs

Author: araujogui

src/env-inl.h

@@ -30,6 +30,7 @@
 #include "node.h"
 #include "node_context_data.h"
 #include "node_internals.h"
+#include "node_json_parser.h"
 #include "node_perf_common.h"
 #include "node_realm-inl.h"
 #include "util-inl.h"
@@ -418,6 +419,13 @@ inline builtins::BuiltinLoader* Environment::builtin_loader() {
   return &builtin_loader_;
 }
 
+inline json_parser::JsonParser* Environment::json_parser() {
+  if (!json_parser_) {
+    json_parser_ = std::make_unique<json_parser::JsonParser>();
+  }
+  return json_parser_.get();
+}
+
 inline const EmbedderPreloadCallback& Environment::embedder_preload() const {
   return embedder_preload_;
 }

src/env.h

@@ -109,6 +109,10 @@ namespace loader {
 class ModuleWrap;
 }  // namespace loader
 
+namespace json_parser {
+class JsonParser;
+}  // namespace json_parser
+
 class Environment;
 class Realm;
 
@@ -765,6 +769,7 @@ class Environment final : public MemoryRetainer {
   inline std::vector<double>* destroy_async_id_list();
 
   builtins::BuiltinLoader* builtin_loader();
+  json_parser::JsonParser* json_parser();
 
   std::unordered_multimap<int, loader::ModuleWrap*> hash_to_module_map;
 
@@ -1246,6 +1251,7 @@ class Environment final : public MemoryRetainer {
   std::unique_ptr<PrincipalRealm> principal_realm_ = nullptr;
 
   builtins::BuiltinLoader builtin_loader_;
+  std::unique_ptr<json_parser::JsonParser> json_parser_;
   EmbedderPreloadCallback embedder_preload_;
 
   // Used by allocate_managed_buffer() and release_managed_buffer() to keep

src/node_json_parser.cc

@@ -16,6 +16,19 @@
 namespace node {
 namespace json_parser {
 
+class JsonParser::Impl {
+ public:
+  simdjson::dom::parser parser;
+};
+
+JsonParser::JsonParser() : impl_(std::make_unique<Impl>()) {}
+
+JsonParser::~JsonParser() = default;
+
+void* JsonParser::GetParser() {
+  return &impl_->parser;
+}
+
 using std::string;
 
 using v8::Array;
@@ -150,15 +163,18 @@ MaybeLocal<Value> ConvertSimdjsonElement(Isolate* isolate,
   }
 }
 
-MaybeLocal<Value> ParseInternal(Isolate* isolate,
+MaybeLocal<Value> ParseInternal(Environment* env,
                                const char* data,
                                size_t length) {
+  Isolate* isolate = env->isolate();
   simdjson::padded_string padded_string(data, length);
 
-  simdjson::dom::parser parser;
+  // Get the cached parser from the Environment
+  simdjson::dom::parser* parser = static_cast<simdjson::dom::parser*>(
+      env->json_parser()->GetParser());
   simdjson::dom::element doc;
 
-  simdjson::error_code error = parser.parse(padded_string).get(doc);
+  simdjson::error_code error = parser->parse(padded_string).get(doc);
 
   if (error) {
     // TODO(araujogui): create a ERR_INVALID_JSON macro
@@ -171,25 +187,27 @@ MaybeLocal<Value> ParseInternal(Isolate* isolate,
 }
 
 void Parse(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
   if (args.Length() < 1 || !args[0]->IsString()) {
-    THROW_ERR_INVALID_ARG_TYPE(args.GetIsolate(),
+    THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
                                "The \"text\" argument must be a string.");
     return;
   }
 
   Local<String> json_str = args[0].As<String>();
 
-  string str = ObjectToString(args.GetIsolate(), json_str);
+  string str = ObjectToString(env->isolate(), json_str);
 
   Local<Value> result;
-  if (!ParseInternal(args.GetIsolate(), str.data(), str.size()).ToLocal(&result))
+  if (!ParseInternal(env, str.data(), str.size()).ToLocal(&result))
     return;
 
   args.GetReturnValue().Set(result);
 }
 
 void ParseFromBuffer(const FunctionCallbackInfo<Value>& args) {
-  Isolate* isolate = args.GetIsolate();
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = env->isolate();
 
   if (args.Length() < 1) {
     THROW_ERR_INVALID_ARG_TYPE(
@@ -216,7 +234,7 @@ void ParseFromBuffer(const FunctionCallbackInfo<Value>& args) {
   }
 
   Local<Value> result;
-  if (!ParseInternal(isolate, data, length).ToLocal(&result)) return;
+  if (!ParseInternal(env, data, length).ToLocal(&result)) return;
 
   args.GetReturnValue().Set(result);
 }

src/node_json_parser.h

@@ -8,6 +8,21 @@
 namespace node {
 namespace json_parser {
 
+class JsonParser {
+ public:
+  JsonParser();
+  ~JsonParser();
+
+  JsonParser(const JsonParser&) = delete;
+  JsonParser& operator=(const JsonParser&) = delete;
+
+  void* GetParser();
+
+ private:
+  class Impl;
+  std::unique_ptr<Impl> impl_;
+};
+
 void Initialize(v8::Local<v8::Object> target,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,