Post

[V8] Garbage Collection (GC)

[V8] Garbage Collection (GC)

지금까지 V8의 객체 구조를 공부하면서 HeapObject, Map, JSArray, FixedArray 같은 객체들이 V8 Heap에 존재한다는 것을 배웠다.

그런데 객체가 계속 생성되기만 하고 사라지지 않는다면 Heap은 언젠가 가득 차게 된다.

1
2
3
4
5
let obj = {
  	value: 123
};

obj = null;

처음 obj를 만들었을 때 V8은 Heap에 객체를 하나 생성한다.

그런데 이후 obj = null이 실행되면 기존 객체를 사용할 방법이 사라진다.

C라면 이런 메모리를 직접 free()해야 하지만 JavaScript에는 free()가 없다.

이때 V8이 사용하지 않는 객체를 자동으로 찾아 메모리를 회수한다.

이것이 Garbace Collection, 줄여서 GC라고 한다.


GC

GC는 더 이상 사용되지 않는 객체를 찾아 메모리를 회수하는 시스템이다.

하지만 단순히 변수가 없어졌다고 객체를 제거할 수는 없다.

1
2
3
4
5
6
let a = {};
let b = {};

a.child = b;

b = null;

위 코드에서 변수 b는 더 이상 기존 객체를 직접 참조하지 않는다.

하지만 a.child를 통해 여전히 해당 객체에 접근할 수 있다.

따라서 객체가 살아 있는지 판단할 때는 단순히 변수의 존재 여부가 아니라 객체에 도달할 수 있는지를 확인해야 한다.


Reachability

GC에서 중요한 개념은 Reachability이다. 쉽게 말하면 특정 객체까지 참조를 따라가며 접근할 수 있는지를 의미한다.

1
Root -> A -> B -> C    D

A, B, C는 Root에서 시작해서 접근할 수 있다 (Reachable)

반대로 D는 어디서도 참조되지 않는다 (Unreachable)

따라서 D는 GC 대상이 된다.

정리하면 Root에서 도달 가능하다면 Live, 도달 불가능이라면 Garbage가 되어 GC는 이런 방식으로 살아 있는 객체와 필요 없는 객체를 구분한다.


Generation GC

문제는 Heap 전체를 매번 검사하면 너무 느리다는 것이다. JavaScript에서는 임시 객체가 굉장히 많이 생성된다.

1
2
3
4
5
for (let i = 0; i < 100000; i++) {
  	let obj = {
      	value: i
    };
}

위 코드에서 생성되는 대부분의 객체는 오래 살아남지 않는다.

V8은 이런 특성을 이용한다.

이를 Generational Hypothesis라고 한다.

대부분의 객체는 생성된 이후 얼마 지나지 않아 죽는다.

따라서 모든 객체를 같은 방식으로 관리하지 않고 수명에 따라 세대를 나눈다.

  • Young Generation
  • Old Generation

대부분의 새로운 객체는 Young Generation에서 시작한다.

그리고 오래 살아남은 객체는 Old Generation으로 이동할 수 있다.


Young Generation

Young Generation은 생성된 지 얼마 되지 않은 객체들이 주로 존재하는 영역이다.

새로 생성된 객체 대부분은 금방 필요 없어지기 때문에 Young Generation에서는 GC가 비교적 자주 발생한다.

Young Generation의 기본적인 GC 방식은 Scavenger이다.

Young Generation을 대상으로 하는 GC를 일반적으로 Minor GC라고 부른다.


Scavenger

Scavenger는 Young Generation에서 살아 있는 객체만 남기는 방식으로 동작한다.

핵심은 주긍ㄴ 객체를 하나씩 지우는 것이 아니라 살아 있는 객체를 복사하는 것이다.

예를 들어 다음과 같은 Heap 상태가 있다고 가정한다.

1
[A][dead][B][dead][C]

여기서 살아 있는 객체는 A, B, C이다.

Scavenger는 살아 있는 객체만 다른 공간으로 복사한다.

1
[A][B][C]

그리고 기존 공간 전체를 다시 사용할 수 있게 만든다.

이 방식은 Young Generation에서 객체 대부분이 금방 죽는다는 특성과 잘 맞는다.


Semi-Space

Scavenger를 이해하려면 Semi-Space 구조를 잘 알아야 한다.

Young Generation은 개념적으로 두 개의 공간을 사용한다.

  • From-Space
  • To-Space

현재 From-Space에 다음과 같이 객체가 존재한다고 한다.

1
[A][dead][B][dead][C]

Minor GC가 발생하면 살아 있는 객체만 To-Space로 복사한다.

결과적으로 To-Space에는 A, B, C만 있고 이전 From-Space는 비워진 공간처럼 다시 사용할 수 있다.

즉 죽은 객체를 하나씩 제거하는 것이 아니라 살아 있는 객체만 복사하는 방식이다.


Object Movement

Scavenger는 객체를 다른 Semi-Space로 복사한다.

Minor GC가 발생하고 다른 Semi-Space로 이동하면 주소가 변경될 수 있다.

