10413 words
52 minutes
[Trino]Trino 쿼리 실행 원리: MPP 엔진을 "왜"부터 이해하기
- Trino Web UI의 낯선 용어들 : Runnable Drivers, Worker Parallelism, Splits, Live Plan 속 LocalExchange 등
- 용어를 하나씩 외우면 금방 헷갈림 → “이 장치는 어떤 문제를 풀려고 생겼나?” 로 따라가면 전체 그림이 연결됨
- MPP(Massively Parallel Processing) 엔진의 목표 : 한 대로는 느린 일을 여러 대가 나눠서 동시에 하게 만드는 것
- 막상 나눠서 하면 문제가 차례로 생기고, Trino의 각 개념은 그 문제를 하나씩 해결하기 위해 존재
- 이 글의 구성
- 쿼리 하나가 들어와 결과가 나갈 때까지를 “문제 → 해결” 순서로 추적
- 마지막에 Web UI 지표 읽는 법과 운영 원칙으로 연결
- Spark와의 공통점·차이점은 MPP와 데이터 레이크하우스 관점에서의 Spark 참고
설정 이름과 기본값은 Trino 버전에 따라 바뀌므로, 실제 적용 전 사용 중인 버전의 공식 문서 확인 필요
예시 쿼리
- 글 전체에서 아래 쿼리 하나를 끝까지 사용
- 큰 팩트 테이블과 작은 차원 테이블의 조인, 필터, 집계, 정렬이 모두 들어 있는 전형적인 분석 쿼리
SELECT c.country, sum(o.amount) AS totalFROM orders o -- 수십억 건, 파일 수천 개JOIN customers c -- 수백만 건 ON o.customer_id = c.idWHERE o.order_date = DATE '2026-10-01'GROUP BY c.countryORDER BY total DESCLIMIT 101. 계획 단계: Coordinator, Worker, 최적화
1.1 누군가는 계획을 세워야 함: Coordinator와 Worker
- 문제 : 워커 20대가 각자 이 SQL을 실행하면 누가 어떤 파일을 읽을지, 결과를 어디로 보낼지, 언제 끝났는지 아무도 모름
- 해결 : 역할 분리
- Coordinator : SQL 해석, 작업 분할, 배정, 진행 상황 관리. 데이터는 거의 만지지 않음
- Worker : 맡겨진 일만 수행. 데이터를 읽고, 계산하고, 다음 단계로 넘김
- 공장으로 치면 Coordinator는 생산 관리자, Worker는 라인 작업자
- 외부 데이터 소스와의 연결
- Connector : 외부 저장소 접근 담당
- Catalog : 커넥터 설정 하나에 이름을 붙인 것
- Trino는 자체 스토리지가 없음. 데이터는 Iceberg/Hive(S3, HDFS), RDB, Kafka 같은 외부 저장소에 존재
- 여기서 생기는 성격
- 관리자가 한 명 → Coordinator가 죽으면 클러스터가 멈춤 (단일 장애점)
- 관리자가 라인 일까지 하면 지휘가 늦어짐 → Coordinator를 Worker와 겸용하지 않는 것이 운영 기본 원칙
1.2 무엇을 할지 정확히 알아야 함: 파싱, 분석, 최적화
- 문제 : SQL은 “무엇을 원하는지”만 말하고 “어떻게 할지”는 말하지 않음
- 해결 : Coordinator가 커넥터에 메타데이터(테이블 구조, 파티션, 파일 위치, 통계)를 물어 실행 계획 수립
- 핵심 원칙 : “읽는 양을 최대한 줄여라” → 분산 처리에서 가장 비싼 일은 데이터를 읽고 옮기는 것
order_date = '2026-10-01'조건을 스캔 단계까지 내려 해당 날짜 파티션만 읽음 (파티션 프루닝, predicate pushdown)amount,customer_id처럼 필요한 컬럼만 읽음 (projection pushdown)- 통계가 있으면 어느 테이블이 작은지 보고 조인 순서와 방식 선택 (비용 기반 최적화)
- 계획 이전 단계 : 쿼리 접수 시 Resource Group 규칙에 따라 대기열에 들어감
- 그룹의 동시 실행 한도가 차 있으면 QUEUED 상태로 대기
- 여기서 생기는 성격
- Hive/Iceberg 계열은 메타스토어가 느리면 계산 시작 전 계획 단계에서 시간이 흐름
- 통계가 없으면 옵티마이저는 눈을 감고 계획을 세우는 셈
Concept
- Coordinator : 쿼리 접수·파싱·계획·스케줄링·결과 전달을 담당하는 노드. 데이터 처리는 하지 않으며 단일 장애점이므로 워커 겸용을 피함
- Worker : Coordinator가 배정한 작업을 받아 데이터를 읽고 계산하는 노드. 클러스터의 실제 처리량을 결정
- Connector / Catalog : 외부 저장소 접근을 추상화한 플러그인과, 그 설정 인스턴스에 붙인 이름. 스토리지 없는 쿼리 엔진이 여러 저장소를 하나의 SQL로 다루는 기반
- Predicate / Projection Pushdown : 필터 조건과 필요한 컬럼 목록을 스캔 단계로 내려 읽는 양 자체를 줄이는 최적화. 파티션 프루닝은 predicate pushdown의 대표 사례
- Cost-Based Optimizer (CBO) : 테이블 통계로 후보 플랜의 비용을 추정해 조인 순서와 방식을 고르는 옵티마이저. 통계가 없으면 보수적인 기본 선택에 의존
- Resource Group : 쿼리를 그룹별로 분류해 동시 실행 수·메모리·대기열을 제한하는 어드미션 제어 장치. 워크로드 간 간섭을 막는 1차 수단
2. 분산의 경계: Stage와 Exchange
- MPP를 이해하는 데 가장 중요한 부분
- 문제 : 워커 20대가 orders 파일을 나눠 읽는 것까지는 쉬움
GROUP BY country를 하려면 같은 국가의 데이터가 한 곳에 모여야 합계를 낼 수 있음- 한국 주문이 워커 20대에 흩어져 있으면 아무도 한국 합계를 모름
- 조인도 마찬가지 :
customer_id가 같은 주문과 고객 정보가 한 곳에서 만나야 함
- 해결 : 데이터를 키 기준으로 다시 섞어 재배치 → Exchange(셔플)
- 키의 해시값을 보고 “한국은 워커 3번, 일본은 워커 7번” 식으로 전송
- Exchange가 필요한 지점마다 계획을 잘라 Stage로 분할
- Stage = “데이터 재배치 없이 한 번에 할 수 있는 작업 묶음”
Stage 0: 상위 10개 최종 선택, 클라이언트로 반환 ↑ (한 곳으로 모으기 - gather)Stage 1: 국가별 최종 합계 ↑ (country 기준 재배치 - hash partition)Stage 2: orders 스캔 + customers와 조인 + 국가별 부분 합계 ↑ (customers를 각 워커에 복제 - broadcast)Stage 3: customers 스캔- Exchange의 분배 방식
| 방식 | 의미 | 사용 예 |
|---|---|---|
| Hash partitioned | 키 해시로 나눠 분배 | GROUP BY, 대형 조인 |
| Broadcast | 모든 대상에 같은 데이터 복제 | 작은 테이블과의 조인 |
| Gather | 한 곳으로 모음 | 최종 출력, 최종 정렬 |
- 왜 부분 합계를 먼저 하는가
- 셔플은 네트워크를 타서 비쌈
- 수십억 건을 그대로 국가별로 보내는 대신, 각 워커가 자기 범위에서 먼저 국가별로 합쳐 둠 (partial aggregation)
- 워커당 국가 수만큼의 행만 보내면 됨 → 옮기기 전에 최대한 줄인다는 같은 원칙
- 여기서 생기는 성격
- 셔플이 있는 쿼리는 네트워크 비용 발생
- 특정 키에 데이터가 몰리면(skew) 그 키를 맡은 워커 하나만 오래 일함
- 분산 처리의 전체 시간은 가장 느린 작업자가 결정 → skew는 치명적
Concept
- Exchange (Shuffle) : 다음 연산에 필요한 키 기준으로 데이터를 노드 간에 재배치하는 단계. 분산 쿼리에서 네트워크 비용이 집중되는 지점
- Stage : Exchange 경계로 잘라낸 플랜 조각. 데이터 재배치 없이 한 번에 실행할 수 있는 연산 묶음
- Hash / Broadcast / Gather 분배 : 키 해시로 나누기, 전체 복제, 한 곳으로 모으기의 세 가지 Exchange 방식. 집계·대형 조인, 소형 조인, 최종 출력에 각각 사용
- Partial Aggregation : 셔플 전에 각 노드가 자기 데이터로 부분 집계를 먼저 수행하는 최적화. 전송량을 원본 행 수에서 그룹 수 수준으로 줄임
- Data Skew : 특정 키에 데이터가 몰려 일부 작업만 오래 걸리는 현상. 분산 작업의 전체 시간은 가장 느린 작업이 결정하므로 병렬화 효과를 무력화함
3. 일 나누기: Task와 Split
3.1 같은 일을 여러 워커가 나눠 맡음: Task
- 문제 : Stage는 “할 일의 종류”일 뿐. Stage 2를 실제로 누가 하는가
- 해결 : 같은 Stage를 여러 워커에 복제 배치
- 워커 20대에 Stage 2를 하나씩 놓으면 Task 20개
- 모든 Task는 같은 일을 하되 서로 다른 데이터를 맡음
Stage = 작업 지시서, Task = 그 지시서를 받은 각 작업자의 작업대
- 같은 Stage 안에서 Task별 처리량을 비교하면 워커 간 데이터 쏠림 확인 가능
3.2 잘게 쪼개야 고르게 나눌 수 있음: Split
- 문제 : orders의 2026-10-01 파티션을 워커 20대에 어떻게 나눌까
- “1번 워커는 파일 1~100번”처럼 미리 크게 정해 두면, 1번 워커에 큰 파일이 몰리거나 1번 워커가 느린 노드일 때 전체가 늦어짐
- 해결 : 데이터를 **작은 조각(Split)**으로 쪼개고, 일을 끝낸 워커에게 다음 조각을 계속 배정
- 은행 창구에서 손님을 창구별로 미리 배정하지 않고, 번호표를 뽑아 빈 창구로 보내는 방식
- 빠른 워커는 많이, 느린 워커는 적게 처리 → 자연스럽게 균형
- Split에 대해 기억할 점
- Split은 데이터 자체가 아니라 “이 파일의 여기서부터 여기까지”라는 위치 정보
- Split은 커넥터가 생성하며 커넥터마다 실체가 다름
| 커넥터 | Split 하나가 가리키는 것 |
|---|---|
| Hive | 파일 하나, 또는 큰 파일의 일부 구간 |
| Iceberg / Delta Lake | 데이터 파일(또는 그 일부 구간)과 적용할 delete 파일 정보 |
| Kafka | 특정 파티션의 offset 범위 |
| JDBC (MySQL, PostgreSQL 등) | 보통 테이블 전체가 split 1개 |
- Coordinator는 split 목록을 한꺼번에 만들지 않고 조금씩 만들어 배정
- 파일이 수만 개일 때 목록을 다 만들 때까지 기다리면 그만큼 워커가 놂
- 그래서 큰 쿼리는 실행 중에도 split 생성이 계속됨
- 여기서 생기는 성격
- 쪼개는 단위가 너무 잘면(작은 파일 수만 개) 조각마다 붙는 관리 비용 증가
- 쪼갤 수 없으면(JDBC 테이블 통째로 split 1개) 병렬화 불가
- Iceberg라면 delete 파일이 쌓일수록 split 하나하나가 무거워짐
- 그래서 파일 크기 관리와 compaction이 성능에 직결 (Iceberg 테이블 유지보수 참고)
Concept
- Task : 하나의 Stage를 워커 한 대에서 실행하는 단위. 같은 Stage의 Task들은 같은 연산을 서로 다른 데이터에 수행함
- Split : 커넥터가 만든 “읽을 데이터 범위”에 대한 위치 정보. 파일 구간, Kafka offset 범위 등 커넥터마다 실체가 다름
- Dynamic Work Assignment : 작업을 미리 고정 배정하지 않고 끝난 작업자에게 다음 조각을 계속 넘기는 스케줄링 방식. 노드 속도 차이와 데이터 크기 편차를 자동으로 흡수함
- Lazy Split Enumeration : split 목록 전체를 만들기 전에 일부부터 배정해 실행을 시작하는 방식. 파일이 많은 테이블에서 첫 처리까지의 대기를 줄임
- Splittability : 데이터를 병렬로 읽을 수 있게 나눌 수 있는 성질. 단일 split만 나오는 소스는 클러스터 크기와 무관하게 병렬화되지 않음
4. 워커 내부 실행: Pipeline, Driver, Thread
4.1 작업대 안에도 멈춰야 하는 지점이 있음: Pipeline과 LocalExchange
- 문제 : 워커 하나의 Task(Stage 2) 안을 보면 일이 한 줄로 쭉 흐르지 않음
- 조인을 하려면 customers로 해시 테이블을 먼저 다 만들어야 orders를 대조할 수 있음. 반쯤 만든 상태에서 대조하면 결과가 틀림
- 스캔은 split 수만큼 병렬로 돌리고 싶지만, 해시 테이블 만들기나 집계는 코어 수에 맞춘 일정한 병렬도가 효율적
- 해결 : Task 안의 작업을 멈춤 없이 흐르는 구간별로 분할 → Pipeline
- Pipeline = 연산자(Operator) 체인의 설계도
- Pipeline 사이에는 워커 메모리 안에서 데이터를 넘기는 LocalExchange 배치
Task (Stage 2) 내부 Pipeline A: customers 받기 → [LocalExchange: id 해시로 분배] Pipeline B: → 해시 테이블 만들기 ← 이게 끝나야 Pipeline C: orders 스캔 → 조인(해시 테이블 조회) → 국가별 부분 합계 → 출력- 실행 시 앞 Pipeline 끝에
LocalExchangeSink, 뒤 Pipeline 시작에LocalExchangeSource연산자가 붙고, 둘 사이에 메모리 버퍼가 놓임
RemoteExchange와 LocalExchange
| 구분 | RemoteExchange | LocalExchange |
|---|---|---|
| 범위 | Stage와 Stage 사이 (워커 간) | 같은 Task 안의 Pipeline 사이 (워커 내부) |
| 전송 | HTTP 네트워크 | 메모리 버퍼 |
| 경계 | Stage를 나눔 | Pipeline을 나눔 |
- 존재 이유는 같음 : 데이터 배치를 바꿔야 해서
- 차이는 범위 : RemoteExchange는 워커 사이, LocalExchange는 워커 안
LocalExchange가 하는 일
- 병렬도 변경 : 앞 Pipeline은 split 수만큼, 뒤 Pipeline은 코어 수 기준으로 돌 수 있게 함
- 같은 키를 같은 실행체로 모음 : RemoteExchange로 같은 키가 같은 워커에 모였더라도, 그 안에서 여러 실행체가 나눠 처리하려면 워커 내부에서 한 번 더 키별 분배 필요
- 하나로 모음 : 최종 LIMIT처럼 한 실행체가 전부 봐야 하는 경우
- 부하 균등화 : split마다 데이터 양이 들쭉날쭉할 때 뒤쪽에 고르게 배분
- Live Plan이나
EXPLAIN에 분배 방식이 함께 표시됨
| 표시 | 의미 | 주로 쓰이는 곳 |
|---|---|---|
partitioning = HASH | 키 해시로 분배 | 병렬 집계, 조인 build |
partitioning = ROUND_ROBIN | 돌아가며 고르게 분배 | 병렬도 조정, 부하 균등화 |
partitioning = SINGLE | 하나로 모음 | 최종 LIMIT, 출력 직전 |
- 운영 포인트
SINGLELocalExchange는 워커 안의 직렬화 지점 → 뒤 연산이 무거우면 코어가 많아도 사실상 한 스레드로 처리- LocalExchange 버퍼가 차면 앞 Pipeline이 멈춤 → 스캔 쪽이 대기 중으로 보여도 원인은 스토리지가 아니라 같은 Task 안 뒤쪽 연산이 느린 것일 수 있음
4.2 실제로 일하는 주체: Driver
- 문제 : Pipeline은 설계도일 뿐. 실제로 돌아가는 무언가가 필요
- 해결 : Pipeline을 실행 가능한 인스턴스로 찍어낸 것이 Driver
Pipeline = 클래스, Driver = 인스턴스
- Driver 자체는 계산 로직이 없음
- 연산자 체인 사이에서 데이터 묶음(Page)을 앞에서 꺼내 뒤로 넘기는 일만 반복
- 필터링, 해시 연산 같은 실제 계산은 각 연산자가 수행
loop: for 인접한 Operator 쌍 (앞, 뒤): if 뒤가 입력을 받을 수 있고, 앞에서 page를 꺼낼 수 있으면: page를 앞에서 꺼내 뒤에 넣는다 모든 Operator가 막혀 있으면 → blocked 상태로 반환 할당된 시간을 다 쓰면 → 양보하고 반환 모두 끝나면 → finished- Driver 개수는 Pipeline 종류에 따라 다름
- 소스 Pipeline(테이블 스캔으로 시작) : split 하나당 Driver 하나. 이 워커에 split 300개가 배정되면 Driver도 300개
- 중간 Pipeline(LocalExchange나 원격 데이터로 시작) : split과 무관하게 정해진 개수(
task.concurrency기준)
- Driver의 네 가지 상태
| 상태 | 의미 |
|---|---|
| Queued | 배정됐지만 아직 한 번도 실행되지 않음 |
| Running (Runnable) | 실행 중이거나, 막힌 것이 없어 스레드만 받으면 바로 실행 가능 |
| Blocked | 무언가를 기다리느라 진행 불가 (원격 데이터, 출력 버퍼, 메모리, 조인 build 완료, 스토리지 I/O 등) |
| Done | 처리 완료 |
- 예 : 조인의 Probe 쪽 Driver는 Build 쪽 해시 테이블이 완성될 때까지 Blocked로 대기 → 완성되면 Runnable로 바뀌어 조회 시작
4.3 일은 수천 개, 손은 수십 개: Driver와 Thread의 분리
- 문제 : 워커 하나에 Driver가 수천 개 생길 수 있지만 CPU 코어는 수십 개. Driver마다 OS 스레드를 하나씩 주면
- 스레드 수천 개가 코어 수십 개를 두고 다투느라 컨텍스트 스위칭 비용 폭증
- 더 나쁜 점 : 데이터를 기다리는 Driver도 스레드를 붙잡고 잠듦 → 일할 수 있는 Driver가 있어도 스레드가 없어 진행 못 함
- 해결 : 스레드는 코어 수 정도로 고정하고, Driver들이 그 스레드를 돌아가며 짧게(약 1초씩) 사용
- 일할 수 있는 Driver는 큐에 줄을 섬 (Runnable)
- 스레드를 받으면 정해진 시간만 일하고 양보
- 진행할 수 없으면 스레드를 즉시 반납하고 빠짐 (Blocked). 기다리던 것이 해결되면 다시 줄을 섬
- “기다리는 일은 손을 놓고 비켜라, 할 수 있는 일만 손을 써라” → CPU는 항상 실제로 진행 가능한 일에만 쓰임
- 스케줄링 큐는 multilevel feedback queue 방식
- CPU를 오래 쓴 쿼리의 Driver일수록 우선순위가 내려감
- 무거운 배치 쿼리가 돌고 있어도 대시보드의 짧은 쿼리가 줄 맨 뒤로 밀리지 않게 하는 장치
Split은 “무엇을 처리할지”, Driver는 “그것을 처리하는 실행체”, Thread는 “Driver를 실제로 돌리는 CPU 자원”
Concept
- Pipeline : Task 안에서 멈춤 없이 이어지는 Operator 체인의 설계도. 해시 테이블 완성처럼 반드시 기다려야 하는 지점에서 나뉨
- LocalExchange : 같은 워커 안의 Pipeline 사이에서 메모리 버퍼로 데이터를 재분배하는 장치. 병렬도 변경, 키별 재분배, 단일화, 부하 균등화를 담당
- Driver : Pipeline을 실행 가능한 형태로 만든 인스턴스. 소스 Pipeline은 split당 1개, 중간 Pipeline은
task.concurrency기준으로 생성 - Build / Probe : 해시 조인에서 해시 테이블을 만드는 쪽과 그 테이블을 조회하는 쪽. Probe는 Build 완료 전까지 진행할 수 없음
- Cooperative Scheduling : 실행체가 정해진 시간만 쓰고 스스로 양보하는 스케줄링 방식. 고정된 스레드 풀로 수천 개의 실행체를 컨텍스트 스위칭 폭증 없이 돌림
- Multilevel Feedback Queue : 누적 CPU 사용량이 많은 작업의 우선순위를 단계적으로 낮추는 스케줄링 큐. 무거운 쿼리 속에서도 짧은 쿼리의 응답성을 지킴
- Serialization Point : 병렬 흐름이 하나의 실행체로 모이는 지점. 이 뒤의 연산이 무거우면 코어 수와 무관하게 단일 스레드 성능에 묶임
5. 데이터 흐름: Page, 스트리밍, Backpressure
5.1 한 줄씩이 아니라 컬럼 묶음으로: Page
- 문제 : 분석 쿼리는 행은 수십억 개를 훑지만 컬럼은 몇 개만 씀
- 행 단위로 하나씩 처리하면 필요 없는 컬럼까지 메모리에 올리고, 행마다 함수 호출 비용이 붙음
- 해결 : **컬럼별로 묶은 덩어리(Block)**를 모아 Page 단위로 처리
- 같은 타입의 값이 연속으로 붙어 있어 CPU 캐시 효율이 좋고, 한 번에 많은 값을 처리
- 필터나 계산식은 쿼리마다 JVM 바이트코드로 생성해 빠르게 실행
- 저장 포맷이 Parquet, ORC 같은 컬럼형이면 필요한 컬럼만 디스크에서 읽을 수 있어 궁합이 맞음
5.2 기다리지 않게 흘려보냄: 스트리밍 실행과 Backpressure
- 문제 : Stage 3이 다 끝나야 Stage 2, Stage 2가 다 끝나야 Stage 1이 시작하는 식이면
- 각 단계의 중간 결과를 어딘가에 다 쌓아 둬야 함
- 전체 시간이 단계별 시간의 합이 됨
- MapReduce가 단계마다 디스크에 써서 느렸던 이유
- 해결 : 모든 Stage를 동시에 띄우고, 앞에서 만든 데이터를 조금씩 바로 뒤로 흘려보냄
- 중간 결과를 디스크에 쓰지 않고 메모리 버퍼로 전달
- 각 Task는 결과를 Output Buffer에 담음
- 다음 Stage의 Task가 HTTP로 당겨 감 (pull)
- 왜 밀어주지(push) 않고 당겨 가는가
- 받는 쪽이 감당할 수 있는 만큼만 가져가게 하려는 것
- 뒤쪽이 느리면 덜 당겨 감 → 앞쪽 버퍼가 참 → 버퍼가 찬 앞쪽 Driver는 Blocked 되어 생산 중단
- 이것이 Backpressure. 라인 끝 작업자가 느리면 컨베이어 벨트가 꽉 차서 앞 작업자가 손을 멈추는 것과 같음
- 덕분에 메모리가 무한정 쌓이지 않고, 전체가 가장 느린 구간의 속도에 자동으로 맞춰짐
- 이 흐름은 클라이언트까지 이어짐
- 클라이언트도 결과를 페이지 단위로 당겨 감
- BI 툴이 결과를 천천히 가져가면 그 압력이 쿼리 전체에 거꾸로 전파
5.3 이 설계의 대가
- 메모리
- 중간 결과를 메모리에 들고 흐르므로 메모리 사용량이 큼. 해시 테이블과 집계 상태가 모두 메모리에 있음
- 쿼리당 메모리 한도(
query.max-memory,query.max-memory-per-node등)와 JVM 여유 공간 설정이 중요
- 실패에 약함
- 중간 결과가 어디에도 저장되지 않으므로, 기본 모드에서는 워커 하나가 죽으면 쿼리 전체가 실패
- 두 약점에 대한 대응 장치 : 메모리 부족에는 Disk Spill, 실패에는 Fault-tolerant Execution (6장)
Concept
- Columnar In-memory Format (Page / Block) : 같은 컬럼의 값을 연속 배치한 Block을 묶은 Page 단위로 데이터를 처리하는 방식. 캐시 효율과 벡터 단위 처리로 행 단위 처리보다 빠름
- Bytecode Generation : 쿼리의 필터·계산식을 실행 시점에 JVM 바이트코드로 생성해 해석 비용 없이 실행하는 기법. 표현식 평가 오버헤드를 줄임
- Pipelined Execution : 모든 Stage를 동시에 띄우고 중간 결과를 메모리 버퍼로 바로 흘려보내는 실행 방식. 단계별 대기와 디스크 쓰기가 없어 지연이 짧음
- Pull-based Exchange : 다음 단계가 앞 단계의 Output Buffer에서 데이터를 당겨 가는 전송 방식. 소비자가 감당할 수 있는 만큼만 가져가게 함
- Backpressure : 하류가 느리면 버퍼가 차서 상류 생산이 자동으로 멈추는 흐름 제어. 메모리 폭증을 막고 전체 속도를 가장 느린 구간에 맞춤
6. 스트리밍의 약점 보완: Disk Spill과 FTE
6.1 메모리가 모자라면 잠시 디스크에: Disk Spill
- 문제 : 데이터를 끝까지 다 받아야 결과를 낼 수 있는 연산은 입력이 클수록 메모리를 계속 쌓음
- 조인 Build 쪽 해시 테이블, GROUP BY 집계 상태, ORDER BY 정렬 버퍼 등
- 스트리밍으로 흘려보낼 수 없는 구간이라, 메모리 한도에 닿으면
exceeded memory limit에러로 실패
- 해결 : 메모리가 부족해지면 중간 상태를 로컬 디스크에 잠시 써 두었다가, 나중에 다시 읽어 이어서 처리 → Disk Spill (spill to disk)
- 책상이 좁으면 서류 일부를 서랍에 넣어 두고, 필요할 때 다시 꺼내 보는 것과 같음
- 동작 방식
- 연산자 메모리 중 “필요하면 내려놓을 수 있는 메모리”를 revocable memory로 따로 관리. 해시 테이블, 집계 상태처럼 디스크로 옮길 수 있는 메모리가 해당
- 워커 메모리 사용량이 일정 수준을 넘으면, 메모리 관리자가 연산자들에게 이 메모리의 회수(revoke) 요청
- 요청받은 연산자는 자기 상태를 Page 단위로 직렬화해 spill 경로(로컬 디스크)에 쓰고 메모리를 비움
- 입력을 다 받은 뒤 디스크에 쓴 조각들을 다시 읽어 합치며 최종 결과 생성. 예 : ORDER BY는 정렬된 조각 여러 개를 써 두었다가 마지막에 병합
- Spill을 지원하는 대표 연산
| 연산 | Spill되는 것 |
|---|---|
| 조인 | Build 쪽 해시 테이블 (Build 테이블이 파티션되어 있을 때 피크 메모리 감소) |
| 집계 (GROUP BY) | 누적 중인 집계 결과 |
| ORDER BY | 중간 정렬 결과 |
| Window 함수 | 윈도우 처리 중간 결과 |
- 주요 설정
spill-enabled(켜기),spiller-spill-path(spill 디렉터리)max-spill-per-node/query-max-spill-per-node(노드별, 쿼리별 spill 용량 상한)- 세션 단위로도 켜고 끌 수 있음
- spill 데이터 압축(
spill-compression-codec), 암호화(spill-encryption-enabled) 옵션 존재
- 알고 써야 할 한계
- 느림 : 메모리 작업을 디스크 쓰기·읽기로 바꾸는 것이라 디스크 속도에 묶임. “실패하지 않게 하는 장치”이지 “빠르게 하는 장치”가 아님
- 모든 쿼리를 살리지는 못함 : 공식 문서도 spill을 켠다고 메모리를 많이 쓰는 모든 쿼리의 실행이 보장되지는 않는다고 명시. 내려놓을 수 없는 메모리가 크거나, 키 하나에 데이터가 몰린 skew처럼 쪼개서 내려놓기 어려운 경우 여전히 실패 가능
- 디스크 구성이 중요 : 빠른 로컬 SSD를 OS 디스크와 분리해서 쓰고, spill 경로 디스크 포화도를 모니터링. spill 경로 여러 개를 독립 디스크(JBOD)로 다루므로 RAID는 불필요
- 레거시 기능 : 현재 공식 문서는 spill을 레거시 기능으로 분류. 메모리보다 큰 대형 배치는 FTE 쪽으로 가는 흐름이므로 도입 전 사용 버전의 지원 상태 확인 필요
6.2 실패해도 다시 할 수 있게: Fault-tolerant Execution
- 대형 배치용 장치 : Fault-tolerant Execution(FTE)
retry-policy=TASK로 켜면 Stage 사이 데이터를 외부 저장소(S3 등)에 써서 실패한 Task만 재실행- 중간 데이터가 메모리가 아니라 외부 저장소에 쌓이므로 메모리보다 큰 작업도 처리 가능
- 대신 그만큼 느려짐
- 속도(스트리밍)와 안정성(중간 저장)을 맞바꾸는 선택 → 운영에서 ad-hoc 클러스터와 배치 클러스터를 나누는 이유
6.3 Spill과 FTE 비교
| 구분 | Disk Spill | Fault-tolerant Execution |
|---|---|---|
| 해결하는 문제 | 한 연산자의 메모리 부족 | 워커·Task 실패, 메모리보다 큰 대형 작업 |
| 데이터를 쓰는 곳 | 워커 로컬 디스크 | 외부 저장소 (Exchange Manager: S3, HDFS 등) |
| 범위 | 연산자 내부 상태 | Stage 사이 데이터 전체 |
| 실패 복구 | 안 됨 (워커가 죽으면 여전히 쿼리 실패) | 실패한 Task만 재시도 |
| 비용 | 로컬 디스크 I/O | 외부 저장소 쓰기·읽기, 지연 증가 |
| 위치 | 레거시 기능 | 대형 배치의 권장 방향 |
- Spill = “책상이 좁을 때 서랍을 쓰는 것”
- FTE = “작업 중간중간 결과를 창고에 보관해서, 사고가 나도 그 지점부터 다시 하는 것”
- 둘 다 스트리밍 설계의 약점을 메우는 장치이고, 둘 다 속도를 대가로 치름
Concept
- Blocking Operator : 입력을 끝까지 받아야 결과를 낼 수 있는 연산자. 해시 조인 build, 집계, 정렬이 해당하며 스트리밍 엔진의 메모리 사용이 집중되는 지점
- Disk Spill : 메모리가 부족할 때 연산자의 중간 상태를 로컬 디스크에 내려놓았다가 다시 읽어 처리하는 기법. 실패를 막는 대신 디스크 속도에 묶임
- Revocable Memory : 필요 시 디스크로 내려놓을 수 있어 메모리 관리자가 회수를 요청할 수 있는 메모리. spill 대상 여부를 가르는 기준
- Fault-tolerant Execution (FTE) : Stage 사이 데이터를 외부 저장소에 기록해 실패한 Task만 재시도하는 실행 모드. 안정성과 메모리 초과 작업 처리를 얻는 대신 지연이 늘어남
- Exchange Manager : FTE에서 Stage 간 중간 데이터를 저장하는 외부 저장소 계층. S3, HDFS 등을 사용
- Latency vs Reliability Trade-off : 중간 결과를 저장하지 않으면 빠르지만 실패에 약하고, 저장하면 복구 가능하지만 느려지는 관계. 대화형과 배치 클러스터를 분리하는 근거
7. 조인과 최종 반환
7.1 조인은 “누구를 옮길지”의 문제: Broadcast vs Partitioned
- 문제 : orders(수십억)와 customers(수백만)를 만나게 해야 함. 무엇을 어떻게 옮길까
- 해결 : 해시 조인은 한쪽(Build)으로 해시 테이블을 만들고 다른 쪽(Probe)이 조회하는 방식. 분산 방식은 두 가지 중 선택
| 방식 | 동작 | 장점 | 위험 |
|---|---|---|---|
| Broadcast | 작은 테이블을 모든 워커에 통째로 복제 | 큰 테이블은 움직이지 않아 빠름 | Build 쪽이 크면 워커마다 메모리 폭증 |
| Partitioned | 양쪽을 조인 키로 해시 재배치 | 큰 테이블끼리도 가능 | 네트워크 셔플 비용, skew에 취약 |
- 예시 쿼리는 customers가 상대적으로 작으므로 Broadcast가 유리. 통계가 있으면 옵티마이저가 판단
- Dynamic Filtering
- customers 쪽 해시 테이블을 만들면서 실제 존재하는
id값을 모아 orders 스캔에 필터로 전달 - 조인될 리 없는 orders 행은 아예 읽지 않음 → 역시 “읽는 양을 줄여라” 원칙
- customers 쪽 해시 테이블을 만들면서 실제 존재하는
7.2 마지막은 한 곳으로: 최종 집계와 반환
- Stage 2의 각 Task가 국가별 부분 합계를 만들어
country기준으로 재배치 - Stage 1의 각 Task가 자기가 맡은 국가들의 최종 합계 계산. 워커 안에서는
LocalExchange[HASH country]로 다시 나눠 여러 Driver가 병렬로 합침 - 상위 10개를 고르려면 결국 한 곳에서 비교해야 함 → 각 Task가 자기 상위 10개만 골라 보내고(옮기기 전에 줄이기) Stage 0에서 최종 10개 선택
- Coordinator를 거쳐 클라이언트가 결과를 당겨 감
Concept
- Broadcast Join : 작은 테이블을 모든 워커에 복제해 큰 테이블을 움직이지 않고 조인하는 분산 방식. Build 쪽이 크면 워커마다 메모리가 폭증함
- Partitioned Join : 양쪽 테이블을 조인 키 해시로 재배치해 같은 키끼리 같은 노드에서 만나게 하는 분산 방식. 큰 테이블끼리도 가능하지만 셔플 비용과 skew에 취약
- Dynamic Filtering : Build 쪽에서 실제로 존재하는 조인 키 값을 모아 Probe 쪽 스캔에 런타임 필터로 전달하는 최적화. 조인될 수 없는 행을 읽기 단계에서 제거
- Partial TopN : 각 노드가 자기 데이터에서 상위 N개만 골라 보내고 최종 단계에서 다시 N개를 고르는 방식. ORDER BY … LIMIT의 전송량과 단일 노드 부담을 줄임
8. 전체 흐름 정리
[Coordinator] SQL 접수 → 대기열(Resource Group) → 파싱/분석(메타데이터) → 최적화(읽는 양 줄이기) → Exchange 지점마다 Stage로 자르기 → Stage를 워커에 Task로 배치 → 커넥터에게 Split을 조금씩 받아 Task에 계속 나눠 주기
[Worker의 Task 내부] Pipeline(설계도)으로 나뉨 ─ LocalExchange로 연결 → Pipeline마다 Driver(실행체) 생성 (소스는 split당 1개) → Driver들이 고정된 스레드를 약 1초씩 돌아가며 사용 → 막히면 비키고(Blocked), 풀리면 다시 줄 서고(Runnable) → Operator들이 Page(컬럼 묶음) 단위로 계산
[Stage와 Stage 사이] Output Buffer → 다음 Stage가 HTTP로 당겨 감 (Backpressure) 모든 Stage가 동시에 돌며 데이터가 스트리밍으로 흐름
[끝] 최종 Stage에서 모아서 → Coordinator → 클라이언트가 당겨 감실행 계층
Query └─ Stage : Exchange 경계로 자른 플랜 조각 (클러스터 전체) └─ Task : Stage를 워커 1대에서 실행하는 단위 └─ Pipeline : Task 안에서 멈춤 없이 흐르는 Operator 체인 (설계도) └─ Driver : Pipeline의 실행 인스턴스 (실제 실행체) └─ Operator : 실제 계산 (Scan, Filter, Join, Aggregation …) ↕ Page(컬럼형 데이터 묶음) 단위로 이동| 개념 | 한 줄 정의 | 기억할 점 |
|---|---|---|
| Coordinator | 쿼리 접수, 계획, 스케줄링, 결과 전달 | 워커 겸용 금지, 단일 장애점 |
| Worker | 데이터 읽기와 계산 | 동일 사양 권장, 메모리가 주 병목 |
| Stage | Exchange 지점마다 나뉜 플랜 조각 | 여러 Stage가 동시에 스트리밍 실행 |
| Task | Stage × 워커 | Task 간 처리량 차이로 skew 확인 |
| Split | “무엇을 읽을지” 가리키는 데이터 조각 정보 | 커넥터가 생성, 조금씩 나눠 줌 |
| Pipeline | Operator 체인 설계도 | LocalExchange에서 나뉨 |
| Driver | Pipeline의 실행 인스턴스 | 소스는 split당 1개, 중간은 task.concurrency 기준 |
| Thread | 워커의 고정 실행 스레드 | Driver를 약 1초 단위로 번갈아 실행 |
| Exchange | 데이터 재배치 | Remote는 워커 간, Local은 워커 내부 |
9. Web UI에서 이 개념들 읽기
- 여기까지 이해하면 Web UI 지표들이 무엇을 말하는지 보임
9.1 Cluster Overview
| 항목 | 실제 의미 | 판단 기준 |
|---|---|---|
| Runnable Drivers | 클러스터 전체 Running 상태 Driver 합 (“할 수 있는 일의 개수”) | Worker Parallelism보다 훨씬 크면 CPU 포화 |
| Worker Parallelism | 워커 실행 스레드 총합 (“손의 개수”) | Runnable Drivers의 비교 기준 |
| Queued Queries | Resource Group 한도로 대기 중인 쿼리 | 지속적으로 쌓이면 동시성 한도와 용량 점검 |
| Blocked Queries | 진행 못 하고 대기 중인 쿼리 | CPU는 한가한데 많으면 I/O, 셔플 병목 |
- “Running”이 아니라 “Runnable”인 이유 (4.3 참고)
- 실제로 CPU를 쓰는 Driver뿐 아니라, 막힌 것 없이 스레드만 기다리는 Driver도 포함
9.2 Splits는 사실 Driver 수
- 쿼리 목록, 쿼리 상세의 Stage 영역, Task 테이블의 Splits(Queued / Running / Blocked / Done) 는 커넥터 split 개수가 아니라 대부분 Driver 개수
- 소스 Pipeline에서는 split 수와 같음
- 중간 Pipeline의 Driver도 함께 집계됨 → 테이블 스캔이 없는 집계 Stage에도 Splits 숫자가 찍힘
- 쿼리 상세의 Splits 타임라인 화면
- Task별로 Driver가 언제 시작해서 언제 끝났는지 막대로 표시
- 쿼리가 시간을 어디서 썼는지 시각적으로 파악 가능
9.3 Live Plan
- Stage별 연산자 노드를 표시
- Stage 박스 사이의 연결 = RemoteExchange
- Stage 박스 안의 LocalExchange = 워커 안에서 Pipeline이 나뉘는 지점
- 분배 방식(HASH, ROUND_ROBIN, SINGLE)과 앞뒤 노드의 처리 시간, 행 수를 비교하면 어디서 병렬성이 끊기고 어디서 시간이 몰리는지 보임
9.4 병목 판별 패턴
| 보이는 모습 | 해석 |
|---|---|
| Running ≈ 스레드 수, Queued 많음 | CPU가 병목 |
| Blocked 많음, CPU 한가 | I/O, 셔플, 조인 build, 클라이언트 수신 대기 |
| 소스 Stage에 Blocked 다수 | 스토리지 지연, 또는 같은 Task 안 뒤쪽 연산이 느림 |
| 조인 Probe 쪽 Stage에 Blocked 다수 | Build 쪽 해시 테이블 완성 대기 |
| 대부분 Done, 몇 개만 계속 Running | 데이터 skew 또는 특정 노드 문제 |
| 소스 split 수가 과도하게 많음 | 작은 파일 문제 → compaction |
| 소스 split이 1개 수준 | 병렬화 불가 (JDBC 커넥터, 분할 불가 파일) |
SINGLE LocalExchange 뒤에 시간 집중 | 워커 내부 직렬화 지점이 병목 |
| 쿼리 통계에 spill 발생, spill 디스크 사용률 높음 | 메모리 부족으로 디스크에 내려놓는 중 → 디스크 속도에 묶임 |
Concept
- Runnable Drivers vs Worker Parallelism : 진행 가능한 실행체 수와 실행 스레드 수의 비교. 전자가 훨씬 크면 CPU 포화, 비슷한데 느리면 다른 곳이 병목
- Blocked Driver : 원격 데이터·출력 버퍼·메모리·조인 build 등을 기다리느라 진행하지 못하는 실행체. CPU가 한가한데 Blocked가 많으면 대기성 병목
- UI Splits = Driver Count : Web UI의 Splits 수치는 커넥터 split이 아니라 Driver 수에 가까움. 스캔이 없는 Stage에도 값이 찍히는 이유
- Straggler Task : 대부분의 작업이 끝났는데 소수만 계속 실행 중인 작업. 데이터 skew나 특정 노드 문제의 대표 증상
10. 설계가 만든 성격, 그리고 운영 원칙
- 지금까지의 모든 장치는 네 가지 원칙에서 나옴. 운영 주의점도 결국 여기서 파생
| 설계 원칙 | 만들어진 장치 | 운영상 주의점 |
|---|---|---|
| 나눠서 동시에 한다 | Stage, Task, Split, Driver | 가장 느린 조각이 전체 시간을 결정 → skew, 느린 노드, 분할 불가 데이터가 치명적 |
| 옮기기 전에 줄인다 | Pushdown, 부분 집계, Dynamic Filtering, Broadcast | 파티션 설계, 컬럼형 포맷, 통계 수집이 성능의 기반 |
| 기다리지 않고 흘린다 | 스트리밍, 메모리 버퍼, Backpressure (약점 보완: Disk Spill, FTE) | 메모리 사용량이 크고 한 군데 실패가 전체 실패 → 메모리 한도, FTE 분리 |
| 할 수 있는 일에만 손을 쓴다 | Driver와 Thread 분리, Runnable/Blocked | Runnable vs Parallelism으로 CPU 병목, Blocked로 대기 병목 판별 |
- 이 원칙에서 이어지는 실무 습관
- 워크로드 분리 : Resource Group으로 대시보드, ad-hoc, ETL을 나누고, 필요하면 클러스터 자체를 분리. 대형 배치는 FTE를 켠 클러스터로
- 메모리 안전장치 : 쿼리당 메모리 한도, JVM 힙 여유 공간, 실행 시간과 스캔 바이트 상한(
query.max-execution-time,query.max-scan-physical-bytes등) 설정 - Spill은 보험으로만 : 켠다면 빠른 로컬 SSD 분리, 노드별·쿼리별 spill 상한, 디스크 사용률 모니터링. spill이 잦은 쿼리는 그 자체를 튜닝 대상(조인 방식, skew, 근사 함수, 쿼리 구조)으로 보고, 근본적으로 메모리보다 큰 작업은 FTE 클러스터로
- 데이터 레이아웃 관리 : 적절한 파일 크기, 과하지 않은 파티션, 자주 필터링하는 컬럼 기준 정렬, 정기 compaction이 설정 튜닝보다 효과가 큰 경우가 많음
- 통계 수집 :
ANALYZE등으로 통계를 만들어야 비용 기반 조인 최적화가 제대로 동작 - 확인 습관 :
EXPLAIN으로 pushdown과 조인 방식을,EXPLAIN ANALYZE와 UI의 Stage/Task 통계로 실제 병목과 skew를 확인 - 관측 : Event Listener로 쿼리 완료 로그를 쌓고, JMX 메트릭을 수집해 위 지표들을 시계열로 확인
- 대용량 결과는 저장소로 : 큰 결과를 클라이언트로 끌어오지 말고
CREATE TABLE AS SELECT로 직접 기록. Backpressure를 떠올리면 이유가 분명함
Concept
- Workload Isolation : 대시보드·ad-hoc·ETL처럼 성격이 다른 쿼리를 Resource Group이나 별도 클러스터로 분리하는 운영 원칙. 무거운 작업이 짧은 쿼리의 지연을 망치지 않게 함
- Query Guardrail : 쿼리당 메모리·실행 시간·스캔 바이트에 상한을 거는 안전장치. 폭주 쿼리 하나가 클러스터 전체를 잠식하는 것을 막음
- Data Layout Optimization : 파일 크기, 파티션 설계, 정렬, compaction으로 읽는 양과 split 수를 조절하는 최적화. 엔진 설정 튜닝보다 효과가 큰 경우가 많음
- EXPLAIN vs EXPLAIN ANALYZE : 실행 전 계획(pushdown, 조인 방식)을 보는 명령과, 실제 실행 후 연산자별 시간·행 수를 보는 명령. 추정과 실측을 비교해 병목을 찾음
Trino의 개념들은 따로 외울 용어가 아니라 하나의 이야기. 나눠서 동시에 하려니 모여야 하는 순간이 생기고(Stage, Exchange), 고르게 나누려니 잘게 쪼개야 하고(Split), 한 작업대 안에서도 멈춤 지점이 있고(Pipeline, LocalExchange), 일은 많은데 손은 적으니 돌아가며 써야 하고(Driver, Thread), 기다리지 않으려니 흘려보내야 함(스트리밍, Backpressure)
- 처음 보는 지표나 플랜 노드를 만나면 던질 질문 : “이건 나누기, 줄이기, 흘리기, 손 아끼기 중 무엇을 위한 장치인가?” → 대부분 이 질문 하나로 해석됨
추가적으로 공부하면 좋은 컨셉, 주제들
- Trino Cost-Based Optimizer 통계 :
SHOW STATS,ANALYZE로 수집되는 NDV·null 비율·히스토그램이 조인 순서와 분배 방식 선택에 쓰이는 방식 - Join Reordering & Join Distribution Type :
join_reordering_strategy,join_distribution_type세션 속성으로 옵티마이저 선택을 확인·제어하는 방법 - Exchange Manager 구성 : FTE용 S3/HDFS Exchange 설정과
retry-policy=QUERYvsTASK의 차이 - Iceberg 커넥터 최적화 : 파일 크기, delete 파일,
$files·$manifests메타데이터 테이블로 split 문제를 진단하는 방법 - Spark 실행 모델과의 비교 : Stage 단위 배치 실행·셔플 파일 기반 복구·AQE를 쓰는 Spark와 스트리밍 파이프라인 Trino의 트레이드오프
[Trino]Trino 쿼리 실행 원리: MPP 엔진을 "왜"부터 이해하기
https://yjinheon.netlify.app/posts/02de/03-spark/trino-mpp-internals/