warp.broadcast() 일대다 통신

워프 레벨 조정에서는 broadcast()를 사용하여 하나의 레인에서 워프 내 다른 모든 레인으로 데이터를 공유할 수 있습니다. 이 강력한 기본 요소를 통해 공유 메모리나 명시적 동기화 없이 블록 레벨 계산, 조건부 로직 조정, 일대다 통신 패턴을 효율적으로 수행할 수 있습니다.

핵심 통찰: broadcast() 연산은 SIMT 실행을 활용하여 하나의 레인(보통 레인 0)이 계산한 값을 같은 워프의 모든 레인에 전달하며, 효율적인 조정 패턴과 집합적 의사결정을 가능하게 합니다.

브로드캐스트 연산이란? 브로드캐스트 연산은 하나의 스레드가 값을 계산하고 그룹 내 다른 모든 스레드와 공유하는 통신 패턴입니다. 블록 레벨 통계 계산, 집합적 의사결정, 워프 내 모든 스레드에 설정 파라미터 전달 등의 조정 작업에 필수적입니다.

핵심 개념

이 퍼즐에서 배울 내용:

• broadcast()를 활용한 워프 레벨 브로드캐스트
• 일대다 통신 패턴
• 집합 계산 전략
• 레인 간 조건부 조정
• 브로드캐스트-shuffle 결합 연산

broadcast() 연산은 하나의 레인(기본적으로 레인 0)이 자신의 값을 다른 모든 레인과 공유할 수 있게 합니다: \[\Large \text{broadcast}(\text{value}) = \text{value_from_lane_0_to_all_lanes}\]

이를 통해 복잡한 조정 패턴이 간단한 워프 레벨 연산으로 변환되어, 명시적 동기화 없이 효율적인 집합 계산이 가능합니다.

브로드캐스트 개념

기존 조정 방식은 복잡한 공유 메모리 패턴이 필요합니다:

# 기존 방식 - 복잡하고 오류가 발생하기 쉬움
shared_memory[lane] = local_computation()
sync_threads()  # 비용이 큰 동기화
if lane == 0:
    result = compute_from_shared_memory()
sync_threads()  # 또 다른 비용이 큰 동기화
final_result = shared_memory[0]  # 모든 스레드가 읽음

기존 방식의 문제점:

• 메모리 오버헤드: 공유 메모리 할당이 필요
• 동기화: 비용이 큰 배리어 연산이 여러 번 필요
• 복잡한 로직: 공유 메모리 인덱스와 접근 패턴 관리
• 오류 발생 가능성: 경쟁 상태가 쉽게 발생

broadcast()를 사용하면 조정이 간결해집니다:

# 워프 브로드캐스트 방식 - 간단하고 안전
collective_value = 0
if lane == 0:
    collective_value = compute_block_statistic()
collective_value = broadcast(collective_value)  # 모든 레인과 공유
result = use_collective_value(collective_value)

브로드캐스트의 장점:

• 메모리 오버헤드 제로: 공유 메모리 불필요
• 자동 동기화: SIMT 실행이 정확성을 보장
• 간단한 패턴: 하나의 레인이 계산하고 모든 레인이 수신
• 조합 가능: 다른 워프 연산과 쉽게 결합

1. 기본 브로드캐스트

레인 0이 블록 레벨 통계를 계산하고 모든 레인과 공유하는 기본 브로드캐스트 패턴을 구현합니다.

요구사항:

• 레인 0이 현재 블록의 처음 4개 요소의 합을 계산해야 합니다
• 이 계산된 값을 broadcast()를 사용하여 워프의 다른 모든 레인과 공유해야 합니다
• 각 레인은 이 공유된 값을 자신의 입력 요소에 더해야 합니다

테스트 데이터: 입력 [1, 2, 3, 4, 5, 6, 7, 8, ...]은 출력 [11, 12, 13, 14, 15, 16, 17, 18, ...]을 생성해야 합니다

과제: 하나의 레인만 블록 레벨 계산을 수행하되, 모든 레인이 그 결과를 자신의 개별 연산에 사용하려면 어떻게 조정해야 할까요?

구성

