
Technology
에너자이가 Synaptics Torq NPU용 IREE/MLIR 컴파일러를 개발하면서 SLICE 병렬화로 늘어난 DMA 비용을 줄인 방법을 소개합니다.
Jaeho Kim
2026년 10월 20일
안녕하세요, 에너자이입니다. 에너자이는 최근 글로벌 반도체사인 Synaptics의 Astra SL2610 제품군에 탑재된 Torq NPU를 위해, 오픈소스 IREE/MLIR 기반 Torq 컴파일러의 백엔드 구현과 모델 최적화에 참여했는데요. 오늘은 그 여정에서 마주했던 Challenge와 얻은 Insight들에 대해 다루고자 합니다.
특히, NPU의 두 연산 블록(SLICE)으로 연산을 나눠 병렬 실행할 때 생기는 숨은 데이터 이동(DMA) 비용을, 컴파일러의 어느 계층에서 어떻게 줄였는지 자세히 소개할 예정입니다.
귀중한 기회를 만들어주신 Synaptics에 다시 한 번 감사드립니다!
아직 만들어지고 있는 NPU 생태계
최근 몇 년 사이 domain-specific architecture에 대한 관심은 빠르게 커져 왔습니다. CPU와 GPU가 범용적인 로직 처리와 대량 병렬처리 작업을 나눠 처리하는 방향으로 발전해 온 것처럼, 딥러닝에서 주로 등장하는 텐서 연산에 특화된 새로운 아키텍처에 대한 중요성도 점점 커지고 있었습니다. 특히 최근 딥러닝 모델을 기반으로 하는 서비스가 빠르게 늘어나면서 이러한 흐름은 더욱 가속되고 있는데요.
그 결과 많은 기업이 neural-network 실행에 특화된 processing unit, 즉 NPU(Neural Processing Unit)를 개발하고 실제 제품에 탑재하고 있습니다. 특히 제한된 전력과 메모리 안에서 모델을 실행하면서도 충분히 똑똑한 결과물을 제공해야 하는 엣지 컴퓨팅 산업에서는 NPU의 중요성이 더욱 큽니다.
하지만 CPU나 GPU와 달리, NPU에는 아직 성숙한 컴파일러와 런타임 환경, 그리고 이를 바탕으로 하는 두터운 생태계가 없습니다. 제조사마다 그 구조가 크게 다르고, 상용화의 역사도 GPU에 비하면 아직 짧습니다. 하드웨어와 소프트웨어의 경계를 어떻게 설정하여 어떤 식으로 인터페이스를 둘지에 대해서도 널리 합의된 기준이 없다보니, API와 인프라 역시 플랫폼마다 크게 달라집니다. 어떤 경우에는 이미 양산이 진행되고 있는 NPU임에도 이를 제대로 활용할 수 있는 소프트웨어 스택의 지원이 미비하기도 합니다.
너무 당연해 보였던 최적화
일을 나누고 병렬로 실행하는 것은 현대 최적화 기술에서 가장 기본적인 방식일 겁니다. Astra SL2619의 Torq NPU에는 SLICE라고 부르는 두 개의 compute block이 있기 때문에, 하나의 operation을 둘로 나눠 각 SLICE에서 절반씩 실행하는 것이 당연한 최적화처럼 보입니다.
그런데 조금 더 자세히 살펴보면 실제로는 그렇게 단순하지 않다는 것을 알 수 있습니다.
SLICE 프로그램은 NPU 위의 작은 on-chip memory인 LRAM에 이미 올라와 있는 데이터를 사용합니다.
XRAM은 NPU 실행을 위해 보드의 주메모리인 DRAM에 예약된 영역입니다.
데이터는 DMA를 통해 XRAM과 LRAM 사이를 이동합니다. SLICE가 연산을 위해 데이터를 사용하려면 먼저 LRAM까지 가져와야 하고, 필요한 경우 결과를 다시 XRAM으로 복사합니다.
한 텐서 연산의 데이터를 나누면 병렬 실행의 기회는 늘어날 수 있지만, 동시에 데이터 이동도 늘어날 수 있습니다. Torq 컴파일러의 파이프라인을 보면, 아직 수학적 의미의 텐서 연산을 다루는 IR(Intermediate Representation)에서 이 텐서를 어떻게 나눌지가 결정되는 구조입니다. 이 시점에는 구체적인 DMA 과정이나 SLICE 프로그램이 아직 존재하지 않습니다. 이후 나누어진 연산들이 더 낮은 단계의 IR로 변환되면, 각자 별도의 load, store, program-code transfer를 가지게 될 수 있습니다. 나누어진 연산이 같은 상수 값이나 입력을 필요로 한다면 같은 데이터가 여러 번 이동할 수도 있습니다.
또 하나 미묘한 점이 있습니다. SLICE 프로그램이 2개라고 해서 실제로 이 둘이 완전히 겹쳐서 실행됨을 보장하는 것은 아닙니다. 현재 스케줄러는 IR에 있는 start와 wait operation의 순서에 따라 작업을 배치합니다. 두 프로그램이 동시에 실행되려면 각각의 wait에 도달하기 전에 두 프로그램이 모두 먼저 시작되어야 합니다.
컴파일러 로직상 MLIR의 병렬 루프 연산인 scf.forall에 대해 펼쳐주면 (loop unroll) 위 코드블록의 첫 번째 예시와 같은 작업 스케줄이 만들어질 수 있습니다. 하지만 두 번째 예시와 같이 단순히 두 operation이 나란히 실행되도록 각 operation 바로 뒤에 자신의 wait가 붙는다면, 첫 번째 SLICE의 실행이 끝날 때까지 두 번째 SLICE는 시작하지 못하게 됩니다.
데이터 이동은 또 다른 문제를 만듭니다. DMA는 SLICE 실행과 동시에 수행될 수 있기 때문에, 데이터 이동 횟수가 늘어났다고 해서 그 시간 그대로 실행 시간이 늘어나는 것은 아닙니다. 하지만 스케줄러가 처리해야 할 일 자체는 여전히 늘어나며, 겹쳐서 실행되지 못한 부분은 결국 critical path를 길게 만듭니다.
Torq를 작업하면서 저희는 이런 패턴을 반복해서 마주쳤습니다. 수학적 의미의 텐서 연산을 표현하는 IR에서는 좋아 보였던 최적화가 컴파일러의 더 낮은 단계에 내려가고 나서야 새로운 비용을 드러내는 경우가 있었습니다. 병렬화 자체가 어렵다기보다는, 병렬화를 위해 새로 추가되는 비용을 충분히 이른 시점에 알아내고 최소화하는 것이 어려웠습니다.
이 관찰은 자연스럽게 컴파일러 설계에 대한 질문으로 이어집니다. 어떤 결정이 한 추상화 단계에서 이루어지지만 그 비용은 다른 추상화 단계에서 나타난다면, 각각의 최적화는 어디에서 수행되어야 할까요?
Torq가 여러 컴파일러 계층을 사용하는 이유
컴파일러는 원래의 모델을 최종 하드웨어 코드로 바꾸기까지 여러 형태의 IR을 거칩니다. 그리고 최적화마다 판단에 필요한 정보가 다릅니다.
어떤 최적화는 하드웨어와 상관없이 여러 환경에서 공통으로 사용할 수 있지만, 어떤 최적화는 대상 하드웨어의 데이터 흐름이나 지원 연산, 메모리 구조를 알아야만 제대로 적용할 수 있습니다. 문제는 이 둘이 완전히 독립적이지 않다는 점입니다. 앞 단계에서 내린 결정이 뒤 단계의 성능에 그대로 영향을 줍니다.
연산 결합(fusion)이 대표적인 예입니다. 여러 연산을 하나로 합치면 중간 결과를 별도로 만들어 메모리에 저장하는 일을 줄일 수 있습니다. 하지만 합쳐진 연산이 NPU가 직접 지원하는 소수의 전용 연산 형태에 맞지 않을 수도 있고, 억지로 맞추는 과정에서 생기는 비용이 오히려 연산을 합쳐 얻는 이득보다 커질 수도 있습니다. 타일링(tiling)도 마찬가지입니다. 텐서를 어떤 크기로 나눌지는 비교적 높은 단계의 IR에서도 결정할 수 있지만, 실제로 어떤 크기가 효율적인지는 결국 하드웨어의 메모리 용량과 할당 방식에 따라 달라집니다.
Torq는 이런 문제를 해결하기 위해 컴파일러를 여러 계층으로 나눕니다. MLIR에서는 각 계층을 dialect라는 단위로 구성하고, dialect마다 서로 다른 추상화 단계의 연산과 정보를 표현합니다. Torq는 텐서의 수학적 의미와 높은 단계의 최적화를 가능한 한 오래 MLIR의 표준 dialect에 남겨 둡니다. NPU 프로그램이나 메모리 배치처럼 구체적인 하드웨어 정보가 필요해지는 시점부터 Torq 전용 dialect를 사용합니다.
Torq 컴파일러는 IREE plugin으로 구현되어 있고, MLIR을 기반으로 동작합니다. 이 글에서 주로 다루는 계층은 다음 세 가지입니다.
linalg계층: 텐서 연산을 주로 수학적인 의미로 표현하는 MLIR의 표준 dialect입니다. 타일링이나 연산 결합처럼 하드웨어에 지나치게 종속되지 않은 최적화가 주로 이 단계에서 이루어집니다. 일부 패스가 대상 하드웨어의 정보를 참고할 수는 있지만, 아직 실제 NPU 프로그램이나 내부 데이터 경로까지 드러나지는 않습니다.torq_hl계층: 연산에 Torq NPU의 의미를 부여하는 dialect입니다. XRAM과 LRAM 사이의 데이터 이동과 SLICE 프로그램 실행이 이 단계부터 직접 표현되기 때문에, 어떤 데이터를 NPU 메모리 안팎으로 옮겨야 하는지, 프로그램을 언제 실행하는지가 보이기 시작합니다.torq_hw계층: 실제 하드웨어가 사용하는 descriptor에 대응하는 dialect입니다. D/W/B/Q 데이터 경로와 ALU/ACT 설정처럼 하나의 SLICE 작업을 실제로 구성하는 정보가 IR에 직접 나타납니다.
같은 행렬 곱셈이 각 계층에서 어떻게 표현되는지 보면 차이를 더 쉽게 이해할 수 있습니다.
세 단계에서 수행하려는 계산 자체는 같습니다. 달라지는 것은 IR에 담기는 정보의 구체성입니다. linalg에서는 텐서 연산의 수학적 의미만 중요합니다. torq_hl로 내려오면 이 연산을 NPU에서 실행하기 위해 필요한 정보가 붙습니다. 마지막으로 torq_hw에서는 D(Input Data), W(Weight), B(Bias/Scale), Q(Output)와 ALU/ACT 설정처럼 실제 하드웨어 동작에 가까운 정보까지 드러납니다.
여기에 프로그램 실행과 데이터 이동까지 포함하면, 높은 단계의 IR에서는 보이지 않던 비용이 더욱 분명해집니다.
linalg에서는 행렬 곱셈 하나로 보이던 연산이 torq_hl에서는 XRAM 주소를 찾고, LRAM을 할당하고, 입력을 불러오고, 프로그램을 실행한 뒤 기다리고, 마지막 결과를 다시 저장하는 여러 단계로 풀어집니다. 실제 계산은 똑같지만, 그 계산을 NPU에서 실행하기 위해 필요한 준비 비용이 이 단계부터 눈에 보이기 시작합니다.
저희가 Torq를 작업하면서 여러 컴파일러 계층이 중요하다고 느낀 이유도 여기에 있습니다. linalg 단계에서 텐서를 한 번 나누는 결정이 torq_hl에서는 추가 메모리 주소와 DMA, 프로그램 실행으로 이어질 수 있습니다. 반대로 어떤 문제는 이런 하드웨어 세부사항이 생기기 전에 고치는 편이 훨씬 쉽고, 또 어떤 문제는 낮은 단계까지 내려가야 필요한 정보를 얻을 수 있습니다. 모든 최적화를 한 단계에 몰아넣기보다, 필요한 정보가 드러나는 시점에 각각의 문제를 처리하는 편이 훨씬 자연스럽습니다.
이런 구조는 새로운 하드웨어에 대응할 때도 도움이 됩니다. NPU가 지원하는 연산이나 메모리 크기, 내부 데이터 경로는 제품 세대에 따라 달라질 수 있습니다. 높은 단계의 텐서 의미와 낮은 단계의 하드웨어 세부사항을 분리해 두면, 대상 하드웨어가 바뀌더라도 컴파일러 전체를 함께 뜯어고쳐야 하는 범위를 줄일 수 있습니다.
Slicing으로 생긴 추가 비용 줄이기
이제 병렬화를 위해 텐서를 나눴을 때 추가 비용이 어디에서 생기는지 확인할 수 있게 되었습니다. 이후 저희가 진행한 최적화의 방향은 비교적 분명했습니다. 병렬 실행 자체는 유지하면서, 그 과정에서 불필요하게 늘어난 데이터 이동을 최대한 줄이는 것입니다.
다만 문제마다 필요한 정보가 달랐기 때문에 모든 수정이 같은 단계에 들어가지는 않았습니다. 어떤 문제는 아직 수학적인 텐서 연산만 보이는 linalg 단계에서 해결하는 것이 좋았고, 어떤 문제는 실제 메모리 이동이 드러나는 torq_hl까지 내려가야 해결할 수 있었습니다.
linalg에서 연속된 Elementwise 연산을 하나로 묶기
linalg 단계에서는 연속된 elementwise 연산이 각각 따로 slicing되는 경우가 있었습니다. 복합 activation이나 후처리 연산은 정규화 과정을 거치면서 여러 개의 linalg.generic 연산으로 풀어지는 경우가 많습니다. 이 연산들이 각각 다른 루프에 들어가면 앞 연산의 중간 결과가 다음 루프까지 살아남아야 하고, 이후 낮은 단계에서 XRAM에 저장되는 상황이 생길 수 있습니다.
저희는 이런 연산 묶음에 붙어 있던 torq-fuse-group 값을 하나로 통일했습니다. 컴파일러는 같은 그룹의 linalg 연산을 하나의 scf.forall 안에 넣고, 그룹이 다르면 별도의 루프로 나눕니다. 따라서 slicing이 시작되기 전에 연속된 연산 전체에 같은 그룹을 부여하면, 나중에 이미 나뉜 루프를 다시 합칠 필요 없이 처음부터 하나의 루프로 만들 수 있습니다. 아래 예시는 실제보다 긴 연산 묶음을 보기 쉽게 세 단계로 줄인 것입니다.
이 문제가 나타났던 컴파일 경로에서는 서로 다른 scf.forall 사이를 넘어가는 중간 결과가 XRAM에 저장되면서 불필요한 왕복이 생겼습니다. 연속된 연산 전체를 하나의 루프 안에 두면 중간 결과를 LRAM에 더 오래 유지할 수 있고, 그만큼 DMA도 줄어듭니다. 여기서 중요한 것은 단순히 여러 연산을 합치는 것 자체가 아니라, 연산 사이의 중간 결과를 가능한 한 칩 내부에 계속 남겨두는 것입니다.

