Modern Embedded Recipes · 103/152

RCU (Read-Copy-Update) 기초 — Quiescent State·Grace Period

2026년 4월 18일 · Hawk · 5분 읽기

#한 줄 요약

“RCU = reader 경로를 가볍게 하고 writer가 reclamation 비용을 부담하는 read-mostly 동기화.” 핵심은 grace period입니다. 모든 reader가 한 번씩 quiescent state를 지나야 옛 객체를 free할 수 있습니다.

#어떤 상황에서 쓰나

routing table, config object, kernel module 목록처럼 읽기는 자주, 쓰기는 가끔인 데이터에 RCU가 빛납니다. Reader 쪽은 lock도, atomic도 안 쓰니 contention이 0에 가깝습니다. SMP 환경에서 reader 수가 늘어도 성능이 일정합니다.

리눅스 커널은 오랫동안 여러 RCU flavor를 운영해 왔고, 사용자 공간에서도 liburcu(URCU) 계열을 사용할 수 있습니다. flavor별 API·등록·메모리 모델이 다르므로 임베디드 Linux의 read-mostly 자료구조에 적용할 때 구현 문서를 확인합니다.

#핵심 개념

API	동작
`rcu_read_lock`	reader 진입 — 사실상 `preempt_disable` 또는 그보다 가벼움
`rcu_dereference`	protected pointer를 안전하게 읽음
`rcu_read_unlock`	reader 탈출 — quiescent state 신호 가능
`rcu_assign_pointer`	writer가 새 객체 publish
`synchronize_rcu`	모든 in-flight reader가 끝날 때까지 wait (grace period)
`call_rcu`	callback을 grace period 후 호출 (sleep 안 하고 free)

전형적인 update 흐름입니다.

new = copy + modify
rcu_assign_pointer(global, new)
synchronize_rcu (또는 call_rcu)
free(old)

핵심 보장은 모든 진행 중 reader가 끝난 후에만 옛 객체가 free된다는 점입니다.

RCU의 trade-off는 네 가지로 정리됩니다.

reader 경로의 작업량과 contention을 줄일 수 있지만 비용이 0이라고 보장하지 않습니다.
writer는 grace period 만큼 기다립니다.
한순간 old와 new가 동시에 존재하므로 메모리를 더 씁니다.
writer가 빈번하면 RWLock이 더 낫습니다.

#코드 / 실제 사용 예

#Linux kernel RCU

1
struct config *cfg;
2

3
void writer(void) {
4
    struct config *old, *new;
5

6
    new = kmalloc(sizeof(*new), GFP_KERNEL);
7
    *new = *current_cfg();
8
    new->max_threads = 16;
9

10
    old = rcu_dereference_protected(cfg, lockdep_is_held(&cfg_mtx));
11
    rcu_assign_pointer(cfg, new);
12
    synchronize_rcu();      /* 모든 reader가 끝날 때까지 wait */
13
    kfree(old);
14
}
15

16
void reader(void) {
17
    struct config *c;
18
    rcu_read_lock();
19
    c = rcu_dereference(cfg);
20
    process(c);
21
    rcu_read_unlock();
22
}

reader는 flavor와 구현에 따라 preemption/상태 표시나 메모리 barrier를 수행할 수 있습니다. lock과 atomic이 없더라도 비용이 0은 아니므로 target에서 측정합니다.

#URCU (User-space RCU)

1
#include <urcu.h>
2

3
struct config *cfg;
4

5
void *reader_thread(void *arg) {
6
    rcu_register_thread();
7
    for (;;) {
8
        rcu_read_lock();
9
        struct config *c = rcu_dereference(cfg);
10
        process(c);
11
        rcu_read_unlock();
12
    }
13
    rcu_unregister_thread();
14
}
15

16
void update_config(struct config *new_cfg) {
17
    struct config *old = rcu_xchg_pointer(&cfg, new_cfg);
18
    synchronize_rcu();
19
    free(old);
20
}
21

22
int main(void) {
23
    rcu_init();
24
    /* threads ... */
25
}

URCU는 liburcu library를 link하면 사용자 공간에서도 RCU semantic을 그대로 씁니다. 임베디드 Linux daemon에 적합합니다.

#call_rcu (비동기 free)

1
struct foo {
2
    struct rcu_head rcu;
3
    int data;
4
};
5

6
static void foo_free(struct rcu_head *r) {
7
    struct foo *f = container_of(r, struct foo, rcu);
8
    kfree(f);
9
}
10

11
void writer(void) {
12
    struct foo *old = rcu_dereference_protected(g, ...);
13
    rcu_assign_pointer(g, new);
14
    call_rcu(&old->rcu, foo_free);    /* sleep 없이 grace period 예약 */
15
}

synchronize_rcu는 caller가 sleep합니다. ISR이나 atomic context에서는 call_rcu로 callback을 예약합니다.

#List 변경 (rculist.h)