• 벡터 크기: SIZE = WARP_SIZE (GPU에 따라 32 또는 64)
• 그리드 구성: (1, 1) 그리드당 블록 수
• 블록 구성: (WARP_SIZE, 1) 블록당 스레드 수
• 데이터 타입: DType.float32
• 레이아웃: Layout.row_major(SIZE) (1D row-major)

완성할 코드

fn basic_broadcast[
    layout: Layout, size: Int
](
    output: LayoutTensor[dtype, layout, MutAnyOrigin],
    input: LayoutTensor[dtype, layout, ImmutAnyOrigin],
):
    """
    Basic broadcast: Lane 0 computes a block-local value, broadcasts it to all lanes.
    Each lane then uses this broadcast value in its own computation.
    """
    global_i = Int(block_dim.x * block_idx.x + thread_idx.x)
    lane = Int(lane_id())
    if global_i < size:
        var broadcast_value: output.element_type = 0.0

        # FILL IN (roughly 10 lines)

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

브로드캐스트 전: 레인 0은 val₀, 레인 1은 val₁, 레인 2는 val₂, ...
브로드캐스트 후: 레인 0은 val₀, 레인 1은 val₀, 레인 2는 val₀, ...

var shared_value = 초기값
if lane == 0:
    # 레인 0만 계산
    shared_value = 특별한_계산()
# 모든 레인이 브로드캐스트에 참여
shared_value = broadcast(shared_value)

기본 브로드캐스트 테스트:

pixi run p25 --broadcast-basic

pixi run -e amd p25 --broadcast-basic

pixi run -e apple p25 --broadcast-basic

uv run poe p25 --broadcast-basic

풀었을 때의 예상 출력:

WARP_SIZE:  32
SIZE:  32
output: HostBuffer([11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0])
expected: HostBuffer([11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0])
✅ Basic broadcast test passed!

솔루션

fn basic_broadcast[
    layout: Layout, size: Int
](
    output: LayoutTensor[dtype, layout, MutAnyOrigin],
    input: LayoutTensor[dtype, layout, ImmutAnyOrigin],
):
    """
    Basic broadcast: Lane 0 computes a block-local value, broadcasts it to all lanes.
    Each lane then uses this broadcast value in its own computation.
    """
    global_i = Int(block_dim.x * block_idx.x + thread_idx.x)
    lane = Int(lane_id())

    if global_i < size:
        # Step 1: Lane 0 computes special value (sum of first 4 elements in this block)
        var broadcast_value: output.element_type = 0.0
        if lane == 0:
            block_start = Int(block_idx.x * block_dim.x)
            var sum: output.element_type = 0.0
            for i in range(4):
                if block_start + i < size:
                    sum += input[block_start + i]
            broadcast_value = sum

        # Step 2: Broadcast lane 0's value to all lanes in this warp
        broadcast_value = broadcast(broadcast_value)

        # Step 3: All lanes use broadcast value in their computation
        output[global_i] = broadcast_value + input[global_i]

if global_i < size:
    # 단계 1: 레인 0이 특별한 값을 계산
    var broadcast_value: output.element_type = 0.0
    if lane == 0:
        # 레인 0만 이 계산을 수행
        block_start = block_idx.x * block_dim.x
        var sum: output.element_type = 0.0
        for i in range(4):
            if block_start + i < size:
                sum += input[block_start + i]
        broadcast_value = sum

    # 단계 2: 레인 0의 값을 모든 레인과 공유
    broadcast_value = broadcast(broadcast_value)

    # 단계 3: 모든 레인이 브로드캐스트 값을 활용
    output[global_i] = broadcast_value + input[global_i]

사이클 1: 레인별 계산
  레인 0: input[0] + input[1] + input[2] + input[3] = 1+2+3+4 = 10을 계산
  레인 1: broadcast_value는 0.0 유지 (레인 0이 아님)
  레인 2: broadcast_value는 0.0 유지 (레인 0이 아님)
  ...
  레인 31: broadcast_value는 0.0 유지 (레인 0이 아님)

사이클 2: broadcast(broadcast_value) 실행
  레인 0: 자신의 값 유지 → broadcast_value = 10.0
  레인 1: 레인 0의 값 수신 → broadcast_value = 10.0
  레인 2: 레인 0의 값 수신 → broadcast_value = 10.0
  ...
  레인 31: 레인 0의 값 수신 → broadcast_value = 10.0

