Go 카운터 벤치마크: Mutex, Atomic, 패딩을 비교해봤다
공유 카운터와 고루틴별 카운터를 Go로 구현해 Mutex, Atomic, 패딩의 연산 시간을 비교했습니다. 측정값과 캐시 경합을 함께 살펴봅니다.

얼마 전 Jon Gjengset의 동시성과 동기화 비용에 관한 강연 영상을 봤습니다.
영상에서는 Mutex 경합과 캐시 일관성, False Sharing, 패딩을 다룹니다.
락을 없애도 같은 캐시 라인을 쓰면 경합이 남는다는 설명이 궁금했습니다. Go에서 공유 카운터와 고루틴별 카운터를 만들고, 패딩을 넣기 전후의 연산 시간을 측정해봤습니다.
같은 Mutex를 여러 고루틴이 기다리면
공유 카운터를 여러 고루틴이 안전하게 증가시켜야 할 때 가장 먼저 떠올리는 코드는 Mutex입니다.
var mu sync.Mutex
var counter uint64
mu.Lock()
counter++
mu.Unlock()
단일 고루틴(Uncontended) 환경에서 이 코드를 돌려보면 생각보다 꽤 빠릅니다. 경쟁하는 고루틴이 없으면 Go의 Mutex는 빠른 경로(fast path)를 통해 원자적 연산 한두 번으로 락을 바로 획득하고 풀기 때문입니다.
여러 고루틴이 같은 Mutex를 획득하려 하면 경합(Contended)이 생깁니다.
고루틴 A: Lock 획득 ──────── 작업 ──────── Unlock
고루틴 B: Lock 대기 (Spinning / Park) ───────→ 깨어남(Wake) → 작업
고루틴 C: Lock 대기 (Spinning / Park) ──────────────────────────→ 깨어남 → 작업
경쟁이 발생하면 단순히 함수를 호출하는 시간을 넘어 다음과 같은 런타임 동작이 일어납니다.
- Spinning vs Waiting: 락을 쥔 고루틴이 금방 끝날 것 같으면 잠시 CPU 루프를 돌며 대기(Spinning)하지만, 길어지면 고루틴을 대기 상태로 전환합니다.
- 고루틴 Park: 대기 상태로 들어간 고루틴은 런타임 스케줄러에 의해 실행 큐에서 제외(
park)되어 잠듭니다. CPU 자원을 낭비하지 않기 위해서입니다. - 스케줄러 오버헤드: 락을 쥐고 있던 고루틴이
Unlock()을 호출하면, 잠자고 있던 고루틴을 다시 깨워 실행 가능한 상태(ready/unpark)로 만들고 CPU에 올리는 스케줄링 비용이 들어갑니다.
경합이 생기면 락 연산 외에 대기 중인 고루틴을 재우고 깨우는 비용도 들 수 있습니다. 아래 벤치마크는 전체 연산 시간을 비교하며, 스케줄러 비용만 따로 측정하지는 않습니다.
Atomic에도 캐시 경합이 남는다
같은 카운터를 atomic.Uint64로 바꿔봤습니다. 락 대기는 없지만 여러 코어가 같은 메모리를 수정한다는 조건은 그대로입니다.
var counter atomic.Uint64
counter.Add(1)
atomic.Add는 CPU 수준의 원자적 명령어를 사용해 Read-Modify-Write 과정을 깨지지 않게 처리합니다. 이 연산 자체가 Mutex처럼 고루틴을 대기 큐에 넣지는 않습니다. 실제 비용은 경합 정도와 하드웨어에 따라 달라집니다.
하지만 여러 코어가 동시에 같은 atomic 변수를 수정하도록 벤치마크를 돌려보면, 코어 수를 늘려도 기대만큼 성능이 선형적으로 늘어나지 않습니다.
그 이유는 하드웨어 수준의 캐시 일관성(Cache Coherence) 에 있습니다.
같은 메모리 주소 (counter)
│
┌────────────┴────────────┐
▼ ▼
Core 0의 L1/L2 Core 1의 L1/L2
│ │
[ counter: 10 ] [ counter: 10 ]
각 CPU 코어는 독립된 L1/L2 캐시를 가지고 있습니다. Core 0이 counter 값을 11로 수정하면, Core 1이 가진 캐시의 복사본은 낡은 값(stale data)이 됩니다.
하드웨어는 데이터 일관성을 유지하기 위해 캐시 일관성 프로토콜(예: MESI)을 동작시킵니다. Core 0이 해당 메모리에 쓰기를 하려면 다른 코어들의 캐시를 무효화(Invalidate)하고 해당 캐시 라인의 쓰기 소유권(Ownership) 을 가져와야 합니다.
캐시 일관성을 설명할 때는 변수 크기와 캐시 라인 크기를 구분해야 합니다.
캐시 일관성은 8바이트 변수 하나가 아니라 캐시 라인 단위로 관리됩니다. 아래 그림에서는 설명을 위해 캐시 라인 크기를 64바이트로 가정했습니다.
Core 0과 Core 1이 동시에 같은 카운터를 계속 수정하면, 64바이트 캐시 라인의 소유권이 코어 사이를 탁구공처럼 쉴 새 없이 오가게 됩니다.
Core 0: "내가 쓸게" → Cache line 소유권 획득 (Core 1 캐시 Invalidate)
Core 1: "나도 쓸게" → Core 1로 소유권 강제 이동 (Core 0 캐시 Invalidate)
Core 0: "다시 내가 쓸게" → Core 0으로 소유권 강제 이동 ...
이것이 바로 Cache Line Bouncing (또는 Ping-Pong) 입니다.
- Mutex: 런타임/스케줄러 레벨의 Lock Contention + 캐시 라인 이동 비용.
- Atomic: 런타임 스케줄링 비용은 지웠지만, 같은 메모리 위치를 두고 벌어지는 하드웨어 레벨의 Cache Contention(True Sharing) 은 그대로 남아 있습니다.
카운터를 나눠도 느린 경우: False Sharing
다음에는 고루틴마다 카운터를 하나씩 줬습니다. 각 Worker는 자기 인덱스의 값만 증가시킵니다.
type compactCounter struct {
value atomic.Uint64
}
counters := make([]compactCounter, workers)
// 각 고루틴(id)은 오직 자기 카운터만 수정
counters[id].value.Add(1)
논리적으로 보면 고루틴끼리 공유하는 변수는 전혀 없습니다. 고루틴 0은 counters[0]만, 고루틴 1은 counters[1]만 건드립니다.
그런데 실제로 벤치마크를 돌려보니 코어 수를 늘려도 성능이 거의 오르지 않았습니다. 변수를 쪼갰는데 왜 여전히 느릴까요?
서로 다른 변수가 같은 캐시 라인에 놓이면 False Sharing이 생길 수 있습니다. 아래는 64바이트 캐시 라인을 가정한 배치입니다.
하나의 64-byte Cache Line
┌──────────────┬──────────────┬──────────────┬──────────────┬─────────────┐
│ counters[0] │ counters[1] │ counters[2] │ counters[3] │ ... │
│ (8 bytes) │ (8 bytes) │ (8 bytes) │ (8 bytes) │ │
└──────────────┴──────────────┴──────────────┴──────────────┴─────────────┘
▲ ▲
Core 0이 쓰기 Core 1이 쓰기 ───▶ 하드웨어 입장에서는 같은 Cache Line!
uint64는 8바이트입니다. 슬라이스로 연속된 메모리에 구조체를 배치하면, 64바이트 캐시 라인 하나에 최대 8개의 카운터가 함께 묶여 들어갑니다.
- 프로그래머 입장: "우리는 서로 다른 변수를 쓰고 있어."
- CPU 하드웨어 입장: "같은 64바이트 덩어리를 서로 수정하고 있으니 캐시 라인 소유권을 뺏어와야겠군!"
코드에서는 다른 변수여도 캐시 라인을 공유할 수 있습니다. 그래서 카운터를 나누는 것에 더해 메모리 배치도 바꿔보기로 했습니다.
카운터 사이에 패딩 넣기
카운터 뒤에 빈 공간을 넣어 인접한 값 사이의 거리를 늘렸습니다. 이 예제에서는 구조체 크기를 64바이트로 맞췄습니다.
const cacheLineSize = 64
type paddedCounter struct {
value atomic.Uint64
_ [cacheLineSize - 8]byte // 56바이트 패딩을 넣어 구조체 크기를 64바이트로 맞춤
}
슬라이스의 각 값은 64바이트 간격으로 놓입니다. 아래 그림은 64바이트 캐시 라인에 정렬된 경우를 단순화한 것입니다. 실제 캐시 라인 크기와 메모리 정렬에 따라 배치는 달라질 수 있습니다.
Cache Line 0 (64 bytes): [ counters[0] (8B) | Padding (56B) ] ──▶ Core 0 전용
Cache Line 1 (64 bytes): [ counters[1] (8B) | Padding (56B) ] ──▶ Core 1 전용
값이 서로 다른 캐시 라인에 놓이면 한 카운터에 쓸 때 다른 카운터의 캐시 라인을 무효화하지 않아도 됩니다.
측정에서는 Padded 버전의 연산당 시간이 Worker 수를 늘릴수록 줄었습니다. 다만 코드에 넣은 64바이트 패딩이 모든 CPU에서 같은 결과를 내는 것은 아닙니다.
벤치마크 코드와 측정 결과
영상에서 다룬 개념들을 단계별로 검증하기 위해 작성한 단일 벤치마크 파일입니다. 외부 패키지 없이 Go 표준 라이브러리만으로 동작합니다.
// mutex_benchmark_test.go
package mutexbench
import (
"runtime"
"sync"
"sync/atomic"
"testing"
)
const cacheLineSize = 64
var benchmarkSink uint64
type compactCounter struct {
value atomic.Uint64
}
type paddedCounter struct {
value atomic.Uint64
_ [cacheLineSize - 8]byte
}
func benchmarkWorkers() int {
workers := runtime.GOMAXPROCS(0)
if workers < 2 {
return 2
}
return workers
}
// 모든 worker가 준비된 후 동시에 시작하도록 제어
func runWorkers(b *testing.B, workers int, worker func(id, operations int)) {
b.Helper()
base := b.N / workers
remainder := b.N % workers
var wg sync.WaitGroup
start := make(chan struct{})
wg.Add(workers)
for id := 0; id < workers; id++ {
operations := base
if id < remainder {
operations++
}
go func(id, operations int) {
defer wg.Done()
<-start
worker(id, operations)
}(id, operations)
}
b.ResetTimer()
close(start)
wg.Wait()
b.StopTimer()
}
// 1. 단일 고루틴 Mutex (Uncontended 기준선)
func BenchmarkMutexUncontended(b *testing.B) {
var mu sync.Mutex
var counter uint64
b.ResetTimer()
for i := 0; i < b.N; i++ {
mu.Lock()
counter++
mu.Unlock()
}
b.StopTimer()
benchmarkSink = counter
}
// 2. 다중 고루틴 Contended Mutex (스케줄러 대기/스위칭 오버헤드 확인)
func BenchmarkMutexContended(b *testing.B) {
var mu sync.Mutex
var counter uint64
workers := benchmarkWorkers()
runWorkers(b, workers, func(_, operations int) {
for i := 0; i < operations; i++ {
mu.Lock()
counter++
mu.Unlock()
}
})
benchmarkSink = counter
}
// 3. 단일 고루틴 Atomic (Atomic 기준선)
func BenchmarkAtomicUncontended(b *testing.B) {
var counter atomic.Uint64
b.ResetTimer()
for i := 0; i < b.N; i++ {
counter.Add(1)
}
b.StopTimer()
benchmarkSink = counter.Load()
}
// 4. 다중 고루틴 단일 Atomic 공유 (True Sharing & Cache line bouncing)
func BenchmarkAtomicShared(b *testing.B) {
var counter atomic.Uint64
workers := benchmarkWorkers()
runWorkers(b, workers, func(_, operations int) {
for i := 0; i < operations; i++ {
counter.Add(1)
}
})
benchmarkSink = counter.Load()
}
// 5. Worker별 분리했으나 같은 캐시 라인에 인접 (False Sharing 관찰)
func BenchmarkAtomicPerWorkerFalseSharing(b *testing.B) {
workers := benchmarkWorkers()
counters := make([]compactCounter, workers)
runWorkers(b, workers, func(id, operations int) {
for i := 0; i < operations; i++ {
counters[id].value.Add(1)
}
})
var total uint64
for i := range counters {
total += counters[i].value.Load()
}
benchmarkSink = total
}
// 6. Worker별 분리 + 64바이트 패딩 적용 (완전 독립 캐시 라인)
func BenchmarkAtomicPerWorkerPadded(b *testing.B) {
workers := benchmarkWorkers()
counters := make([]paddedCounter, workers)
runWorkers(b, workers, func(id, operations int) {
for i := 0; i < operations; i++ {
counters[id].value.Add(1)
}
})
var total uint64
for i := range counters {
total += counters[i].value.Load()
}
benchmarkSink = total
}
아래 명령어로 GOMAXPROCS를 1, 2, 4, 8로 바꾸며 측정했습니다. Worker 수는 코드의 benchmarkWorkers()에서 이 값에 맞춥니다.
go test -run '^$' -bench . -benchmem -cpu 1,2,4,8 -benchtime=1s
goos: darwin
goarch: arm64
cpu: Apple M1
BenchmarkMutexUncontended 25678597 42.81 ns/op 0 B/op 0 allocs/op
BenchmarkMutexUncontended-2 34123828 39.71 ns/op 0 B/op 0 allocs/op
BenchmarkMutexUncontended-4 33129189 44.75 ns/op 0 B/op 0 allocs/op
BenchmarkMutexUncontended-8 20302449 56.94 ns/op 0 B/op 0 allocs/op
BenchmarkMutexContended 48201966 57.57 ns/op 0 B/op 0 allocs/op
BenchmarkMutexContended-2 17562024 71.57 ns/op 0 B/op 0 allocs/op
BenchmarkMutexContended-4 13547197 84.30 ns/op 0 B/op 0 allocs/op
BenchmarkMutexContended-8 13032274 103.50 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicUncontended 53713500 27.57 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicUncontended-2 75818004 27.49 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicUncontended-4 72694228 25.96 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicUncontended-8 47006671 23.82 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicShared 50803596 26.47 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicShared-2 42895312 38.59 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicShared-4 39331423 35.43 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicShared-8 40400395 35.30 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicPerWorkerFalseSharing 60451240 30.78 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicPerWorkerFalseSharing-2 59208940 28.59 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicPerWorkerFalseSharing-4 32549728 31.06 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicPerWorkerFalseSharing-8 34775804 31.45 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicPerWorkerPadded 28126098 45.68 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicPerWorkerPadded-2 100000000 35.69 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicPerWorkerPadded-4 38509623 27.91 ns/op 0 B/op 0 allocs/op
BenchmarkAtomicPerWorkerPadded-8 214378833 7.27 ns/op 0 B/op 0 allocs/op
PASS
측정 환경은 Apple M1입니다. Go의 ARM64 캐시 패딩 구현은 M1의 캐시 라인을 128바이트로 설명합니다. 따라서 이 코드의 64바이트 간격만으로 모든 카운터가 독립된 캐시 라인에 놓인다고 볼 수는 없습니다. 아래 수치는 코드 그대로 실행한 결과이며, 128바이트 패딩과 비교한 결과는 포함하지 않았습니다.
이번 실행에서는 다음 차이가 보였습니다. -cpu 값은 GOMAXPROCS를 바꾸며, 측정값에는 작업 분배와 런타임의 비용도 포함됩니다.
- Mutex 경합:
MutexContended는-cpu 1에서57.57ns,-cpu 8에서103.50ns였습니다. 같은 벤치마크에서 병렬 실행 수를 늘렸을 때 연산당 시간이 늘었습니다. - AtomicShared의 한계 (True Sharing):
AtomicShared는-cpu 1에서26.47ns,-cpu 2에서38.59ns였습니다. 병렬 실행 수를 늘려도 하나의 카운터에 쓰기가 모이므로 처리량이 함께 늘지는 않았습니다. - 인접한 카운터:
FalseSharing은-cpu 1에서30.78ns,-cpu 8에서31.45ns였습니다. 값은 나눴지만 연산당 시간은 거의 줄지 않았습니다. 실제 캐시 무효화 횟수를 따로 측정한 것은 아니므로, 이 값만으로 원인별 비용을 나눌 수는 없습니다. - 패딩 적용 전후:
Padded는-cpu 1에서45.68ns,-cpu 8에서7.27ns였습니다. 병렬 실행 수를 늘렸을 때는 패딩 없는 버전보다 빨랐지만,-cpu 1에서는 오히려 느렸습니다. 이 결과만으로 캐시 경합이 모두 사라졌다고 단정할 수는 없습니다.
카운터를 어디에 둘지도 봐야 했다
이번 측정에서는 같은 Mutex를 기다리는 비용뿐 아니라, Atomic 카운터의 배치에 따른 차이도 보였습니다. 특히 고루틴별 카운터에 패딩을 넣은 버전은 병렬 실행 수를 늘렸을 때 연산당 시간이 줄었습니다.
다만 공유 카운터와 고루틴별 카운터는 사용 방법도 다릅니다. 각각의 값을 모아 읽는 비용이나 실시간 합계가 필요한 조건까지 이번 측정에 포함한 것은 아닙니다. 복잡한 상태를 함께 갱신해야 한다면 Mutex가 필요할 수도 있습니다.
카운터가 병목이라면 락을 바꾸기 전에 공유 범위와 쓰기 빈도를 확인하고, 값을 나눈 뒤에는 메모리 배치도 살펴봐야겠다고 느꼈습니다. 여기 나온 수치는 한 번의 실행 결과이므로 다른 환경에서는 반복 측정해 비교할 필요가 있습니다.