1
#include <linux/rculist.h>
2

3
struct entry {
4
    struct list_head list;
5
    int key;
6
};
7

8
LIST_HEAD(g_list);
9

10
void add_entry(struct entry *e) {
11
    spin_lock(&list_lock);
12
    list_add_rcu(&e->list, &g_list);
13
    spin_unlock(&list_lock);
14
}
15

16
void remove_entry(struct entry *e) {
17
    spin_lock(&list_lock);
18
    list_del_rcu(&e->list);
19
    spin_unlock(&list_lock);
20
    synchronize_rcu();
21
    kfree(e);
22
}
23

24
void scan(void) {
25
    struct entry *e;
26
    rcu_read_lock();
27
    list_for_each_entry_rcu(e, &g_list, list) {
28
        process(e);
29
    }
30
    rcu_read_unlock();
31
}

list 변경은 spinlock으로 writer끼리만 막고, scan은 RCU로 무비용 traverse합니다.

#Read-mostly counter (sharded)

1
/* per-CPU counter — RCU 변종 */
2
DEFINE_PER_CPU(unsigned long, hits);
3

4
void hit(void) {
5
    this_cpu_inc(hits);
6
}
7

8
unsigned long total(void) {
9
    unsigned long s = 0;
10
    for_each_possible_cpu(c) s += per_cpu(hits, c);
11
    return s;
12
}

per-CPU counter는 RCU와 같은 정신입니다. 각 CPU가 자기 자리만 쓰고, 읽을 때만 모읍니다.

#측정 / 성능 비교

패턴	reader 1코어	reader 8코어 scaling
spinlock	100 ns	악화 (contention)
rwlock	150 ns	일부 scaling
RCU	측정 필요	workload별 측정

reader가 늘 때 RCU가 유리할 수 있지만 결과는 reader critical section·cache·flavor·workload에 따라 달라집니다.

1
writer 비용 비교
2
spinlock writer         측정 필요
3
rwlock writer           측정 필요
4
RCU writer + grace     측정 필요
5
RCU writer + call_rcu  측정 필요

writer는 RCU가 더 비싸므로 read-mostly일 때 의미가 있습니다.

#자주 보는 함정

rcu_read_lock 밖에서 dereference

1
struct config *c = rcu_dereference(cfg);   /* unlock 밖 — UB */

rcu_dereference는 반드시 rcu_read_lock 안에서만 호출합니다. 그렇지 않으면 reader가 진행 중인지 RCU가 모릅니다.

read lock 중에 sleep

1
rcu_read_lock();
2
msleep(10);    /* preempt 가능 → grace period 추정 깨짐 */
3
rcu_read_unlock();

전통적 RCU는 reader가 sleep하면 안 됩니다. sleep이 필요한 경우 SRCU(Sleepable RCU)를 씁니다.

writer만 보호 안 하고 add/del

1
list_add_rcu(...);   /* spinlock 없음 — writer끼리 race */

RCU는 reader와 writer 사이만 보호합니다. 여러 writer는 별도 lock으로 mutual exclusion이 필요합니다.

synchronize_rcu를 hot path에서

1
for (i = 0; i < N; i++) {
2
    new = ...;
3
    rcu_assign_pointer(p, new);
4
    synchronize_rcu();     /* 매 iteration ms 대기 */
5
}

여러 update를 한 번에 묶거나 call_rcu로 비동기 처리합니다.

User-space에서 register 누락

1
/* URCU thread가 rcu_register_thread 안 부름 */
2
rcu_read_lock();    /* 등록 안 된 thread → assert fail 또는 silent corruption */

URCU는 각 thread가 명시적으로 register/unregister해야 합니다.

#정리

RCU는 reader 비용 0, writer가 grace period를 부담하는 read-mostly 동기화입니다.
rcu_read_lock과 rcu_dereference로 reader를 보호합니다.
rcu_assign_pointer와 synchronize_rcu(또는 call_rcu)로 writer가 publish합니다.
여러 writer는 별도 spinlock이 필요합니다.
사용자 공간은 liburcu(URCU)로 같은 패턴을 씁니다.
Sleep 가능한 reader가 필요하면 SRCU를 씁니다.
writer가 빈번하면 RWLock이 더 적합합니다.

다음 편은 Hazard Pointer입니다. lock-free 메모리 회수를 다룹니다.

#관련 항목

Modern Embedded Recipes · 104 of 152

Hazard Pointer 분석 — Lock-Free Memory Reclamation

Lock-free 메모리 회수, ABA 회피, RCU와의 비교, C++ proposal까지 hazard pointer의 원리와 구현을 정리합니다.

2026년 4월 18일 · recipes

같은 시리즈에서 이어 읽기

Compare-And-Swap 패턴 — Stack·Counter·Linked List 적용

CAS loop, strong과 weak CAS, ABA 회피, exponential backoff, spurious failure까지 CAS 사용의 표준 패턴을 정리합니다.