前言：在 Node.js 中我们有时候会使用 global.gc() 主动触发 gc 来测试一些代码，因为我们知道 V8 gc 的执行时机是不定的。但是可能很少同学知道 global.gc() 的实现，本文介绍一些在 V8 中关于这部分的实现。
了解 global.gc() 实现之前，首先看一下 V8 的 Extension 机制。Extension 机制用于拓展 V8 的能力。在 V8 初始化的过程中，V8::Initialize 会初始化 Extension 机制，具体在 Bootstrapper::InitializeOncePerProcess 中。
代码语言：javascript复制void Bootstrapper::InitializeOncePerProcess() {
v8::RegisterExtension(std::make_unique<GCExtension>(GCFunctionName()));
v8::RegisterExtension(std::make_unique<ExternalizeStringExtension>());
v8::RegisterExtension(std::make_unique<StatisticsExtension>());
v8::RegisterExtension(std::make_unique<TriggerFailureExtension>());
v8::RegisterExtension(std::make_unique<IgnitionStatisticsExtension>());
}V8 通过 RegisterExtension 注册了多个 Extension。
代码语言：javascript复制void RegisterExtension(std::unique_ptr<Extension> extension) {
RegisteredExtension::Register(std::move(extension));
}
void RegisteredExtension::Register(std::unique_ptr<Extension> extension) {
RegisteredExtension* new_extension = new RegisteredExtension(std::move(extension));
new_extension->next_ = first_extension_;
first_extension_ = new_extension;
}执行完 Register 后就形成了一个 Extension 链表，RegisteredExtension 对象只是对 Extension 对象的简单封装，它内部持有 Extension 对象和一个链表 next 指针，另外还有一个全局的对象 first_extension_ 指向链表头部。注册完 Extension 后，接下来看看初始化 Extension 的逻辑。具体的调用链是 NewContext -> CreateEnvironment -> InvokeBootstrapper.Invoke -> Bootstrapper::CreateEnvironment -> InstallExtensions -> Genesis::InstallExtensions。
代码语言：javascript复制bool Genesis::InstallExtensions(Isolate* isolate,
Handle<Context> native_context,
v8::ExtensionConfiguration* extensions) {
ExtensionStates extension_states;
return InstallAutoExtensions(isolate, &extension_states) &&
(!FLAG_expose_gc || InstallExtension(isolate, "v8/gc", &extension_states))
}当启动 V8 的时候设置了 expose_gc 标记，那么就会执行 InstallExtension。
代码语言：javascript复制bool Genesis::InstallExtension(Isolate* isolate,
v8::RegisteredExtension* current,
ExtensionStates* extension_states) {
HandleScope scope(isolate);
extension_states->set_state(current, VISITED);
v8::Extension* extension = current->extension();
// 安装依赖
for (int i = 0; i < extension->dependency_count(); i ) {
if (!InstallExtension(isolate, extension->dependencies()[i],
extension_states)) {
return false;
}
}
// 编译 Extension
CompileExtension(isolate, extension);
extension_states->set_state(current, INSTALLED);
return true;
}至此就完成了 Extension 的安装。接下来具体看一下 global.gc() 对应的具体实现。
代码语言：javascript复制class V8_EXPORT Extension {
public:
Extension(const char* name, const char* source = nullptr, int dep_count = 0,
const char** deps = nullptr, int source_length = -1);
virtual ~Extension() { delete source_; }
virtual Local<FunctionTemplate> GetNativeFunctionTemplate(
Isolate* isolate, Local<String> name) {
return Local<FunctionTemplate>();
}
const char* name() const { return name_; }
size_t source_length() const { return source_length_; }
const String::ExternalOneByteStringResource* source() const {
return source_;
}
int dependency_count() const { return dep_count_; }
const char** dependencies() const { return deps_; }
void set_auto_enable(bool value) { auto_enable_ = value; }
bool auto_enable() { return auto_enable_; }
// Disallow copying and assigning.
Extension(const Extension&) = delete;
void operator=(const Extension&) = delete;
private:
const char* name_;
size_t source_length_; // expected to initialize before source_
String::ExternalOneByteStringResource* source_;
int dep_count_;
const char** deps_;
bool auto_enable_;
};Extension 是 Extension 机制的基类，从上面代码中我们可以大致了解到一个 Extension 需要实现什么。接着看 gc Extension 的实现。
代码语言：javascript复制class GCExtension : public v8::Extension {
public:
explicit GCExtension(const char* fun_name)
: v8::Extension("v8/gc", BuildSource(buffer_, sizeof(buffer_), fun_name)) {}
v8::Local<v8::FunctionTemplate> GetNativeFunctionTemplate(
v8::Isolate* isolate, v8::Local<v8::String> name) override;
static void GC(const v8::FunctionCallbackInfo<v8::Value>& args);
private:
static const char* BuildSource(char* buf, size_t size, const char* fun_name) {
base::SNPrintF(base::Vector<char>(buf, static_cast<int>(size)),
"native function %s();", fun_name);
return buf;
}
char buffer_[50];
};在 bytecode-generator.cc 中有以下代码。
代码语言：javascript复制 v8::Local<v8::FunctionTemplate> info = expr->extension()->GetNativeFunctionTemplate(v8_isolate, Utils::ToLocal(expr->name()));所以我们来看一下 GetNativeFunctionTemplate。
代码语言：javascript复制首先看 GetNativeFunctionTemplate。
```c
v8::Local<v8::FunctionTemplate> GCExtension::GetNativeFunctionTemplate(
v8::Isolate* isolate, v8::Local<v8::String> str) {
return v8::FunctionTemplate::New(isolate, GCExtension::GC);
}大致就是当我们执行 global.gc() 时就会执行 GCExtension::GC 函数。
代码语言：javascript复制void GCExtension::GC(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::Isolate* isolate = args.GetIsolate();
// 没有参数则同步执行 kFullGarbageCollection gc，即执行 global.gc() 时
if (args.Length() == 0) {
InvokeGC(isolate, ExecutionType::kSync,
v8::Isolate::GarbageCollectionType::kFullGarbageCollection);
return;
}
auto maybe_options = Parse(isolate, args);
if (maybe_options.IsNothing()) return;
GCOptions options = maybe_options.ToChecked();
// 否则根据参数处理
switch (options.execution) {
case ExecutionType::kSync:
InvokeGC(isolate, ExecutionType::kSync, options.type);
break;
case ExecutionType::kAsync: {
v8::HandleScope scope(isolate);
auto resolver = v8::Promise::Resolver::New(isolate->GetCurrentContext())
.ToLocalChecked();
args.GetReturnValue().Set(resolver->GetPromise());
auto task_runner =
V8::GetCurrentPlatform()->GetForegroundTaskRunner(isolate);
CHECK(task_runner->NonNestableTasksEnabled());
task_runner->PostNonNestableTask(
std::make_unique<AsyncGC>(isolate, resolver, options.type));
} break;
}
}从这个函数中我们可以知道，global.gc 函数是可以带参数的，参数可以控制 gc 是同步还是异步，还可以控制 gc 的类型，我们知道 V8 里针对不同的 space 有不同的 gc 策略。参数的具体函数使用可以参考。
代码语言：javascript复制Provides garbage collection on invoking |fun_name|(options), where
- options is a dictionary like object. See supported properties below.
- no parameter refers to options:
{type: 'major', execution: 'sync'}.
- truthy parameter that is not setting any options:
{type: 'minor', execution: 'sync'}.
Supported options:
- type: 'major' or 'minor' for full GC and Scavenge, respectively.
- execution: 'sync' or 'async' for synchronous and asynchronous execution,
respectively.
- Defaults to {type: 'major', execution: 'sync'}.
Returns a Promise that resolves when GC is done when asynchronous execution
is requested, and undefined otherwise.继续看核心函数 InvokeGC。
代码语言：javascript复制void InvokeGC(v8::Isolate* isolate, ExecutionType execution_type,
v8::Isolate::GarbageCollectionType type) {
Heap* heap = reinterpret_cast<Isolate*>(isolate)->heap();
switch (type) {
case v8::Isolate::GarbageCollectionType::kMinorGarbageCollection:
heap->CollectGarbage(i::NEW_SPACE, i::GarbageCollectionReason::kTesting,
kGCCallbackFlagForced);
break;
case v8::Isolate::GarbageCollectionType::kFullGarbageCollection:
EmbedderStackStateScope stack_scope(
heap,
execution_type == ExecutionType::kAsync
? EmbedderStackStateScope::kImplicitThroughTask
: EmbedderStackStateScope::kExplicitInvocation,
execution_type == ExecutionType::kAsync
? v8::EmbedderHeapTracer::EmbedderStackState::kNoHeapPointers
: v8::EmbedderHeapTracer::EmbedderStackState::
kMayContainHeapPointers);
heap->PreciseCollectAllGarbage(i::Heap::kNoGCFlags,
i::GarbageCollectionReason::kTesting,
kGCCallbackFlagForced);
break;
}
}InvokeGC 就是根据同步的参数去调 heap 对象的 gc 接口从而做不同类型的 gc 回收。这就是 global.gc 的大致实现。
除此之外，还有其他 Extension，我们也可以自己写拓展，不过有点限制的是需要在 V8 初始化时就设置需要安装的 Extension。例如我们可以设置 expose_statistics 标记，然后通过全局函数收集堆信息（不同的 V8 版本支持的不一样）。
代码语言：javascript复制node -expose_statistics -e "console.log(global.getV8Statistics())"另外 V8 内部也实现了一些 Extension，包括内置的和一些 Demo，有兴趣的同学可以自行查看。
