V8 新生代垃圾回收的实现-编程学习网

前言：因为最近在做一些 gc track 的事情，所以打算了解一下 V8 GC 的实现。介绍 V8 GC 的文章网上已经有很多，就不打算再重复介绍。本文主要介绍一下新生代 GC 的实现，代码参考 V8 10.2，因为 GC 的实现非常复杂，只能介绍一些大致的实现，读者需要对 V8 GC 有一定的了解，比如新生代是分为 from 和 to 两个 space，然后在 GC 时是如何处理的。

说到 GC 首先需要介绍内存，具体来说，是堆内存，V8 把内存分为新生代和老生代，其中老生代又分为很多种类型，不过本文只关注新生代。下面先来看一下在 V8 初始化的过程中，涉及到新生代的部分，具体逻辑在 Heap::SetUpSpaces 函数。

void Heap::SetUpSpaces(...) {
    // 分配内存
    space_[NEW_SPACE] = new_space_ = new NewSpace(
          this, 
          memory_allocator_->data_page_allocator(), 
          initial_semispace_size_,
          max_semi_space_size_,
          new_allocation_info);
    // 初始化 GC 调度对象
    scavenge_job_.reset(new ScavengeJob());
    scavenge_task_observer_.reset(
        new ScavengeTaskObserver(
        this, 
        ScavengeJob::YoungGenerationTaskTriggerSize(this))
    );
    new_space()->AddAllocationObserver(scavenge_task_observer_.get());
    // 初始化 GC 收集器
    scavenger_collector_.reset(new ScavengerCollector(this));
}

在 V8 的堆中，通过 new_space_ 字段记录了新生代的堆内存对象，另外还有几个和 GC 相关的逻辑，scavenge_job_ 和 scavenge_task_observer_ 是处理 GC 对象，下面来逐个分析下。

1、分配内存

NewSpace::NewSpace(Heap* heap, v8::PageAllocator* page_allocator,
                   size_t initial_semispace_capacity,
                   size_t max_semispace_capacity,
                   LinearAllocationArea* allocation_info) ...,
      to_space_(heap, kToSpace),
      from_space_(heap, kFromSpace) {
  to_space_.SetUp(initial_semispace_capacity, max_semispace_capacity);
  from_space_.SetUp(initial_semispace_capacity, max_semispace_capacity);
  to_space_.Commit();
}

NewSpace 中初始化了 from 和 to 两个 space。from 和 to 两个 space 是用 SemiSpace 表示。看一下它的 SetUp 方法。

void SemiSpace::SetUp(size_t initial_capacity, size_t maximum_capacity) {
  minimum_capacity_ = RoundDown(initial_capacity, Page::kPageSize);
  target_capacity_ = minimum_capacity_;
  maximum_capacity_ = RoundDown(maximum_capacity, Page::kPageSize);
}

SetUp 初始化了该 space 的内存大小字段，但是还没有分配内存。SetUp 执行完之后接着调了 to space 的 Commit 的方法(没有调 from space 的 Commit 方法，根据 V8 的注释，因为 from space 是在 GC 时才需要的，这里大概是用了懒初始化)。接着看 Commit。

bool SemiSpace::Commit() {
  // 计算需要多少 Page
  const int num_pages = static_cast<int>(target_capacity_ / Page::kPageSize);
  for (int pages_added = 0; pages_added < num_pages; pages_added++) {
    // 分配 Page
    Page* new_page = heap()->memory_allocator()->AllocatePage(
        MemoryAllocator::AllocationMode::kUsePool, this, NOT_EXECUTABLE);
    // 保存起来
    memory_chunk_list_.PushBack(new_page);
  }
}

Commit 根据需要的内存计算出 Page 数，然后分配内存，Page 是内存管理的单位，一块内存是由多个 Page 组成的。至此，新生代的内存分配完毕。

2、 GC 处理

首先看一下 ScavengeJob。ScavengeJob 是管理 GC 调度的。

class ScavengeJob {
 public:
  ScavengeJob() V8_NOEXCEPT = default;
  // 判断是否需要发起 GC
  void ScheduleTaskIfNeeded(Heap* heap);
  // 发起 GC 的阈值
  static size_t YoungGenerationTaskTriggerSize(Heap* heap);

 private:
  class Task;
  // 判断内存是否达到了阈值
  static bool YoungGenerationSizeTaskTriggerReached(Heap* heap);

  void set_task_pending(bool value) { task_pending_ = value; }

