前言：GC 是一个古老、复杂并且很 Cool 的技术，本文大概介绍一下早期 V8 中关于 GC 实现的部分，代码版本 0.1.5，早期版本利于快速理解整体的逻辑，因为现代版本已经非常复杂。
HandleScope 和 Handle
首先看一下 Handle 一般的用法，Handle 是 GC 非常核心的概念。
HandleScope scope;
Handle<JSObject> obj(object);
这两句代码里涉及了两个核心的概念。首先看看 HandleScope。
class HandleScope {
public:
// 记录之前的上下文
HandleScope() : previous_(current_){
current_.extensions = 0;
}
~HandleScope() {
// 如果自己申请了内存，则释放
if (current_.extensions > 0) DeleteExtensions();
// 出栈，指向前面那个
current_ = previous_;
}
static void** CreateHandle(void* value);
class Data {
public:
// 分配的内存块数
int extensions;
// 下一个可用的位置
void** next;
// 达到limit执行的地址后说明当前内存块用完了
void** limit;
inline void Initialize() {
extensions = -1;
next = limit = NULL;
}
};
// 当前的HandleScope
static Data current_;
// 上一个HandleScope
const Data previous_;
}
首先看一下 Data 数据结构，Data 有三个字段
- next 表示下次创建 Handle 时使用的地址。
- limit表示超过 limit 则需要重新申请内存，V8 是按块申请的，limit 就是块的末地址。
- extensions 表示该 HandleScope 申请了多少块内存。
接着继续看 current 类静态变量，这个变量记录了当前用于分配 Handle 的地址信息，接着看 HandleScope 类本身。HandleScope 是基于 RAII 机制管理一个函数中，多个 Handle 创建和销毁的对象。HandleScope 在构造函数中记录了当前的上下文，然后在析构函数中进行恢复。我们看到在 HandleScope 的构造函数中把当前上下文记录在 previous_ 里，然后重置 extensions，表示该 HandleScope 还没有申请内存，因为新的 HandleScope 会沿用前一个 HandleScope 的空闲内存，因为 V8 只把 current 赋值给 previous_ ，然后接着使用 current 去分配内存，只有当 HandleScope 内存不够时，才会分配新的内存块。看一下下面的图。
首先看一下上图的左边，当我们创建第一个 HandleScope 时，该 HandleScope 对象就会保存当前 HandleScope 的上下文，这时候当前 HandleScope 上下文是 NULL，然后创建第一个 Handle 时因为 next == limit == NULL，所以需要申请一块内存，即 extensions 为 1。当创建第二个 Handle 后，就变成了左上角的样子。接着我们又定义了第二个 HandleScope，那么首先 第二个 HandleScope 同样在 previous_ 中记录当前的上下文，即 current 的值，接着在第二个 HandleScope 中分配一个 Handle 就变成了右图的样子。接下来看退出 HandleScope 时的逻辑，从代码中可以看到，首先判断本 HandleScope 是否创建了额外的内存块，是则释放，然后把 previous_ 中保存的上下文赋值给 current，那么 current 就恢复到了上一个 HandleScope 的上下文。
了解了 HandleScope 和 Handle 之后，我们接下来分析一下堆内存，主要是分析内存分配器、新生代和老生代（不包括代码区，map 区等）。
内存分配器 MemoryAllocator
V8 堆内存的申请和回收由内存分配器管理，新生代和老生代只是负责使用。首先看看 MemoryAllocator 的定义。
class MemoryAllocator : public AllStatic {
public:
static const int kMaxNofChunks = 1 << Page::kPageSizeBits;
static const int kPagesPerChunk = 64;
static const int kChunkSize = kPagesPerChunk * Page::kPageSize;
private:
// Maximum space size in bytes.
static int capacity_;
// Allocated space size in bytes.
static int size_;
// The initial chunk of virtual memory.
static VirtualMemory* initial_chunk_;
class ChunkInfo BASE_EMBEDDED {
public:
ChunkInfo() : address_(NULL), size_(0), owner_(NULL) {}
void init(Address a, size_t s, PagedSpace* o) {
address_ = a;
size_ = s;
owner_ = o;
}
Address address() { return address_; }
size_t size() { return size_; }
PagedSpace* owner() { return owner_; }
private:
Address address_;
size_t size_;
PagedSpace* owner_;
};
static List<ChunkInfo> chunks_;
static List<int> free_chunk_ids_;
static int max_nof_chunks_;
static int top_;
};
MemoryAllocator 中由 chunks_ 负责管理具体的内存，chunks_ 是一个 ChunkInfo 链表，从 ChunkInfo 中可以看到它主要记录了内存的起始地址和大小，以及所属的 space（新生代、老生代）。
接下来看 MemoryAllocator 的初始化。
// Setup memory allocator and allocate an initial chunk of memory. The
// initialchunk is double the size of the new space to ensure that we can
// find a pair of semispaces that are contiguous and aligned to their size.
// capacity 最大的内存大小（新生代 + 老生代）
bool MemoryAllocator::Setup(int capacity) {
// 页的整数倍
capacity_ = RoundUp(capacity, Page::kPageSize);
// 最大的chunk数,
max_nof_chunks_ = (capacity_ / (kChunkSize - Page::kPageSize)) + 4;
size_ = 0;
ChunkInfo info;
for (int i = max_nof_chunks_ - 1; i >= 0; i--) {
chunks_.Add(info);
free_chunk_ids_.Add(i);
}
top_ = max_nof_chunks_;
return true;
}
主要是初始化了内部的一些数据结构，没有实质的操作。接下来才是分配内存。
void* chunk = MemoryAllocator::ReserveInitialChunk(2 * young_generation_size_);
接着看 ReserveInitialChunk
void* MemoryAllocator::ReserveInitialChunk(const size_t requested) {
// 新建一个VM对象，分配size的虚拟内存，记录在VM对象
initial_chunk_ = new VirtualMemory(requested);
size_ += requested;
// 返回分配内存的首地址
return initial_chunk_->address();
}
VirtualMemory::VirtualMemory(size_t size, void* address_hint) {
// 映射一块内存
address_ = mmap(address_hint, size, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE,
kMmapFd, kMmapFdOffset);
size_ = size;
}
这就完成了内存的申请。
新生代堆内存管理
// 刚才分配的空间中，老生代在开始位置
Address old_space_start = reinterpret_cast<Address>(chunk);
// 紧接着是新生代，算出大小是young_generation_size_的n倍，值大于old_space_start的最小值
Address new_space_start = RoundUp(old_space_start, young_generation_size_);
// 代码空间等于新生代开始+新生代大小
Address code_space_start = new_space_start + young_generation_size_;
// 老生代空间大小
int old_space_size = new_space_start - old_space_start;
/*
因为chunk的空间两倍的young_generation_size_,新生代大小占了一半，
所以还有一半，剩下的一半老生代占了old_space_size，所以剩下的代码区大小
*/
int code_space_size = young_generation_size_ - old_space_size;
/*
|young_generation_size_|
chunk => -----------------------------------
^ ^ ^ ^
| | | |
old new code end
*/
// 分配一个管理新生代地址空间的对象，传入初始值和最大值
// 因为新生代分配from和to，所以这两个初始化值是每个空间的属性
new_space_ = new NewSpace(initial_semispace_size_, semispace_size_);
进行了一系列的计算后，开始初始化新生代。接下来看 NewSpace。
class NewSpace : public Malloced {
public:
// Create a new space with a given allocation capacity (ie, the capacity of
// *one* of the semispaces). The constructor does not allocate heap memory
// from the OS. When the space is set up, it is given a contiguous chunk of
// memory of size 2 * semispace_capacity. To support fast containment
// testing in the new space, the size of this chunk must be a power of two
// and it must be aligned to its size.
NewSpace(int initial_semispace_capacity, int maximum_semispace_capacity);
private:
int capacity_;
int maximum_capacity_;
// The semispaces.
SemiSpace* to_space_;
SemiSpace* from_space_;
Address start_;
uint32_t address_mask_;
uint32_t object_mask_;
uint32_t object_expected_;
/*
struct AllocationInfo {
Address top; // current allocation top
Address limit; // current allocation limit
};
*/
// 管理新生代内存的数据结构
AllocationInfo allocation_info_;
AllocationInfo mc_forwarding_info_;
};
新生代分为两个 SemiSpace。结构差不多，就不再介绍。了解了定义，看看初始化的逻辑。
// 设置需要管理的地址空间，start是首地址，size是大小
bool NewSpace::Setup(Address start, int size) {
// to区
if (to_space_ == NULL
|| !to_space_->Setup(start, maximum_capacity_)) {
return false;
}
// from区，和to区一人一半
if (from_space_ == NULL
|| !from_space_->Setup(start + maximum_capacity_, maximum_capacity_)) {
return false;
}
// 开始地址
start_ = start;
/*
address_mask的高位是地址的有效位，
size是只有一位为一，减一后一变成0，一右边
的全部0位变成1，然后取反，高位的0变成1，再加上size中本来的1，
即从左往右的1位地址有效位
*/
address_mask_ = ~(size - 1);
// 计算堆对象地址掩码，低位是标记位，判断的时候需要保留,kHeapObjectTag是堆对象的标记
object_mask_ = address_mask_ | kHeapObjectTag;
// 见 contains 函数，对象地址里低位是标记位，判断的时候需要带上
object_expected_ = reinterpret_cast<uint32_t>(start) | kHeapObjectTag;
// 初始化管理的内存信息
allocation_info_.top = to_space_->low();
allocation_info_.limit = to_space_->high();
mc_forwarding_info_.top = NULL;
mc_forwarding_info_.limit = NULL;
return true;
}
至此，新生代的数据结构和初始化分析完成。接下来看老生代，老生代的数据结构和新生代差不多，不再分析，区别是老生代的内存是用链表管理的，而不是连续的内存，直接看初始化流程。
bool PagedSpace::Setup(Address start, size_t size) {
int num_pages = 0;
first_page_ = MemoryAllocator::CommitPages(start, size, this, &num_pages);
// 初始化page链表，清除记录集
for (Page* p = first_page_; p->is_valid(); p = p->next_page()) {
p->ClearRSet();
}
// 设置管理内存分配的结构体，为第一个空闲页
SetAllocationInfo(&allocation_info_, first_page_);
return true;
}
接着看 CommitPages
// 保存和管理虚拟地址start到start+size的空间，
Page* MemoryAllocator::CommitPages(Address start, size_t size,
PagedSpace* owner, int* num_pages) {
// chunk中的页数，一个chunk包括多个页
*num_pages = PagesInChunk(start, size);
// 保存内存信息到chunkInfo
int chunk_id = Pop();
chunks_[chunk_id].init(start, size, owner);
// 按页初始化内存信息
return InitializePagesInChunk(chunk_id, *num_pages, owner);
}
继续看 InitializePagesInChunk
// 初始化某块内存为page管理的结构
Page* MemoryAllocator::InitializePagesInChunk(int chunk_id, int pages_in_chunk,
PagedSpace* owner) {
Address chunk_start = chunks_[chunk_id].address();
// 算出有效的开始地址，即要对齐
Address low = RoundUp(chunk_start, Page::kPageSize);
Address page_addr = low;
for (int i = 0; i < pages_in_chunk; i++) {
Page* p = Page::FromAddress(page_addr);
// 保存下一页的地址和当前所属的chunk_id
p->opaque_header = OffsetFrom(page_addr + Page::kPageSize) | chunk_id;
// 不是large object
p->is_normal_page = 1;
// 指向下一页地址
page_addr += Page::kPageSize;
}
// page_addr此时执行最后一页的末尾，减去一页大小得到最后一页的起始地址
Page* last_page = Page::FromAddress(page_addr - Page::kPageSize);
// 下一页地址为0
last_page->opaque_header = OffsetFrom(0) | chunk_id;
return Page::FromAddress(low);
}
一个内存块里面包括多个 Page，上面的代码是按 Page 为单位初始化内存。整体流程完成后，结构图如下。
新建对象
分析完数据结构和初始化流程，接下来看创建对象时的内存分配。
Local<v8::Object> v8::Object::New() {
i::Handle<i::JSObject> obj = i::Factory::NewJSObject(i::Top::object_function());
return Utils::ToLocal(obj);
}
Handle<JSObject> Factory::NewJSObject(Handle<JSFunction> constructor,
PretenureFlag pretenure) {
CALL_HEAP_FUNCTION(Heap::AllocateJSObject(*constructor, pretenure), JSObject);
}
Object* Heap::AllocateJSObject(JSFunction* constructor,
PretenureFlag pretenure) {
return AllocateJSObjectFromMap(constructor->initial_map(), pretenure);
}
Object* Heap::AllocateJSObjectFromMap(Map* map, PretenureFlag pretenure) {
Object* properties = AllocatePropertyStorageForMap(map);
// Allocate the JSObject.
// 选择分配的 Space
AllocationSpace space = (pretenure == TENURED) ? OLD_SPACE : NEW_SPACE;
// 对象所需内存太大（map 中记录了大小），则直接在大对象 Space 分配
if (map->instance_size() > MaxHeapObjectSize()) space = LO_SPACE;
// 分配内存
Object* obj = Allocate(map, space);
// Initialize the JSObject.
InitializeJSObjectFromMap(JSObject::cast(obj),
FixedArray::cast(properties),
map);
return obj;
}
接着看 Allocate。
// 根据map的type分配一个对象的空间，然后设置该对象的map属性是map
Object* Heap::Allocate(Map* map, AllocationSpace space) {
Object* result = AllocateRaw(map->instance_size(), space);
// 转成HeapObject才有set_map函数
HeapObject::cast(result)->set_map(map);
return result;
}
// 在哪块空间分配多少内存
Object* Heap::AllocateRaw(int size_in_bytes, AllocationSpace space) {
// 在新生代中分配内存
if (NEW_SPACE == space) {
return new_space_->AllocateRaw(size_in_bytes);
}
Object* result;
// 在对应的空间分配大小
if (OLD_SPACE == space) {
result = old_space_->AllocateRaw(size_in_bytes);
} else if (CODE_SPACE == space) {
result = code_space_->AllocateRaw(size_in_bytes);
} else if (LO_SPACE == space) {
result = lo_space_->AllocateRaw(size_in_bytes);
} else {
result = map_space_->AllocateRaw(size_in_bytes);
}
return result;
}
Object* AllocateRaw(int size_in_bytes) {
// allocation_info_ 就是初始化时记录的内存信息，allocation_info_ 负责管理内存的分配
return AllocateRawInternal(size_in_bytes, &allocation_info_);
}
Object* NewSpace::AllocateRawInternal(int size_in_bytes,
AllocationInfo* alloc_info) {
// alloc_info->top保存了该空间当前可分配的地址,加上当前申请分配的
Address new_top = alloc_info->top + size_in_bytes;
// 超过了内存大小
if (new_top > alloc_info->limit) {
return Failure::RetryAfterGC(size_in_bytes, NEW_SPACE);
}
// 地址+低一位的标记，转成堆对象的地址表示，即低位置1
Object* obj = HeapObject::FromAddress(alloc_info->top);
// 更新指针，指向下一块可分配的内存
alloc_info->top = new_top;
return obj;
}
我们可以看到分配内存是非常快的，只需要移动一下指针。
垃圾回收
但是有一个需要注意的是，当内存不够时就需要进行 GC，具体处理逻辑在之前代码的 CALL_HEAP_FUNCTION 宏中。
#define CALL_HEAP_FUNCTION(FUNCTION_CALL, TYPE) \
do { \
GC_GREEDY_CHECK(); \
Object* __object__ = FUNCTION_CALL; \
if (__object__->IsFailure()) { \
if (__object__->IsRetryAfterGC()) { \
if (!Heap::CollectGarbage( \
Failure::cast(__object__)->requested(), \
Failure::cast(__object__)->allocation_space())) { \
/* TODO(1181417): Fix this. */ \
v8::internal::V8::FatalProcessOutOfMemory("CALL_HEAP_FUNCTION"); \
} \
__object__ = FUNCTION_CALL; \
if (__object__->IsFailure()) { \
if (__object__->IsRetryAfterGC()) { \
/* TODO(1181417): Fix this. */ \
v8::internal::V8::FatalProcessOutOfMemory("CALL_HEAP_FUNCTION"); \
} \
return Handle<TYPE>(); \
} \
} else { \
return Handle<TYPE>(); \
} \
} \
return Handle<TYPE>(TYPE::cast(__object__)); \
} while (false)
重点看 Heap::CollectGarbage。
bool Heap::CollectGarbage(int requested_size, AllocationSpace space) {
// The VM is in the GC state until exiting this function.
VMState state(GC);
{ GCTracer tracer;
GarbageCollectionPrologue();
// 选择GC算法
GarbageCollector collector = SelectGarbageCollector(space);
tracer.set_collector(collector);
StatsRate* rate = (collector == SCAVENGER)
? &Counters::gc_scavenger
: &Counters::gc_compactor;
rate->Start();
// 开始垃圾回收
PerformGarbageCollection(space, collector);
rate->Stop();
GarbageCollectionEpilogue();
}
// GC 后内存是否能满足当前需要分配的内存
switch (space) {
case NEW_SPACE:
return new_space_->Available() >= requested_size;
case OLD_SPACE:
return old_space_->Available() >= requested_size;
case CODE_SPACE:
return code_space_->Available() >= requested_size;
case MAP_SPACE:
return map_space_->Available() >= requested_size;
case LO_SPACE:
return lo_space_->Available() >= requested_size;
}
return false;
}
早期的 V8 GC 是同步的，还没有并行、并发等优化逻辑，继续 PerformGarbageCollection。
在 V8 初始化时会初始化新生代堆内存的数据结构。
void Heap::PerformGarbageCollection(AllocationSpace space,
GarbageCollector collector) {
if (collector == MARK_COMPACTOR) {
MarkCompact();
int promoted_space_size = PromotedSpaceSize();
promoted_space_limit_ =
promoted_space_size + Max(2 * MB, (promoted_space_size/100) * 35);
old_gen_exhausted_ = false;
if (space == NEW_SPACE && !MarkCompactCollector::HasCompacted()) {
Scavenge();
}
} else {
Scavenge();
}
}
这里我们可以看到经常听到的 Scavenge 和 MarkCompact 算法。首先看 Scavenge。
void Heap::Scavenge() {
gc_state_ = SCAVENGE;
// from区和to区互换，to区变成空白，from区则分配了各种对象
new_space_->Flip();
// 重置to区的指针，因为to区变空闲了
new_space_->ResetAllocationInfo();
CopyVisitor copy_visitor;
// 遍历根，复制对象到另一个区
IterateRoots(©_visitor);
// 设置临界线，以此判断新生代对象是否可以经历了二次 GC，即可以晋升带老生代
new_space_->set_age_mark(new_mark);
gc_state_ = NOT_IN_GC;
}
实际的逻辑比这个负责很多，不过这里只是大致了解流程。CopyVisitor 对象负责把对象复制到另一个区。
class CopyVisitor: public ObjectVisitor {
public:
void VisitPointer(Object** p) {
CopyObject(p);
}
void VisitPointers(Object** start, Object** end) {
// Copy all HeapObject pointers in [start, end)
for (Object** p = start; p < end; p++) CopyObject(p);
}
private:
void CopyObject(Object** p) {
if (!Heap::InFromSpace(*p)) return;
Heap::CopyObject(reinterpret_cast<HeapObject**>(p));
}
};
继续看 Heap::CopyObject。
void Heap::CopyObject(HeapObject** p) {
ASSERT(InFromSpace(*p));
HeapObject* object = *p;
// map 对象记录了对象的元信息
HeapObject* first_word = object->map();
int object_size = object->SizeFromMap(Map::cast(first_word));
Object* result;
// 是否满足晋升条件
/*
bool Heap::ShouldBePromoted(Address old_address, int object_size) {
/*
小于age_mark说明已经经过了一次gc回收了，第二次的时候还存活则可以晋升到老生代
age_mark是from区的值，但是是在from区和to区交换之后，所以其实是to区的值
*/
return old_address < new_space_->age_mark()
|| (new_space_->Size() + object_size) >= (new_space_->Capacity() >> 2);
}
*/
if (ShouldBePromoted(object->address(), object_size)) {
bool has_pointers =
type != HEAP_NUMBER_TYPE &&
(type >= FIRST_NONSTRING_TYPE ||
String::cast(object)->representation_tag() != kSeqStringTag);
// 在对应的 Space 分配内存，把对象复制过去
if (has_pointers) {
result = old_space_->AllocateRaw(object_size);
} else {
result = code_space_->AllocateRaw(object_size);
}
if (!result->IsFailure()) {
*p = MigrateObject(p, HeapObject::cast(result), object_size);
if (has_pointers) {
promoted_top -= kPointerSize;
Memory::Object_at(promoted_top) = *p;
}
return;
}
}
// 不晋升的复制到新生代的另一个区，下次还存活再晋升
result = new_space_->AllocateRaw(object_size);
*p = MigrateObject(p, HeapObject::cast(result), object_size);
}
MigrateObject 实现了对象的复制。
HeapObject* Heap::MigrateObject(HeapObject** source_p,
HeapObject* target,
int size) {
void** src = reinterpret_cast<void**>((*source_p)->address());
void** dst = reinterpret_cast<void**>(target->address());
int counter = size/kPointerSize - 1;
do {
*dst++ = *src++;
} while (counter-- > 0);
(*source_p)->set_map(reinterpret_cast<Map*>(target));
return target;
}
至此就完成了新生代 GC 的分析，紧接着分析老生代的。
void Heap::MarkCompact() {
gc_state_ = MARK_COMPACT;
MarkCompactPrologue();
// 开始回收
MarkCompactCollector::CollectGarbage();
MarkCompactEpilogue();
gc_state_ = NOT_IN_GC;
}
老生代 GC 比较复杂。
void MarkCompactCollector::CollectGarbage() {
Prepare();
// 标记
MarkLiveObjects();
// 清除大对象
SweepLargeObjectSpace();
// 是否压缩，压缩是为了防止内存碎片，否则直接清楚
if (compacting_collection_) {
EncodeForwardingAddresses();
UpdatePointers();
RelocateObjects();
RebuildRSets();
} else {
SweepSpaces();
}
Finish();
}
这里我们只分析标记和清除，V8 早期也还没有并行标记，延迟清除等逻辑。
void MarkCompactCollector::MarkLiveObjects() {
// 新生代有一半空间时空闲的，可以使用，marking_stack用于遍历扫描对象的数据结构
marking_stack.Initialize(Heap::new_space()->FromSpaceLow(),
Heap::new_space()->FromSpaceHigh());
MarkingVisitor marking_visitor;
// 从根开始遍历，进行标记
Heap::IterateStrongRoots(&marking_visitor);
while (true) {
// IterateStrongRoots 会不断压对象进栈，这里继续遍历，直到为空
MarkObjectsReachableFromTopFrame();
// 遍历的时候，栈可能溢出，内存不够，ok 的话继续遍历其他的
if (!marking_stack.overflowed()) {
if (has_processed_weak_pointers) break;
GlobalHandles::MarkWeakRoots(&MustBeMarked);
GlobalHandles::IterateWeakRoots(&marking_visitor);
has_processed_weak_pointers = true;
continue;
}
// 清除标记
marking_stack.clear_overflowed();
// 继续遍历，到栈为空
ScanOverflowedObjects(&lo_it);
}
}
首先看如何从根开始遍历。
void Heap::IterateStrongRoots(ObjectVisitor* v) {
// 遍历 Handle，忽略其他根
HandleScopeImplementer::Iterate(v);
}
void HandleScopeImplementer::Iterate(ObjectVisitor* v) {
ImplementationUtilities::HandleScopeData* current =
ImplementationUtilities::CurrentHandleScope();
Iterate(v, thread_local.Blocks(), current);
}
主要看 ImplementationUtilities::CurrentHandleScope()。
static HandleScopeData* CurrentHandleScope() {
return &v8::HandleScope::current_;
}
v8::HandleScope::current_ 就是前面介绍的 HandleScope。
void HandleScopeImplementer::Iterate(
ObjectVisitor* v,
List<void**>* blocks,
ImplementationUtilities::HandleScopeData* handle_data) {
// Iterate over all handles in the blocks except for the last.
for (int i = blocks->length() - 2; i >= 0; --i) {
Object** block =
reinterpret_cast<Object**>(blocks->at(i));
v->VisitPointers(block, &block[kHandleBlockSize]);
}
// Iterate over live handles in the last block (if any).
if (!blocks->is_empty()) {
v->VisitPointers(reinterpret_cast<Object**>(blocks->last()),
reinterpret_cast<Object**>(handle_data->next));
}
}
Iterate 实现遍历全部的 Handle。接着看遍历时对对象的处理。具体实现在 MarkingVisitor。
void VisitPointer(Object** p) {
MarkObjectByPointer(p);
}
void MarkObjectByPointer(Object** p) {
Object* obj = *p;
if (!obj->IsHeapObject()) return;
MarkCompactCollector::MarkObject(HeapObject::cast(obj));
}
static inline void MarkObject(HeapObject* obj) {
// 没有标记则标记
if (!is_marked(obj)) MarkUnmarkedObject(obj);
}
void MarkCompactCollector::MarkUnmarkedObject(HeapObject* obj) {
// 打上标记
set_mark(obj);
// 押入栈，扫描它的子指针，类似遍历树
if (!marking_stack.overflowed()) {
marking_stack.Push(obj);
} else {
// Set object's stack overflow bit, wait for rescan.
// 溢出了则后面继续扫描
set_overflow(obj);
}
}
扫描和标记完全部对象后就进行清除。
void MarkCompactCollector::SweepSpaces() {
SweepSpace(Heap::old_space(), &DeallocateOldBlock);
}
static void SweepSpace(PagedSpace* space, DeallocateFunction dealloc) {
PageIterator it(space, PageIterator::PAGES_IN_USE);
while (it.has_next()) {
Page* p = it.next();
bool is_previous_alive = true;
Address free_start = NULL;
HeapObject* object;
// 遍历老生代的每一个对象，没有标记的则清除（回收内存）
for (Address current = p->ObjectAreaStart();
current < p->AllocationTop();
current += object->Size()) {
object = HeapObject::FromAddress(current);
// 如果标记，则先清除，然后回收（如果连续的内存则一起回收）
if (is_marked(object)) {
clear_mark(object);
if (!is_previous_alive) { // Transition from free to live.
dealloc(free_start, current - free_start);
is_previous_alive = true;
}
} else {
if (is_previous_alive) { // Transition from live to free.
free_start = current;
is_previous_alive = false;
}
}
}
if (!is_previous_alive) {
int free_size = p->AllocationTop() - free_start;
if (free_size > 0) {
dealloc(free_start, free_size);
}
}
}
}
接着看 dealloc 的回收逻辑。
void MarkCompactCollector::DeallocateOldBlock(Address start,
int size_in_bytes) {
// 清除记录集，记录集记录了老生代执行新生代的指针
Heap::ClearRSetRange(start, size_in_bytes);
Heap::old_space()->Free(start, size_in_bytes);
}
void Free(Address start, int size_in_bytes) {
int wasted_bytes = free_list_.Free(start, size_in_bytes);
accounting_stats_.DeallocateBytes(size_in_bytes);
accounting_stats_.WasteBytes(wasted_bytes);
}
int OldSpaceFreeList::Free(Address start, int size_in_bytes) {
FreeListNode* node = FreeListNode::FromAddress(start);
node->set_size(size_in_bytes);
int index = size_in_bytes >> kPointerSizeLog2;
node->set_next(free_[index].head_node_);
free_[index].head_node_ = node->address();
available_ += size_in_bytes;
needs_rebuild_ = true;
return 0;
}
这里的内存并不是直接释放，而是存到空闲链表，后续使用。可参考前面的图。
扫一扫
2312
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
