덕삼
블로그

Go 강의 21편 — 느린 곳은 프로파일로 찾고, 고친 효과는 같은 벤치마크로 증명한다

느리다는 말을 숫자로 바꾸고, 고친 효과를 어떻게 증명합니까?

벤치마크로 기준 숫자(ns/op, B/op, allocs/op)를 여러 번 재고, 프로파일로 시간이 어디로 가는지 찾고, 고친 뒤 같은 벤치마크를 같은 조건에서 다시 재서 가운데값을 견줍니다. 이 편은 한국어 글 검사기를 줄인 코드에 병목 하나를 심어 두고 이 순서로 찾아 7배 빠르게 만듭니다. 도구의 숫자도 확인합니다. 이 맥의 CPU 프로파일은 맨 위에 엉뚱한 함수를 올려놓았습니다.

초시계 아래를 달리는 배달 로봇, CPU 상자에 청진기를 댄 의사 로봇, 병목 막대에 동그라미를 친 그래프

초시계가 벤치마크, 청진기가 프로파일러입니다. 막대 하나가 유난히 높으면 거기부터 고칩니다.

선수 편은 로드맵의 15·16·17편입니다. 출력은 2026-11-18 에 Apple M4 Pro(14코어), macOS, Go 1.26.2 로 다른 작업과 함께 돌린 것이라 시간은 비율로 읽습니다.

결과를 버린 벤치마크는 아무것도 재지 않는다

부작용 없는 함수 Mix 를 세 방식으로 쟀습니다. 옛 방식은 for i := 0; i < b.N; i++ 이고, Go 1.24 부터는 for b.Loop() 를 씁니다.

func BenchmarkMixOldDiscard(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Mix(uint64(i)) // 결과를 버린다
	}
}

func BenchmarkMixLoop(b *testing.B) {
	var i uint64
	for b.Loop() {
		Mix(i)
		i++
	}
}
벤치마크(-count 5 가운데값)ns/op
옛 방식, 결과 버림0.2289
옛 방식, 빈 루프0.2359
옛 방식, 전역 변수에 담음0.5527
b.Loop, 결과 버림1.687
b.Loop, 빈 루프1.630

결과를 버린 옛 방식은 빈 루프와 시간이 같았습니다. -gcflags=-m 이 inlining call to Mix 를 찍었으니, 인라인된 계산이 쓰이지 않아 지워진 것입니다. go doc testing.B.Loop 는 루프 안 호출의 인자와 결과를 runtime.KeepAlive 로 살려 둔다고 적습니다. 대신 b.Loop 는 반복마다 약 1.6ns 의 틀 비용이 붙어서, 나노초 단위 함수는 빈 루프와 함께 잽니다.

기준 숫자는 -benchmem 과 -count 로 만든다

검사기의 처음 판은 문장마다 정규식을 다시 컴파일합니다. 일부러 심은 병목입니다.

func CheckV1(text string) []Finding {
	var out []Finding
	for i, s := range sentences(text) {
		for _, r := range Rules {
			re := regexp.MustCompile(r.Pattern)
			for _, m := range re.FindAllString(s, -1) {
				out = append(out, Finding{i, m, r.Hint})
			}
		}
	}
	return out
}
$ go test -run X -bench 'CheckV1$' -benchmem -count 10 ./lint
BenchmarkCheckV1-14    	     516	   2192193 ns/op	 5436445 B/op	   57977 allocs/op
…

200문장 글 한 편에 2.2ms, 5.4MB, 할당 57,977번입니다. 한 번 잰 값은 흔들리므로 열 번 재서 가운데값을 씁니다. 비교 도구 benchstat 은 이 맥에 깔려 있지 않아서, 가운데값과 변화율만 찍는 80줄이 안 되는 benchmed 를 예제에 두었습니다.

CPU 프로파일은 맨 위부터 믿지 않는다

$ go test -run X -bench 'CheckV1$' -benchtime 6s -cpuprofile cpu-v1.out -memprofile mem-v1.out ./lint
$ go tool pprof -top -nodecount=3 cpu-v1.out
Duration: 7.63s, Total samples = 8940ms (117.18%)
      flat  flat%   sum%        cum   cum%
    3790ms 42.39% 42.39%     3790ms 42.39%  runtime.kevent
     790ms  8.84% 51.23%      790ms  8.84%  runtime.pthread_cond_wait
     720ms  8.05% 59.28%      720ms  8.05%  runtime.madvise

