Folly Code Review · 41/89

folly::SharedMutex 분석

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

#한 줄 요약

folly::SharedMutex는 std::shared_mutex와 동등한 reader-writer lock이지만 작고(4-byte) 빠르며 reader-priority/writer-priority/uncontended path 최적화를 가진다. fbcode 의 동기화 default.

#동기

std::shared_mutex는 표준이지만 다음 한계가 있다.

구현 크기 40+ byte (libstdc++/libc++).
writer starvation에 대한 policy가 implementation-defined.
uncontended 케이스가 system call까지 가는 경우가 있다.

server에서 ConcurrentHashMap의 shard마다 mutex가 박혀 있다 보면 mutex 자체의 메모리도 무시 못 한다. folly는 sizeof = 4 byte의 SharedMutex를 만들었다. 또한 reader/writer priority를 template parameter로 선택.

1
folly::SharedMutexReadPriority   m1;   // reader 우선
2
folly::SharedMutexWritePriority  m2;   // writer 우선 (default)
3
folly::SharedMutex                m3;   // alias of WritePriority

#API & 사용법

1
#include <folly/SharedMutex.h>
2

3
folly::SharedMutex mu;
4

5
// 1. write lock
6
{
7
  std::unique_lock<folly::SharedMutex> g(mu);
8
  // 쓰기
9
}
10

11
// 2. read lock
12
{
13
  std::shared_lock<folly::SharedMutex> g(mu);
14
  // 읽기
15
}
16

17
// 3. upgrade lock (folly 확장)
18
{
19
  folly::SharedMutex::UpgradeHolder uh(mu);
20
  // read access — 하지만 동시 다른 upgrade는 막힘
21
  // 필요하면 write로 승격
22
  folly::SharedMutex::WriteHolder wh(std::move(uh));
23
}
24

25
// 4. try
26
if (mu.try_lock()) {  /* exclusive */ }
27
if (mu.try_lock_shared()) {  /* shared */ }

표준 unique_lock/shared_lock과 호환. C++17 RAII가 그대로 동작.

#내부 구현

1
// 약식 — folly/SharedMutex.h
2
class SharedMutex {
3
  // 한 word (32-bit) 에 모든 상태
4
  std::atomic<uint32_t> state_;
5
  // bit layout:
6
  //   bit 0      : has writer
7
  //   bit 1      : has upgrade
8
  //   bit 2-31   : reader count
9
};

state 한 32-bit에 모든 lock 상태. 4-byte total.

#Uncontended write

1
// 약식
2
void lock() {
3
  uint32_t expected = 0;
4
  if (state_.compare_exchange_weak(expected,
5
                                    kWriterMask,
6
                                    std::memory_order_acquire)) {
7
    return;   // 성공 — 한 instruction
8
  }
9
  // 경쟁 — 느린 path
10
  slowLock();
11
}

contention 없으면 CAS 한 번으로 끝. 30-40 cycle. std::mutex는 보통 50-100 cycle.

#Uncontended read

1
void lock_shared() {
2
  uint32_t old = state_.fetch_add(kReaderIncrement, std::memory_order_acquire);
3
  if (!(old & kWriterMask)) return;   // writer 없으면 성공
4
  // writer 있음 — fetch_sub로 취소 후 wait
5
  state_.fetch_sub(kReaderIncrement);
6
  slowLockShared();
7
}

writer가 없으면 atomic add 한 번. cache line이 dirty 되긴 하지만 CAS retry는 없다.

#경쟁 시 — Park/Unpark

contended path는 futex 기반 park. spin 몇 cycle 후 sleep, writer가 unlock 시 wake. linux의 futex_wait/futex_wake, macOS/BSD의 __ulock_*.

1
// 약식
2
void slowLock() {
3
  for (int spin = 0; spin < kMaxSpins; ++spin) {
4
    if (try_lock()) return;
5
    cpu_pause();
6
  }
7
  // park
8
  while (!try_lock()) {
9
    futex_wait(&state_, current);
10
  }
11
}
12

