제18장. 병렬 인덱서 파이프라인: 단계별 병목, 역압과 잠금 순서

초당 수만 건이 몰려도 DB 커넥션과 힙을 유한하게 묶어 두는 비동기 스트림 — 단계별 병목 모형, 유한 버퍼와 역압, 인메모리 팬아웃 버퍼, 그리고 프루닝과 맞물린 internal_contract_id 잠금 순서

핵심 키워드: Parallel Indexer · Little's Law · Backpressure · Fan-Out Buffer · FOR KEY SHARE · Quadruple Witching
"파이프라이닝은 여러 명령의 실행 단계를 겹쳐 처리함으로써 전체 처리량을 높이는 구현 기법이다." — 데이비드 패터슨, 존 헤네시, 『컴퓨터 구성과 설계: 하드웨어/소프트웨어 인터페이스』, 파이프라이닝

1. '네 마녀의 날(Quadruple Witching)' 마감 동시호가와 직렬 루프의 한계

매년 3월, 6월, 9월, 12월의 세 번째 금요일 오후, 글로벌 파생상품 데스크와 청산소(Central Counterparty, CCP)에는 일 년에 네 번 찾아오는 거래 폭주가 옵니다. 주가지수 선물, 주가지수 옵션, 개별주식 선물, 개별주식 옵션의 만기가 한날한시에 겹치는 이른바 '네 마녀의 날(Quadruple Witching)'입니다. 장 마감 몇 초 동안 내가격(In-the-Money) 옵션의 자동 권리 행사, 차액 정산, 기초자산 인도, 차기월물 롤오버 트랜잭션이 한꺼번에 몰립니다.

이런 스파이크 앞에서 처리량을 잃는 노드의 원인은 흔히 동기식 직렬 수집 루프(Synchronous Sequential Loop)입니다:

나이브(Naive) 노드의 직렬 동기 루프 Pseudocode
while (true) {
  event = networkQueue.receive();        // 1. 네트워크 소켓 무제한 수신
  payload = deserialize(event);          // 2. CPU 집약적 Protobuf 역직렬화
  verifySignatures(payload);             // 3. 비대칭 암호 서명 검증 (CPU 포화)
  existing = db.select(payload.keys);    // 4. 데이터베이스 단건 동기 조회 (I/O 대기)
  newState = applyRules(existing);       // 5. 상태 전이 계산
  db.execute("INSERT ... UPDATE ...");   // 6. 단건 디스크 커밋 (네트워크 왕복 블로킹)
}

초당 12,000건 이상의 이벤트가 들어오면 이 루프는 세 방향으로 무너집니다. 첫째, 단일 스레드가 디스크 커밋 응답을 기다리는 동안 다른 CPU 코어는 놀고 있습니다. 둘째, 처리량을 올리려고 스레드를 무작정 늘리면 데이터베이스 커넥션 풀이 고갈됩니다. 셋째, 수신 큐에 상한이 없으면 미처리 바이트가 힙에 쌓이고, 긴 GC 정지 끝에 OutOfMemoryError로 노드가 멈춥니다.

1960~70년대 스타일의 다단계 산업 어셈블리 컨베이어 벨트: 공급 호퍼에서 단일 레일로 정렬된 뒤 병렬 로봇 팔이 사전 조회를 수행하고 배치 호퍼에서 묶여 다중 피스톤으로 주입되는 추상 스팟 만화
[FIG 18.1] 병렬 인덱서 조립 라인: 입력 매핑(병렬 CPU), 순차 번호 부여(단일 스레드), DB 사전 조회(병렬 I/O), 재배치와 배치 조립, 병렬 DB 쓰기, 원장 끝 갱신으로 분업화된 단계들.
삽화 구성 및 생성 프롬프트 보기 (Illustration Spec & Prompt) 열기 / 닫기
연출 의도: 1960~70년대 미국 인디 카툰 및 벨 연구소 매뉴얼 스타일로, 투입 호퍼에서 엄격한 단일 레일로 정렬되고, 병렬 로봇 암이 선행 검사를 거쳐 배치 호퍼로 모인 뒤 다채널 피스톤으로 고속 주입되는 5단계 산업 컨베이어 라인을 추상적으로 묘사.
Sparse 1960s-1970s American editorial spot cartoon on plain aged warm-gray newsprint paper. In empty paper space, a 5-stage industrial assembly conveyor pipeline: an intake sorting bay feeding into a strict single-file alignment track, branching into parallel pre-reading mechanical arms, converging into a batch grouping hopper, and ending at multi-channel database injection plungers. Minimalist abstract 1960s-1970s American indie comic spot illustration and Saul Steinberg doodle style, raw dip-pen black ink lines, flat geometric shapes, coarse off-register gray Zip-A-Tone halftone dots, 75% empty paper negative space, no room background, zero text or letters anywhere in the image. --ar 16:9

