folly::MicroSpinLock — 가장 좁은 spin lock

한 줄 요약: MicroSpinLock은 1-byte spin lock이다. 절대 sleep 하지 않고 CPU를 점유하며 대기한다. critical section이 수십 nanosecond 수준일 때 가장 빠르다.

#동기

std::mutex와 MicroLock은 contention 시 futex로 sleep한다. sleep의 cost는 context switch — 보통 수 μs. critical section이 수십 ns면 sleep이 훨씬 더 비싸다.

1
시나리오: 10ns critical section, 가끔 contention
2

3
std::mutex contended  : 1000ns (futex syscall + wake)
4
MicroSpinLock contended : 50ns (CPU spin ~ critical section 길이)

CPU를 잠깐 태우는 게 sleep보다 싸다는 결정. 단 critical section이 길면 spin 비용이 누적돼 context switch보다 비싸진다 — trade-off가 critical section 길이에 결정적.

#API

1
#include <folly/SpinLock.h>
2

3
folly::MicroSpinLock m{};   // 명시적으로 {} (POD-aggregate init)
4
m.lock();
5
// critical section
6
m.unlock();
7

8
// RAII
9
{
10
  std::lock_guard lk(m);
11
  // ...
12
}

MicroLock과 같은 표면. 차이는 contention 시 동작.

#init

1
folly::MicroSpinLock m;
2
m.init();              // 명시적 init — 일부 컴파일러에서 zero-init 보장 위해

또는 zero-init 영역(static, calloc)에 두면 자동으로 unlocked.

#내부 구현

1
// folly/SpinLock.h 약식
2
class MicroSpinLock {
3
 public:
4
  void lock() noexcept {
5
    while (!try_lock()) {
6
      asm_volatile_pause();   // PAUSE / YIELD
7
    }
8
  }
9

10
  bool try_lock() noexcept {
11
    return __atomic_test_and_set(&lock_, __ATOMIC_ACQUIRE) == 0;
12
  }
13

14
  void unlock() noexcept {
15
    __atomic_clear(&lock_, __ATOMIC_RELEASE);
16
  }
17

18
 private:
19
  uint8_t lock_;
20
};

#acquire / release가 보장하는 것

lock의 try-set은 ACQUIRE, clear는 RELEASE다. 이 조합이 mutex의 의미를 만든다.

unlock 이전의 CS 안 쓰기들이 다음에 lock을 잡는 스레드의 읽기에 visible해진다. spin-lock도 결국 release/acquire pair로 데이터 visibility를 보장하는 도구다.

핵심은 셋.

1. test_and_set — atomic 1-bit set. acquire fence.
2. PAUSE 명령 — x86의 pause, ARM의 yield. spin loop hint로 CPU power 절감, hyperthread 양보.
3. clear with release — release fence.

1
spin loop:
2
  PAUSE          ; CPU에게 spin 중임을 알림
3
  TEST_AND_SET   ; atomic
4
  JZ done        ; 0이면 (이전 unlocked) 잠금 성공
5
  JMP spin loop
6
done:

PAUSE는 1-15 cycle. CPU에 짧은 backoff를 알린다. memory ordering buffer를 비워 cache line 경합을 줄인다. PAUSE 없는 spin은 심각하게 성능을 깎는다.

#언제 spin이 옳은가

짧고 자주, contention 적음 → spin이 이긴다.

#안전 사용 — preemption

spin 도중 OS가 lock holder를 preempt하면 spinner는 그 quantum 내내 헛 spin한다. preemption-aware 시스템 (RT scheduler, sched_setscheduler)에서는 lock holder의 priority를 spinner와 동등 이상으로 두는 게 안전.

userland에서 일반적으로는 두 가지 가이드.

1. critical section 안에 절대 syscall/blocking I/O 두지 않음.
2. critical section은 가능한 한 짧게 — assignment, increment, 짧은 list 조작.

