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