  bool task_pending_ = false;
};

ScavengeJob 记录了内存达到多少时需要发起 GC，并实现了发起 GC 的逻辑。我们先看一下阈值。

size_t ScavengeJob::YoungGenerationTaskTriggerSize(Heap* heap) {
  // FLAG_scavenge_task_trigger = 80
  return heap->new_space()->Capacity() * FLAG_scavenge_task_trigger / 100;
}
bool ScavengeJob::YoungGenerationSizeTaskTriggerReached(Heap* heap) {
  return heap->new_space()->Size() >= YoungGenerationTaskTriggerSize(heap);
}

V8 默认逻辑是内存达到 80% 时触发 GC，可以通过 scavenge_task_trigger flag 进行控制。V8 会调用 ScheduleTaskIfNeeded 判断是否需要发起 GC。

void ScavengeJob::ScheduleTaskIfNeeded(Heap* heap) {
  if (FLAG_scavenge_task && !task_pending_ && !heap->IsTearingDown() &&
      YoungGenerationSizeTaskTriggerReached(heap)) {
    v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(heap->isolate());
    auto taskrunner = V8::GetCurrentPlatform()->GetForegroundTaskRunner(isolate);
    if (taskrunner->NonNestableTasksEnabled()) {
      taskrunner->PostNonNestableTask(
          std::make_unique<Task>(heap->isolate(), this)
      );
      task_pending_ = true;
    }
  }
}

ScheduleTaskIfNeeded 首先判断内存是否达到了阈值，是的就给线程池提交一个 GC 人物。V8 中有一个 platform 的概念，比如在 Node.js 里是 NodePlatform，这个对象内部有一个线程池，V8 会把 GC 任务提交到线程池中等待处理。一个 GC 任务由 Task 对象表示。

class ScavengeJob::Task : public CancelableTask {
 public:
  Task(Isolate* isolate, ScavengeJob* job)
      : CancelableTask(isolate), isolate_(isolate), job_(job) {}
  // CancelableTask overrides.
  void RunInternal() override;
  Isolate* isolate() const { return isolate_; }
 private:
  Isolate* const isolate_;
  ScavengeJob* const job_;
};

Task 继承了 CancelableTask，并且内部有一个 ScavengeJob 对象。

class V8_EXPORT_PRIVATE CancelableTask : public Cancelable,
                                         NON_EXPORTED_BASE(public Task) {
 public:
  // Task overrides.
  void Run() final {
    if (TryRun()) {
      RunInternal();
    }
  }

  virtual void RunInternal() = 0;
};

当任务给线程池调度执行时，CancelableTask 的 Run 函数会被执行，从而执行 RunInternal 函数，该函数由子类实现。接着看 ScavengeJob::Task 中关于这个函数的实现。

void ScavengeJob::Task::RunInternal() {
  VMState<GC> state(isolate());
  if (ScavengeJob::YoungGenerationSizeTaskTriggerReached(isolate()->heap())) {
    isolate()->heap()->CollectGarbage(NEW_SPACE,
                                      GarbageCollectionReason::kTask);
  }
  job_->set_task_pending(false);
}

这里再次进行了内存是否达到阈值的判断，如果达到了就直接进行 GC，下面看 CollectGarbage。

bool Heap::CollectGarbage(AllocationSpace space,
                          GarbageCollectionReason gc_reason,
                          const v8::GCCallbackFlags gc_callback_flags) {
  const char* collector_reason = nullptr;
  // 根据 space 选择 GC 回收器类型，这里是新生代，选择的是 SCAVENGER，具体可以参考 SelectGarbageCollector 逻辑
  GarbageCollector collector = SelectGarbageCollector(space, &collector_reason);
  // 根据 GC 回收器类型选择 GC 类型，这个就是我们在 gc track 时拿到的类型
  GCType gc_type = GetGCTypeFromGarbageCollector(collector);
  {
    GCCallbacksScope scope(this);
    // 执行“开始 GC” 回调，我们注册的 GC track 回调在这里被执行
    if (scope.CheckReenter()) {
      CallGCPrologueCallbacks(gc_type, kNoGCCallbackFlags);
    }
  }
  // 执行 GC
  PerformGarbageCollection(collector, gc_reason, collector_reason, gc_callback_flags);
  // 执行 “GC 执行完”回调
  {
    GCCallbacksScope scope(this);
    if (scope.CheckReenter()) {
      CallGCEpilogueCallbacks(gc_type, gc_callback_flags);
    }
  }
}

