Spinlock 성능 분석 — Spin-Wait vs Context Switch·Ticket·MCS

1
Hold time 1 µs:
2
  Spin:    1 µs CPU 낭비, 곧바로 진행
3
  Sleep:   context switch ~3 µs × 2 = 6 µs overhead
4
  → Spin이 우세
5

6
Hold time 1 ms:
7
  Spin:    1 ms × N CPU 낭비
8
  Sleep:   6 µs overhead
9
  → Sleep이 우세

1
typedef struct { atomic_int locked; } spinlock_t;
2

3
void spin_lock(spinlock_t *lock) {
4
    while (atomic_exchange(&lock->locked, 1)) {
5
        /* spin */
6
    }
7
}
8

9
void spin_unlock(spinlock_t *lock) {
10
    atomic_store(&lock->locked, 0);
11
}

1
spin:
2
    ldrex r1, [r0]
3
    cmp   r1, #0
4
    bne   spin
5
    mov   r2, #1
6
    strex r3, r2, [r0]
7
    cmp   r3, #0
8
    bne   spin

1
void spin_lock(spinlock_t *lock) {
2
    while (1) {
3
        while (atomic_load_explicit(&lock->locked,
4
                                    memory_order_relaxed)) {
5
            cpu_relax();
6
        }
7
        if (!atomic_exchange(&lock->locked, 1)) return;
8
    }
9
}

1
typedef struct {
2
    atomic_int next;
3
    atomic_int now_serving;
4
} ticket_lock_t;
5

6
void ticket_lock(ticket_lock_t *l) {
7
    int my_ticket = atomic_fetch_add(&l->next, 1);
8
    while (atomic_load(&l->now_serving) != my_ticket) {
9
        cpu_relax();
10
    }
11
}
12

13
void ticket_unlock(ticket_lock_t *l) {
14
    atomic_fetch_add(&l->now_serving, 1);
15
}

1
struct mcs_node {
2
    struct mcs_node *next;
3
    atomic_int locked;
4
};
5

6
void mcs_lock(struct mcs_node *l, struct mcs_node *self) {
7
    self->next = NULL;
8
    self->locked = 1;
9

10
    struct mcs_node *prev = atomic_exchange(l, self);
11
    if (prev) {
12
        prev->next = self;
13
        while (atomic_load(&self->locked)) cpu_relax();
14
    }
15
}
16

17
void mcs_unlock(struct mcs_node *l, struct mcs_node *self) {
18
    if (!self->next) {
19
        if (atomic_compare_exchange(l, &self, NULL)) return;
20
        while (!self->next) cpu_relax();
21
    }
22
    atomic_store(&self->next->locked, 0);
23
}

1
TTAS    : N waiter — unlock 시 N CPU 모두 invalidate, 1 CPU만 성공
2
Ticket  : N waiter — 모두 now_serving 공유 → 매 unlock N miss
3
MCS     : N waiter — 각자 다른 line → unlock 시 1 line만 invalidate

1
spin_lock(&mylock);
2
critical_code();
3
spin_unlock(&mylock);
4

5
unsigned long flags;
6
spin_lock_irqsave(&mylock, flags);
7
critical_code();
8
spin_unlock_irqrestore(&mylock, flags);

1
Cortex-M3/M4 single core:
2
  spinlock은 의미가 없습니다. 다른 task가 lock을 풀려면 CPU가 필요한데
3
  spin이 CPU를 점유하므로 영원히 풀리지 않습니다.
4
  → IRQ disable 또는 BASEPRI로 critical section을 보호합니다.
5

6
SMP Cortex-M (RP2040, Cortex-M55+M85):
7
  cross-core spinlock이 필요합니다.
8
  CMSIS RTOS와 Zephyr가 atomic API를 제공합니다.

1
k_spinlock_t lock;
2
k_spinlock_key_t key = k_spin_lock(&lock);
3
critical_code();
4
k_spin_unlock(&lock, key);

1
void adaptive_lock(lock_t *l) {
2
    int spins = 0;
3
    while (!try_lock(l)) {
4
        if (++spins > THRESHOLD) {
5
            block_self();
6
            return;
7
        }
8
        cpu_relax();
9
    }
10
}

1
static inline void cpu_relax(void) {
2
    asm volatile ("yield");
3
}

1
/* Cortex-M3 — 단일 core */
2
spin_lock(&l);   /* 영원 spin */

1
spin_lock(&l);
2
http_request();   /* 수 초 동안 모든 다른 core가 spin */
3
spin_unlock(&l);

1
spin_lock(&l);
2
/* IRQ 활성 → ISR이 같은 lock 시도 → deadlock */

1
while (locked) ;   /* hot loop, power 낭비, SMT 굶주림 */

1
              1 core    2 core    4 core
2
hold 100 ns    0 ns     30 ns     90 ns
3
hold   1 µs    0 ns    400 ns      2 µs
4
hold  10 µs    0 ns      8 µs     25 µs    ← mutex 우세 시작
5
hold 100 µs    0 ns     80 µs    250 µs    ← mutex 압도적