성능 분석

프로그램이 작성된 후 우리는 단순히 실행 가능한 것뿐만 아니라 안정적이고 효율적인 애플리케이션이기를 원합니다. 다양한 테스트를 통해 프로그램의 대부분 안정성을 보장할 수 있지만, 프로그램이 효율적인지는 성능 분석을 수행해야 합니다. 이전 내용에서 성능 분석의 유일한 수단은 Benchmark 를 통해 특정 기능 유닛의 평균 실행 시간, 메모리 할당 상황 등을 테스트하는 것이었습니다. 그러나 실제로 프로그램 성능 분석에 대한 요구는 이보다 훨씬 더 많습니다. 때로는 프로그램 전체의 CPU 점유율, 메모리 점유율, 힙 할당 상황, 고루틴 상태, 핫스팟 코드 경로 등을 분석해야 합니다. 이는 Benchmark 가 충족할 수 없는 부분입니다. 다행히 go 도구 체인에는 많은 성능 분석 도구가 통합되어 개발자가 사용할 수 있도록 제공되므로 아래에서 하나씩 설명하겠습니다.

탈출 분석

Go 에서 변수의 메모리 할당은 컴파일러가 결정하며, 일반적으로 스택과 힙 두 곳에 할당됩니다. 스택에 할당되어야 할 변수가 힙에 할당되는 경우를 탈출 (escape) 이라고 하며, 탈출 분석은 프로그램의 메모리 할당 상황을 분석하는 것입니다. 이는 컴파일 시기에 수행되므로 정적 분석의 일종입니다.

TIP

자세한 내용은 메모리 할당 문서를 참조하십시오.

지역 포인터 참조

package main

func main() {
  GetPerson()
}

type Person struct {
  Name string
  Mom  *Person
}

func GetPerson() Person {
  mom := Person{Name: "lili"}
  son := Person{Name: "jack", Mom: &mom}
  return son
}

GetPerson 함수에서 mom 변수를 생성했습니다. 이는 함수 내에서 생성되었으므로 원래는 스택에 할당되어야 하지만 son 의 Mom 필드에 의해 참조되고 son 이 함수 반환 값으로 반환되므로 컴파일러는 이를 힙에 할당합니다. 이는 매우 간단한 예이므로 이해하는 데 많은 노력이 필요하지 않지만, 프로젝트가 더 커서 코드 행 수가 수만 행이라면 인공 분석은 쉽지 않을 것입니다. 따라서 도구를 사용하여 탈출 분석을 수행해야 합니다. 앞서 메모리 할당은 컴파일러가 주도한다고 언급했는데, 따라서 탈출 분석도 컴파일러가 완료하며 사용은 매우 간단합니다. 다음 명령만 실행하면 됩니다.

bash

$ go build -gcflags="-m -m -l"

gcflags는 컴파일러 gc 의 매개변수입니다.

-m, 코드 최적화 제안 출력, 두 개가 함께 사용되면 더 세부적인 출력을 제공합니다.
-l, 인라인 최적화 비활성화

출력은 다음과 같습니다.

bash

$ go build -gcflags="-m -m -l" .
# golearn/example
./main.go:13:2: mom escapes to heap:
./main.go:13:2:   flow: son = &mom:
./main.go:13:2:     from &mom (address-of) at ./main.go:14:35
./main.go:13:2:     from Person{...} (struct literal element) at ./main.go:14:15
./main.go:13:2:     from son := Person{...} (assign) at ./main.go:14:6
./main.go:13:2:   flow: ~r0 = son:
./main.go:13:2:     from return son (return) at ./main.go:15:2
./main.go:13:2: moved to heap: mom

컴파일러는 변수 mom 이 탈출했음을 명확히 알려주며, 그 이유는 반환 값이 함수 내의 지역 포인터를 포함했기 때문입니다. 이 경우 외에도 탈출 현상이 발생할 수 있는 다른 상황들이 있습니다.

::: tips

탈출 분석의 세부사항에 관심이 있다면 표준 라이브러리 cmd/compile/internal/escape/escape.go 에서 더 많은 내용을 확인할 수 있습니다.

:::

클로저 참조

클로저가 함수 외부의 변수를 참조하면 해당 변수도 힙으로 탈출합니다. 이는 이해하기 쉽습니다.

package main

func main() {
  a := make([]string, 0)
  do(func() []string {
    return a
  })
}

func do(f func() []string) []string {
  return f()
}

출력