接着看 PerformGarbageCollection。

size_t Heap::PerformGarbageCollection(
    GarbageCollector collector, GarbageCollectionReason gc_reason,
    const char* collector_reason, const v8::GCCallbackFlags gc_callback_flags) {
  switch (collector) {
    case GarbageCollector::MARK_COMPACTOR:
      MarkCompact();
      break;
    case GarbageCollector::MINOR_MARK_COMPACTOR:
      MinorMarkCompact();
      break;
    case GarbageCollector::SCAVENGER:
      Scavenge();
      break;
  }
}

继续调用 Scavenge。

void Heap::Scavenge() {
  // 进行 from space 和 to space 的翻转
  new_space()->Flip();
  new_space()->ResetLinearAllocationArea();
  // We also flip the young generation large object space. All large objects
  // will be in the from space.
  new_lo_space()->Flip();
  new_lo_space()->ResetPendingObject();
  // Implements Cheney's copying algorithm
  scavenger_collector_->CollectGarbage();
}

Scavenge 是真正执行 GC 的地方，首先第一步进行 from space 和 to space 的翻转，然后执行 GC。我们看看翻转的逻辑。

void NewSpace::Flip() { SemiSpace::Swap(&from_space_, &to_space_); }
void SemiSpace::Swap(SemiSpace* from, SemiSpace* to) {
  auto saved_to_space_flags = to->current_page()->GetFlags();
  // We swap all properties but id_.
  std::swap(from->target_capacity_, to->target_capacity_);
  std::swap(from->maximum_capacity_, to->maximum_capacity_);
  std::swap(from->minimum_capacity_, to->minimum_capacity_);
  std::swap(from->age_mark_, to->age_mark_);
  std::swap(from->memory_chunk_list_, to->memory_chunk_list_);
  std::swap(from->current_page_, to->current_page_);
  std::swap(from->external_backing_store_bytes_,
            to->external_backing_store_bytes_);
  std::swap(from->committed_physical_memory_, to->committed_physical_memory_);
  to->FixPagesFlags(saved_to_space_flags, Page::kCopyOnFlipFlagsMask);
  from->FixPagesFlags(Page::NO_FLAGS, Page::NO_FLAGS);
}

这里只是进行了一些字段的交换，真正的逻辑在 GC 收集器中。

void ScavengerCollector::CollectGarbage() {
  ScopedFullHeapCrashKey collect_full_heap_dump_if_crash(isolate_);

  std::vector<std::unique_ptr<Scavenger>> scavengers;
  Scavenger::EmptyChunksList empty_chunks;
  // 计算需要提交多少个 GC 任务
  const int num_scavenge_tasks = NumberOfScavengeTasks();
  Scavenger::CopiedList copied_list;
  Scavenger::PromotionList promotion_list;
  EphemeronTableList ephemeron_table_list;

  {
    for (int i = 0; i < num_scavenge_tasks; ++i) {
      scavengers.emplace_back(
          new Scavenger(this, heap_, is_logging, &empty_chunks, &copied_list,
                        &promotion_list, &ephemeron_table_list, i));
    }
    // 拿到 heap 中的所有内存块
    std::vector<std::pair<ParallelWorkItem, MemoryChunk*>> memory_chunks;
    RememberedSet<OLD_TO_NEW>::IterateMemoryChunks(
        heap_, [&memory_chunks](MemoryChunk* chunk) {
          memory_chunks.emplace_back(ParallelWorkItem{}, chunk);
        });
    // 遍历堆对象迭代器
    RootScavengeVisitor root_scavenge_visitor(scavengers[kMainThreadId].get());
    {
      // 遍历堆对象
      heap_->IterateRoots(&root_scavenge_visitor, options);
      // 遍历 global handle 对象
      isolate_->global_handles()->IterateYoungStrongAndDependentRoots( &root_scavenge_visitor);
      scavengers[kMainThreadId]->Publish();
    }
    // 提交 GC 任务
    {
      // Parallel phase scavenging all copied and promoted objects.
      V8::GetCurrentPlatform()
          ->PostJob(v8::TaskPriority::kUserBlocking,
                    std::make_unique<JobTask>(this, &scavengers,
                                              std::move(memory_chunks),
                                              &copied_list, &promotion_list))
          ->Join();
    }
  }
  // 回收 ArrayBuffer 内存，比如 Node.js 的 Buffer
  {
    TRACE_GC(heap_->tracer(), GCTracer::Scope::SCAVENGER_SWEEP_ARRAY_BUFFERS);
    SweepArrayBufferExtensions();
  }
}