사이클 3: 브로드캐스트 값을 활용한 개별 계산
  레인 0: output[0] = 10.0 + input[0] = 10.0 + 1.0 = 11.0
  레인 1: output[1] = 10.0 + input[1] = 10.0 + 2.0 = 12.0
  레인 2: output[2] = 10.0 + input[2] = 10.0 + 3.0 = 13.0
  ...
  레인 31: output[31] = 10.0 + input[31] = 10.0 + 32.0 = 42.0

2. 조건부 브로드캐스트

레인 0이 블록 데이터를 분석하고 모든 레인에 영향을 미치는 결정을 내리는 조건부 조정을 구현합니다.

요구사항:

• 레인 0이 현재 블록의 처음 8개 요소를 분석하고 최댓값을 찾아야 합니다
• 이 최댓값을 broadcast()를 사용하여 다른 모든 레인에 전달해야 합니다
• 각 레인은 조건부 로직을 적용합니다: 자신의 요소가 최댓값의 절반보다 크면 2배로, 그렇지 않으면 절반으로 만듭니다

테스트 데이터: 입력 [3, 1, 7, 2, 9, 4, 6, 8, ...] (반복 패턴)은 출력 [1.5, 0.5, 14.0, 1.0, 18.0, 2.0, 12.0, 16.0, ...]을 생성해야 합니다

과제: 블록 레벨 분석과 요소별 조건부 변환을 모든 레인에 걸쳐 어떻게 조정할까요?

구성

• 벡터 크기: SIZE = WARP_SIZE (GPU에 따라 32 또는 64)
• 그리드 구성: (1, 1) 그리드당 블록 수
• 블록 구성: (WARP_SIZE, 1) 블록당 스레드 수

완성할 코드

fn conditional_broadcast[
    layout: Layout, size: Int
](
    output: LayoutTensor[dtype, layout, MutAnyOrigin],
    input: LayoutTensor[dtype, layout, ImmutAnyOrigin],
):
    """
    Conditional broadcast: Lane 0 makes a decision based on block-local data, broadcasts it to all lanes.
    All lanes apply different logic based on the broadcast decision.
    """
    global_i = Int(block_dim.x * block_idx.x + thread_idx.x)
    lane = Int(lane_id())
    if global_i < size:
        var decision_value: output.element_type = 0.0

        # FILL IN (roughly 10 lines)

        current_input = input[global_i]
        threshold = decision_value / 2.0
        if current_input >= threshold:
            output[global_i] = current_input * 2.0  # Double if >= threshold
        else:
            output[global_i] = current_input / 2.0  # Halve if < threshold

var decision = 기본값
if lane == 0:
    # 블록 로컬 데이터 분석
    decision = 분석_후_결정()
decision = broadcast(decision)

if (로컬_데이터가 broadcast_기준을 충족):
    # 하나의 변환 적용
else:
    # 다른 변환 적용

조건부 브로드캐스트 테스트:

pixi run p25 --broadcast-conditional

pixi run -e amd p25 --broadcast-conditional

uv run poe p25 --broadcast-conditional

풀었을 때의 예상 출력:

WARP_SIZE:  32
SIZE:  32
output: HostBuffer([1.5, 0.5, 14.0, 1.0, 18.0, 2.0, 12.0, 16.0, 1.5, 0.5, 14.0, 1.0, 18.0, 2.0, 12.0, 16.0, 1.5, 0.5, 14.0, 1.0, 18.0, 2.0, 12.0, 16.0, 1.5, 0.5, 14.0, 1.0, 18.0, 2.0, 12.0, 16.0])
expected: HostBuffer([1.5, 0.5, 14.0, 1.0, 18.0, 2.0, 12.0, 16.0, 1.5, 0.5, 14.0, 1.0, 18.0, 2.0, 12.0, 16.0, 1.5, 0.5, 14.0, 1.0, 18.0, 2.0, 12.0, 16.0, 1.5, 0.5, 14.0, 1.0, 18.0, 2.0, 12.0, 16.0])
✅ Conditional broadcast test passed!

솔루션