$ go build -gcflags="-m -m -l" .
# golearn/example
./main.go:10:9: f does not escape
./main.go:4:2: main capturing by value: a (addr=false assign=false width=24)
./main.go:4:11: make([]string, 0) escapes to heap:
./main.go:4:11:   flow: a = &{storage for make([]string, 0)}:
./main.go:4:11:     from make([]string, 0) (spill) at ./main.go:4:11
./main.go:4:11:     from a := make([]string, 0) (assign) at ./main.go:4:4
./main.go:4:11:   flow: ~r0 = a:
./main.go:4:11:     from return a (return) at ./main.go:6:3
./main.go:4:11: make([]string, 0) escapes to heap
./main.go:5:5: func literal does not escape

공간 부족

스택 공간이 부족할 때도 탈출 현상이 발생합니다. 아래는 1<<15 용량을 할당한 슬라이스입니다.

package main

func main() {
  _ = make([]int, 0, 1<<15)
}

출력

$ go build -gcflags="-m -m -l" .
# golearn/example
./main.go:4:10: make([]int, 0, 32768) escapes to heap:
./main.go:4:10:   flow: {heap} = &{storage for make([]int, 0, 32768)}:
./main.go:4:10:     from make([]int, 0, 32768) (too large for stack) at ./main.go:4:10
./main.go:4:10: make([]int, 0, 32768) escapes to heap

길이 미지정

슬라이스의 길이가 변수일 때도 길이가 미지정이므로 탈출 현상이 발생합니다 (map 은 제외).

package main

func main() {
  n := 100
  _ = make([]int, n)
}

출력

$ go build -gcflags="-m -m -l" .
# golearn/example
./main.go:5:10: make([]int, n) escapes to heap:
./main.go:5:10:   flow: {heap} = &{storage for make([]int, n)}:
./main.go:5:10:     from make([]int, n) (non-constant size) at ./main.go:5:10
./main.go:5:10: make([]int, n) escapes to heap

또 다른 특별한 경우는 함수 매개변수가 ...any 타입일 때도 탈출이 발생할 수 있습니다.

package main

import "fmt"

func main() {
  n := 100
  fmt.Println(n)
}

출력

$ go build -gcflags="-m -m -l" .
# golearn/example
./main.go:7:14: n escapes to heap:
./main.go:7:14:   flow: {storage for ... argument} = &{storage for n}:
./main.go:7:14:     from n (spill) at ./main.go:7:14
./main.go:7:14:     from ... argument (slice-literal-element) at ./main.go:7:13
./main.go:7:14:   flow: {heap} = {storage for ... argument}:
./main.go:7:14:     from ... argument (spill) at ./main.go:7:13
./main.go:7:14:     from fmt.Println(... argument...) (call parameter) at ./main.go:7:13
./main.go:7:13: ... argument does not escape
./main.go:7:14: n escapes to heap

우리가 탈출 분석을 수행하고 메모리 할당을 이렇게 세밀하게 제어하는 주된 이유는 GC 부하를 줄이기 위함입니다. 하지만 Go 는 C 언어가 아니며 메모리 할당의 최종 결정권은 여전히 컴파일러에게 있습니다. 극단적인 성능 요구 사항을 제외하고는 대부분의 경우 메모리 할당의 세부사항에 너무 집중할 필요는 없습니다. GC 가 탄생한 목적 자체가 개발자를 해방시키기 위한 것이기 때문입니다.

작은 팁

일부 참조 타입의 경우 더 이상 사용하지 않을 것이 확인되면 nil 로 설정하여 GC 에게 회수할 수 있도록 알려줄 수 있습니다.

type Writer struct {
  buf []byte
}

func (w Writer) Close() error {
  w.buff = nil
  return nil
}

pprof

pprof(program profiling) 는 프로그램 성능 분석의 강력한 도구로, 실행 시 데이터의 일부를 샘플링하며 CPU, 메모리, 고루틴, 락, 스택 정보 등 많은 부분을 다룹니다. 그런 다음 도구를 사용하여 샘플링된 데이터를 분석하고 결과를 표시합니다.

따라서 pprof 사용 단계는 두 단계뿐입니다.

데이터 수집
결과 분석

수집

데이터 수집 방식에는 자동과 수동 두 가지가 있으며 각각 장단점이 있습니다. 이에 앞서 메모리와 CPU 소모를 시뮬레이션하는 간단한 함수를 작성하겠습니다.

func Do() {
  for i := 0; i < 10; i++ {
    slice := makeSlice()
    sortSlice(slice)
  }
}

func makeSlice() []int {
  var s []int
  for range 1 << 24 {
    s = append(s, rand.Int())
  }
  return s
}

