通过快照加速 Node.js 的启动

前言：随着 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::vectorargs,

const std::vectorexec_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_ptrmain_instance;

std::string result;

{

const std::vector& 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);

Localcontext;

{

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::MaybeLocalresult = 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* 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(#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* indexes) {

size_t i = 0;

HandleScope handle_scope(isolate_);

for (size_t j = 0; j < AsyncWrap::PROVIDERS_LENGTH; j++) {

MaybeLocalmaybe_field = isolate_->GetDataFromSnapshotOnce((*indexes)[i++]);

Localfield;

async_wrap_providers_[j].Set(isolate_, field);

}

}

可以看到直接通过快照信息调用 GetDataFromSnapshotOnce 获取对应的数据，然后设置到 async_wrap_providers_。

总结：可以看到通过快照极大加速了 Node.js 的启动过程，而快照技术的思想很简单，就是保存副本避免每次重新创建一样的数据，但是实现上是非常复杂的。甚至有同学提出是否可以在任意时刻给进程当前状态打一个快照，这样进程挂掉后就可以直接恢复到之前的状态，这听起来很美好，但是实现起来可能会非常复杂。