fn conditional_broadcast[
    layout: Layout, size: Int
](
    output: LayoutTensor[dtype, layout, MutAnyOrigin],
    input: LayoutTensor[dtype, layout, ImmutAnyOrigin],
):
    """
    Conditional broadcast: Lane 0 makes a decision based on block-local data, broadcasts it to all lanes.
    All lanes apply different logic based on the broadcast decision.
    """
    global_i = Int(block_dim.x * block_idx.x + thread_idx.x)
    lane = Int(lane_id())

    if global_i < size:
        # Step 1: Lane 0 analyzes block-local data and makes decision (find max of first 8 in block)
        var decision_value: output.element_type = 0.0
        if lane == 0:
            block_start = Int(block_idx.x * block_dim.x)
            decision_value = input[block_start] if block_start < size else 0.0
            for i in range(1, min(8, min(WARP_SIZE, size - block_start))):
                if block_start + i < size:
                    current_val = input[block_start + i]
                    if current_val > decision_value:
                        decision_value = current_val

        # Step 2: Broadcast decision to all lanes in this warp
        decision_value = broadcast(decision_value)

        # Step 3: All lanes apply conditional logic based on broadcast decision
        current_input = input[global_i]
        threshold = decision_value / 2.0
        if current_input >= threshold:
            output[global_i] = current_input * 2.0  # Double if >= threshold
        else:
            output[global_i] = current_input / 2.0  # Halve if < threshold

if global_i < size:
    # 단계 1: 레인 0이 블록 데이터를 분석하고 결정을 내림
    var decision_value: output.element_type = 0.0
    if lane == 0:
        # 블록의 처음 8개 요소 중 최댓값 찾기
        block_start = block_idx.x * block_dim.x
        decision_value = input[block_start] if block_start < size else 0.0
        for i in range(1, min(8, min(WARP_SIZE, size - block_start))):
            if block_start + i < size:
                current_val = input[block_start + i]
                if current_val > decision_value:
                    decision_value = current_val

    # 단계 2: 결정을 broadcast하여 모든 레인을 조정
    decision_value = broadcast(decision_value)

    # 단계 3: 모든 레인이 브로드캐스트에 기반한 조건부 로직을 적용
    current_input = input[global_i]
    threshold = decision_value / 2.0
    if current_input >= threshold:
        output[global_i] = current_input * 2.0  # 임계값 이상이면 2배
    else:
        output[global_i] = current_input / 2.0  # 임계값 미만이면 절반

입력 데이터: [3.0, 1.0, 7.0, 2.0, 9.0, 4.0, 6.0, 8.0, ...]

단계 1: 레인 0이 처음 8개 요소의 최댓값을 찾음
  레인 0 분석:
    input[0] = 3.0으로 시작
    input[1] = 1.0과 비교 → 3.0 유지
    input[2] = 7.0과 비교 → 7.0으로 갱신
    input[3] = 2.0과 비교 → 7.0 유지
    input[4] = 9.0과 비교 → 9.0으로 갱신
    input[5] = 4.0과 비교 → 9.0 유지
    input[6] = 6.0과 비교 → 9.0 유지
    input[7] = 8.0과 비교 → 9.0 유지
    최종 decision_value = 9.0

단계 2: decision_value = 9.0을 모든 레인에 broadcast
  모든 레인: decision_value = 9.0, threshold = 4.5

단계 3: 레인별 조건부 실행
  레인 0: input[0] = 3.0 < 4.5 → output[0] = 3.0 / 2.0 = 1.5
  레인 1: input[1] = 1.0 < 4.5 → output[1] = 1.0 / 2.0 = 0.5
  레인 2: input[2] = 7.0 ≥ 4.5 → output[2] = 7.0 * 2.0 = 14.0
  레인 3: input[3] = 2.0 < 4.5 → output[3] = 2.0 / 2.0 = 1.0
  레인 4: input[4] = 9.0 ≥ 4.5 → output[4] = 9.0 * 2.0 = 18.0
  레인 5: input[5] = 4.0 < 4.5 → output[5] = 4.0 / 2.0 = 2.0
  레인 6: input[6] = 6.0 ≥ 4.5 → output[6] = 6.0 * 2.0 = 12.0
  레인 7: input[7] = 8.0 ≥ 4.5 → output[7] = 8.0 * 2.0 = 16.0
  ...나머지 레인에 패턴 반복

