前言：随着 Node.js 的越来越强大，代码量也变得越来越多，不可避免地拖慢了 Node.js 的启动速度，针对这个问题，Node.js 社区通过 V8 的 snapshot 技术对 Node.js 的启动做了优化，在 github 有很多关于此的 issue 讨论，大家有兴趣也可以去看一下。通过快照加速启动是一个非常复杂的过程，这需要对 V8 有深入的理解。本文介绍一下如何在 Node.js 中使用快照加速 Node.js 的启动。以 v16.13.1 为例，社区一直在优化这里面的速度，不同的版本的速度可能不一样。
Node.js 默认开启了快照功能。编译后会生成一个 node_snapshot.cc 文件。里面定义了几个方法和保存了快照的数据，在 Node.js 启动的时候会用到。我们也可以在编译的时候关闭这个功能，具体执行 ./configure --without-node-snapshot。除了控制编译时是否生成快照，还可以控制启动时是否使用快照，默认是使用，可以通过 --no-node-snapshot 关闭。我们看看效果。
const { performance } = require('perf_hooks');
console.log(performance.nodeTiming.bootstrapComplete - performance.nodeTiming.nodeStart);
可以通过 perf_hooks 模块拿到 Node.js 在启动过程的时间，这里我们首先在不使用快照的情况下看看时间。具体执行 node --no-node-snapshot test.js，我的电脑上是 42.165621001273394 毫秒。然后再看使用快照时的时间。具体执行 node test.js，我电脑是 24.800417000427842 毫秒，我们看到速度有了很大的提升。接下来我们看看 Node.js 关于这部分的大致实现。首先看编译配置。
['node_use_node_snapshot=="true"', {
'dependencies': [
'node_mksnapshot',
],
'actions': [
{
'action_name': 'node_mksnapshot',
'process_outputs_as_sources': 1,
'inputs': [
'<(node_mksnapshot_exec)',
],
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/node_snapshot.cc',
],
'action': [
'<@(_inputs)',
'<@(_outputs)',
],
},
],}, {
'sources': [
'src/node_snapshot_stub.cc'
],
}],
我们看到这里根据 node_use_node_snapshot 判断要不要生成快照，这个变量在 configure.py 中设置，也就是前面说的 --without-node-snapshot。
如果 node_use_node_snapshot 为 false，则编译 node_snapshot_stub.cc。
node_snapshot_stub.cc 提供了一个默认的实现，因为 Node.js 的 C++ 代码里会用到这几个函数。如果 node_use_node_snapshot 为 true 则执行 node_mksnapshot.cc 并且把快照写入到文件 node_snapshot.cc。接下来看一下 node_mksnapshot.cc 是如何生成快照的。
int main(int argc, char* argv[]) {
argv = uv_setup_args(argc, argv);
v8::V8::SetFlagsFromString("--random_seed=42");
std::ofstream out;
out.open(argv[1], std::ios::out | std::ios::binary);
node::InitializationResult result = node::InitializeOncePerProcess(argc, argv);
{
std::string snapshot =
node::SnapshotBuilder::Generate(result.args, result.exec_args);
out << snapshot;
out.close();
}
node::TearDownOncePerProcess();
return 0;
}
InitializeOncePerProcess 做了一些初始化操作，重点是 Generate(直接看底层的 Generate)。
void SnapshotBuilder::Generate(SnapshotData* out,
const std::vector<std::string> args,
const std::vector<std::string> exec_args) {
Isolate* isolate = Isolate::Allocate();
isolate->SetCaptureStackTraceForUncaughtExceptions(
true, 10, v8::StackTrace::StackTraceOptions::kDetailed);
per_process::v8_platform.Platform()->RegisterIsolate(isolate,
uv_default_loop());
std::unique_ptr<NodeMainInstance> main_instance;
std::string result;
{
const std::vector<intptr_t>& external_references =
NodeMainInstance::CollectExternalReferences();
SnapshotCreator creator(isolate, external_references.data());
Environment* env;
{
main_instance =
NodeMainInstance::Create(isolate,
uv_default_loop(),
per_process::v8_platform.Platform(),
args,
exec_args);
HandleScope scope(isolate);
creator.SetDefaultContext(Context::New(isolate));
out->isolate_data_indices = main_instance->isolate_data()->Serialize(&creator);
Local<Context> context;
{
TryCatch bootstrapCatch(isolate);
context = NewContext(isolate);
}
Context::Scope context_scope(context);
// Create the environment
env = new Environment(main_instance->isolate_data(),
context,
args,
exec_args,
nullptr,
node::EnvironmentFlags::kDefaultFlags,
{});
// Run scripts in lib/internal/bootstrap/
{
TryCatch bootstrapCatch(isolate);
v8::MaybeLocal<Value> result = env->RunBootstrapping();
result.ToLocalChecked();
}
// Serialize the native states
out->env_info = env->Serialize(&creator);
// Serialize the context
size_t index = creator.AddContext(context, {SerializeNodeContextInternalFields, env});
}
// Must be out of HandleScope
out->blob =
creator.CreateBlob(SnapshotCreator::FunctionCodeHandling::kClear);
}
per_process::v8_platform.Platform()->UnregisterIsolate(isolate);
}
可以看到就是模拟了 Node.js 的启动过程，然后把相关的数据写入到快照中。最终生成了一个文件。
这个文件和前面默认的 node_snapshot_stub.cc 文件类似，多了快照数据。有了快照再来看一下怎么使用。
int Start(int argc, char** argv) {
InitializationResult result = InitializeOncePerProcess(argc, argv);
if (result.early_return) {
return result.exit_code;
}
{
Isolate::CreateParams params;
const std::vector<size_t>* indices = nullptr;
const EnvSerializeInfo* env_info = nullptr;
// 是否使用快照
bool use_node_snapshot =
per_process::cli_options->per_isolate->node_snapshot;
if (use_node_snapshot) {
// 获取快照信息
v8::StartupData* blob = NodeMainInstance::GetEmbeddedSnapshotBlob();
if (blob != nullptr) {
params.snapshot_blob = blob;
indices = NodeMainInstance::GetIsolateDataIndices();
env_info = NodeMainInstance::GetEnvSerializeInfo();
}
}
uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME);
// 通过快照初始化
NodeMainInstance main_instance(¶ms,
uv_default_loop(),
per_process::v8_platform.Platform(),
result.args,
result.exec_args,
indices);
result.exit_code = main_instance.Run(env_info);
}
TearDownOncePerProcess();
return result.exit_code;
}
Start 是 Node.js 启动时执行的函数，在上面代码中可以看到如果开启了快照并且生成了快照，那么就通过快照进行初始化，否则走正常初始化流程，下面是 IsolateData 的初始化逻辑。
if (indexes == nullptr) {
CreateProperties();} else {
DeserializeProperties(indexes);
}
我们可以看到有快照则反序列化后进行初始化就行，否则需要进行创建。我们对比一下使用和没有使用快照进行初始化的代码的对比，以 async_wrap_providers_ 为例。下面是没有使用快照。
void IsolateData::CreateProperties() {
async_wrap_providers_[AsyncWrap::PROVIDER_ ## Provider].Set( \
isolate_, \
String::NewFromOneByte( \
isolate_, \
reinterpret_cast<const uint8_t*>(#Provider), \
NewStringType::kInternalized, \
sizeof(#Provider) - 1).ToLocalChecked());
NODE_ASYNC_PROVIDER_TYPES(V)
}
上面是通过宏初始化 async_wrap_providers_ 数组的逻辑，可以看到使用 V8 的 API 创建字符串然后设置到 async_wrap_providers_ 中。接下来看使用了快照的初始化逻辑。
void IsolateData::DeserializeProperties(const std::vector<size_t>* indexes) {
size_t i = 0;
HandleScope handle_scope(isolate_);
for (size_t j = 0; j < AsyncWrap::PROVIDERS_LENGTH; j++) {
MaybeLocal<String> maybe_field = isolate_->GetDataFromSnapshotOnce<String>((*indexes)[i++]);
Local<String> field;
async_wrap_providers_[j].Set(isolate_, field);
}
}
可以看到直接通过快照信息调用 GetDataFromSnapshotOnce 获取对应的数据，然后设置到 async_wrap_providers_。
总结：可以看到通过快照极大加速了 Node.js 的启动过程，而快照技术的思想很简单，就是保存副本避免每次重新创建一样的数据，但是实现上是非常复杂的。甚至有同学提出是否可以在任意时刻给进程当前状态打一个快照，这样进程挂掉后就可以直接恢复到之前的状态，这听起来很美好，但是实现起来可能会非常复杂。
