tools: js2c-cache

Makefile

@@ -532,6 +532,8 @@ CPPLINT_FILES = $(filter-out $(CPPLINT_EXCLUDE), $(wildcard \
 	test/addons/*/*.h \
 	tools/icu/*.cc \
 	tools/icu/*.h \
+	tools/*.cc \
+	tools/*.h \
 	))
 
 cpplint:

doc/api/vm.markdown

@@ -36,6 +36,12 @@ The options when creating a script are:
   code are controlled by the options to the script's methods.
 - `timeout`: a number of milliseconds to execute `code` before terminating
   execution. If execution is terminated, an [`Error`][] will be thrown.
+- `cachedData`: an optional `Buffer` with V8's code cache data for the supplied
+  source. When supplied `cachedDataRejected` value will be set to either
+  `true` or `false` depending on acceptance of the data by V8.
+- `produceCachedData`: if `true` and no `cachedData` is present - a `Buffer`
+  with V8's code cache data will be produced and stored in `cachedData` property
+  of the returned `vm.Script` instance.
 
 ### script.runInContext(contextifiedSandbox[, options])
 

node.gyp

@@ -502,6 +502,13 @@
     {
       'target_name': 'node_js2c',
       'type': 'none',
+      'conditions': [
+        [ 'target_arch == host_arch', {
+          'dependencies': [
+            'js2c-cache#target',
+          ],
+        }],
+      ],
       'toolsets': ['host'],
       'actions': [
         {
@@ -522,7 +529,10 @@
             }],
             [ 'node_use_perfctr=="false"', {
               'inputs': [ 'src/perfctr_macros.py' ]
-            }]
+            }],
+            [ 'target_arch == host_arch', {
+              'inputs': [ '<(PRODUCT_DIR)/js2c-cache' ],
+            }],
           ],
           'action': [
             '<(python)',
@@ -533,6 +543,21 @@
         },
       ],
     }, # end node_js2c
+    {
+      'target_name': 'js2c-cache',
+      'type': 'executable',
+      'dependencies': [
+        'deps/v8/tools/gyp/v8.gyp:v8',
+        'deps/v8/tools/gyp/v8.gyp:v8_libplatform'
+      ],
+      'include_dirs': [
+        'tools',
+        'deps/v8/include',
+      ],
+      'sources': [
+        'tools/js2c-cache.cc',
+      ],
+    }, # end js2c-cache
     {
       'target_name': 'node_dtrace_header',
       'type': 'none',
@@ -694,7 +719,7 @@
       'sources': [
         'test/cctest/util.cc',
       ],
-    }
+    },
   ], # end targets
 
   'conditions': [

src/env.h

@@ -61,6 +61,8 @@ namespace node {
   V(buffer_string, "buffer")                                                  \
   V(bytes_string, "bytes")                                                    \
   V(bytes_parsed_string, "bytesParsed")                                       \
+  V(cached_data_string, "cachedData")                                         \
+  V(cached_data_rejected_string, "cachedDataRejected")                        \
   V(callback_string, "callback")                                              \
   V(change_string, "change")                                                  \
   V(oncertcb_string, "oncertcb")                                              \
@@ -175,6 +177,7 @@ namespace node {
   V(preference_string, "preference")                                          \
   V(priority_string, "priority")                                              \
   V(processed_string, "processed")                                            \
+  V(produce_cached_data_string, "produceCachedData")                          \
   V(prototype_string, "prototype")                                            \
   V(raw_string, "raw")                                                        \
   V(rdev_string, "rdev")                                                      \

src/node.cc

@@ -114,13 +114,15 @@ using v8::Integer;
 using v8::Isolate;
 using v8::Local;
 using v8::Locker;
+using v8::MaybeLocal;
 using v8::Message;
 using v8::Number;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::Promise;
 using v8::PromiseRejectMessage;
 using v8::PropertyCallbackInfo;
+using v8::ScriptCompiler;
 using v8::SealHandleScope;
 using v8::StackFrame;
 using v8::StackTrace;
@@ -1586,23 +1588,27 @@ static void ReportException(Environment* env, const TryCatch& try_catch) {
 
 
 // Executes a str within the current v8 context.
-static Local<Value> ExecuteString(Environment* env,
-                                  Local<String> source,
-                                  Local<String> filename) {
+static Local<Value> ExecuteSource(Environment* env,
+                                  ScriptCompiler::Source* source) {
   EscapableHandleScope scope(env->isolate());
   TryCatch try_catch;
 
   // try_catch must be nonverbose to disable FatalException() handler,
   // we will handle exceptions ourself.
   try_catch.SetVerbose(false);
 
-  Local<v8::Script> script = v8::Script::Compile(source, filename);
-  if (script.IsEmpty()) {
+  MaybeLocal<v8::Script> maybe_script = v8::ScriptCompiler::Compile(
+      env->context(),
+      source,
+      source->GetCachedData() == nullptr ? ScriptCompiler::kNoCompileOptions :
+                                           ScriptCompiler::kConsumeCodeCache);
+  delete source;
+  if (maybe_script.IsEmpty()) {
     ReportException(env, try_catch);
     exit(3);
   }
 
-  Local<Value> result = script->Run();
+  Local<Value> result = maybe_script.ToLocalChecked()->Run();
   if (result.IsEmpty()) {
     ReportException(env, try_catch);
     exit(4);
@@ -3157,7 +3163,7 @@ void LoadEnvironment(Environment* env) {
   try_catch.SetVerbose(false);
 
   Local<String> script_name = FIXED_ONE_BYTE_STRING(env->isolate(), "node.js");
-  Local<Value> f_value = ExecuteString(env, MainSource(env), script_name);
+  Local<Value> f_value = ExecuteSource(env, MainSource(env, script_name));
   if (try_catch.HasCaught())  {
     ReportException(env, try_catch);
     exit(10);

src/node.js

@@ -972,6 +972,10 @@
     return NativeModule._source[id];
   };
 
+  NativeModule.getSourceCachedData = function(id) {
+    return NativeModule._source[id + '__cached_data'];
+  };
+
   NativeModule.wrap = function(script) {
     return NativeModule.wrapper[0] + script + NativeModule.wrapper[1];
   };
@@ -983,10 +987,12 @@
 
   NativeModule.prototype.compile = function() {
     var source = NativeModule.getSource(this.id);
+    var cachedData = NativeModule.getSourceCachedData(this.id);
     source = NativeModule.wrap(source);
 
     var fn = runInThisContext(source, {
       filename: this.filename,
+      cachedData: cachedData,
       lineOffset: 0
     });
     fn(this.exports, NativeModule.require, this, this.filename);

src/node_contextify.cc

@@ -13,6 +13,7 @@ namespace node {
 
 using v8::AccessType;
 using v8::Array;
+using v8::ArrayBuffer;
 using v8::Boolean;
 using v8::Context;
 using v8::Debug;
@@ -40,6 +41,7 @@ using v8::ScriptCompiler;
 using v8::ScriptOrigin;
 using v8::String;
 using v8::TryCatch;
+using v8::Uint8Array;
 using v8::UnboundScript;
 using v8::V8;
 using v8::Value;
@@ -507,15 +509,35 @@ class ContextifyScript : public BaseObject {
     Local<Integer> lineOffset = GetLineOffsetArg(args, 1);
     Local<Integer> columnOffset = GetColumnOffsetArg(args, 1);
     bool display_errors = GetDisplayErrorsArg(args, 1);
+    MaybeLocal<Uint8Array> cached_data_buf = GetCachedData(env, args, 1);
+    bool produce_cached_data = GetProduceCachedData(env, args, 1);
     if (try_catch.HasCaught()) {
       try_catch.ReThrow();
       return;
     }
 
+    ScriptCompiler::CachedData* cached_data = nullptr;
+    if (!cached_data_buf.IsEmpty()) {
+      ArrayBuffer::Contents contents =
+          cached_data_buf.ToLocalChecked()->Buffer()->GetContents();
+      cached_data = new ScriptCompiler::CachedData(
+          reinterpret_cast<uint8_t*>(contents.Data()), contents.ByteLength());
+    }
+
     ScriptOrigin origin(filename, lineOffset, columnOffset);
-    ScriptCompiler::Source source(code, origin);
-    Local<UnboundScript> v8_script =
-        ScriptCompiler::CompileUnbound(env->isolate(), &source);
+    ScriptCompiler::Source source(code, origin, cached_data);
+    ScriptCompiler::CompileOptions compile_options =
+        ScriptCompiler::kNoCompileOptions;
+
+    if (source.GetCachedData() != nullptr)
+      compile_options = ScriptCompiler::kConsumeCodeCache;
+    else if (produce_cached_data)
+      compile_options = ScriptCompiler::kProduceCodeCache;
+
+    Local<UnboundScript> v8_script = ScriptCompiler::CompileUnbound(
+        env->isolate(),
+        &source,
+        compile_options);
 
     if (v8_script.IsEmpty()) {
       if (display_errors) {
@@ -525,6 +547,19 @@ class ContextifyScript : public BaseObject {
       return;
     }
     contextify_script->script_.Reset(env->isolate(), v8_script);
+
+    if (compile_options == ScriptCompiler::kConsumeCodeCache) {
+      args.This()->Set(
+          env->cached_data_rejected_string(),
+          Boolean::New(env->isolate(), source.GetCachedData()->rejected));
+    } else if (compile_options == ScriptCompiler::kProduceCodeCache) {
+      const ScriptCompiler::CachedData* cached_data = source.GetCachedData();
+      MaybeLocal<Object> buf = Buffer::Copy(
+          env,
+          reinterpret_cast<const char*>(cached_data->data),
+          cached_data->length);
+      args.This()->Set(env->cached_data_string(), buf.ToLocalChecked());
+    }
   }
 
 
@@ -677,6 +712,43 @@ class ContextifyScript : public BaseObject {
   }
 
 
+  static MaybeLocal<Uint8Array> GetCachedData(
+      Environment* env,
+      const FunctionCallbackInfo<Value>& args,
+      const int i) {
+    if (!args[i]->IsObject()) {
+      return MaybeLocal<Uint8Array>();
+    }
+    Local<Value> value = args[i].As<Object>()->Get(env->cached_data_string());
+    if (value->IsUndefined()) {
+      return MaybeLocal<Uint8Array>();
+    }
+
+    if (!value->IsUint8Array()) {
+      Environment::ThrowTypeError(
+          args.GetIsolate(),
+          "options.cachedData must be a Buffer instance");
+      return MaybeLocal<Uint8Array>();
+    }
+
+    return value.As<Uint8Array>();
+  }
+
+
+  static bool GetProduceCachedData(
+      Environment* env,
+      const FunctionCallbackInfo<Value>& args,
+      const int i) {
+    if (!args[i]->IsObject()) {
+      return false;
+    }
+    Local<Value> value =
+        args[i].As<Object>()->Get(env->produce_cached_data_string());
+
+    return value->IsTrue();
+  }
+
+
   static Local<Integer> GetLineOffsetArg(
                                       const FunctionCallbackInfo<Value>& args,
                                       const int i) {

src/node_javascript.cc

@@ -11,26 +11,57 @@
 
 namespace node {
 
+using v8::ArrayBuffer;
 using v8::HandleScope;
 using v8::Local;
 using v8::Object;
+using v8::ScriptCompiler;
+using v8::ScriptOrigin;
 using v8::String;
+using v8::Uint8Array;
 
-Local<String> MainSource(Environment* env) {
-  return OneByteString(env->isolate(), node_native, sizeof(node_native) - 1);
+ScriptCompiler::Source* MainSource(Environment* env, Local<String> filename) {
+  Local<String> source_str =
+      OneByteString(env->isolate(), node_native, sizeof(node_native) - 1);
+
+  ScriptOrigin origin(filename);
+  ScriptCompiler::CachedData* cached_data = nullptr;
+
+  // NOTE: It is illegal to have empty arrays in C, so we use { 0 } for this
+  // purposes.
+  if (sizeof(node_native_cache) <= 1) {
+    cached_data = new ScriptCompiler::CachedData(node_native_cache,
+                                                 sizeof(node_native_cache));
+  }
+
+  return new ScriptCompiler::Source(source_str, origin, cached_data);
 }
 
 void DefineJavaScript(Environment* env, Local<Object> target) {
   HandleScope scope(env->isolate());
 
+  Local<String> cache_postfix =
+      String::NewFromUtf8(env->isolate(), "__cached_data");
+
   for (int i = 0; natives[i].name; i++) {
     if (natives[i].source != node_native) {
       Local<String> name = String::NewFromUtf8(env->isolate(), natives[i].name);
       Local<String> source = String::NewFromUtf8(env->isolate(),
-                                                  natives[i].source,
-                                                  String::kNormalString,
-                                                  natives[i].source_len);
+                                                 natives[i].source,
+                                                 String::kNormalString,
+                                                 natives[i].source_len);
       target->Set(name, source);
+
+      if (natives[i].cache_len <= 1)
+        continue;
+
+      Local<ArrayBuffer> cache_ab = ArrayBuffer::New(env->isolate(),
+          const_cast<unsigned char*>(natives[i].cache),
+          natives[i].cache_len);
+      Local<Uint8Array> cache =
+          Uint8Array::New(cache_ab, 0, natives[i].cache_len);
+
+      target->Set(String::Concat(name, cache_postfix), cache);
     }
   }
 }

src/node_javascript.h

@@ -7,7 +7,8 @@
 namespace node {
 
 void DefineJavaScript(Environment* env, v8::Local<v8::Object> target);
-v8::Local<v8::String> MainSource(Environment* env);
+v8::ScriptCompiler::Source* MainSource(Environment* env,
+                                       v8::Local<v8::String> filename);
 
 }  // namespace node