func sortSlice(s []int) {
  slices.Sort(s)
}

수동

수동 수집은 코드로 제어하는 방식으로, 장점은 제어 가능하고 유연하며 사용자 정의가 가능하다는 점입니다. 코드에서 직접 pprof 를 사용하려면 runtime/pprof 패키지를 import 해야 합니다.

package main

import (
  "log"
  "os"
  "runtime/pprof"
)

func main() {
    Do()
  w, _ := os.Create("heap.pb")
  heapProfile := pprof.Lookup("heap")
  err := heapProfile.WriteTo(w, 0)
  if err != nil {
    log.Fatal(err)
  }
}

pprof.Lookup가 지원하는 매개변수는 아래 코드와 같습니다.

profiles.m = map[string]*Profile{
    "goroutine":    goroutineProfile,
    "threadcreate": threadcreateProfile,
    "heap":         heapProfile,
    "allocs":       allocsProfile,
    "block":        blockProfile,
    "mutex":        mutexProfile,
}

이 함수는 수집된 데이터를 지정된 파일에 기록하며, 기록 시 전달된 숫자는 다음과 같은 의미를 가집니다.

0, 압축된 Protobuf 데이터 기록, 가독성 없음
1, 텍스트 형식 데이터 기록, 읽기 가능, HTTP 인터페이스가 이 형식으로 반환합니다.
2, goroutine 만 사용 가능, panic 스타일의 스택 정보 출력

CPU 데이터 수집은 별도의 pprof.StartCPUProfile 함수를 사용해야 하며, 일정 시간 샘플링이 필요하고 원본 데이터는 읽을 수 없습니다.

package main

import (
  "log"
  "os"
  "runtime/pprof"
  "time"
)

func main() {
    Do()
  w, _ := os.Create("cpu.out")
  err := pprof.StartCPUProfile(w)
  if err != nil {
    log.Fatal(err)
  }
  time.Sleep(time.Second * 10)
  pprof.StopCPUProfile()
}

trace 데이터 수집도 마찬가지입니다.

package main

import (
  "log"
  "os"
  "runtime/trace"
  "time"
)

func main() {
    Do()
  w, _ := os.Create("trace.out")
  err := trace.Start(w)
  if err != nil {
    log.Fatal(err)
  }
  time.Sleep(time.Second * 10)
  trace.Stop()
}

자동

net/http/pprof 패키지는 위의 분석 함수를 HTTP 인터페이스로 래핑하여 기본 라우트에 등록합니다.

package pprof

import ...

func init() {
    http.HandleFunc("/debug/pprof/", Index)
    http.HandleFunc("/debug/pprof/cmdline", Cmdline)
    http.HandleFunc("/debug/pprof/profile", Profile)
    http.HandleFunc("/debug/pprof/symbol", Symbol)
    http.HandleFunc("/debug/pprof/trace", Trace)
}

이를 통해 한 번의 실행으로 pprof 데이터 수집을 할 수 있습니다.

package main

import (
  "net/http"
    // 반드시 이 패키지를 import 해야 합니다.
  _ "net/http/pprof"
)

func main() {
    go func(){
        http.ListenAndServe(":8080", nil)
    }
    for {
        Do()
    }
}

이제 브라우저에서 http://127.0.0.1:8080/debug/pprof에 접속하면 다음과 같은 페이지가 나타납니다.

페이지에는 몇 가지 선택 가능한 옵션이 있으며, 각각은 다음을 의미합니다.

allocs: 메모리 할당 샘플링
block: 동기화 프리미티브의 블로킹 추적
cmdline: 현재 프로그램의 명령줄 호출
goroutine: 모든 고루틴 추적
heap: 활성 객체의 메모리 할당 샘플링
mutex: 뮤텍스 관련 정보 추적
profile: CPU 분석, 일정 시간 분석 후 파일 다운로드
threadcreate: 새 OS 스레드 생성 원인 분석
trace: 현재 프로그램 실행 상황 추적, 파일 다운로드

여기서의 데이터는 대부분 가독성이 높지 않으며 주로 도구 분석용으로 사용됩니다.

구체적인 분석 작업은 뒤에서 진행합니다. profile 과 trace 두 옵션을 제외하고 웹에서 데이터 파일을 다운로드하려면 query 파라미터 debug=1 을 제거하면 됩니다. 또한 기본 라우트 대신 자체 라우트에 이러한 인터페이스를 통합할 수도 있습니다.

package main

import (
  "net/http"
  "net/http/pprof"
)