这里的逻辑非常多，除了回收新生代对象的内存，还会处理 global handle 和 ArrayBuffer 的内存。不过这里我们只关注一般的新生代对象。接着遍历堆对象的过程。

void Heap::IterateRoots(RootVisitor* v, base::EnumSet<SkipRoot> options) {
  v->VisitRootPointers(Root::kStrongRootList, nullptr,
                       roots_table().strong_roots_begin(),
                       roots_table().strong_roots_end());
 // ... 省略非常多逻辑
}

Heap 对象提供了迭代的接口，具体迭代逻辑由 Visitor 实现，这里是 RootScavengeVisitor。

void RootScavengeVisitor::VisitRootPointer(Root root, const char* description,
                                           FullObjectSlot p) {
  ScavengePointer(p);
}
void RootScavengeVisitor::ScavengePointer(FullObjectSlot p) {
  Object object = *p;
  // 如果是新生代对象则处理
  if (Heap::InYoungGeneration(object)) {
    scavenger_->ScavengeObject(FullHeapObjectSlot(p), HeapObject::cast(object));
  }
}

接着看 ScavengeObject。

template <typename THeapObjectSlot>
SlotCallbackResult Scavenger::ScavengeObject(THeapObjectSlot p,
                                             HeapObject object) {
  return EvacuateObject(p, map, object);
}
template <typename THeapObjectSlot>
SlotCallbackResult Scavenger::EvacuateObject(THeapObjectSlot slot, Map map,
                                             HeapObject source) {
  int size = source.SizeFromMap(map);
  // 堆对象的大小
  VisitorId visitor_id = map.visitor_id();
  switch (visitor_id) {
    // ...  省略其他 case
    default:
      return EvacuateObjectDefault(map, slot, source, size,
                                   Map::ObjectFieldsFrom(visitor_id));
  }
}
emplate <typename THeapObjectSlot, Scavenger::PromotionHeapChoice promotion_heap_choice>
SlotCallbackResult Scavenger::EvacuateObjectDefault(
    Map map, THeapObjectSlot slot, HeapObject object, int object_size,
    ObjectFields object_fields) {
  // 是否可以晋升到老生代，新生代对象经过 n 次 GC 还存活则可以晋升到老生代（n = 1）
  if (!heap()->ShouldBePromoted(object.address())) {
    // 不能晋升则移到 from space
    result = SemiSpaceCopyObject(map, slot, object, object_size, object_fields);
  }
  // 否则晋升到老生代
  result = PromoteObject<THeapObjectSlot, promotion_heap_choice>(
      map, slot, object, object_size, object_fields);
  // 晋升失败则 fallback，移到 from 区
  SemiSpaceCopyObject(map, slot, object, object_size, object_fields);
}

接着看 SemiSpaceCopyObject 和 PromoteObject。

template <typename THeapObjectSlot>
CopyAndForwardResult Scavenger::SemiSpaceCopyObject(
    Map map, THeapObjectSlot slot, HeapObject object, int object_size,
    ObjectFields object_fields) {
  AllocationAlignment alignment = HeapObject::RequiredAlignment(map);
  // 在 from space 分配一块新的内存，把 to space 的对象移动过去
  AllocationResult allocation = allocator_.Allocate(
      NEW_SPACE, object_size, AllocationOrigin::kGC, alignment);
   // 进行对象迁移
   MigrateObject(map, object, target, object_size, kPromoteIntoLocalHeap);
}
bool Scavenger::MigrateObject(Map map, HeapObject source, HeapObject target,
                              int size,
                              PromotionHeapChoice promotion_heap_choice) {
  // 内存复制，比如通过 memmove
  heap()->CopyBlock(target.address() + kTaggedSize,
                    source.address() + kTaggedSize, size - kTaggedSize);

   // 触发对象移动事件，比如 heap_profiler 回监听这个事件
  if (V8_UNLIKELY(is_logging_)) {
    heap()->OnMoveEvent(target, source, size);
  }
}

至此就完成了对象的迁移。接着看对象的晋升。

template <typename THeapObjectSlot,
          Scavenger::PromotionHeapChoice promotion_heap_choice>
