Go 언어 GC 오버헤드 문제와 효과적인 해결 방안

Go 언어 GC 오버헤드 문제와 효과적인 해결 방안

---

서론

안녕하세요, Golang 개발자 여러분!

 

오늘은 Go 언어의 Garbage Collector(GC)가 어떤 상황에서 오버헤드를 발생시키는지, 그리고 이를 어떻게 효과적으로 회피할 수 있는지에 대해 이야기해보려고 합니다.

 

Go의 GC는 일반적으로 매우 효율적이지만, 특정 조건에서는 성능에 영향을 줄 수 있는 경우가 있습니다.

 

이를 이해하고 최적화하는 방법을 함께 알아볼까요?

 

Go의 Garbage Collector란?

Go 언어의 Garbage Collector는 동시 마크-스위프(Goroutine) GC를 사용합니다.

 

이 방식은 마크 단계와 스위프 단계로 나뉘며, 사용자 프로그램과 동시에 동작하여 Stop the World(StW) 시간을 최소화합니다.

 

마크 단계에서는 루트에서부터 객체를 추적하여 사용 중인 메모리를 표시하고, 스위프 단계에서는 표시되지 않은 메모리를 해제합니다.

 

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    a := make([]*int, 1e9)

    for i := 0; i < 10; i++ {
        start := time.Now()
        runtime.GC()
        fmt.Printf("GC took %s\n", time.Since(start))
    }

    runtime.KeepAlive(a)
}

 

위 코드는 10억 개의 포인터를 할당하고 GC의 소요 시간을 측정하는 예제입니다.

 

GC 오버헤드가 높아지는 경우

Go의 GC는 힙에 할당된 메모리의 양과 포인터의 수에 민감하게 반응합니다.

 

힙에 많은 데이터를 할당하면 GC가 이를 스캔하는 데 더 많은 시간이 소요될 수 있습니다.

 

특히 다음과 같은 경우에 GC 오버헤드가 크게 증가할 수 있습니다:

 

• 대규모 인메모리 데이터베이스 구축: 수억 개의 객체를 메모리에 할당하는 경우.
• 복잡한 데이터 구조 사용: 포인터가 많은 구조체나 복잡한 맵 구조.
• 긴 생명 주기를 갖는 객체: 객체의 생존 시간이 길수록 GC는 이를 추적해야 하므로 오버헤드가 증가.

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    a := make([]int, 1e9)

    for i := 0; i < 10; i++ {
        start := time.Now()
        runtime.GC()
        fmt.Printf("GC took %s\n", time.Since(start))
    }

    runtime.KeepAlive(a)
}

 

위 예제는 포인터 대신 정수 슬라이스를 할당했을 때의 GC 소요 시간을 측정한 것입니다.

 

결과는 포인터를 사용할 때보다 훨씬 빠르게 GC가 수행되는 것을 확인할 수 있습니다.

 

GC 오버헤드를 회피하는 방법

GC 오버헤드를 줄이기 위해 몇 가지 전략을 고려할 수 있습니다.

 

하지만 이들 방법은 모두 상황에 따라 다르게 적용될 수 있으며, 완벽한 해결책은 아닙니다.

 

1. GC 관할 외 메모리 할당

직접 시스템 콜을 사용하여 메모리를 할당하고 관리하는 방법입니다.

 

이는 안전성과 유지보수성 측면에서 권장되지 않습니다.

2. 포인터를 최소화한 데이터 구조 사용

가능한 한 포인터를 사용하지 않고 값 기반의 데이터 구조를 사용하는 것이 좋습니다.

 

예를 들어, 문자열을 포인터 대신 정수 인덱스로 관리하거나, 복잡한 맵 구조 대신 1차원 슬라이스를 사용하는 방법이 있습니다.

 

// 포인터를 사용하지 않은 문자열 관리 예시
type StringPool struct {
    data   string
    indexes []int
}

func (sp *StringPool) Add(s string) {
    sp.indexes = append(sp.indexes, len(sp.data))
    sp.data += s
}

func (sp *StringPool) Get(index int) string {
    // 적절한 인덱싱 로직 구현
    return string(sp.data[index : index+1])
}

 

실험을 통한 GC 성능 확인

 

실제로 GC의 오버헤드를 확인하기 위해 몇 가지 실험을 해보겠습니다.

포인터를 사용한 경우

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    a := make([]*int, 1e9)

    for i := 0; i < 10; i++ {
        start := time.Now()
        runtime.GC()
        fmt.Printf("GC took %s\n", time.Since(start))
    }

    runtime.KeepAlive(a)
}

 

실행 결과:

GC took 5.614972137s
GC took 1.972851931s
...

 

포인터를 사용하지 않은 경우

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    a := make([]int, 1e9)

    for i := 0; i < 10; i++ {
        start := time.Now()
        runtime.GC()
        fmt.Printf("GC took %s\n", time.Since(start))
    }

    runtime.KeepAlive(a)
}

 

실행 결과:

GC took 692.498µs
GC took 282.914µs
...

 

위 실험을 통해 포인터를 많이 사용할수록 GC의 오버헤드가 증가함을 확인할 수 있습니다.

 

결론

Go 언어의 Garbage Collector는 일반적인 사용에서는 매우 효율적이지만, 대규모 힙 할당이나 포인터 사용이 많은 경우에는 성능 저하가 발생할 수 있습니다.

 

이를 해결하기 위해서는 데이터 구조를 최적화하거나, 포인터 사용을 최소화하는 등의 노력이 필요합니다.

 

앞으로 Go의 GC는 더욱 발전할 것이므로, 최신 업데이트를 주시하며 최적화 방안을 지속적으로 모색하는 것이 중요합니다.

 

---