13
void unlock() {
14
  state_.fetch_and(~kWriterMask, std::memory_order_release);
15
  if (waiters_) futex_wake_all(&state_);
16
}

spin → futex_wait의 hybrid. 짧은 critical section은 spin으로 끝, 긴 건 sleep.

#Reader vs Writer Priority

1
// 약식 — Writer priority (default)
2
void lock_shared() {
3
  uint32_t old = state_.load();
4
  while (true) {
5
    if (old & (kWriterMask | kWriterPendingMask)) {
6
      // writer가 대기 중이면 reader는 양보
7
      park();
8
      continue;
9
    }
10
    if (state_.compare_exchange_weak(old, old + kReaderIncrement)) return;
11
  }
12
}

WritePriority는 writer가 대기 중이면 새 reader를 들이지 않는다. writer starvation 방지. fbcode default.

ReadPriority는 반대로 reader를 우선. write throughput이 낮아도 reader latency가 최소.

#std/abseil 비교

1
// std
2
std::shared_mutex mu;
3
{ std::unique_lock g(mu); ... }
4

5
// abseil
6
absl::Mutex mu;
7
{ absl::MutexLock l(&mu); ... }
8
{ absl::ReaderMutexLock l(&mu); ... }
9
// 추가로 conditional critical section, debug deadlock detection
10

11
// folly
12
folly::SharedMutex mu;
13
{ std::unique_lock g(mu); ... }

항목	std::shared_mutex	absl::Mutex	folly::SharedMutex
sizeof	40+ byte	8 byte	4 byte
Uncontended cost	50-100 ns	30-50 ns	20-30 ns
Priority policy	implementation defined	고정 (writer 우선)	template parameter
Conditional CS	X	`Mutex::Await`	X
Deadlock detection	X	debug build	X

absl::Mutex는 조건 변수까지 통합된 형태. folly::SharedMutex는 pure RW lock에 집중.

#성능

1
benchmark: N reader threads + 1 writer thread, hot loop
2
                                     (N=8)
3
  std::shared_mutex                    1.2M ops/s/reader
4
  absl::Mutex (Reader)                 2.4M
5
  folly::SharedMutex (WritePriority)   3.8M
6
  folly::SharedMutex (ReadPriority)    4.2M
7
  no lock                             18.0M (baseline)

folly가 2-3배 빠름. 4-byte size + uncontended fast path 효과.

#코드 리뷰 포인트

1
// Good — Synchronized와 함께
2
folly::Synchronized<Data, folly::SharedMutex> data;
3
auto r = data.rlock();   // shared
4
auto w = data.wlock();   // exclusive
5

6
// Bad — 외부 lock 객체로 SharedMutex 직접 노출
7
folly::SharedMutex mu;
8
Data d;
9
{ std::unique_lock g(mu); d.x = 1; }
10
// 잠금 누락 위험 — Synchronized로 묶기

가능한 한 Synchronized<T, SharedMutex>로 사용. raw mutex는 lock 누락 가능성.

1
// 주의 — 매우 짧은 critical section엔 RWLock 오버킬
2
folly::SharedMutex mu;
3
{
4
  std::shared_lock g(mu);
5
  return data.size();   // 1 instruction
6
}
7
// RWSpinLock 또는 atomic이 더 빠를 수 있음

critical section이 100 cycle 이하면 spin lock 또는 atomic 직접 사용이 빠르다. SharedMutex의 가치는 contention 시 park 가능성.

#안티패턴

upgrade lock을 길게 유지: upgrade lock은 reader-blocking이 아니지만 다른 upgrade-blocking. 짧게.
사용자 코드가 state_ bit를 직접 조작: implementation detail, 절대 의존 금지.
SharedMutex_ReadPriority를 default로 선택: writer starvation 위험. fbcode 표준은 WritePriority.