CopyAndForwardResult Scavenger::PromoteObject(Map map, THeapObjectSlot slot,
                                              HeapObject object,
                                              int object_size,
                                              ObjectFields object_fields) {
  AllocationAlignment alignment = HeapObject::RequiredAlignment(map);
  AllocationResult allocation;
  // 在老生代分配一块内存
  allocation = allocator_.Allocate(OLD_SPACE, object_size,
                                       AllocationOrigin::kGC, alignment);

  HeapObject target;
  allocation.To(&target);
  // 迁移过去
  MigrateObject(map, object, target, object_size, promotion_heap_choice);
}

对象的晋升本质上也是内存的复制，只不过是复制到了老生代的内存。完成了 from space 和 to space 对象的处理后，还需要另外的任务需要处理。具体由提交给线程池的 JobTask 对象实现。

V8::GetCurrentPlatform()
          ->PostJob(v8::TaskPriority::kUserBlocking,
                    std::make_unique<JobTask>(this, &scavengers,
                                              std::move(memory_chunks),
                                              &copied_list, &promotion_list))
          ->Join();

来看一下该对象 Run 的实现。

void ScavengerCollector::JobTask::Run(JobDelegate* delegate) {
  Scavenger* scavenger = (*scavengers_)[delegate->GetTaskId()].get();
  ProcessItems(delegate, scavenger);
}
void ScavengerCollector::JobTask::ProcessItems(JobDelegate* delegate,
                                               Scavenger* scavenger) {
  double scavenging_time = 0.0;
  {
    TimedScope scope(&scavenging_time);
    // 并行处理内存
    ConcurrentScavengePages(scavenger);
    scavenger->Process(delegate);
  }
}
void ScavengerCollector::JobTask::ConcurrentScavengePages(
    Scavenger* scavenger) {
  while (remaining_memory_chunks_.load(std::memory_order_relaxed) > 0) {
    base::Optional<size_t> index = generator_.GetNext();
    if (!index) return;
    for (size_t i = *index; i < memory_chunks_.size(); ++i) {
      auto& work_item = memory_chunks_[i];
      if (!work_item.first.TryAcquire()) break;
      scavenger->ScavengePage(work_item.second);
      if (remaining_memory_chunks_.fetch_sub(1, std::memory_order_relaxed) <=
          1) {
        return;
      }
    }
  }
}

具体看 scavenger->ScavengePage(work_item.second) 。

void Scavenger::ScavengePage(MemoryChunk* page) {
  CodePageMemoryModificationScope memory_modification_scope(page);
  if (page->slot_set<OLD_TO_NEW, AccessMode::ATOMIC>() != nullptr) {
    InvalidatedSlotsFilter filter = InvalidatedSlotsFilter::OldToNew(page);
    RememberedSet<OLD_TO_NEW>::IterateAndTrackEmptyBuckets(
        page,
        [this, &filter](MaybeObjectSlot slot) {
          if (!filter.IsValid(slot.address())) return REMOVE_SLOT;
          return CheckAndScavengeObject(heap_, slot);
        },
        &empty_chunks_local_);
  }
  if (page->invalidated_slots<OLD_TO_NEW>() != nullptr) {
    page->ReleaseInvalidatedSlots<OLD_TO_NEW>();
  }

  RememberedSet<OLD_TO_NEW>::IterateTyped(
      page, [=](SlotType type, Address addr) {
        return UpdateTypedSlotHelper::UpdateTypedSlot(
            heap_, type, addr, [this](FullMaybeObjectSlot slot) {
              return CheckAndScavengeObject(heap(), slot);
            });
      });

  AddPageToSweeperIfNecessary(page);
}

大概就是进行了数据的更新和内存的回收。至此，GC 的流程就大致分析完了。

触发 GC

刚出分析了 GC 的处理过程，接下来看看什么时候会触发 GC。相关代码如下。

scavenge_task_observer_.reset(new ScavengeTaskObserver(this, ScavengeJob::YoungGenerationTaskTriggerSize(this)));
new_space()->AddAllocationObserver(scavenge_task_observer_.get());

V8 初始化时，给新生代对象注册了一个内存分配的观察者，首先看一下观察者的实现。

class ScavengeTaskObserver : public AllocationObserver {
 public:
  ScavengeTaskObserver(Heap* heap, intptr_t step_size)
      : AllocationObserver(step_size), heap_(heap) {}

  void Step(int bytes_allocated, Address, size_t) override {
    heap_->ScheduleScavengeTaskIfNeeded();
  }
 private:
  Heap* heap_;
};