slicing을 켠 erf(1x1024x64, bf16)의 컴파일 시점 타임라인을 보면 차이가 더 분명합니다. 각 패널의 위쪽은 elementwise 연산 전체를 하나의 fuse group으로 묶기 전, 아래쪽은 묶은 뒤입니다. 아래 패널은 파란 영역인 실행 초반 330 µs를 확대한 것입니다. ①에서는 각 연산이 끝날 때마다 두 SLICE의 결과를 XRAM으로 저장하고, ②에서는 다음 연산을 위해 같은 값을 다시 LRAM으로 읽어옵니다. ③처럼 연산 전체를 하나의 fuse group으로 묶으면 중간 결과가 LRAM에 남아 있고 SLICE 프로그램도 연달아 실행됩니다. 그 결과 store 횟수는 36회(2.6 MB)에서 7회(448 KB)로 줄었고, 추정 실행 시간도 1834.9 µs에서 888.0 µs로 줄었습니다.
메모리 변환보다 필요한 SLICE를 먼저 추출하기
다른 문제는 컴파일러가 torq_hl 단계까지 내려간 뒤에 나타났습니다. 이 단계에서도 일부 값은 여전히 텐서 형태로 표현되지만, 이제 어느 메모리에 놓일지가 type에 함께 표현됩니다. 기존 IR에서는 큰 값을 먼저 XRAM으로 옮긴 뒤, 실제로 필요한 작은 부분만 나중에 잘라내는 형태가 만들어질 수 있었습니다.
저희는 연산 순서를 바꿔, 값이 아직 LRAM에 있을 때 필요한 부분을 먼저 잘라내고 그 작은 값만 XRAM으로 옮기도록 수정했습니다. 이렇게 하면 큰 텐서 전체를 굳이 XRAM까지 내보낼 필요가 없습니다. 또한 작은 값에 남아 있는 불필요한 왕복은 기존 컴파일러 최적화가 제거할 수 있는 형태가 됩니다.