3. 브로드캐스트-shuffle 조정

broadcast()와 shuffle_down()을 모두 결합한 고급 조정을 구현합니다.

요구사항:

• 레인 0이 블록의 처음 4개 요소의 평균을 계산하고 이 스케일링 팩터를 모든 레인에 브로드캐스트해야 합니다
• 각 레인은 shuffle_down(offset=1)을 사용하여 다음 이웃의 값을 가져와야 합니다
• 대부분의 레인: 스케일링 팩터에 (현재_값 + 다음_이웃_값)을 곱합니다
• 워프의 마지막 레인: 스케일링 팩터에 현재_값만 곱합니다 (유효한 이웃 없음)

테스트 데이터: 입력은 [2, 4, 6, 8, 1, 3, 5, 7, ...] 패턴을 따릅니다 (처음 4개 요소: 2,4,6,8 이후 1,3,5,7 반복)

• 레인 0이 스케일링 팩터를 계산: (2+4+6+8)/4 = 5.0
• 예상 출력: [30.0, 50.0, 70.0, 45.0, 20.0, 40.0, 60.0, 40.0, ...]

과제: 하나의 레인의 계산이 모든 레인에 영향을 미치면서, 각 레인이 자신의 이웃 데이터에도 접근해야 하는 상황에서 여러 워프 기본 요소를 어떻게 조정할까요?

구성

• 벡터 크기: SIZE = WARP_SIZE (GPU에 따라 32 또는 64)
• 그리드 구성: (1, 1) 그리드당 블록 수
• 블록 구성: (WARP_SIZE, 1) 블록당 스레드 수

완성할 코드

fn broadcast_shuffle_coordination[
    layout: Layout, size: Int
](
    output: LayoutTensor[dtype, layout, MutAnyOrigin],
    input: LayoutTensor[dtype, layout, ImmutAnyOrigin],
):
    """
    Combine broadcast() and shuffle_down() for advanced warp coordination.
    Lane 0 computes block-local scaling factor, broadcasts it to all lanes in the warp.
    Each lane uses shuffle_down() for neighbor access and applies broadcast factor.
    """
    global_i = Int(block_dim.x * block_idx.x + thread_idx.x)
    lane = Int(lane_id())
    if global_i < size:
        var scale_factor: output.element_type = 0.0

        # FILL IN (roughly 14 lines)

# 단계 1: 브로드캐스트 조정
var shared_param = lane_0이면_계산()
shared_param = broadcast(shared_param)

# 단계 2: 셔플 이웃 접근
current_val = input[global_i]
neighbor_val = shuffle_down(current_val, offset)

# 단계 3: 결합 계산
result = 결합(current_val, neighbor_val, shared_param)

브로드캐스트-shuffle 조정 테스트:

pixi run p25 --broadcast-shuffle-coordination

pixi run -e amd p25 --broadcast-shuffle-coordination

uv run poe p25 --broadcast-shuffle-coordination

풀었을 때의 예상 출력:

WARP_SIZE:  32
SIZE:  32
output: HostBuffer([30.0, 50.0, 70.0, 45.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 35.0])
expected: HostBuffer([30.0, 50.0, 70.0, 45.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 40.0, 20.0, 40.0, 60.0, 35.0])
✅ 브로드캐스트 + 셔플 coordination test passed!

솔루션