func main() {
  mux := http.NewServeMux()
  mux.HandleFunc("/trace", pprof.Trace)
  servre := &http.Server{
    Addr:    ":8080",
    Handler: mux,
  }
  servre.ListenAndServe()
}

이렇게 하면 gin, iris 등 다른 웹 프레임워크에도 통합할 수 있습니다.

분석

수집된 데이터 파일을 얻은 후 명령줄 또는 웹 두 가지 방식으로 분석할 수 있으며, 둘 다 pprof 명령줄 도구를 사용해야 합니다. go 에 기본적으로 통합되어 있으므로 별도로 다운로드할 필요가 없습니다.

pprof 오픈소스 주소: google/pprof: pprof is a tool for visualization and analysis of profiling data (github.com)

명령줄

이전에 수집한 데이터 파일을 매개변수로 사용합니다.

bash

$ go tool pprof heap.pb

데이터가 웹에서 수집된 경우 파일 이름 대신 웹 URL 을 사용합니다.

bash

$ go tool pprof -http :8080 http://127.0.0.1/debug/pprof/heap

그러면 다음과 같은 대화형 명령줄이 나타납니다.

bash

15:27:38.3266862 +0800 CST
Type: inuse_space
Time: Apr 15, 2024 at 3:27pm (CST)
No samples were found with the default sample value type.
Try "sample_index" command to analyze different sample values.
Entering interactive mode (type "help" for commands, "o" for options)
(pprof)

help 를 입력하면 다른 명령을 확인할 수 있습니다.

  Commands:
    callgrind        Outputs a graph in callgrind format
    comments         Output all profile comments
    disasm           Output assembly listings annotated with samples
    dot              Outputs a graph in DOT format
    eog              Visualize graph through eog
    evince           Visualize graph through evince
  ...

명령줄에서 데이터를 볼 때는 일반적으로 top 명령을 사용하며 traces 명령도 사용할 수 있지만 출력이 매우 깁니다. top 명령은 간단히 대략적인 내용만 확인하는 용도입니다.

(pprof) top 5
Showing nodes accounting for 117.49MB, 100% of 117.49MB total
      flat  flat%   sum%        cum   cum%
  117.49MB   100%   100%   117.49MB   100%  main.makeSlice (inline)
         0     0%   100%   117.49MB   100%  main.Do
         0     0%   100%   117.49MB   100%  main.main
         0     0%   100%   117.49MB   100%  runtime.main

일부 지표를 간단히 소개하겠습니다 (CPU 도 동일).

flat, 현재 함수가 소비한 리소스
cum, 현재 함수 및 이후 호출 체인이 소비한 리소스 총합
flat%, flat/total
cum%, cum/total

전체 호출 스택의 메모리 점유율이 117.49MB 임을 명확히 볼 수 있습니다. Do 함수 자체는 아무것도 하지 않고 다른 함수만 호출하므로 flat 지표는 0 입니다. 슬라이스 생성은 makeSlice 함수에서 수행하므로 flat 지표는 100% 입니다.

시각화 형식으로 변환할 수 있으며 pprof 는 pdf, svg, png, gif 등 상당히 많은 형식을 지원합니다 (Graphviz 설치 필요).

(pprof) png
Generating report in profile001.png

이미지를 통해 전체 호출 스택의 메모리 상황을 더 명확하게 볼 수 있습니다.

list 명령을 사용하여 소스 코드 형태로 확인할 수 있습니다.

