임베디드 Lock-free 기초 — atomic·memory ordering·CAS

1
// Mutex 기반
2
std::mutex m;
3
int counter = 0;
4
void increment() {
5
    std::lock_guard lock(m);
6
    counter++;
7
}
8

9
// Lock-free
10
std::atomic<int> counter{0};
11
void increment() {
12
    counter.fetch_add(1);   // atomic
13
}

1
#include <atomic>
2

3
std::atomic<int> counter{0};
4

5
counter.store(42);
6
int v = counter.load();
7
counter.fetch_add(1);          // counter++ (atomic)
8
int old = counter.exchange(0); // 교체
9

10
// Compare-and-swap
11
int expected = 5;
12
bool success = counter.compare_exchange_weak(expected, 10);
13
// counter == 5면 10으로 변경 + true
14
// 아니면 expected = current value + false

1
std::atomic<Node*> head{nullptr};
2

3
void push(Node* n) {
4
    Node* old_head = head.load();
5
    do {
6
        n->next = old_head;
7
    } while (!head.compare_exchange_weak(old_head, n));
8
    // CAS 성공할 때까지 retry
9
}

1
// Thread 1: pop 시도
2
Node* old_top = top.load();        // = A
3
// (이때 Thread 2가 A pop, B push, A push)
4
// 이제 top = A지만 *A->next는 변경*
5
top.compare_exchange_weak(old_top, old_top->next);
6
// CAS 성공 — 그러나 old_top->next는 잘못된 값

1
counter.store(1, std::memory_order_relaxed);
2
counter.load(std::memory_order_acquire);
3
counter.fetch_add(1, std::memory_order_release);
4
counter.compare_exchange_weak(expected, new_value,
5
                                std::memory_order_seq_cst,
6
                                std::memory_order_acquire);

1
std::atomic<uint32_t> tick_count{0};
2

3
extern "C" void SysTick_Handler() {
4
    tick_count.fetch_add(1, std::memory_order_relaxed);
5
}
6

7
uint32_t get_uptime_ms() {
8
    return tick_count.load(std::memory_order_relaxed);
9
}

1
template<typename T, size_t N>
2
class SpscQueue {
3
    static_assert((N & (N - 1)) == 0, "N must be power of 2");
4

5
    T buffer_[N];
6
    std::atomic<size_t> head_{0};   // producer
7
    std::atomic<size_t> tail_{0};   // consumer
8
    static constexpr size_t kMask = N - 1;
9

10
public:
11
    bool push(const T& value) {
12
        size_t h = head_.load(std::memory_order_relaxed);
13
        size_t next = (h + 1) & kMask;
14

15
        if (next == tail_.load(std::memory_order_acquire)) {
16
            return false;   // full
17
        }
18

19
        buffer_[h] = value;
20
        head_.store(next, std::memory_order_release);
21
        return true;
22
    }
23

24
    bool pop(T& out) {
25
        size_t t = tail_.load(std::memory_order_relaxed);
26
        if (t == head_.load(std::memory_order_acquire)) {
27
            return false;   // empty
28
        }
29

30
        out = buffer_[t];
31
        tail_.store((t + 1) & kMask, std::memory_order_release);
32
        return true;
33
    }
34
};

1
SpscQueue<Event, 64> event_queue;
2

3
extern "C" void UART_IRQHandler() {
4
    Event e = read_uart();
5
    event_queue.push(e);   // ISR가 producer
6
}
7

8
void main_loop() {
9
    Event e;
10
    while (event_queue.pop(e)) {
11
        process(e);   // main이 consumer
12
    }
13
}

1
// 직접 구현 어렵다 — 검증된 라이브러리 사용
2
#include <boost/lockfree/queue.hpp>
3
boost::lockfree::queue<int, boost::lockfree::capacity<128>> q;

1
// V1 — Critical section
2
void update_shared() {
3
    __disable_irq();
4
    counter++;
5
    if (counter > MAX) counter = 0;
6
    __enable_irq();
7
}
8

9
// V2 — Lock-free (단순 카운터만)
10
std::atomic<int> counter{0};
11
void update_shared() {
12
    int v;
13
    int next;
14
    do {
15
        v = counter.load();
16
        next = (v + 1) > MAX ? 0 : v + 1;
17
    } while (!counter.compare_exchange_weak(v, next));
18
}

1
// Cortex-M0+
2
void increment() {
3
    __disable_irq();
4
    ++counter;
5
    __enable_irq();
6
}

1
counter.store(1);   // 기본 seq_cst — 가장 느림

1
int v = counter.load();
2
process(v);
3
counter.store(v + 1);   // 다른 thread가 끼어들면 race

1
std::atomic<HugeStruct> obj;   // hardware atomic 불가 — lock 사용

1
# Cortex-M4, simple counter increment
2

3
1. Mutex (FreeRTOS):     ~600 cycles
4
2. Critical section:     ~30 cycles
5
3. Atomic fetch_add:     ~15 cycles
6
4. Plain ++ (no sync):   ~5 cycles (but unsafe)