fn broadcast_shuffle_coordination[
    layout: Layout, size: Int
](
    output: LayoutTensor[dtype, layout, MutAnyOrigin],
    input: LayoutTensor[dtype, layout, ImmutAnyOrigin],
):
    """
    Combine broadcast() and shuffle_down() for advanced warp coordination.
    Lane 0 computes block-local scaling factor, broadcasts it to all lanes in the warp.
    Each lane uses shuffle_down() for neighbor access and applies broadcast factor.
    """
    global_i = Int(block_dim.x * block_idx.x + thread_idx.x)
    lane = Int(lane_id())

    if global_i < size:
        # Step 1: Lane 0 computes block-local scaling factor
        var scale_factor: output.element_type = 0.0
        if lane == 0:
            # Compute average of first 4 elements in this block's data
            block_start = Int(block_idx.x * block_dim.x)
            var sum: output.element_type = 0.0
            for i in range(4):
                if block_start + i < size:
                    sum += input[block_start + i]
            scale_factor = sum / 4.0

        # Step 2: Broadcast scaling factor to all lanes in this warp
        scale_factor = broadcast(scale_factor)

        # Step 3: Each lane gets current and next values
        current_val = input[global_i]
        next_val = shuffle_down(current_val, 1)

        # Step 4: Apply broadcast factor with neighbor coordination
        if lane < WARP_SIZE - 1 and global_i < size - 1:
            # Combine current + next, then scale by broadcast factor
            output[global_i] = (current_val + next_val) * scale_factor
        else:
            # Last lane in warp or last element: only current value, scaled by broadcast factor
            output[global_i] = current_val * scale_factor

if global_i < size:
    # 단계 1: 레인 0이 블록 로컬 스케일링 팩터를 계산
    var scale_factor: output.element_type = 0.0
    if lane == 0:
        block_start = block_idx.x * block_dim.x
        var sum: output.element_type = 0.0
        for i in range(4):
            if block_start + i < size:
                sum += input[block_start + i]
        scale_factor = sum / 4.0

    # 단계 2: 스케일링 팩터를 모든 레인에 broadcast
    scale_factor = broadcast(scale_factor)

    # 단계 3: 각 레인이 shuffle을 통해 현재 값과 다음 값을 가져옴
    current_val = input[global_i]
    next_val = shuffle_down(current_val, 1)

    # 단계 4: 브로드캐스트 팩터를 이웃 조정과 결합하여 적용
    if lane < WARP_SIZE - 1 and global_i < size - 1:
        output[global_i] = (current_val + next_val) * scale_factor
    else:
        output[global_i] = current_val * scale_factor

입력 데이터: [2, 4, 6, 8, 1, 3, 5, 7, ...]

단계 1: 레인 0이 스케일링 팩터를 계산
  레인 0 계산: (input[0] + input[1] + input[2] + input[3]) / 4
              = (2 + 4 + 6 + 8) / 4 = 20 / 4 = 5.0
  다른 레인: scale_factor는 0.0 유지

단계 2: scale_factor = 5.0을 모든 레인에 broadcast
  모든 레인: scale_factor = 5.0

단계 3: 이웃 접근을 위한 셔플 연산
  레인 0: current_val = input[0] = 2, next_val = shuffle_down(2, 1) = input[1] = 4
  레인 1: current_val = input[1] = 4, next_val = shuffle_down(4, 1) = input[2] = 6
  레인 2: current_val = input[2] = 6, next_val = shuffle_down(6, 1) = input[3] = 8
  레인 3: current_val = input[3] = 8, next_val = shuffle_down(8, 1) = input[4] = 1
  ...
  레인 31: current_val = input[31], next_val = 미정의

단계 4: 브로드캐스트 스케일링과 결합한 계산
  레인 0: output[0] = (2 + 4) * 5.0 = 6 * 5.0 = 30.0
  레인 1: output[1] = (4 + 6) * 5.0 = 10 * 5.0 = 50.0
  레인 2: output[2] = (6 + 8) * 5.0 = 14 * 5.0 = 70.0
  레인 3: output[3] = (8 + 1) * 5.0 = 9 * 5.0 = 45.0
  ...
  레인 31: output[31] = 7 * 5.0 = 35.0 (경계 - 이웃 없음)

요약

이 섹션의 핵심 패턴은 다음과 같습니다

var shared_value = initial_value
if lane == 0:
    shared_value = compute_block_statistic()
shared_value = broadcast(shared_value)
result = use_shared_value(shared_value, local_data)

핵심 장점:

• 일대다 조정: 하나의 레인이 계산하고 모든 레인이 혜택을 받음
• 동기화 오버헤드 제로: SIMT 실행이 조정을 처리
• 조합 가능한 패턴: 셔플과 다른 워프 연산과 쉽게 결합

활용 분야: 블록 통계, 집합적 의사결정, 파라미터 공유, 적응형 알고리즘.