观察者的实现很简单，V8 在分配内存的过程中会执行观察者的 Step 方法，该方法会判断是否需要 GC，下面是 ScheduleScavengeTaskIfNeeded 的实现。

void Heap::ScheduleScavengeTaskIfNeeded() {
  scavenge_job_->ScheduleTaskIfNeeded(this);
}
void ScavengeJob::ScheduleTaskIfNeeded(Heap* heap) {
  if (FLAG_scavenge_task && !task_pending_ && !heap->IsTearingDown() &&
      YoungGenerationSizeTaskTriggerReached(heap)) {
    v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(heap->isolate());
    auto taskrunner =
        V8::GetCurrentPlatform()->GetForegroundTaskRunner(isolate);
    if (taskrunner->NonNestableTasksEnabled()) {
      taskrunner->PostNonNestableTask(
          std::make_unique<Task>(heap->isolate(), this));
      task_pending_ = true;
    }
  }
}

这个过程刚出已经分析过了。接下来再往前看，什么时候会调用 Step。创建完观察者后，会把观察者注册到 newSpace 中。

new_space()->AddAllocationObserver(scavenge_task_observer_.get());

看一下 AddAllocationObserver。

void Space::AddAllocationObserver(AllocationObserver* observer) {
  allocation_counter_.AddAllocationObserver(observer);
}

那么 allocation_counter_ 又是什么呢?allocation_counter_ 是 AllocationCounter 对象。

class AllocationCounter final {
 public:
  AllocationCounter() = default;
  V8_EXPORT_PRIVATE void AddAllocationObserver(AllocationObserver* observer);

  V8_EXPORT_PRIVATE void RemoveAllocationObserver(AllocationObserver* observer);

  V8_EXPORT_PRIVATE void AdvanceAllocationObservers(size_t allocated);

  V8_EXPORT_PRIVATE void InvokeAllocationObservers(Address soon_object,
                                                   size_t object_size,
                                                   size_t aligned_object_size);
 private:
  struct AllocationObserverCounter final {
    AllocationObserverCounter(AllocationObserver* observer, size_t prev_counter,
                              size_t next_counter)
        : observer_(observer),
          prev_counter_(prev_counter),
          next_counter_(next_counter) {}

    AllocationObserver* observer_;
  };
  std::vector<AllocationObserverCounter> observers_;
};

AllocationCounter 里记录了多个 AllocationObserverCounter 对象，而 AllocationObserverCounter 对象封装了 AllocationObserver 对象。来看一下 AddAllocationObserver 方法的实现。

void AllocationCounter::AddAllocationObserver(AllocationObserver* observer) {
    observers_.push_back(AllocationObserverCounter(observer, current_counter_,
                                                 observer_next_counter));
}

newSpace 通过 AllocationCounter 管理了多个观察者，接着看调用观察者的时机，也就是分配内存的时候。

AllocationResult SpaceWithLinearArea::AllocateRawAligned(
    int size_in_bytes, AllocationAlignment alignment, AllocationOrigin origin) {
  // 分配内存
  AllocationResult result = AllocateFastAligned(
      size_in_bytes, &aligned_size_in_bytes, alignment, origin);
  // 调用观察者
  InvokeAllocationObservers(result.ToAddress(), size_in_bytes,
                            aligned_size_in_bytes, max_aligned_size);

  return result;
}

接着看 InvokeAllocationObservers。

void AllocationCounter::InvokeAllocationObservers(Address soon_object,
                                                  size_t object_size,
                                                  size_t aligned_object_size) {
  for (AllocationObserverCounter& aoc : observers_) {
    if (aoc.next_counter_ - current_counter_ <= aligned_object_size) {
      {
        // 执行观察者的 Step 方法，也就是刚出分析 GC 处理时提到的
        aoc.observer_->Step(
            static_cast<int>(current_counter_ - aoc.prev_counter_), soon_object,
            object_size);
      }
    }
  }
}

至此，所有的过程分析完毕。

4 、总结

V8 的 GC 经过多年的优化已经变得非常高效，和其他优化技术一起实现了 V8 引擎的高性能。具体的实现非常复杂，涉及的逻辑非常多，时间有限，也就只能大致分析一下，了解基础的原理。

文章详情

V8 新生代垃圾回收的实现

1、分配内存

2、 GC 处理

触发 GC

4 、总结

软考中级精品资料免费领

相关文章

猜你喜欢