콘텐츠로 이동

Synchronization

Legato 영역은 명시적인 의존성이 없으면 비동기로 실행될 수 있습니다.
데이터 이동 연산이 top 작업과 코어 작업을 잇는 synchronization 지점을 만듭니다.

load와 receive 순서

legato.tensor.request_load는 load 요청을 발행합니다. legato.tensor.receive 또는 legato.tensor.receive_type이 요청한 데이터를 대상 컨텍스트에서 실체화합니다.

1
2
3
4
5
with device.get_top():
    legato.tensor.request_load(x, device.get_core(0), "sram")

with device.get_core(0):
    received_x = legato.tensor.receive(x, 0, "sram")

세 번째 인자는 대상 이름입니다. 흔히 쓰는 Bertha 대상은 "sram"과 "mpu_buffer"입니다.

여러 요청

같은 대상에 요청을 여러 개 발행하면, 현재 Bertha 흐름은 보통 요청 순서대로 소비합니다.

1
2
3
4
5
6
7
with device.get_top():
    legato.tensor.request_load(x, device.get_core(0), "sram")
    legato.tensor.request_load(y, device.get_core(0), "sram")

with device.get_core(0):
    received_x = legato.tensor.receive(x, 0, "sram")
    received_y = legato.tensor.receive(y, 1, "sram")

타입이 지정된 receive에는 대상 텐서 타입과, 필요하면 동적 shape을 주십시오.

1
2
3
4
5
6
weight_type = legato.get_model().tensor_type(
    legato.types.float("bfloat16"), [256, 128], "mpu_weight"
)

with device.get_core(0):
    weight = legato.tensor.receive_type(weight_type, 0, None, "mpu_buffer")

순서 요구 사항

요청과 수신을 문서에 설명된 순서대로 짝지어 올바른 실행 컨텍스트에 작성하십시오. 값이 아니라 공유 저장 공간을 통해 의존성이 전달되면 명시적인 동기화를 사용합니다.

컨텍스트 간 barrier (legato.sync)

데이터가 값으로 전달되는 의존성이 아니라 opaque(컴파일러가 내용을 추적할 수 없는) DRAM 파라미터를 통해 흐를 때는, 명시적인 barrier id로 producer(데이터를 만드는 쪽)와 consumer(데이터를 쓰는 쪽) 컨텍스트의 순서를 강제하십시오.

1
2
3
4
5
6
7
with device.get_core(0):
    legato.tensor.memcpy(k_view, k)
    legato.sync.signal(0)          # core producer

with device.get_top():
    legato.sync.wait(0, device.get_core(0))   # top consumer
    legato.tensor.request_load(k_view, device.get_core(0), "mpu_buffer")

정적 barrier 핸들

정적 barrier id를 여러 곳에서 공유하고 이름 붙은 핸들이 짝을 읽기 쉽게 해 줄 때는 legato.sync.barrier(id)를 사용하십시오. 이 핸들은 컴파일 시점에 해석되며, 정수 id를 넘기는 것과 정확히 같게 lowering됩니다.

1
2
3
4
5
6
7
8
9
k_ready = legato.sync.barrier(1)

with device.get_core(0):
    legato.tensor.memcpy(k_view, k)
    legato.sync.signal(k_ready)

with device.get_top():
    legato.sync.wait(k_ready, device.get_core(0))
    legato.tensor.request_load(k_view, device.get_core(0), "mpu_buffer")

동적 barrier id

barrier id를 런타임에만 알 수 있을 때(예: 커널 인자에서 올 때)는 executor 컨텍스트 안에서 index로 cast하고, 그 SSA 값을 signal과 wait 양쪽에 사용하십시오. top 쪽 wait에는 여전히 devices=가 필요합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from legato.language import arith

# barrier_slot: legato.types.integer("int64")  — 커널 파라미터

with device.get_core(0):
    legato.tensor.memcpy(k_view, k)
    dyn_id = arith.cast(barrier_slot, legato.types.index())
    legato.sync.signal(dyn_id)

with device.get_top():
    dyn_id = arith.cast(barrier_slot, legato.types.index())
    legato.sync.wait(dyn_id, device.get_core(0))
    legato.tensor.request_load(k_view, device.get_core(0), "mpu_buffer")

컴파일러는 런타임 id만으로는 producer 코어를 추론할 수 없으므로, wait에서 devices=를 생략하면 컴파일 에러입니다.

동적 core mask (devices=)

device.get_core(0) 같은 정적 executor 리스트 대신 index SSA 코어 bitmask를 넘길 수 있습니다. 동적 request_load 대상에 쓰는 것과 같은 형태의 값입니다. 리터럴 barrier id는 상수로 두어도 됩니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from legato.language import arith

# core_mask: legato.types.integer("int64")  — 런타임 bitmap, 예: (1 << core_id)

with device.get_core(0):
    legato.tensor.memcpy(k_view, k)
    legato.sync.signal(0)

with device.get_top():
    cores = arith.cast(core_mask, legato.types.index())
    legato.sync.wait(0, cores)
    legato.tensor.request_load(k_view, device.get_core(0), "mpu_buffer")

arith.cast(...)는 with device.get_top(): 안에서 (signal이면 producer 코어 컨텍스트 안에서) 만드십시오. 함수 범위에서 만든 cast는 executor가 없어 lowering에 실패합니다.

완전히 동적인 id와 core mask

barrier id와 core mask가 모두 런타임 값이면, 각 executor 컨텍스트 안에서 cast하고 producer 코어와 top에서 같은 dyn_id를 사용하십시오.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from legato.language import arith

with device.get_core(0):
    legato.tensor.memcpy(k_view, k)
    dyn_id = arith.cast(barrier_slot, legato.types.index())
    legato.sync.signal(dyn_id)

with device.get_top():
    dyn_id = arith.cast(barrier_slot, legato.types.index())
    cores = arith.cast(core_mask, legato.types.index())
    legato.sync.wait(dyn_id, cores)

이런 패턴에서는 producer/consumer 균형을 정적으로 증명할 수 없으면 컴파일러가 경고를 냅니다. 그 경우 정확성은 프로그램이 id와 core mask를 올바르게 짝지었는지에 달려 있습니다.

API 요약:

API 컨텍스트 동작
legato.sync.signal(id) core producer가 준비되었음을 알립니다.
legato.sync.wait(id, devices=...) top 선택한 producer를 기다립니다.
legato.sync.barrier(id) — 명시적 id를 읽기 쉽게 만드는 핸들

규칙 (v1):

  • top 쪽 sync_wait에는 모두 devices=가 필요합니다 (컴파일러는 producer 코어를 추론하지 않습니다). legato.tensor.request_load와 같은 executor 선택 방식을 씁니다 (정적 executor 리스트 또는 동적 index bitmask).
  • core 컨텍스트에서 devices=를 쓰면 에러입니다.
  • top에서 코어로의 fan-out signal(id, devices=...)은 아직 지원하지 않습니다.
  • 모든 wait는 producer 코어의 signal과 짝을 맞추십시오. 컴파일러는 균형을 검증할 수 없으면 경고하고, 교착 상태(deadlock)를 증명할 수 있으면 에러를 냅니다.
  • barrier는 분기와 반복이 없는 직선 코드(straight-line code)에 두십시오. 펼쳐지지 않은 제어 흐름(scf.for/scf.if) 안에 중첩된 signal/wait는 런타임 실행 횟수를 알 수 없어 컴파일러가 균형을 증명하지 못합니다. 이 경우 barrier는 lowering하지만 모든 교착 상태 검사를 경고로 낮추고, 프로그램이 올바르다는 데 의존합니다.