Wait-Free Signaling — Atomic Flag·Sequence·Latest-Value

1
atomic_bool ready = false;
2
volatile data_t data;
3

4
/* Producer */
5
data = compute();
6
atomic_store_explicit(&ready, true, memory_order_release);
7
                                /* O(1) — wait-free */
8

9
/* Consumer */
10
if (atomic_load_explicit(&ready, memory_order_acquire)) {
11
    use(data);
12
    atomic_store(&ready, false);   /* consume */
13
}

1
struct {
2
    atomic_uint64_t seq;
3
    sensor_data_t data;
4
} sensor;
5

6
/* Writer */
7
void update(sensor_data_t new_d) {
8
    uint64_t s = atomic_load(&sensor.seq);
9
    atomic_store(&sensor.seq, s | 1);   /* odd = writing */
10
    __DMB();
11
    sensor.data = new_d;
12
    __DMB();
13
    atomic_store(&sensor.seq, s + 2);   /* even = stable */
14
}
15

16
/* Reader */
17
bool read(sensor_data_t *out) {
18
    uint64_t s;
19
    do {
20
        s = atomic_load(&sensor.seq);
21
        if (s & 1) return false;   /* writing now */
22
        *out = sensor.data;
23
    } while (s != atomic_load(&sensor.seq));
24
    return true;
25
}

1
struct {
2
    atomic_int active;
3
    sensor_data_t buf[2];
4
} ds;
5

6
/* Writer */
7
void write(sensor_data_t new) {
8
    int next = !atomic_load(&ds.active);
9
    ds.buf[next] = new;
10
    __DMB();
11
    atomic_store(&ds.active, next);
12
}
13

14
/* Reader */
15
void read(sensor_data_t *out) {
16
    int idx = atomic_load(&ds.active);
17
    *out = ds.buf[idx];   /* may be racing — but consistent buf */
18
}

1
struct {
2
    atomic_int active;   /* reader 가져갈 buffer */
3
    atomic_int next;     /* 다음 active 후보 */
4
    int writer_buf;       /* writer 현재 채우는 */
5
    sensor_data_t buf[3];
6
} tb;
7

8
/* Writer */
9
void write(sensor_data_t new) {
10
    int wb = tb.writer_buf;
11
    tb.buf[wb] = new;
12
    int prev_next = atomic_exchange(&tb.next, wb);
13
    tb.writer_buf = prev_next;
14
    /* prev_next: 이전 next → 이제 writer가 채울 buffer */
15
}
16

17
/* Reader */
18
void read(sensor_data_t *out) {
19
    int n = atomic_exchange(&tb.next, atomic_load(&tb.active));
20
    atomic_store(&tb.active, n);
21
    *out = tb.buf[n];
22
}

1
/* 32-bit aligned word — Cortex-M3+ 자동 atomic */
2
volatile uint32_t status;
3

4
ISR: status = STATUS_OK;
5
task: if (status == STATUS_OK) ...

1
/* ARMv8.1 LSE — single instruction */
2
atomic_fetch_add(&counter, 1, memory_order_relaxed);
3
                /* → LDADD — 단일 명령, contention 무관 wait-free */

1
/* Reader — wait-free */
2
rcu_read_lock();   /* no-op or preempt-disable */
3
struct data *d = rcu_dereference(global);
4
use(d);
5
rcu_read_unlock();
6

7
/* Writer — may wait (grace period) */
8
struct data *new = malloc(sizeof(*new));
9
copy_old_to_new(new);
10
modify(new);
11
rcu_assign_pointer(global, new);
12
synchronize_rcu();
13
free(old);

1
volatile uint32_t isr_count;
2
volatile uint32_t task_seen;
3

4
/* ISR */
5
void IRQ(void) {
6
    isr_count++;
7
    /* No wake, no lock — just count */
8
}
9

10
/* Task — periodic poll */
11
void task(void *p) {
12
    for (;;) {
13
        uint32_t now = isr_count;
14
        if (now != task_seen) {
15
            handle_events(now - task_seen);
16
            task_seen = now;
17
        }
18
        vTaskDelay(10);
19
    }
20
}

1
/* RP2040 SIO peripheral */
2
uint32_t saved = spin_lock_blocking(spin_lock_instance(0));
3
critical();
4
spin_unlock(spin_lock_instance(0), saved);

1
do {
2
    old = atomic_load(&x);
3
} while (!atomic_compare_exchange(&x, &old, old+1));
4
/* contention 시 무한 retry — lock-free, not wait-free */

1
read(buf[active]);   /* writer가 active 변경 *중* — race */

1
volatile uint64_t timestamp;   /* split load/store — not atomic */

1
my_atomic_op();   /* lock-free? wait-free? — 측정 안 함 */