2. 병렬 인덱서의 단계와 병목 모형

참여자 노드의 인덱서는 동기화기에서 받은 업데이트를 Ledger API용 테이블에 적재하는 Pekko 스트림입니다. 소스 코드의 단계 구성은 다음과 같습니다(괄호는 기본값).

  1. 입력 큐: 상한 max-input-buffer-size(업데이트 50개)의 역압 큐.
  2. 입력 묶음과 inputMapper: 업데이트를 최대 submission-batch-size(50개)씩 묶고, 최대 input-mapping-parallelism(16)개 묶음을 병렬로 DB 행(DbDto)으로 변환합니다. CPU 단계입니다.
  3. seqMapper: 단일 스레드로 순서를 지키며 이벤트 순번을 매기고 문자열을 내부 정수로 치환(interning)합니다.
  4. dbPrepare: 최대 db-prepare-parallelism(4)개 묶음을 병렬로, 비활성화 대상 계약의 마지막 활성화와 내부 계약 ID(internal_contract_id)를 DB에서 조회합니다.
  5. 재배치와 batcher: DbDto를 최소 100개, 최대 5,000개의 적재 배치로 다시 묶고, JDBC 파라미터 배열로 조립합니다. 병렬도는 ingestion-parallelism(16)을 따릅니다. 별도 설정 batching-parallelism(4)은 폐기 예정입니다.
  6. ingester: 최대 16개 배치를 병렬로 PostgreSQL에 씁니다. 같은 수의 PostgreSQL 백엔드가 적재를 맡습니다.
  7. 원장 끝 갱신(tail): 완료된 배치를 최대 max-tailer-batch-size(10)개씩 합쳐 단일 스레드로 원장 끝(ledger end)을 기록합니다. 이 단계의 완료가 일관된 시점을 정합니다. 뒤이어 후처리(post-processing-parallelism, 8)가 따릅니다.

단계별 처리 천장은 대기행렬 이론의 단순 모형으로 추정할 수 있습니다. 아래 지연 값 \(\tau_k\)는 측정치가 아니라 설명용 가정입니다.

Throughput_max = min_k ( (W_k * B_k) / τ_k ), ρ_k = (λ * τ_k) / (W_k * B_k) < 1

\(W_k\)는 단계 \(k\)의 병렬도, \(B_k\)는 작업 하나가 나르는 업데이트 수, \(\tau_k\)는 작업 하나의 지연이다. 리틀의 법칙(\(L = \lambda \cdot W\))에 따라 각 단계에 머무는 양은 유입률과 체류 시간의 곱이고, 유한 버퍼가 그 상한을 정한다.

M_model ≈ S_u·(Q_in + (P_map + P_prep + 2·16)·b_sub) + S_d·2·P_ing·b_ing^max = 8 KiB·2,650 + 0.5 KiB·160,000 ≈ 99 MiB

힙 상한은 설명용 모형입니다. 기본값 \(Q_{\text{in}} = 50\), \(b_{\text{sub}} = 50\), \(P_{\text{map}} = 16\), \(P_{\text{prep}} = 4\), \(P_{\text{ing}} = 16\), \(b_{\text{ing}}^{\max} = 5{,}000\)을 넣고, Pekko 비동기 경계 두 곳의 입력 버퍼(기본 16개 원소)를 더하면 앞쪽에 업데이트 \(50 + (16 + 4 + 32) \times 50 = 2{,}650\)개, 뒤쪽(batcher와 ingester)에 DbDto \(2 \times 16 \times 5{,}000 = 160{,}000\)개가 머물 수 있습니다.

