🏁 경쟁 상태 디버깅

개요

NVIDIA compute-sanitizer를 사용해 잘못된 결과를 일으키는 경쟁 상태를 식별하면서 실패하는 GPU 프로그램을 디버깅합니다. 공유 메모리 연산에서 동시성 버그를 찾는 racecheck 도구 사용법을 배웁니다.

공유 메모리로 여러 스레드의 값을 누적해야 하는 GPU 커널이 있습니다. 테스트는 실패하는데, 로직은 올바른 것 같습니다. 당신의 과제는 실패를 일으키는 경쟁 상태를 찾아 수정하는 것입니다.

구성

comptime SIZE = 2
comptime BLOCKS_PER_GRID = 1
comptime THREADS_PER_BLOCK = (3, 3)  # 9개 스레드 중 4개만 활성화
comptime dtype = DType.float32

실패하는 커널

comptime SIZE = 2
comptime BLOCKS_PER_GRID = 1
comptime THREADS_PER_BLOCK = (3, 3)
comptime dtype = DType.float32
comptime layout = Layout.row_major(SIZE, SIZE)


fn shared_memory_race(
    output: LayoutTensor[dtype, layout, MutAnyOrigin],
    a: LayoutTensor[dtype, layout, ImmutAnyOrigin],
    size: UInt,
):
    row = thread_idx.y
    col = thread_idx.x

    shared_sum = LayoutTensor[
        dtype,
        Layout.row_major(1),
        MutAnyOrigin,
        address_space = AddressSpace.SHARED,
    ].stack_allocation()

    if row < size and col < size:
        shared_sum[0] += a[row, col]

    barrier()

    if row < size and col < size:
        output[row, col] = shared_sum[0]

전체 파일 보기: problems/p10/p10.mojo

코드 실행

pixi run p10 --race-condition

출력은 다음과 같습니다

out shape: 2 x 2
Running race condition example...
out: HostBuffer([0.0, 0.0, 0.0, 0.0])
expected: HostBuffer([6.0, 6.0, 6.0, 6.0])
stack trace was not collected. Enable stack trace collection with environment variable `MOJO_ENABLE_STACK_TRACE_ON_ERROR`
Unhandled exception caught during execution: At /home/ubuntu/workspace/mojo-gpu-puzzles/problems/p10/p10.mojo:122:33: AssertionError: `left == right` comparison failed:
   left: 0.0
  right: 6.0

compute-sanitizer가 GPU 코드의 문제를 어떻게 찾아내는지 살펴봅시다.

compute-sanitizer로 디버깅하기

1단계: racecheck로 경쟁 상태 식별

compute-sanitizer와 racecheck 도구를 사용하여 경쟁 상태를 식별합니다:

pixi run compute-sanitizer --tool racecheck mojo problems/p10/p10.mojo --race-condition

출력은 다음과 같습니다

========= COMPUTE-SANITIZER
out shape: 2 x 2
Running race condition example...
========= Error: Race reported between Write access at p10_shared_memory_race_...+0x140
=========     and Read access at p10_shared_memory_race_...+0xe0 [4 hazards]
=========     and Write access at p10_shared_memory_race_...+0x140 [5 hazards]
=========
out: HostBuffer([0.0, 0.0, 0.0, 0.0])
expected: HostBuffer([6.0, 6.0, 6.0, 6.0])
AssertionError: `left == right` comparison failed:
  left: 0.0
  right: 6.0
========= RACECHECK SUMMARY: 1 hazard displayed (1 error, 0 warnings)

분석: 프로그램에 1개의 경쟁 상태와 9개의 개별 위험 요소가 있습니다:

• 4개의 read-after-write 위험 요소 (다른 스레드가 쓰는 동안 읽기)
• 5개의 write-after-write 위험 요소 (여러 스레드가 동시에 쓰기)

2단계: synccheck와 비교

동기화 문제가 아닌 경쟁 상태인지 확인합니다:

