Spinlock vs Mutex 결정 가이드 — Context Switch·Hold Time

1
mutex (sleep lock)
2
  contention 시 caller가 sleep → context switch
3
  hold time이 길수록 유리
4
  ISR에서 사용 금지
5

6
spinlock (busy lock)
7
  contention 시 caller가 busy wait
8
  hold time이 매우 짧을 때만 유리
9
  ISR과 process context 모두 사용 가능
10
  Linux: spin_lock_irqsave가 IRQ까지 disable

1
DEFINE_SPINLOCK(my_lock);
2

3
/* process context */
4
spin_lock(&my_lock);
5
critical_section();
6
spin_unlock(&my_lock);
7

8
/* process + ISR 둘 다 접근 가능한 자원 */
9
spin_lock_irqsave(&my_lock, flags);
10
critical_section();
11
spin_unlock_irqrestore(&my_lock, flags);

1
DEFINE_MUTEX(my_mtx);
2

3
mutex_lock(&my_mtx);
4
file_io();
5
mutex_unlock(&my_mtx);
6

7
/* timeout */
8
if (mutex_lock_interruptible(&my_mtx)) return -ERESTARTSYS;
9

10
/* ISR/atomic context는 절대 사용 불가 — mutex_lock은 sleep */

1
struct spinlock {
2
    std::atomic<int> v{0};
3

4
    void lock(void) {
5
        int expected = 0;
6
        while (!v.compare_exchange_weak(
7
                expected, 1, std::memory_order_acquire)) {
8
            expected = 0;
9
            __asm__ volatile("yield" ::: "memory");
10
        }
11
    }
12

13
    void unlock(void) {
14
        v.store(0, std::memory_order_release);
15
    }
16
};

1
struct ticket_lock {
2
    std::atomic<unsigned> next{0};
3
    std::atomic<unsigned> now{0};
4

5
    void lock(void) {
6
        unsigned my = next.fetch_add(1, std::memory_order_acquire);
7
        while (now.load(std::memory_order_acquire) != my) {
8
            __asm__ volatile("yield" ::: "memory");
9
        }
10
    }
11

12
    void unlock(void) {
13
        now.fetch_add(1, std::memory_order_release);
14
    }
15
};

1
struct mcs_node {
2
    std::atomic<mcs_node *> next{nullptr};
3
    std::atomic<bool> locked{false};
4
};
5

6
void mcs_lock(mcs_node **tail, mcs_node *me) {
7
    mcs_node *prev = tail->exchange(me, std::memory_order_acquire);
8
    if (prev) {
9
        me->locked.store(true, std::memory_order_relaxed);
10
        prev->next.store(me, std::memory_order_release);
11
        while (me->locked.load(std::memory_order_acquire))
12
            __asm__ volatile("yield" ::: "memory");
13
    }
14
}
15

16
void mcs_unlock(mcs_node **tail, mcs_node *me) {
17
    mcs_node *succ = me->next.load(std::memory_order_acquire);
18
    if (!succ) {
19
        mcs_node *exp = me;
20
        if (tail->compare_exchange_strong(exp, nullptr)) return;
21
        while (!(succ = me->next.load(std::memory_order_acquire)));
22
    }
23
    succ->locked.store(false, std::memory_order_release);
24
}

1
질문 1: 작업이 sleep 가능한가?
2
   no → spinlock (ISR/atomic context)
3
   yes → 질문 2
4

5
질문 2: hold time이 얼마인가?
6
   < 1 µs    spinlock 또는 atomic 직접
7
   1~10 µs   spinlock (SMP에서만)
8
   > 10 µs   mutex
9

10
질문 3: contention이 큰가? (코어 ≥ 8, 동시 thread > 4)
11
   yes      MCS / qspinlock 사용
12
   no       기본 spinlock으로 충분

1
Cortex-A72 8-core, no contention
2
spinlock acquire/release         15 cycle
3
mutex lock/unlock (futex)        ~50 ns (uncontended fast path)
4
ticket lock                      18 cycle
5
MCS lock                         20 cycle
6

7
contention 8 thread, 100 ns critical section
8
basic spinlock                   ~2 µs/op (cache ping-pong)
9
ticket lock                      ~1.8 µs/op
10
MCS lock                         ~300 ns/op (각자 자기 line)
11
mutex                            ~600 ns/op (context switch)

1
spinlock vs mutex (hold time별, 4 thread)
2
hold 100 ns: spinlock 0.4 µs/op, mutex 0.9 µs/op
3
hold 10 µs: spinlock 12 µs/op, mutex 11 µs/op
4
hold 100 µs: spinlock 80 µs/op, mutex 105 µs/op

1
spin_lock(&x);   /* UP에서는 preempt_disable과 같음 — spin할 다른 코어 없음 */

1
spin_lock(&x);
2
msleep(10);     /* BUG — spin 상태로 sleep 불가능 */
3
spin_unlock(&x);

1
void irq_handler(...) {
2
    mutex_lock(&m);     /* sleep 시도 → kernel oops */
3
}

1
spin_lock(&x);
2
if (rare_path) {
3
    file_io();    /* 평소는 빠르지만 가끔 ms 단위 */
4
}
5
spin_unlock(&x);

1
while (!try_lock());    /* hot read — system 전반 영향 */