업데이트당 \(S_u = 8\) KiB, DbDto당 \(S_d = 0.5\) KiB를 가정하면 \(21{,}200 + 80{,}000 = 101{,}200\) KiB, 약 99 MiB입니다. 크기 가정이 바뀌면 값도 바뀝니다. 요점은 모든 버퍼가 유한하므로 디스크가 느려져도 힙 점유가 상한을 넘지 않는다는 것입니다.

MODEL 18.1 · 단계별 처리 천장과 유한 버퍼에 의한 힙 상한 (설명용 모형)

2.1 유입률 12,000 TPS에서의 수치 대입과 병목 이동

32코어 노드를 가정하고 기본 병렬도에 예시 지연을 넣어 봅니다. 적재 배치는 업데이트 200개(업데이트당 DbDto 4개, 배치당 800개)라고 가정합니다.

  • inputMapper: \(W = 16\), 묶음 \(B = 50\), 묶음당 \(\tau = 50\) ms(업데이트당 1 ms) → \(16 \times 50 / 0.05\,\text{s} = \mathbf{16{,}000\ \text{TPS}}\), 이용률 \(\rho = 75.0\%\).
  • seqMapper: \(W = 1\), 업데이트당 \(\tau = 0.015\) ms → \(1 / 0.000015\,\text{s} \approx \mathbf{66{,}667\ \text{TPS}}\), \(\rho = 18.0\%\). 한 스레드지만 계산이 가벼워 병목이 아닙니다.
  • dbPrepare: \(W = 4\), \(B = 50\), 묶음당 \(\tau = 12.5\) ms → \(4 \times 50 / 0.0125\,\text{s} = \mathbf{16{,}000\ \text{TPS}}\), \(\rho = 75.0\%\).
  • batcher: \(W = 16\), \(B = 200\), \(\tau = 5\) ms → \(\mathbf{640{,}000\ \text{TPS}}\), \(\rho \approx 1.9\%\).
  • ingester: \(W = 16\), \(B = 200\), 평시 \(\tau = 14\) ms → \(16 \times 200 / 0.014\,\text{s} \approx \mathbf{228{,}571\ \text{TPS}}\), \(\rho \approx 5.3\%\). 제17장의 WAL 튜닝을 빠뜨려 체크포인트 스파이크로 \(\tau = 400\) ms가 되면 천장은 \(16 \times 200 / 0.4\,\text{s} = \mathbf{8{,}000\ \text{TPS}}\)로 떨어지고(\(\rho = 150\%\)), 병목이 입력 매핑·사전 조회에서 DB 쓰기로 옮겨 갑니다.
  • 원장 끝 갱신: \(W = 1\), 배치 10개(업데이트 2,000개)를 합쳐 \(\tau = 5\) ms → \(\mathbf{400{,}000\ \text{TPS}}\), \(\rho = 3.0\%\).
단계 병렬도 \(W_k\) · 단위 \(B_k\) 예시 지연 \(\tau_k\) 단계 처리 천장 12,000 TPS 시 이용률 \(\rho_k\)
inputMapper 16 · 50 50 ms / 묶음 16,000 TPS 75.0% — 평시 공동 상한
seqMapper 1 · 1 0.015 ms / 업데이트 66,667 TPS 18.0% — 순서 보존 단일 스레드
dbPrepare 4 · 50 12.5 ms / 묶음 16,000 TPS 75.0% — 평시 공동 상한
batcher 16 · 200 5 ms / 배치 640,000 TPS 1.9%
ingester (평시) 16 · 200 14 ms / 배치 228,571 TPS 5.3% — 전체 천장은 16,000 TPS
ingester (디스크 지연) 16 · 200 400 ms / 배치 8,000 TPS 150% (병목 이동) — 역압 발동
원장 끝 갱신 1 · 2,000 5 ms / 합친 묶음 400,000 TPS 3.0%