따라서 HeapObject의 주소가 항상 고정되어 있다고 가정하면 안된다.


Promotion

Young Generation에서 계속 살아남는 객체는 언젠가 Old Generation으로 이동한다.

이를 Promotion 또는 Tenuring이라고 한다.

계속 살아남는 객체를 매 Minor GC마다 복사하는 것은 비효율적이다.

그래서 수명이 긴 객체는 Old Generation으로 옮겨 관리한다.

간단하게 생각하면 다음과 같다.

Young Generation = 생성된지 얼마 안 된 객체 Old Generation = 오래 살아남은 객체


Old Generation

Old Generation에는 비교적 오래 살아남은 객체들이 존재한다.

Young Generation처럼 객체를 전부 다른 공간으로 계속 복사하기에는 비용이 크다.

그래서 Old Generation에서는 주로 Mark-Sweep-Compact 방식이 사용된다.


Mark

먼저 살아 있는 객체를 찾는다.

1
Root -> A -> B -> C    D

Root를 따라가며 접근 가능한 객체를 표시한다.

A, B, C -> Marked D -> Unmarked

Marked = 살아 있는 객체 Unmarked = Garbage


Sweep

Mark 단계가 끝나면 살아 있지 않은 객체를 알 수 있다. 이제 Mark되지 않은 객체가 사용하던 메모리를 회수한다.

1
[A][dead][B][dead][C]

Sweep 이후에는

1
[A][free][B][free][C]

처럼 죽은 객체가 사용하던 영역을 다시 사용할 수 있게 된다.


Compaction

Sweep만 계속하면 메모리 공간이 여러 곳에 흩어질 수 있다.

1
[A][free][B][free][C][free]

이를 Fragmentation 메모리 단편화라고 한다.

사용 가능한 공간은 많지만 조각조각 나뉘어 있는 상태이다.

필요한 경우 V8은 살아 있는 객체를 이동시켜 공간을 정리한다.

1
[A][free][B][free][C]

이후

1
[A][B][C][			free			]

이런식으로 바뀐다.

이 과정을 Compaction이라고 한다.

여기서도 객체가 이동할 수 있다.

따라서 Old Generation의 객체 역시 주소가 항상 고정되어 있는 것은 아니다.


Write Barrier

Generational GC에는 한 가지 문제가 있다.

다음과 같은 객체 관계를 생각한다.

1
Old Generation(A) -> Young Generation(B)

A는 Old Generation 객체이고 B는 Young Generation 객체이다.

Minor GC는 빠르게 동작하기 위해 Young Gneneration을 중심으로 검사한다.

그런데 Old Generation의 A가 B를 참조하고 있다면 이를 놓치면 안된다.

그렇다고 Minor GC마다 Old Generation 전체를 검사하면 성능이 나빠진다.

이 문제를 해결하기 위해 Write Barrier를 사용한다.

예를 들어

1
2
javascript
oldObject.child = youngObject;

라는 코드가 실행되면 개념적으로

1
Old Object -> Young Object

라는 관계가 만들어진다.

V8은 특정 pointer 저장 시 GC가 알아야 할 참조 관계가 생기면 Write Barrier를 통해 이를 기록한다.


Remembered Set

Write Barrier가 기록한 Old -> Young 참조를 관리하는 구조가 Remembered Set이다.

1
Old Object -> Young Object

이제 Minor GC는 Old Generation 전체를 검사할 필요 없이 GC Roots + Remembered Set을 이용해 Young Generation의 살아 있는 객체를 찾을 수 있다.

그냥 다음처럼 이해하면 된다.

1
old -> Young Ref -> Write Barrier -> Remembered Set

V8 내부 코드를 보다 보면

1
2
3
WriteBarrier
RememberedSet
OLD_TO_NEW

같은 이름을 볼 수 있는데 기본 아이디어는 이것이다.


Incremental GC

GC 작업이 오래 걸리면 JavaScript 실행이 오래동안 멈출 수 있다.

그래서 V8은 큰 GC 작업을 여러 작은 단계로 나누기도 한다.

이를 Incremental GC라고 한다.

걍 쉽게 말해서 하나의 긴 GC 작업을 여러 단계로 나누어 처리하는 방식이다.


Parallel GC

Parallel GC는 여러 thread가 GC 작업을 함께 처리하는 방식이다.

하나의 GC 작업을 여러 thread가 분담하기 때문에 더 빠르게 처리할 수 있다.


Concurrent GC

Concurrent GC는 JavaScript 실행과 GC 작업이 동시에 진행되는 방식이다.

즉 모든 GC 작업이 JavaScript 실행을 완전히 멈춘 상태에서만 수행되는 것은 아니다.

위 세 가지를 대충 정리하면 다음과 같다.

1
2
3
Incremental = 작업을 여러 조각으로 나눈다
Parallel = 여러 thread가 같은 GC를 함께 수행
Concurrent = JavaScript 실행과 GC가 동시에 진행

This post is licensed under CC BY 4.0 by the author.