#std::atomic_flag와의 비교

1
std::atomic_flag flag = ATOMIC_FLAG_INIT;
2

3
void lock() {
4
  while (flag.test_and_set(std::memory_order_acquire)) {
5
    // PAUSE? — 직접 짜야 함
6
  }
7
}
8
void unlock() { flag.clear(std::memory_order_release); }

std::atomic_flag + spin loop가 가능하지만 PAUSE/yield hint, RAII guard, 사용자 6-bit 같은 편의가 없다. MicroSpinLock이 그 boilerplate를 묶은 형태.

#실전 — 매우 짧은 critical section

1
struct Counter {
2
  folly::MicroSpinLock lock;
3
  uint64_t             value;
4
};
5

6
void Increment(Counter& c) {
7
  std::lock_guard lk(c.lock);
8
  ++c.value;   // 1 instruction
9
}

std::atomic<uint64_t> value + fetch_add 가 더 깔끔. spin lock이 진가를 보이는 건 critical section이 atomic 한 instruction을 넘어선, 그러나 극도로 짧은 경우.

1
struct Slot {
2
  folly::MicroSpinLock lock;
3
  uint8_t              flags;
4
  uint16_t             refCount;
5
  uint32_t             generation;
6
};
7

8
void TouchSlot(Slot& s) {
9
  std::lock_guard lk(s.lock);
10
  s.flags |= kAccessed;
11
  ++s.refCount;
12
  s.generation = NowGen();
13
}

3-4 field를 atomic 하게 일관 갱신 — atomic 하나로 표현 어렵다. spin lock으로 묶는다.

#사용자 7-bit

MicroSpinLock은 8 bit 중 1 bit만 lock에 쓴다. 나머지 7 bit이 사용자 data로 쓸 수 있다. MicroLock(6 bit user)보다 1 bit 더. 단 비공식적 활용이라 직접 비트 조작 필요.

#코드 리뷰 포인트

• critical section 안에 syscall/mutex/blocking 호출 → 즉시 std::mutex로 교체.
• spin이 hot path인데 PAUSE/yield 없음 → 다른 hyperthread를 굶긴다. MicroSpinLock 사용 (이미 PAUSE 포함).
• contention이 항상 큼 → spin 비용이 누적. mutex가 나음.
• userland realtime priority에서 spin → priority inversion.

#자주 보는 안티패턴

1
// 1. critical section에 LOG
2
{
3
  std::lock_guard lk(m);
4
  LOG(INFO) << "in critical";   // I/O — context switch가 spin 중에 일어남
5
}
6

7
// 2. spin lock으로 condition variable 흉내
8
folly::MicroSpinLock m;
9
bool ready = false;
10

11
void Wait() {
12
  while (true) {
13
    std::lock_guard lk(m);
14
    if (ready) return;
15
  }
16
  // → CPU 100% spin. condition variable + std::mutex가 옳음.
17
}
18

19
// 3. 100 라인 critical section
20
{
21
  std::lock_guard lk(m);
22
  ProcessLargeBatch(items);   // ms-scale
23
}
24
// → spin 다른 thread가 ms 동안 헛 spin. std::mutex로.

#std::mutex / MicroLock / MicroSpinLock 선택

#정리

• MicroSpinLock은 1-byte spin lock, sleep 없음.
• PAUSE/yield 명령으로 cache 경합과 power 줄임.
• critical section이 수십 ns일 때 가장 빠름.
• 길어지면 mutex가 나음 — trade-off가 critical section 길이로 결정.
• atomic flag로도 가능하지만 RAII + 사용자 비트가 추가 가치.

#다음 편

Part 19로 넘어가 format, demangle, DynamicConverter를 본다.

#관련 항목

• Folly Part 18-03 — MicroLock
• Folly Part 9-04 — RWSpinLock
• Folly Part 9-05 — PicoSpinLock
• 원문 — folly/SpinLock.h