max_pool(5x5, 1x15x20x384, i8)의 실행 흐름을 보면, 변경 전에는 ① 112.5 KB 크기의 결과 전체를 XRAM으로 옮긴 뒤 ② 각 SLICE가 자신에게 필요한 56.2 KB만 다시 잘라 LRAM으로 가져옵니다. 변경 후에는 ③ 결과가 아직 LRAM에 있을 때 각 SLICE가 필요한 부분을 바로 가져가기 때문에 이 왕복 자체가 사라집니다. 추정 실행 시간은 369.3 µs에서 312.9 µs로 줄었습니다.
앞의 linalg 그룹화와 이번 수정 모두 새로운 연산을 추가한 것은 아닙니다. 필요한 변환은 이미 컴파일러 안에 있었습니다. 중요한 것은 Torq의 메모리 구조에 맞게 IR의 형태를 바꿔, 기존 최적화가 제대로 동작할 수 있는 조건을 만들어 주는 것이었습니다.
새로운 분석을 만들기보다 필요한 정보를 알려주기
torq_hl 단계까지 내려오면 LRAM 주소와 load/store, 프로그램 사이의 경계가 IR에 직접 드러납니다. 따라서 이 단계에서는 중복된 데이터 이동을 더 직접적으로 찾아낼 수 있습니다. 예를 들어 두 SLICE가 같은 읽기 전용 데이터를 각각 따로 불러오고 있다면 한 번만 옮겨 공유하는 편이 낫고, 중간 결과를 임시 XRAM에 저장했지만 이후 한 번도 읽지 않는다면 그 store는 제거하는 편이 낫습니다.
흥미로운 점은 이런 문제를 해결하는 데 필요한 분석과 변환 대부분이 이미 MLIR과 IREE 쪽에 존재했다는 것입니다. 문제는 torq_hl이 Torq 전용 dialect라서, 기존 컴파일러가 각 연산이 메모리를 어떻게 읽고 쓰는지, 또는 다른 위치로 옮겨도 되는지를 알 수 없었다는 데 있었습니다. 그래서 같은 분석을 새로 구현하는 대신, 기존 분석이 torq_hl 연산을 이해할 수 있도록 필요한 정보를 interface로 제공했습니다.
SLICE 프로그램의 각 인자가 읽기용인지 쓰기용인지는 IREE의 interface를 단순화한 AsyncAccessOpInterface를 통해 알려줍니다. 연산 단위의 메모리 접근 정보와 연산 이동 가능 여부는 각각 MemoryEffectsOpInterface와 ConditionallySpeculatable을 사용합니다. 이렇게 연산의 성질을 알려주면 기존 MLIR 분석과 유틸리티도 torq_hl을 대상으로 그대로 사용할 수 있습니다.
가장 직접적인 효과 중 하나는 필요 없는 store를 제거할 수 있게 된 것입니다. 읽기/쓰기 정보가 없다면 컴파일러는 SLICE 프로그램의 모든 인자가 읽힐 수도 있고 쓰일 수도 있다고 보수적으로 가정해야 합니다. 하지만 뒤의 프로그램이 어떤 값을 읽지 않고 새 값으로 완전히 덮어쓴다는 사실을 알 수 있다면, 앞에서 XRAM에 임시로 저장해 둔 값은 더 이상 필요하지 않습니다.
같은 정보는 LRAM이 부족해 어떤 버퍼를 잠시 XRAM으로 내보냈다가 나중에 다시 불러오는 경우에도 활용할 수 있습니다. 중간의 프로그램이 그 버퍼를 읽기만 하고 수정하지 않았다면, 앞서 XRAM에 저장한 값은 여전히 유효합니다. 따라서 새로운 XRAM 공간을 만들고 같은 데이터를 또 저장할 필요 없이, LRAM 공간만 비운 뒤 기존 XRAM 데이터를 나중에 그대로 다시 사용할 수 있습니다.