pixi run compute-sanitizer --tool synccheck mojo problems/p10/p10.mojo --race-condition

출력은 다음과 같습니다

========= COMPUTE-SANITIZER
out shape: 2 x 2
Running race condition example...
out: HostBuffer([0.0, 0.0, 0.0, 0.0])
expected: HostBuffer([6.0, 6.0, 6.0, 6.0])
AssertionError: `left == right` comparison failed:
  left: 0.0
  right: 6.0
========= ERROR SUMMARY: 0 errors

핵심 통찰: synccheck가 0개의 오류를 찾았습니다 - 교착 상태 같은 동기화 문제는 없습니다. 문제는 동기화 버그가 아닌 경쟁 상태입니다.

교착 상태 vs 경쟁 상태: 차이점 이해하기

우리 사례에서:

• 프로그램 완료됨 → 교착 상태 없음 (스레드가 멈추지 않음)
• 잘못된 결과 → 경쟁 상태 (스레드들이 서로의 데이터를 손상)
• 도구 확인 → synccheck는 0개 오류, racecheck는 9개 위험 요소 보고

디버깅에서 이 구분이 중요한 이유:

• 교착 상태 디버깅: 배리어 배치, 조건부 동기화, 스레드 조율에 집중
• 경쟁 상태 디버깅: 공유 메모리 접근 패턴, 원자적 연산 (역주: 중간 상태 없이 완전히 실행되거나 전혀 실행되지 않는 연산), 데이터 의존성에 집중

도전 과제

이 도구들을 활용하여 실패하는 커널을 수정하세요.

솔루션

comptime SIZE = 2
comptime BLOCKS_PER_GRID = 1
comptime THREADS_PER_BLOCK = (3, 3)
comptime dtype = DType.float32
comptime layout = Layout.row_major(SIZE, SIZE)


fn shared_memory_race(
    output: LayoutTensor[dtype, layout, MutAnyOrigin],
    a: LayoutTensor[dtype, layout, ImmutAnyOrigin],
    size: UInt,
):
    """Fixed: sequential access with barriers eliminates race conditions."""
    row = thread_idx.y
    col = thread_idx.x

    shared_sum = LayoutTensor[
        dtype,
        Layout.row_major(1),
        MutAnyOrigin,
        address_space = AddressSpace.SHARED,
    ].stack_allocation()

    # Only thread 0 does all the accumulation work to prevent races
    if row == 0 and col == 0:
        # Use local accumulation first, then single write to shared memory
        local_sum = Scalar[dtype](0.0)
        for r in range(size):
            for c in range(size):
                local_sum += rebind[Scalar[dtype]](a[r, c])

        shared_sum[0] = local_sum  # Single write operation

    barrier()  # Ensure thread 0 completes before others read

    # All threads read the safely accumulated result after synchronization
    if row < size and col < size:
        output[row, col] = shared_sum[0]

shared_sum[0] += a[row, col]  # 경쟁 상태!

if row == 0 and col == 0:

if row == 0 and col == 0:
    local_sum = Scalar[dtype](0.0)
    for r in range(size):
        for c in range(size):
            local_sum += rebind[Scalar[dtype]](a[r, c])
    shared_sum[0] = local_sum  # 단일 쓰기 연산

barrier()  # 스레드 (0,0)이 완료한 후 다른 스레드가 읽도록 보장

if row < size and col < size:
    output[row, col] = shared_sum[0]

pixi run compute-sanitizer --tool racecheck mojo solutions/p10/p10.mojo --race-condition

========= COMPUTE-SANITIZER
out shape: 2 x 2
Running race condition example...
out: HostBuffer([6.0, 6.0, 6.0, 6.0])
expected: HostBuffer([6.0, 6.0, 6.0, 6.0])
✅ Race condition test PASSED! (racecheck will find hazards)
========= RACECHECK SUMMARY: 0 hazards displayed (0 errors, 0 warnings)