3. 역압과 인메모리 팬아웃 버퍼

디스크 지연으로 쓰기 천장이 8,000 TPS로 내려앉으면 초당 4,000건의 초과 유입분은 어디로 갈까요? 인덱서의 모든 단계는 유한한 병렬도와 버퍼를 가진 Pekko 스트림이므로, 하류가 막히면 상류 단계가 차례로 멈추고 마지막에는 입력 큐(업데이트 50개)가 가득 찹니다. 그러면 큐에 업데이트를 넣는 쪽이 기다립니다. 노드는 메모리를 더 할당하는 대신 처리 지연을 늘리고, 디스크가 회복되면 쌓인 일을 따라잡습니다.

1960~70년대 미국 인디 카툰 스타일의 정밀 유압식 흐름 제어 조속기: 고수위와 저수위 부표 밸브가 기계식 스로틀 레버를 조절하여 트랜잭션 캡슐의 범람을 완벽히 차단하는 모습
[FIG 18.2] 역압 조속기: 데이터베이스 쓰기 속도에 맞춰 상류 유입을 늦추고, 유한 버퍼로 비행 중 메모리를 묶어 두는 흐름 제어.
삽화 구성 및 생성 프롬프트 보기 (Illustration Spec & Prompt) 열기 / 닫기
연출 의도: 1960~70년대 인디 카툰 풍으로, 고수위(High Watermark)와 저수위(Low Watermark) 부표 밸브가 기계식 스로틀 레버를 작동시켜 트랜잭션 캡슐들의 유량을 완벽히 평형 상태로 통제하는 유압 조속기를 묘사.
Sparse 1960s-1970s American editorial spot cartoon on plain aged warm-gray newsprint paper. In empty paper space, an abstract hydraulic flow-control governor mechanism: weighted float valves and mechanical throttle levers regulating a flowing stream of geometric transaction capsules between high and low watermark markers, maintaining perfect equilibrium without overflowing. Minimalist abstract 1960s-1970s American indie comic spot illustration and Saul Steinberg doodle style, raw dip-pen black ink lines, flat geometric shapes, coarse off-register gray Zip-A-Tone halftone dots, 75% empty paper negative space, no room background, zero text or letters anywhere in the image. --ar 16:9

3.1 인메모리 팬아웃 버퍼(max-transactions-in-memory-fan-out-buffer-size)

쓰기 병목 다음은 실시간 구독자들의 읽기입니다. 대형 증권사 노드 하나에는 주문집행 엔진, 장중 증거금 계산기, 수탁 지갑 데몬, 준법감시 모니터 등 여러 Ledger API UpdateService gRPC 스트림이 매달려 있습니다. 이들이 새 오프셋마다 PostgreSQL을 조회하면 읽기 풀과 버퍼 캐시에 부담이 됩니다.

Ledger API 서버는 최근 확정된 트랜잭션을 메모리 버퍼에 보관합니다. 크기는 ledger-api.index-service.max-transactions-in-memory-fan-out-buffer-size(기본 1,100)로 정합니다.

  • 최신 구간 구독자: 버퍼 범위 안의 오프셋을 따라오는 업데이트 스트림은 DB를 거치지 않고 메모리 버퍼에서 이벤트를 받습니다.
  • 뒤처진 구독자와 다른 조회: 버퍼 범위 밖의 오프셋을 요청하는 스트림, ACS 스냅샷, 완료(completion) 스트림, 단건 조회는 여전히 DB를 읽습니다. DB 부하가 얼마나 줄어드는지는 워크로드에 따라 다르므로 직접 측정해야 합니다.