AsyncAccessOpInterface를 적용하기 전후의 conv1d 레이어(kernel 127, stride 64, 오디오 80,000 샘플에서 288 채널)를 비교하면 이 효과를 확인할 수 있습니다. ①은 다음 프로그램이 곧바로 덮어쓸 200 KB 값을 XRAM에 저장하는 불필요한 store이고, ②는 그 값과 짝을 이루는 200 KB load입니다. 두 연산은 함께 사라집니다. ③에서는 내용이 바뀌지 않은 309 KB 버퍼를 XRAM에 한 번 더 저장하고 있었는데, 변경 후에는 이미 XRAM에 남아 있는 값을 그대로 재사용합니다. 그 결과 DMA 출력은 22회(4.5 MB)에서 13회(2.4 MB)로 줄었고, 추정 실행 시간은 5091.1 µs에서 4218.8 µs로 감소했습니다.
연산 자체를 루프 밖으로 옮길 수 있는지도 비슷한 방식으로 판단할 수 있습니다. 어떤 연산이 루프를 몇 번 반복하더라도 항상 같은 결과를 만든다면, 매 반복마다 다시 계산하기보다 루프 밖에서 한 번만 계산한 뒤 결과를 재사용하는 편이 효율적입니다. 기존에는 MLIR이 torq_hl 연산을 다른 위치로 옮겨도 안전한지 판단할 수 없었습니다.
모든 torq_hl 연산을 무조건 옮길 수 있도록 한 것은 아닙니다. 실제로 위치를 바꿔도 의미가 달라지지 않는 연산만 대상으로 했고, 인덱스에 따라 값을 가져오는 연산처럼 실행 위치가 의미에 영향을 주는 경우는 제외했습니다. 덕분에 연산 이동이 가능한지 판단하는 로직을 별도로 다시 만들지 않고 MLIR의 getBackwardSlice와 moveLoopInvariantCode를 그대로 활용할 수 있었습니다.
이런 수정들을 통해 slicing 과정에서 생기던 중복 데이터 이동의 일부를 없앨 수 있었습니다. 동시에 문제를 바라보는 관점도 조금 달라졌습니다. 단순히 일을 잘 나누는 것만으로는 충분하지 않았습니다. 병렬화를 위해 추가 비용이 생긴다면, 그 비용까지 다시 줄여야 비로소 병렬 실행이 실제 성능 향상으로 이어집니다.
무엇을 배웠는가
돌이켜보면 개별적인 rewrite나 interface보다 더 중요했던 것은 여러 문제에서 반복해서 나타난 공통된 패턴이었습니다.
첫 번째는 최적화를 하려면 칩 안에서 데이터가 어떻게 움직이는지 먼저 이해해야 한다는 점입니다. Torq에서는 각 연산이 사용할 수 있는 입력 경로와 누산 경로, 후처리 경로가 정해져 있고, 이 제약에 따라 하나의 프로그램 안에 어떤 연산을 함께 넣을 수 있는지가 결정됩니다. 작업 개수나 DMA 전송량은 문제를 찾는 데 좋은 지표이지만, 숫자가 줄었다고 해서 항상 실행 시간이 줄어드는 것은 아닙니다. 연산을 합쳐 작업 수가 줄었더라도 실제로 어떤 커널 경로를 선택하게 되는지, 전체 실행 시간을 결정하는 경로가 어떻게 바뀌는지까지 확인해야 합니다.
두 번째는 제한된 LRAM 안에서 타일링, 연산 결합, slicing을 서로 따로 생각하기 어렵다는 점입니다. 세 가지 모두 어떤 데이터를 칩 안에 남겨둘지, 한 번에 얼마나 많이 보관할지, 그리고 데이터를 몇 번 다시 옮겨야 할지를 결정합니다. 각각을 독립적으로 최적화하면 한쪽에서 얻은 이득을 다른 쪽이 다시 깎아먹는 상황이 쉽게 생깁니다.
그렇다고 모든 정보를 하나의 하드웨어 전용 IR에 몰아넣는 것이 답은 아닙니다. 여러 단계로 나뉜 컴파일러 구조가 최적화 사이의 영향을 없애 주는 것은 아니지만, 그 영향이 어디에서 생기는지 드러나게 해 줍니다. 높은 단계에서는 텐서 연산의 의미를 유지한 채 변환을 수행하고, 낮은 단계에서는 그 결정이 실제 하드웨어에서 어떤 비용으로 이어지는지를 확인할 수 있습니다. 저희에게 이 구조의 장점은 단순히 컴파일러 설계를 깔끔하게 만드는 데 있다기보다, 필요한 정보를 필요한 순간에 볼 수 있게 해 준다는 데 있었습니다.
다음 단계
이 경험은 앞으로 Torq 컴파일러를 어떤 방향으로 발전시키고 싶은지에도 영향을 주고 있습니다. 저희의 목표는 더 다양한 모델과 앞으로 나올 하드웨어를 지원하면서도, 새로운 대상이 추가될 때마다 예외 처리를 계속 덧붙여야 하는 구조를 피하는 것입니다.
1. EasyKernel에서 Nadya로.
현재 Torq의 커널은 자체 C++ DSL인 EasyKernel로 작성되어 있습니다. 하드웨어 descriptor나 instruction stream을 직접 작성하는 대신, 일반적인 반복문에 가까운 형태로 커널을 작성하면 이를 실제 descriptor로 변환해 줍니다. 훨씬 다루기 쉬운 방식이지만, 각 텐서 연산의 구현이 여전히 컴파일러 내부에 들어 있다는 한계가 있습니다. 새로운 연산이나 다음 세대 하드웨어를 지원할 때마다 컴파일러 자체를 수정해야 하고, 커널 구현을 실행 중에 비교하거나 자동으로 튜닝하기도 어렵습니다.
저희가 고민하고 있는 방향 중 하나는 커널 작성을 저희가 개발하고 있는 프로그래밍 언어인 Nadya로 옮기는 것입니다. Nadya는 작성자가 하드웨어 최적화의 모든 세부사항을 직접 알지 않아도 높은 성능의 프로그램을 만들 수 있도록 설계하고 있습니다. 개별 연산을 NPU에서 어떻게 구현할지는 컴파일러 밖의 커널 코드에 두고, 여러 연산을 어떤 순서와 조합으로 실행할지는 컴파일러가 결정하도록 역할을 나누는 방식입니다.
2. 최적화 결정을 탐색 가능한 형태로 만들기.
컴파일 과정에는 아직 경험적인 규칙에 따라 결정되는 값이 많습니다. 타일 크기, SLICE를 어떻게 나눌지, 연산을 합칠지 말지 등이 대표적입니다. 이런 결정을 각각의 컴파일러 패스 안에 고정해 두기보다 외부에서 조절 가능한 값으로 만들고, 여러 조합을 자동으로 탐색할 수 있도록 하고 싶습니다.
탐색 과정 자체는 별도의 도구에서 수행할 수도 있고, 나중에는 컴파일러 안으로 더 깊게 들어올 수도 있습니다. 중요한 것은 어떤 값을 탐색할지 결정하는 로직과 실제 IR을 바꾸는 로직을 분리하는 것입니다. 이렇게 하면 같은 컴파일러 파이프라인을 그대로 두고 여러 설정을 비교할 수 있고, 새로운 하드웨어가 추가될 때마다 모든 최적화 규칙을 처음부터 다시 작성해야 하는 부담도 줄일 수 있습니다.
새로운 종류의 하드웨어를 위한 컴파일러를 강력하면서도 유연하게 만드는 데에는 아직 풀어야 할 문제가 많습니다. 하지만 바로 그 점 때문에 이 프로젝트가 더 재미있다고 생각합니다. ENERZAi는 지금도 이런 문제들을 하나씩 해결해 나가고 있습니다.
오픈소스로 공개된 Torq 컴파일러
이 프로젝트의 가장 큰 장점 중 하나는 하드웨어 명세와 컴파일러 소스코드가 모두 공개되어 있다는 점입니다. Torq 컴파일러는 synaptics-torq/torq-compiler Github 레포에서 확인할 수 있고, 실제 모델 예제는 torq-examples, 공식 문서는 synaptics-torq.github.io에 공개되어 있습니다. 저희가 어떤 문제를 다루고 있는지 누구나 직접 확인할 수 있고, 관심이 있다면 프로젝트에 직접 참여할 수도 있습니다.
그 외에 Torq 프로젝트나 Nadya 등 에너자이의 최적화 기술에 대하여 더 알고 싶으시다면, 언제든 연락 부탁드립니다!