맨 위가 네트워크 대기용 시스템 콜 kevent 입니다. CPU 만 쓰는 벤치마크인데 말이 안 됩니다. 런타임 소스(Go 1.26.2 기준)의 runtime/signal_unix.go 는 프로세스 전체 타이머(setitimer)로 신호를 만들고, 스레드 단위 타이머를 함께 쓰는 플랫폼으로 리눅스를 적습니다. 맥(runtime/os_darwin.go)은 프로세스 타이머만 쓰고, 이 맥에서는 표본이 시스템 콜 중인 스레드로 쏠렸습니다. GOGC=off 로 돌리자 madvise 가 95% 를 가져갔습니다. 리눅스에서는 재 보지 못했습니다.

그래서 내 함수 아래만 걸러 봅니다. flat 은 그 함수 자신이 쓴 시간이고, cum 은 그 함수가 부른 함수까지 합친 시간입니다.

$ go tool pprof -top -cum -focus=lint.CheckV1 cpu-v1.out
      flat  flat%   sum%        cum   cum%
     0.01s  0.11%  0.11%      1.84s 20.58%  example.com/profiling/lint.CheckV1
         0     0%  0.11%      1.54s 17.23%  regexp.MustCompile
         0     0%  0.45%      0.86s  9.62%  regexp/syntax.Parse (inline)