노드 운영자(SRE)를 위한 인덱서·팬아웃 설정 예시 (기본값 표시) HOCON
# JVM 예시: -Xms16g -Xmx16g -XX:+UseZGC -XX:+ZGenerational (짧은 GC 정지가 목표)
canton.participants.clearing_member_node {
  storage.parameters.max-connections = 32

  # 최신 구간 구독자를 메모리에서 서빙하는 버퍼 (기본 1100)
  ledger-api.index-service.max-transactions-in-memory-fan-out-buffer-size = 4096

  parameters.ledger-api-server.indexer {
    max-input-buffer-size = 50          # 입력 큐 상한 (업데이트 수)
    submission-batch-size = 50          # 입력 묶음 크기 (업데이트 수)
    input-mapping-parallelism = 16      # inputMapper 병렬도
    db-prepare-parallelism = 4          # dbPrepare 병렬도
    ingestion-parallelism = 16          # batcher·ingester 병렬도, 인덱서 DB 풀 = 16 + 4 + 2
    max-tailer-batch-size = 10          # 원장 끝 갱신 한 번에 합치는 배치 수
    post-processing-parallelism = 8
  }
}

4. internal_contract_id 순서의 FOR KEY SHARE 잠금: 프루닝과의 조율

ingester가 배치를 쓸 때 마지막으로 남는 위험은 참여자 프루닝과의 경합입니다. 배치의 이벤트가 참조하는 계약 행(par_contracts)을 같은 순간 프루닝이 지우면, 적재된 이벤트가 사라진 계약을 가리키게 됩니다. 인덱서는 배치를 쓰는 트랜잭션 안에서 그 배치가 사용하는 계약 행에 공유 잠금을 겁니다.

인덱서의 읽기 잠금과 프루닝의 쓰기 잠금 SQL
-- ingester: 배치가 사용하는 계약 행에 공유 잠금 (잠금 대기 제한 기본 20초)
SELECT internal_contract_id FROM par_contracts
 WHERE internal_contract_id = ANY(:ids)
 ORDER BY internal_contract_id
 FOR KEY SHARE;

-- 프루닝: 지울 후보 계약 행에 배타 잠금, 기다리지 않고 실패하면 롤백
SELECT internal_contract_id FROM par_contracts
 WHERE internal_contract_id IN (SELECT internal_contract_id FROM lapi_pruning_contract_candidate_temp)
 ORDER BY internal_contract_id
 FOR UPDATE NOWAIT;
LockOrder(B_m) = (c_π(1), …, c_π(r)) s.t. icid(c_π(1)) < icid(c_π(2)) < … < icid(c_π(r))

두 쪽 모두 bigint 내부 계약 ID(\(\mathrm{icid}\)) 오름차순으로 잠근다. 공유 잠금끼리는 충돌하지 않고, 프루닝은 NOWAIT이라 기다리지 않는다.

E(WaitFor) ⊆ { ingester → pruner }, outdeg(pruner) = 0 ⟹ WaitFor is acyclic

대기 그래프의 간선은 인덱서가 프루닝의 배타 잠금을 기다리는 방향뿐이고, 프루닝은 아무도 기다리지 않으므로 순환이 생기지 않습니다.

프루닝이 잠금을 다 얻지 못하면 트랜잭션을 롤백하고 다음 차례에 다시 시도합니다. 인덱서의 잠금이 먼저 잡혀 있으면 그 계약은 이번 프루닝에서 빠지므로, 적재 중인 배치가 참조하는 계약은 지워지지 않습니다.

INVARIANT 18.2 · internal_contract_id 순서 잠금과 프루닝 조율

예를 들어 배치 #41이 내부 계약 ID [9001, 4417]을, 배치 #42가 [4417, 9001]을 사용한다면 두 워커 모두 4417 → 9001 순서로 공유 잠금을 겁니다. 공유 잠금이므로 서로 막지 않습니다. 같은 순간 프루닝이 4417을 지우려 하면 FOR UPDATE NOWAIT가 즉시 실패하고, 프루닝 트랜잭션이 롤백됩니다.

