해설 — seqlock 의 단일 시퀀스·데이터 레이스·메모리 순서 결함 (C++)

난이도: 최상

요약

retry 루프까지 넣어 seqlock 처럼 보이지만 세 가지가 틀렸다. (1) seq_를 갱신마다 한 번만 올려 "쓰기 진행 중"을 표현하지 못한다(홀짝 프로토콜 부재) → 쓰기 도중 시작한 리더가 찢긴 값을 재시도 없이 수락, (2) seq_와 필드가 모두 비원자(plain) 변수라 writer 쓰기와 reader 읽기가 겹치면 데이터 레이스 = UB, (3) 메모리 순서(release/acquire) 미지정이라 필드 쓰기와 시퀀스 쓰기, 시퀀스 읽기와 필드 읽기가 재정렬돼 retry 루프가 무의미해진다.

문제점

1) [프로토콜 결함] 단일 시퀀스 증가 (증상: 찢긴 읽기 수락)

• 증상: (A)에서 쓰기 시작 시 seq_++ 한 번뿐이다. 리더가 (B)의 필드 갱신 도중에 (C)로 s = seq_를 읽으면 이미 증가된 값을 잡고, 찢긴 필드를 읽은 뒤 (D)에서 s != seq_를 검사하지만 그 사이 새 쓰기가 없으면 같아서 찢긴 값을 그대로 수락한다. 올바른 seqlock 은 쓰기 시작 때 홀수(seq|1), 완료 때 짝수로 두 번 올려서, 리더가 "시작 시퀀스가 홀수면 진행 중 → 재시도", "짝수이고 앞뒤가 같아야 일관"으로 판정한다.
• 재현조건: Write의 필드 갱신 중 Read 진입.

2) [데이터 레이스] 비원자 동시 접근 (증상: UB)

• 증상: seq_(비원자)와 pos_/vx_/vy_(비원자)를 writer 와 reader 가 동기화 없이 동시에 읽고 쓴다. C++ 메모리 모델상 이는 정의되지 않은 동작이다 — 컴파일러가 읽기를 합치거나 재정렬하고, retry 루프 자체를 "seq_ 는 안 변한다"고 최적화해 없앨 수도 있다.
• 근본원인: 공유 변수를 std::atomic으로 선언하지 않음.

3) [메모리 순서] release/acquire 부재 (증상: 재정렬로 찢김)

• 증상: 원자로 바꿔도 순서를 지정하지 않으면(혹은 relaxed) store-store/load-load 재정렬로 필드가 시퀀스보다 늦게 보이거나 먼저 보인다. writer 는 "필드 → release 시퀀스", reader 는 "acquire 시퀀스 → 필드 → acquire 시퀀스" 순서를 배리어로 강제해야 한다.

수정안

정식 seqlock: 원자 시퀀스, 홀짝 프로토콜, release/acquire 배리어, 필드는 relaxed 원자(또는 배리어로 감싼 접근).

#include <atomic>
class TransformSnapshot {
    std::atomic<uint32_t> seq_{0};       // 짝수=안정, 홀수=쓰기 중
    std::atomic<float> x_{0}, y_{0}, z_{0}, vx_{0}, vy_{0};
public:
    void Write(const Vec3& p, float vx, float vy) {          // 단일 writer
        uint32_t s = seq_.load(std::memory_order_relaxed);
        seq_.store(s + 1, std::memory_order_relaxed);        // 홀수: 쓰기 시작
        std::atomic_thread_fence(std::memory_order_release);
        x_.store(p.x, std::memory_order_relaxed);
        y_.store(p.y, std::memory_order_relaxed);
        z_.store(p.z, std::memory_order_relaxed);
        vx_.store(vx, std::memory_order_relaxed);
        vy_.store(vy, std::memory_order_relaxed);
        seq_.store(s + 2, std::memory_order_release);        // 짝수: 완료(게시)
    }
    void Read(Vec3& outPos, float& ovx, float& ovy) {        // 다수 reader
        for (;;) {
            uint32_t s1 = seq_.load(std::memory_order_acquire);
            if (s1 & 1) continue;                            // 쓰기 중 → 재시도
            outPos = { x_.load(std::memory_order_relaxed),
                       y_.load(std::memory_order_relaxed),
                       z_.load(std::memory_order_relaxed) };
            ovx = vx_.load(std::memory_order_relaxed);
            ovy = vy_.load(std::memory_order_relaxed);
            std::atomic_thread_fence(std::memory_order_acquire);
            if (seq_.load(std::memory_order_relaxed) == s1) return; // 그 사이 쓰기 없음
        }
    }
};

• 스니펫 검증: g++ -std=c++17 -pthread -fsyntax-only 통과.
• 핵심: 홀짝 시퀀스 + 앞뒤 시퀀스 일치 재시도 + release(writer)/acquire(reader) 펜스. 필드를 원자로 두어 데이터 레이스 UB 를 제거(값 자체는 relaxed 로 충분, 순서는 펜스가 담당).

더 나은 설계 (트레이드오프)

• 불변 스냅샷 + atomic<shared_ptr> 교체: writer 가 새 Transform을 만들어 원자 포인터 교체, reader 는 포인터 하나만 acquire-load. 찢김·재시도 원천 제거. 트레이드오프: 갱신마다 할당·참조카운트(C++20 atomic<shared_ptr> 또는 atomic_load/store(shared_ptr*)).
• double buffering + 원자 인덱스: 두 버퍼 번갈아, 인덱스만 원자 교체. 트레이드오프: 리더 지연이 갱신 주기보다 길면 찢김 가능(2버퍼 한계).
• seqlock 적합 조건: 작은 데이터·드문 쓰기·잦은 읽기에 최적. 데이터가 크거나 쓰기가 잦으면 재시도 비용 폭증.

면접 포인트

• 단일 시퀀스 증가가 왜 찢긴 읽기를 못 막는지, 홀짝 2회 증가와 리더 앞뒤 검증의 필요성.
• C++ 메모리 모델에서 비원자 공유 접근이 UB 인 이유와 std::atomic+fence 로 seqlock 을 올바로 구성하는 법.
• seqlock vs 불변 스냅샷 교체 vs double buffering 의 트레이드오프.