$ go tool pprof -list 'lint.CheckV1' cpu-v1.out
         .      1.54s     54:			re := regexp.MustCompile(r.Pattern)
         .      270ms     55:			for _, m := range re.FindAllString(s, -1) {

출력은 줄였습니다. CheckV1 1.84초 가운데 1.54초(84%)가 54행의 컴파일입니다.

힙 프로파일은 신호 없이 할당을 센다

힙 프로파일은 할당한 바이트 수로 표본을 뽑습니다(go doc runtime.MemProfileRate: 평균 512KiB 마다 하나). 그래서 위 문제가 없습니다.

$ go tool pprof -top -sample_index=alloc_space mem-v1.out
Showing nodes accounting for 15470.51MB, 95.39% of 16218.82MB total
      flat  flat%   sum%        cum   cum%
 6848.13MB 42.22% 42.22%  6848.13MB 42.22%  regexp/syntax.(*compiler).inst (inline)
 5053.04MB 31.16% 73.38%  5053.04MB 31.16%  regexp/syntax.(*parser).newRegexp (inline)
 1183.17MB  7.30% 80.67% 15758.01MB 97.16%  regexp.compile

alloc_space 는 쌓인 할당 총량이라 GC 부담을 봅니다. 같은 파일을 inuse_space 로 보면 2.01MB 뿐이고, 누수처럼 지금 붙잡은 메모리는 이쪽으로 봅니다. 할당 총량의 97% 가 정규식 컴파일 아래여서 CPU 와 힙이 같은 곳을 가리킵니다.

고친 뒤에는 같은 벤치마크로 다시 잰다

규칙은 처음 한 번만 컴파일합니다. sync.OnceValue 는 Go 1.21 부터 있습니다.

var compiled = sync.OnceValue(func() []*regexp.Regexp {
	res := make([]*regexp.Regexp, len(Rules))
	for i, r := range Rules {
		res[i] = regexp.MustCompile(r.Pattern)
	}
	return res
})

-count 10 으로 재고 benchmed 로 가운데값을 뽑았습니다.

열 번 잰 값처음 판고친 판비율
ns/op 가운데값2,105,717301,6877.0배
B/op약 5,438,000약 67,90080배
allocs/op57,977367158배

두 판의 결과가 같은지는 TestCheckMatchesV1 이 확인합니다. 고친 판을 다시 프로파일하면 Check 가 전체 표본의 82.78% 이고, 그 안의 regexp.(*Regexp).FindAllString 이 79.77% 입니다. 다음 병목은 정규식 실행입니다. 할당이 줄자 kevent 쏠림도 10.90% 로 줄었습니다.

잠금 경합은 뮤텍스·블록 프로파일이 따로 보여 준다

잠금 하나로 맵을 지키는 카운터를 b.RunParallel 로 두드렸습니다.

$ go test -run X -bench Counter -benchtime 2s -mutexprofile mutex.out -blockprofile block.out ./contend
$ go tool pprof -top mutex.out
    17.58s 64.95% 64.95%     20.85s 77.03%  sync.(*Mutex).Unlock (inline)
$ go tool pprof -top block.out
    16.81s 76.84% 76.84%     16.81s 76.84%  sync.(*Mutex).Lock (inline)

출력은 맨 윗줄만 남겼습니다. go doc runtime/pprof.Profile 에 따르면 뮤텍스 프로파일은 잠금을 쥔 쪽의 Unlock 에, 블록 프로파일은 기다린 쪽이 막힌 곳에 시간을 적습니다. 고칠 곳은 뮤텍스 프로파일이 가리킵니다.

운영 서버의 pprof 는 루프백 전용 리스너에 연다

net/http/pprof 는 import 하기만 해도 init 에서 http.DefaultServeMux 에 /debug/pprof/ 를 등록합니다(소스 net/http/pprof/pprof.go). 공개 API 는 자기 ServeMux 를 쓰고, pprof 는 -debug 플래그 주소(기본 127.0.0.1:6060)에 따로 엽니다.

debug := http.NewServeMux()
debug.HandleFunc("/debug/pprof/", pprof.Index)
debug.HandleFunc("/debug/pprof/profile", pprof.Profile)
// … symbol, trace 핸들러도 같은 식으로 붙인다
go func() {
	srv := &http.Server{Addr: *debugAddr, Handler: debug, ReadHeaderTimeout: 5 * time.Second}
	log.Println(srv.ListenAndServe())
}()
$ ./pprof-expose.sh
공개 주소 /debug/pprof/: 404
디버그 주소 /debug/pprof/: 200
-default-mux 로 띄운 공개 주소 /debug/pprof/: 200
공개 주소 /debug/pprof/cmdline: ./server -addr 127.0.0.1:18531 -debug 127.0.0.1:18532 -default-mux

DefaultServeMux 로 공개하면 남이 CPU 프로파일을 뜨고 실행 인자까지 읽습니다. 부하를 주는 동안 디버그 주소에서 3초를 떴습니다.

$ go tool pprof -top 'http://127.0.0.1:18522/debug/pprof/profile?seconds=3'
Fetching profile over HTTP from http://127.0.0.1:18522/debug/pprof/profile?seconds=3
Saved profile in …/pprof.server.samples.cpu.001.pb.gz

받은 파일은 PPROF_TMPDIR(기본 $HOME/pprof)에 남습니다. 이 서버 프로파일도 맨 위는 runtime.usleep 이었고, -focus=CheckV1 로 거르니 7.82% 였습니다.

실행 추적은 기다린 시간을 보여 준다

CPU 프로파일은 도는 시간만 셉니다. 차례를 기다린 시간은 실행 추적(trace)에 있고, 웹 화면 대신 go tool trace -pprof 로 표를 뽑았습니다.

$ go test -run CheckAllMatchesSerial -trace trace.out ./lint
$ go tool trace -pprof=sched trace.out > sched.pprof
$ go tool pprof -top sched.pprof
Type: delay
   41.64ms 30.82% 30.82%    41.82ms 30.95%  runtime.chansend1

출력은 줄였습니다. go tool trace -h 는 sched 를 스케줄러 지연(scheduler latency) 프로파일로 설명합니다. 실행할 준비가 됐는데 돌지 못한 시간이고, 이 실행에서는 runtime.chansend1 스택이 가장 컸습니다.

PGO 의 효과는 이 예제에서 잡음 안이었다

프로파일 기반 최적화(PGO)는 잰 CPU 프로파일을 컴파일러에 줍니다. -pgo 기본값 auto 는 main 패키지 폴더의 default.pgo 를 씁니다(go help build). 여기서는 고친 판의 프로파일을 직접 줬습니다.

$ go build -pgo=off -gcflags='all=-m' ./lint 2>&1 | grep -c "inlining call"
14640
$ go build -pgo=check.pgo -gcflags='all=-m' ./lint 2>&1 | grep -c "inlining call"
14755

regexp 의 (*Regexp).doExecute·allMatches 같은 뜨거운 호출이 새로 인라인됐습니다. 그러나 벤치마크를 열 번씩 세 쌍 재니 -6.0%, -1.4%, +0.7% 였습니다. 같은 기계의 다른 부하가 만든 흔들림보다 크다고 말할 수 없습니다.

한 단계 더 — 프로파일러가 재는 방식과 측정 함정

runtime/pprof/pprof.go 의 StartCPUProfile 주석은 표본 주기를 100Hz 로 고정한 이유로, 운영체제가 약 500Hz 넘게 신호를 주지 못하고 표본마다 스택을 읽는 비용이 든다는 점을 듭니다. CPU 하나가 3초 내내 돌아도 표본은 약 300개라, 짧은 프로파일의 몇 퍼센트 차이는 읽지 않습니다.

함정이 편에서 본 것대처
결과를 버린 루프빈 루프와 같은 0.23nsb.Loop, 빈 루프와 함께 잰다
프로파일러 자체의 부담뮤텍스 프로파일을 켜자 121.5 → 202.3ns/op(한 번 잰 값)시간 비교와 프로파일을 따로 돌린다
맥 CPU 프로파일 쏠림맨 위가 kevent·madvise-focus·-cum, 힙 프로파일로 교차 확인

면접에서 이렇게 묻는다

Q1. 벤치마크가 0.2ns/op 처럼 비현실적으로 빠르게 나왔습니다. 무엇을 의심합니까? 결과를 버린 계산이 인라인된 뒤 지워진 경우입니다. 빈 루프와 같은 시간이면 확정입니다. b.Loop 를 쓰거나 결과를 바깥 변수에 담고, -gcflags=-m 으로 인라인 여부를 봅니다.

Q2. pprof 의 flat 과 cum 은 어떻게 다릅니까? flat 은 그 함수 자신의 시간, cum 은 부른 함수까지 합친 시간입니다. 이 편의 CheckV1 은 flat 0.01초, cum 1.84초였습니다. cum 이 큰 함수를 -list 로 열어 시간이 몰린 줄을 찾습니다.

Q3. 힙 프로파일의 alloc_space 와 inuse_space 는 언제 봅니까? alloc_space 는 누적 할당량이라 GC 부담과 할당이 몰린 곳을 찾습니다. inuse_space 는 지금 살아 있는 메모리라 누수를 찾습니다.

Q4. 운영 서버에 pprof 를 켜도 됩니까? 루프백이나 내부망 전용 리스너에만 엽니다. net/http/pprof 는 import 만으로 DefaultServeMux 에 붙어서, 공개 서버가 그 mux 를 쓰면 남이 프로파일과 실행 인자를 가져갑니다. 뮤텍스 프로파일은 이 편의 벤치마크를 121.5 에서 202.3ns/op 로 늦췄으니 상시로 켜 두지 않습니다.

연습

연습 1 — 잠금을 나눠 경합 줄이기

Counter 를 키 해시로 64칸으로 나눠 칸마다 잠그도록 바꾸고, 벤치마크와 뮤텍스 프로파일로 효과를 증명합니다.

풀이
func (s *Sharded) Add(key string) {
	p := &s.parts[maphash.String(s.seed, key)%shards]
	p.mu.Lock()
	p.m[key]++
	p.mu.Unlock()
}

-count 5 가운데값은 잠금 하나가 121.5ns/op, 64칸이 41.33ns/op 였습니다. 뮤텍스 프로파일의 경합 합계는 잠금 하나가 연산 약 1,202만 번에 28.92초, 64칸이 약 5,749만 번에 4.54초로, 연산 하나당 약 30분의 1입니다. 여러 고루틴이 더한 합계가 맞는지는 -race 로 돌린 TestShardedCountsEveryAdd 가 봅니다.

연습 2 — 느린 한 번만 실행 추적으로 남기기

처리가 10ms 를 넘긴 순간의 직전 실행 추적만 파일로 남깁니다.

풀이

Go 1.25 의 runtime/trace.FlightRecorder 는 최근 기록을 메모리에 돌려 담다가 WriteTo 때 씁니다.

fr := trace.NewFlightRecorder(trace.FlightRecorderConfig{MinAge: 2 * time.Second, MaxBytes: 4 << 20})
if err := fr.Start(); err != nil {
	fmt.Fprintln(os.Stderr, err)
	os.Exit(1)
}
defer fr.Stop()
// … 처리마다 시간을 재다가 10ms 를 넘기면
n, err := fr.WriteTo(f)
$ go run ./cmd/flight
150번째 처리 25ms, 직전 기록 165929바이트를 slow.trace 에 썼다

긴 글 한 편만 기록됐고(세 번 돌려 2225ms·164166KB), 파일은 go tool trace 로 읽혔습니다.

정리

느리다는 말은 벤치마크로 숫자가 되고, 프로파일로 위치가 되고, 같은 조건의 재측정으로 증명이 됩니다. 이 편의 병목은 문장마다 하던 정규식 컴파일이었고, 한 번만 하자 7.0배 빨라졌습니다. 다음에 재실 때는 도구의 숫자도 다른 도구로 교차 확인합니다.

3단계는 여기까지입니다. 로드맵의 22편부터는 면접·설계 단계로, 코드 리뷰에서 걸리는 Go 관용구를 다룹니다.