1960~70년대 벨 연구소 스타일의 시각 대조 삽화: 왼쪽에는 두 개의 기계 팔과 톱니바퀴가 서로 역방향으로 맞물려 꼼짝 못 하는 교착 상태가 그려지고, 오른쪽에는 단방향 대각선 에스컬레이터 위로 작은 상자부터 큰 상자까지 자물쇠 달린 큐브들이 크기 순서대로 매끄럽게 상승하는 스팟 만화
[FIG 18.3] 무질서한 잠금 요청이 부르는 교착(좌측) 대 모든 잠금을 내부 계약 ID 오름차순으로 한 방향으로 줄 세우는 잠금 순서(우측).
삽화 구성 및 생성 프롬프트 보기 (Illustration Spec & Prompt) 열기 / 닫기
연출 의도: 좌측의 뒤엉킨 기계 팔·기어 데드락과 우측의 작은 큐브부터 큰 큐브까지 엄격한 오름차순으로 정렬되어 흐르는 단방향 에스컬레이터를 한 화면에 대조하여 다익스트라 자원 계층 정렬 불변식(INVARIANT 18.2)을 직관적으로 표현.
Sparse 1960s-1970s American editorial spot cartoon on plain aged warm-gray newsprint paper. In wide empty paper space, a visual contrast between two mechanical scenes: on the left side, two mechanical arms tangle in a knotted deadlock of jammed interlocking gears; on the right side, a sleek single-direction diagonal mechanical escalator smoothly carries three unmarked padlocked cubes arranged strictly from smallest cube to largest cube upward in harmony. Minimalist abstract 1960s-1970s American indie comic spot illustration and Saul Steinberg / Bell Labs manual doodle style, raw slightly wobbly dip-pen black ink lines, flat geometric shapes, coarse off-register gray Zip-A-Tone halftone dots, 75% empty paper negative space, lo-fi retro printmaking feel, no 3D shading, no room background, strictly zero text, zero letters, zero numbers, zero digits, zero labels, zero symbols, completely blank unmarked cubes. --ar 16:9

5. 실전 코드 대조: 오프셋 체크포인트 gRPC 스트림 소비자와 만기 배치 결제 계약

인메모리 팬아웃 버퍼의 이득을 보려면 애플리케이션 쪽 소비자도 역압 원칙을 따라야 합니다. 클라이언트가 비동기 콜백 안에서 느린 외부 API를 무제한 호출해 처리 지연이 쌓이거나, 오프셋 영속화 없이 재기동마다 원장 처음부터 재구독하면 버퍼 범위를 벗어나 DB 읽기로 되돌아갑니다:

유한 처리 창과 오프셋 체크포인트를 둔 소비자 (UpdateStreamConsumer.ts) TypeScript
// [Client Best Practice] 처리 창을 유한하게 두고 오프셋을 저장해 재연결 시 최신 구간에서 이어받는다
interface LedgerTransactionUpdate {
  offset: bigint;
  workflowId: string;
  archivedIds: string[];
  createdIds: string[];
}

export async function consumeUpdatesWithBackpressure(
  updateStream: AsyncIterable<LedgerTransactionUpdate>,
  loadLastOffset: () => Promise<bigint>,
  saveCheckpointOffset: (off: bigint) => Promise<void>,
  processRiskEngine: (tx: LedgerTransactionUpdate) => Promise<void>
): Promise<void> {
  let lastCommittedOffset = await loadLastOffset();
  const inFlightWindow: Promise<void>[] = [];
  const MAX_IN_FLIGHT = 64; // 클라이언트 힙 상한 (gRPC HTTP/2 흐름 제어와 연동)

  for await (const tx of updateStream) {
    if (tx.offset <= lastCommittedOffset) continue;

    const task = processRiskEngine(tx);
    inFlightWindow.push(task);

    if (inFlightWindow.length >= MAX_IN_FLIGHT) {
      await Promise.all(inFlightWindow);
      inFlightWindow.length = 0;
      lastCommittedOffset = tx.offset;
      // 창 단위로 오프셋 저장 -> 재연결 시 최신 구간에서 이어받음
      await saveCheckpointOffset(lastCommittedOffset);
    }
  }
}
파생상품 동시 만기 일괄 정산 계약 (DerivativeBatchSettlement.daml) Daml
module DerivativeBatchSettlement where

import DA.Action (forA)