(pprof) list Do
Total: 117.49MB
ROUTINE ======================== main.Do in D:\WorkSpace\Code\GoLeran\golearn\example\main.go
         0   117.49MB (flat, cum)   100% of Total
         .          .     21:func Do() {
         .          .     22:   for i := 0; i < 10; i++ {
         .   117.49MB     23:           slice := makeSlice()
         .          .     24:           sortSlice(slice)
         .          .     25:   }
         .          .     26:}
         .          .     27:
         .          .     28:func makeSlice() []int {

이미지와 소스 코드의 경우 web 과 weblist 명령을 사용하여 브라우저에서 이미지와 소스 코드를 볼 수도 있습니다.

웹

앞서 데이터의 다양성을 위해 시뮬레이션 함수를 수정했습니다.

func Do1() {
  for i := 0; i < 10; i++ {
    slice := makeSlice()
    sortSlice(slice)
  }
}

func Do2() {
  for i := 0; i < 10; i++ {
    slice := makeSlice()
    sortSlice(slice)
  }
}

func makeSlice() []int {
  var s []int
  for range 1 << 12 {
    s = append(s, rand.Int())
  }
  return s
}

func sortSlice(s []int) {
  slices.Sort(s)
}

웹 분석은 결과를 시각화하여 수동으로 명령줄을 조작하는 번거로움을 덜어줍니다. 웹 분석을 사용할 때는 다음 명령만 실행하면 됩니다.

bash

$ go tool pprof -http :8080 heap.pb

데이터가 웹에서 수집된 경우 파일 이름 대신 웹 URL 을 사용합니다.

bash

$ go tool pprof -http :8080 http://127.0.0.1:9090/debug/pprof/heap
$ go tool pprof -http :8080 http://127.0.0.1:9090/debug/pprof/profile
$ go tool pprof -http :8080 http://127.0.0.1:9090/debug/pprof/goroutine

TIP

데이터 분석 방법에 대한 자세한 내용은 pprof: How to read the graph 를 참조하십시오.

웹 페이지에는 총 6 개의 확인 가능한 항목이 있습니다.

Top, 명령줄 top 과 동일
Graph, 직선 그래프
Flame Graph, 화염 그래프
Peek,
Source, 소스 코드 보기
Disassemble, 역어셈블리 보기

메모리의 경우 네 가지 차원으로 분석할 수 있습니다.

alloc_objects: 현재까지 할당된 모든 객체 수 (해제된 것 포함)
alloc_spcae: 현재까지 할당된 모든 메모리 공간 (해제된 것 포함)
inuse_objects: 사용 중인 객체 수
inuse_space: 사용 중인 메모리 공간

메모리 분석도

위 그림의 하단 흰색 리프 노드는 다양한 크기의 객체 점유율을 나타냅니다.

CPU 분석도

꺾은선 그래프에 대해 몇 가지 주의할 점이 있습니다.

색이 짙을수록 점유율이 높고, 선이 굵을수록 점유율이 높습니다.
실선은 직접 호출을, 점선은 일부 호출 체인을 생략했음을 나타냅니다.

메모리 화염도

CPU 화염도

화염도의 경우 위에서 아래로 보면 호출 체인이고, 왼쪽에서 오른쪽으로 보면 cum 점유율입니다.

trace

pprof 는 주로 프로그램의 리소스 점유율을 분석하는 반면, trace 는 프로그램의 실행 세부사항을 추적하는 데 더 적합합니다. 이는 전자와 데이터 파일이 호환되지 않으며 go tool trace 명령이 관련 분석 작업을 수행합니다.

수동으로 수집한 데이터는 파일 이름을 매개변수로 사용할 수 있습니다.

$ go tool trace trace.out

자동으로 수집한 경우도 마찬가지입니다.

bash

$ curl http://127.0.0.1:8080/debug/pprof/trace > trace.out && go tool trace trace.out

실행 후 웹 서버가 시작됩니다.

2024/04/15 17:15:40 Preparing trace for viewer...
2024/04/15 17:15:40 Splitting trace for viewer...
2024/04/15 17:15:40 Opening browser. Trace viewer is listening on http://127.0.0.1:51805

열면 페이지는 대략 다음과 같습니다.

여기에는 주로 다음 몇 가지 부분이 포함되며, 이 데이터를 이해하는 것은 쉽지 않습니다.

Event timelines for running goroutines
- trace by proc: 해당 프로세서에서 실행 중인 고루틴의 시간 표시
- trace by thread: OS 스레드에서 실행 중인 고루틴의 시간 표시
- Goroutine analysis: 각 메인 함수별 고루틴 관련 통계 정보
Profiles
- Network blocking profile: 네트워크 IO 로 인해 블로킹된 고루틴 정보
- Synchronization blocking profile: 동기화 프리미티브로 인해 블로킹된 고루틴 정보
- Syscall profile: 시스템 호출로 인해 블로킹된 고루틴 정보
User-defined tasks and regions
- User-defined tasks: 사용자 정의 작업 관련 고루틴 정보
- User-defined regions: 사용자 정의 코드 영역 관련 고루틴 정보
Garbage collection metrics
- Minimum mutator utilization: 최근 GC 의 최대 소요 시간 표시

성능 분석 ​

탈출 분석 ​

지역 포인터 참조 ​

클로저 참조 ​

공간 부족 ​

길이 미지정 ​

pprof ​

수집 ​

수동 ​

자동 ​

분석 ​

명령줄 ​

웹 ​

trace ​

성능 분석

탈출 분석

지역 포인터 참조

클로저 참조

공간 부족

길이 미지정

pprof

수집

수동

자동

분석

명령줄

웹

trace