Folly Code Review · 43/89

folly::RWSpinLock 분석

2026년 6월 6일 · Hawk · 4분 읽기

#한 줄 요약

folly::RWSpinLock은 4-byte 상태에 spin만 하는 reader-writer lock. critical section이 수십 cycle 이내면 SharedMutex의 spin-then-futex보다 빠르다. wait가 길어지면 CPU 낭비.

#동기

SharedMutex도 짧은 wait는 spin한다. 그런데 spin 후에도 lock 못 잡으면 futex로 sleep — 이때 syscall 비용이 발생. critical section이 항상 5-50 cycle 정도라면 spin만 하는 게 syscall 한 번보다 싸다.

1
critical section length  ←→  best primitive
2
  < 50 cycle            : atomic / no lock
3
  50 - 500 cycle        : RWSpinLock / SpinLock
4
  500 cycle - 100 μs    : SharedMutex / Mutex (spin then sleep)
5
  > 100 μs              : Mutex + sleep, condition variable

RWSpinLock은 두 번째 구간. fbcode에서 hot path의 작은 metric 갱신, 작은 counter 보호에 사용.

1
folly::RWSpinLock lock;
2
{
3
  folly::RWSpinLock::WriteHolder g(&lock);
4
  counter += delta;   // 1-2 instruction
5
}

#API & 사용법

1
#include <folly/synchronization/RWSpinLock.h>
2

3
folly::RWSpinLock lock;
4

5
// 1. Write
6
{
7
  folly::RWSpinLock::WriteHolder g(&lock);
8
  // exclusive
9
}
10

11
// 2. Read
12
{
13
  folly::RWSpinLock::ReadHolder g(&lock);
14
  // shared
15
}
16

17
// 3. Upgrade
18
{
19
  folly::RWSpinLock::UpgradedHolder ug(&lock);
20
  // read-like, but can promote to write
21
  folly::RWSpinLock::WriteHolder wg(std::move(ug));
22
}
23

24
// 4. try
25
if (lock.try_lock()) { /* write */ }
26
if (lock.try_lock_shared()) { /* read */ }

표준 unique_lock/shared_lock과 호환되지 않음 — 자체 Holder type만. Holder가 RAII unlock.

#내부 구현

1
// 약식 — folly/synchronization/RWSpinLock.h
2
class RWSpinLock {
3
  // state bit layout (32-bit):
4
  //   bit 0    : writer (1 bit)
5
  //   bit 1    : upgrade pending
6
  //   bit 2-31 : reader count
7
  std::atomic<int32_t> state_;
8
};

4-byte. SharedMutex와 동일 size. 차이는 contended path.

#lock (write)

1
// 약식
2
void lock() {
3
  while (true) {
4
    int32_t expected = 0;
5
    if (state_.compare_exchange_weak(expected, kWriterBit,
6
                                      std::memory_order_acquire)) {
7
      return;
8
    }
9
    do {
10
      cpu_pause();   // PAUSE instruction
11
    } while (state_.load(std::memory_order_relaxed) != 0);
12
  }
13
}

CAS spin + load spin. PAUSE instruction이 spin loop의 cache traffic을 줄임 (Intel pipeline hint).

futex 호출 없음. 영원히 spin.

#lock_shared

1
// 약식
2
void lock_shared() {
3
  while (true) {
4
    int32_t old = state_.load(std::memory_order_relaxed);
5
    if (!(old & kWriterBit) && !(old & kUpgradeBit)) {
6
      if (state_.compare_exchange_weak(old, old + kReaderIncrement,
7
                                        std::memory_order_acquire)) {
8
        return;
9
      }
10
    } else {
11
      cpu_pause();
12
    }
13
  }
14
}

writer가 있거나 upgrade가 pending이면 reader도 양보 (writer-priority 비슷).

#Unlock

1
void unlock()        { state_.fetch_and(~kWriterBit, std::memory_order_release); }
2
void unlock_shared() { state_.fetch_sub(kReaderIncrement, std::memory_order_release); }

waker 없음. 다른 thread는 spin 중이므로 알아서 본다.

#std/abseil 비교

1
// std — spin lock 없음
2
// 직접 구현: std::atomic_flag, std::atomic<int> + CAS spin
3

4
// abseil
5
absl::base_internal::SpinLock spin_mu;   // internal use
6
// public API는 추천 안 함
7

8
// folly
9
folly::SpinLock        sl;    // 단순 mutex
10
folly::RWSpinLock      rw;    // reader-writer
11
folly::PicoSpinLock<T> psl;   // 다음 글 — 1-byte

항목	std (직접)	absl::SpinLock	folly::RWSpinLock
Reader/Writer	직접 구현	exclusive only	O
Public API	없음	internal	O
Park 폴백	없음	길어지면 yield	없음
sizeof	4 byte (CAS)	16 byte	4 byte

abseil은 spin lock을 내부 전용으로 두고 외부에는 absl::Mutex만 권장. folly는 RWSpinLock을 공개 API로 제공.

#성능

1
benchmark: 8 threads, critical section = increment counter (5 cycle)
2
                              throughput / total
3
  folly::RWSpinLock           400 M ops/s
4
  folly::SpinLock             420 M
5
  folly::SharedMutex          180 M
6
  std::shared_mutex            45 M
7
  std::atomic<int> fetch_add  600 M (no lock)

spin lock이 SharedMutex 대비 2배. atomic이 더 빠르나 lock 의미가 필요한 경우는 spin lock.

critical section이 길어지면:

1
critical section = 10 μs
2
  folly::RWSpinLock          50 M (CPU 100% spin)
3
  folly::SharedMutex         48 M (sleep, CPU 70%)

비슷한 throughput에 CPU 사용 차이. RWSpinLock은 power 낭비.

#코드 리뷰 포인트

1
// Good — 매우 짧은 critical section
2
folly::RWSpinLock m;
3
{
4
  folly::RWSpinLock::WriteHolder g(&m);
5
  ++counter;
6
}
7

8
// Bad — I/O를 critical section 안에
9
folly::RWSpinLock m;
10
{
11
  folly::RWSpinLock::WriteHolder g(&m);
12
  database.Query(...);   // ms scale!
13
}
14
// 다른 thread CPU 100% 낭비

I/O, file write, 큰 lookup 같은 밀리초 scale 작업은 SharedMutex로.

1
// 주의 — multiple cores spinning이 cache line bouncing
2
folly::RWSpinLock m;
3
// thread 8개가 동시에 spinning → cache line이 cores 사이 ping-pong

contention 심하면 spin이 BUS traffic 폭발. cores 수에 비해 lock 수가 부족하면 SharedMutex로.

1
// Good — Holder를 항상 wrap
2
{
3
  folly::RWSpinLock::WriteHolder g(&lock);
4
  // ...
5
}
6
// 또는 직접
7
// lock.lock(); ... lock.unlock();   ← 절대 금지

raw lock/unlock은 exception escape 시 leak. Holder RAII만.

#안티패턴

long critical section: spinning thread가 CPU/배터리 낭비. critical section이 1 μs 넘으면 SharedMutex.
spin lock을 multi-core 100% scale에서: cache line bounce가 throughput을 죽인다. shard 또는 fine-grained lock.
lock 안에서 다른 lock 잡기: spin lock 안에서 두 번째 lock이 long wait면 첫 spin이 영원. 가능하면 lock 하나만.