template IndexOptionPosition
  with
    clearingHouse : Party
    clearingMember : Party
    seriesCode : Text
    strikeIndex : Decimal
    contractsCount : Int
  where
    signatory clearingHouse, clearingMember

    choice SettleAtExpiry : ContractId CashVariationSettlement
      with
        closingIndex : Decimal
        multiplierUsd : Decimal
      controller clearingHouse
      do
        let intrinsic = max 0.0 (closingIndex - strikeIndex)
        let payoutUsd = intrinsic * intToDecimal contractsCount * multiplierUsd
        create CashVariationSettlement with
          clearingHouse; clearingMember; seriesCode; payoutUsd

template CashVariationSettlement
  with
    clearingHouse : Party
    clearingMember : Party
    seriesCode : Text
    payoutUsd : Decimal
  where
    signatory clearingHouse
    observer clearingMember

template QuadrupleWitchingBatch
  with
    clearingHouse : Party
    seriesCode : Text
  where
    signatory clearingHouse

    -- 여러 만기 포지션을 하나의 원자적 트랜잭션으로 정산
    choice ExecuteExpiryBatch : [ContractId CashVariationSettlement]
      with
        optionCids : [ContractId IndexOptionPosition]
        closingIndex : Decimal
        multiplierUsd : Decimal
      controller clearingHouse
      do
        forA optionCids (\cid ->
          exercise cid SettleAtExpiry with closingIndex; multiplierUsd)

6. 제도적 현실: 청산 연속성 규제

감독 당국의 시각에서, 만기일이나 분기 말에 특정 청산 회원사 노드가 메모리 부족(OOM)으로 멈추는 사건은 단순한 소프트웨어 버그가 아니라 결제 불이행의 연쇄(Systemic Contagion)로 번질 수 있는 운영 사고입니다.

미국 상품선물거래위원회(CFTC) 규정 1.38, 미국 증권거래위원회(SEC)의 시스템 준법·무결성 규정(Regulation SCI)과 Rule 17a-4, 그리고 CPMI-IOSCO 「금융시장인프라 원칙(PFMI)」 원칙 17(운영 리스크)은 거래량이 급증할 때도 시스템이 비정상 종료나 기록 결측 없이 처리를 이어 가고, 그 용량을 미리 계획·시험할 것을 요구합니다.

역압 구조가 감독 당국에 주는 보증은 명확합니다. 트래픽이 일시적으로 디스크 한계를 넘어도 노드는 OutOfMemoryError로 멈추지 않고, 유한 버퍼 안에서 지연을 늘려 흡수한 뒤 폭주가 지나가면 적체를 따라잡습니다. 다만 지연이 얼마나 늘어나는지는 위 모형이 아니라 실제 부하 시험으로 확인해야 하며, 그 결과가 용량 계획 문서의 근거가 됩니다.

이 장에서 남는 것

  1. 약 일곱 단계의 인덱서와 병목 모형. 입력 큐, inputMapper(16), seqMapper(1), dbPrepare(4), batcher·ingester(16), 원장 끝 갱신(1)으로 CPU와 I/O를 나눈다. 예시 지연에서 평시 천장은 16,000 TPS이고, 디스크 지연(400ms)이면 ingester가 8,000 TPS로 떨어져 병목이 된다.
  2. 유한 버퍼와 역압. 입력 큐는 업데이트 50개, 입력 묶음은 50개가 기본이며, 모든 단계의 병렬도와 버퍼가 유한하므로 힙 점유에 상한이 있다. 크기 가정을 넣은 설명용 모형으로는 약 99 MiB다.
  3. 팬아웃 버퍼는 최신 구간만 덜어 준다. 기본 1,100개 트랜잭션을 메모리에 두고 최신 구간 구독자를 서빙하며, 버퍼 밖 요청·ACS·완료·단건 조회는 DB를 읽는다.
  4. 잠금 순서는 프루닝과의 조율이다. 인덱서는 internal_contract_id 오름차순 FOR KEY SHARE로, 프루닝은 같은 순서 FOR UPDATE NOWAIT로 잠그므로 대기 그래프에 순환이 생기지 않고, 적재 중인 배치가 참조하는 계약은 지워지지 않는다.