따알깍PROMPT DICT 앱으로 열기

게임 개발 · 엔진 · 프로그래밍 · AI · 테크 아트 · 성능 · QA

성능 최적화 · 프로파일링 Performance optimization & profiling

프레임 시간을 FPS가 아닌 ms로 읽는 법, CPU · GPU 병목 판별, 1% low와 프레임 타임 분포, 히치 원인 분류, 측정 → 가설 → 변경 → 재측정 순서, 프로파일러 · 빌드 구성 · Vsync 같은 측정 조건, 벤치 경로와 성능 회귀 판정, 로딩 시간 분해, 배칭 · 컬링 · 파티클 · 그림자 · 텍스처 풀 예산, 분기 예측과 할당 없는 프레임까지 — 엔진 · 클라이언트 프로그래머와 테크니컬 아티스트가 실제로 내리는 성능 판단을 수치 HUD가 붙은 자동 재생 데모와 나쁜 예 / 좋은 예 비교로 보여 준다.

카드 40개 · 카드마다 설명과 바로 복사해 쓸 수 있는 프롬프트 전문 · 앱에서 라이브 데모로 보기

카드 목록 40개
  1. FPS 대신 ms로 말하기 (같은 2 ms의 다른 무게)
  2. CPU 병목 vs GPU 병목 판별 (해상도 ½ 테스트)
  3. 평균 FPS vs 1% low (프레임 타임 분포)
  4. 히치 원인 분류 (GC · 셰이더 · IO · 스트리밍)
  5. 측정 → 가설 → 변경 → 재측정 (추측 최적화 vs 측정 최적화)
  6. 샘플링 vs 계측 프로파일러 (오버헤드 · 놓치는 이벤트)
  7. 측정용 빌드 구성 (에디터 · Debug · Development · Test)
  8. Vsync가 숨기는 비용 (16.7 / 33.3 ms 계단)
  9. 최악 장면 벤치 경로 (고정 경로 · 3회 · 워밍업 제외)
  10. 성능 회귀 판정 (5회 중앙값 · MAD 띠)
  11. 로딩 시간 분해 (IO · 압축 해제 · 초기화 · 셰이더)
  12. 배칭 방식 고르기 (인스턴싱 · 스태틱 · 다이내믹 · 개별)
  13. 컬링 단계별 기여 (프러스텀 → 크기별 거리 → 오클루전)
  14. 파티클 예산은 개수보다 화면 면적 (오버드로 뷰)
  15. 그림자 비용 노브 (거리 · 캐스케이드 · 작은 캐스터 · 캐시)
  16. 그래픽 프리셋 짜기 (설정별 ms 절약 ÷ 화질 손실)
  17. 텍스처 스트리밍 풀 초과 (전체 밉 강등 vs 화면 크기 우선)
  18. 분기 예측 (무작위 vs 정렬 vs 분기 없는 코드)
  19. 스레드별 프레임 예산 (합산 금지 · 헤드룸 15%)
  20. 할당 없는 프레임 (프레임당 0 B 규칙 · 할당 출처 제거)
  21. 목표 프레임 정하기 (P99 기준 · 30 / 40 / 60 고정)
  22. 셰이더 비용 읽기 (텍스처 샘플 · ALU · 발산 분기 · 레지스터)
  23. 정점 · 픽셀 바운드와 작은 삼각형 (2×2 쿼드 낭비)
  24. 렌더 타깃 대역폭 (포맷 바이트 × 해상도 × 접근 횟수)
  25. 포스트 이펙트 단계별 비용 (½ 해상도 · 우버 패스)
  26. CPU ↔ GPU 동기화 정지 (즉시 리드백 vs 2프레임 뒤 읽기)
  27. 스크립트 Tick 호출 비용 (액터 1,000개 vs 매니저 루프)
  28. 로그 · 문자열 비용 (필터돼도 포맷 실행 · 출시 빌드 제거)
  29. 작은 파일 다수 vs 팩 파일 (열기 · 탐색 · 순차 읽기)
  30. 압축 코덱 vs 로딩 속도 (저장 장치별 교차점)
  31. 메모리 피크 vs 평균 (레벨 전환 이중 상주)
  32. 메모리 숫자 세 가지 (관리 힙 · 엔진 추적 · OS 커밋)
  33. 최소 사양 기기 측정 (스펙 비율 환산 금지 · 병목 이동)
  34. 최적화 효과 보고 (1회 평균 vs 반복 중앙값 · P95)
  35. 최적화 우선순위 (ms 이득 ÷ 작업일 · 예산 도달까지만)
  36. 원격 성능 텔레메트리 (세션 평균 vs 버킷 · 등급별 백분위)
  37. 잡 크기 정하기 (너무 잘게 · 너무 크게 · 64개 묶음)
  38. SIMD 벡터화 (스칼라 · 4-wide · 8-wide · 꼬리 마스크)
  39. 정점 포맷 압축 (72 B → 28 B · 양자화 · 옥타 노멀)
  40. 예산 위반 경고 · 소유자 자동 배정 (중복 묶기 · SLA · 상향)

FPS 대신 ms로 말하기 (같은 2 ms의 다른 무게)

Frame time in milliseconds, not FPS: the same +2 ms costs −23 FPS at 120 fps but −1.7 FPS at 30 fps

  • Canvas
  • Unity
  • Unreal

FPS = 1000 / ms 곡선 위에서 같은 2 ms 추가가 120 fps 타깃에선 23 FPS, 30 fps 타깃에선 1.7 FPS로 보이는 것을 비교해, 예산 · 회귀 · 최적화 효과를 ms로 보고해야 하는 이유를 보여 줄 때 쓴다.

프롬프트

Canvas로 x = 프레임 시간 0–40 ms, y = FPS 0–130 그래프에 FPS = 1000/ms 곡선을 그리고 8.33 ms(120 fps)와 33.33 ms(30 fps) 두 점에 같은 +2.0 ms 기능 비용을 1.1초 easeInOutCubic으로 더해 −23.2 FPS vs −1.7 FPS 태그를 띄운 뒤, 5초 뒤에는 −2 ms 최적화로 되돌려 +23.2 vs +1.7을 보여 줘. 오른쪽에는 0–40 ms 가로 막대 두 개에 기본 비용과 빨간 +2 ms 블록이 떨어져 붙고 "120 → 96.8 fps" 숫자가 실시간으로 바뀌게 해 줘.

라이브 데모 열기 — FPS 대신 ms로 말하기 (같은 2 ms의 다른 무게)

CPU 병목 vs GPU 병목 판별 (해상도 ½ 테스트)

CPU-bound vs GPU-bound test: drop the render resolution and watch whether frame time follows

  • Unreal
  • Unity
  • Canvas

렌더 해상도를 100%에서 50%로 내렸을 때 프레임 시간이 따라 내려가면 GPU 병목, 그대로면 CPU 병목이라는 가장 빠른 판별법을 두 장면으로 보여 줄 때 쓴다.

프롬프트

게임 뷰 + stat unit 패널 목업에서 r.ScreenPercentage 슬라이더를 고스트 커서가 1.2초 동안 100% → 50%로 끌면 화면이 저해상도로 픽셀화되고, 장면 1(볼류메트릭 안개)은 GPU 24.0 → 11.3 ms로 프레임도 함께 떨어져 "GPU 병목", 장면 2(유닛 400 · 드로 3,820)는 CPU 23.4 ms가 그대로라 프레임 23.4 ms 유지 → "CPU 병목" 판정을 띄워 줘. 프레임 = max(CPU, GPU)이고 16.6 ms 예산선을 각 막대에 표시해 줘.

라이브 데모 열기 — CPU 병목 vs GPU 병목 판별 (해상도 ½ 테스트)

평균 FPS vs 1% low (프레임 타임 분포)

Average FPS vs 1% low: two captures with the same 60 fps average and very different frame-time distributions

  • Canvas
  • Unity
  • Unreal

평균 60 fps가 같은 두 캡처(고른 16.7 ms vs 15 ms 바탕에 50 ms 스파이크 9번)를 프레임 타임 그래프 · 1% low · P99 · 히스토그램으로 비교해, 끊김은 평균이 아니라 분포의 꼬리로 판단해야 할 때 쓴다.

프롬프트

240프레임 캡처 두 개를 7.4초에 걸쳐 왼쪽부터 그리는 프레임 타임 막대 그래프(16.7 · 33.3 ms 기준선, 20 ms 미만 초록 · 33 ms 미만 노랑 · 그 이상 빨강)로 만들고, 오른쪽 패널에 지금까지 그린 프레임 기준 평균 FPS · 1% low(= 1000 / P99 ms) · P99 ms와 10–55 ms 3 ms 단위 히스토그램을 실시간 계산해 줘. A는 16.7 ± 0.75 ms, B는 9개 프레임이 46–52 ms이고 나머지를 깎아 평균이 정확히 16.67 ms가 되게 해서 평균은 둘 다 60.0, B의 1% low는 약 20 fps가 나오게 해 줘.

라이브 데모 열기 — 평균 FPS vs 1% low (프레임 타임 분포)

히치 원인 분류 (GC · 셰이더 · IO · 스트리밍)

Hitch triage: classifying frame spikes by correlated counters (GC heap drop, PSO creation, synchronous IO, streaming activation)

  • Unreal Insights
  • Unity Profiler
  • Canvas

프레임 타임 스파이크 4개를 같은 시간축의 GC 힙 · PSO 생성 · 동기 IO · 액터 활성화 지표와 맞대어 원인을 분류하고 대처를 정하는 트리아지 절차를 보여 줄 때 쓴다.

프롬프트

120프레임 프레임 타임 그래프(최대 70 ms) 아래에 같은 x축의 지표 레인 4개(GC 힙 톱니선, PSO 생성 틱, 동기 IO MB 막대, 액터 활성화 수)를 두고, 18 · 45 · 74 · 100번 프레임의 38 · 64 · 44 · 29 ms 스파이크를 고스트 커서가 2초 간격으로 차례로 짚으면 그 열이 강조되고 같이 튄 레인에 테두리가 생기며 오른쪽 트리아지 카드에 원인 · 징후 · 대처(오브젝트 풀, PSO 캐시, 비동기 로드, 프레임당 2 ms 시간 분할 활성화)가 뜨게 해 줘.

라이브 데모 열기 — 히치 원인 분류 (GC · 셰이더 · IO · 스트리밍)

측정 → 가설 → 변경 → 재측정 (추측 최적화 vs 측정 최적화)

Optimisation loop: measure → hypothesise → change → re-measure, guess-driven vs profile-driven with Amdahl's law

  • Canvas
  • Unity
  • Unreal

21 ms 프레임에서 "느려 보이는" 0.6 ms 수학 함수를 2배 빠르게 한 추측 최적화(1.4% 단축)와, 프로파일러 1위 그림자 6.1 ms를 줄인 측정 최적화(21% 단축)를 암달의 법칙 숫자로 비교할 때 쓴다.

프롬프트

왼쪽에 측정 · 가설 · 변경 · 재측정 4단계 원형 순서도(현재 단계 강조, A에서는 측정 · 재측정에 빨간 X), 오른쪽에 0–24 ms 누적 프레임 막대와 비용순 프로파일러 목록 8줄(그림자 6.1 · 스키닝 3.2 · 파티클 2.8 · 로직 2.6 · 기타 2.4 · UI 1.9 · AI 1.4 · 수학 0.6)을 두고, A는 수학 0.6 → 0.3 ms로 21.0 → 20.7 ms, B는 그림자 6.1 → 1.6 ms로 21.0 → 16.5 ms가 되게 0.9초 easeInOut으로 줄여 줘. 아래에 이득 = p × (1 − 1/s)를 p · s 값과 함께 계산해 보여 줘.

라이브 데모 열기 — 측정 → 가설 → 변경 → 재측정 (추측 최적화 vs 측정 최적화)

샘플링 vs 계측 프로파일러 (오버헤드 · 놓치는 이벤트)

Sampling vs instrumented profiling: marker overhead inflating tiny calls vs 1 kHz samples missing a 0.4 ms one-off

  • Unity Profiler
  • Unreal Insights
  • Superluminal
  • Canvas

같은 프레임을 스코프 마커 계측(호출 1,200회 × 2 µs → +2.6 ms 부풀림)과 1 kHz 샘플링(0.4 ms 단발 이벤트를 놓침)으로 잰 결과를 나란히 그려, 넓게는 샘플링 · 좁게는 마커로 쓰는 원칙을 보여 줄 때 쓴다.

프롬프트

0–20 ms 시간축에 실제 · 계측 · 샘플링 3개 레인을 두고 3.4초 동안 스캔선이 지나가며 블록을 드러내 줘: 실제는 Update 5.2 · Physics 2.8 · Render 5.6 · Flush 0.4 ms, 계측 레인은 Update 안 GetComponent 1,200회마다 빨간 오버헤드 조각이 붙어 전체가 16.8 ms로 늘어나 16.6 ms 예산선을 넘고, 샘플링 레인은 k + 0.5 ms마다 점을 찍어 Flush 블록이 샘플 사이로 빠지는 것을 점선 상자로 표시해 줘. 아래에는 함수별 샘플 수 막대, 오른쪽에는 ✓/✕ 비교표와 "샘플링으로 넓게 → 마커로 좁게" 규칙을 띄워 줘.

라이브 데모 열기 — 샘플링 vs 계측 프로파일러 (오버헤드 · 놓치는 이벤트)

측정용 빌드 구성 (에디터 · Debug · Development · Test)

Measuring in the right build configuration: editor PIE vs Debug vs Development vs Test/Shipping frame-time breakdown

  • Unreal
  • Unity
  • Canvas

같은 벤치 경로를 에디터 PIE 29.2 · Debug 56.3 · Development 18.2 · Test 14.9 ms로 잰 막대를 에디터 오버헤드 · -O0 · 체크 · 마커 비용으로 쪼개, 성능 판단은 어떤 빌드에서 해야 하는지 정할 때 쓴다.

프롬프트

빌드 구성 4줄의 가로 누적 막대(0–60 ms, 16.6 ms 초록 점선)를 0.45초 간격 easeOutQuart로 자라게 하고, 게임 실제 비용 14.9 ms(파랑) 위에 에디터 오버헤드 12.4 · 최적화 꺼짐 33.0 · 체크와 로그 7.5 / 2.1 / 1.0 · 통계 마커 0.9 / 1.2 ms를 색으로 쌓아 줘. 그다음 "에디터 수치로 결정 금지", "디버깅 전용", "마커 켜고 상대 비교", "최종 판정 기준" 칩을 차례로 붙이고 Test 줄에 초록 테두리, 오른쪽에 같은 빌드 · 경로 · 기기끼리만 비교, vsync off, 워밍업 제외 규칙을 보여 줘.

라이브 데모 열기 — 측정용 빌드 구성 (에디터 · Debug · Development · Test)

Vsync가 숨기는 비용 (16.7 / 33.3 ms 계단)

Vsync quantisation hiding the real cost: measured frame time snaps to 16.7 / 33.3 ms while GPU timestamps stay linear

  • Canvas
  • Unity
  • Unreal
  • PIX

Vsync를 켠 채 재면 GPU 작업이 14 ms든 16 ms든 16.7 ms로, 17 ms가 되는 순간 33.3 ms로 튀어 실제 비용과 남은 여유가 가려지는 것을 계단 그래프와 vblank 타임라인으로 보여 줄 때 쓴다.

프롬프트

왼쪽 그래프는 x = 실제 GPU 작업 10–26 ms, y = 측정값 0–40 ms로 vsync 측정 계단선(16.7 → 33.3)과 GPU 타임스탬프 대각선을 그리고, 작업량 점이 10초 주기 코사인으로 12 ↔ 20 ms를 오가며 두 선의 차이를 빨간 "숨은 차이" 태그로 보여 줘. 오른쪽에는 60 Hz vblank 눈금 위에 프레임 작업 블록과 다음 vblank까지 기다리는 노란 빗금을 그리고, HUD에 "33.3 ms vs 17.2 ms → 0.5 ms만 줄이면 60 fps 복귀"처럼 실제로 줄여야 할 양을 계산해 줘.

라이브 데모 열기 — Vsync가 숨기는 비용 (16.7 / 33.3 ms 계단)

최악 장면 벤치 경로 (고정 경로 · 3회 · 워밍업 제외)

Worst-case benchmark path: free-play runs vs a fixed camera spline through the level hot spots with warm-up excluded

  • Unreal
  • Unity
  • Canvas

레벨 비용 히트맵 위에서 사람마다 다른 자유 플레이 3회(σ 1.8 ms)와 광장 · 폭포 · 아레나를 지나는 고정 스플라인 3회(σ 0.12 ms)를 비교해, 변경 전후를 믿고 비교할 수 있는 벤치 경로를 설계할 때 쓴다.

프롬프트

36×30 셀 비용 히트맵(파랑 → 주황 → 빨강, 핫스폿 3곳 가우스)을 캐시해 두고, A는 무작위 플레이 경로 3개를 1.3초씩 그리며 run 15.2 / 19.6 / 16.8 ms와 σ를, B는 핫스폿을 잇는 Catmull-Rom 고정 경로를 같은 시드로 3번 달려 21.4 / 21.6 / 21.3 ms(σ 0.12)를 막대로 보여 줘. 경로 앞 5초 구간은 점선 "워밍업 제외"로 표시하고, 측정값 = 경로 구간 평균이라는 규칙을 아래에 써 줘.

라이브 데모 열기 — 최악 장면 벤치 경로 (고정 경로 · 3회 · 워밍업 제외)

성능 회귀 판정 (5회 중앙값 · MAD 띠)

Performance regression gate in CI: single runs with a fixed +3 % threshold vs 5-run medians against a rolling baseline ± max(3 %, 3·MAD)

  • Jenkins
  • GitHub Actions
  • Canvas

빌드마다 1회 측정 + 고정 3% 임계로는 노이즈와 같은 회귀의 반복으로 알림이 12건 쏟아지고, 5회 중앙값 + 기준선 MAD 띠로는 #16의 +1.1 ms 회귀 1건만 잡히는 것을 비교해 CI 성능 게이트를 설계할 때 쓴다.

프롬프트

빌드 #1–24의 벤치 ms를 15–19 ms 축에 3.2초 동안 하나씩 찍고, A는 1회 측정값과 첫 빌드 +3%(16.48 ms) 빨간 점선을 넘는 점마다 빨간 삼각형 알림을 달아 알림 수를 세 줘. B는 빌드마다 5회 실행을 회색 점으로, 중앙값을 큰 점으로 찍고 직전 10빌드 중앙값 ± max(3%, 3 × MAD) 초록 띠를 벗어난 #16(+1.1 ms, +6.9%)에만 알림과 커밋 해시 태그를 붙인 뒤 이후 빌드는 열린 이슈로 묶어 알림 1건으로 끝나게 해 줘.

라이브 데모 열기 — 성능 회귀 판정 (5회 중앙값 · MAD 띠)

로딩 시간 분해 (IO · 압축 해제 · 초기화 · 셰이더)

Load-time breakdown: serial IO → decompress → init → shader stages vs overlapped streaming, parallel decompression, PSO cache and deferred init

  • Unreal
  • Unity
  • Canvas

18.4초 걸리던 직렬 로딩을 단계별로 재고, IO와 4스레드 압축 해제를 겹치고 셰이더는 PSO 캐시 0.3초 · 초기화는 필수 1.4초만 남기고 나머지를 플레이 뒤로 미뤄 조작 가능까지 8.0초로 줄이는 판단을 간트로 보여 줄 때 쓴다.

프롬프트

0–20초 간트 두 개를 같은 재생 헤드가 7.2초 동안 훑게 해 줘: A는 메인 한 줄에 IO 6.2 · 압축 해제 4.8 · 초기화 3.9 · 셰이더 3.5초가 이어져 로딩 바가 18.4초에 끝나고, B는 IO 스트림 6.2초 동안 0.45초 간격 해제 청크가 따라붙고 PSO 캐시 0.3 · 필수 초기화 1.4초 뒤 8.0초에 "조작 가능" 초록 선, 남은 초기화 2.6초는 빗금으로 백그라운드에 그려 줘. 끝에 "단계별로 재고 → 가장 긴 단계부터 겹친다" 토스트를 띄워 줘.

라이브 데모 열기 — 로딩 시간 분해 (IO · 압축 해제 · 초기화 · 셰이더)

배칭 방식 고르기 (인스턴싱 · 스태틱 · 다이내믹 · 개별)

Choosing a batching path per object type: GPU instancing vs static batching vs dynamic batching vs individual draws (decision tree)

  • Unity
  • Unreal
  • Canvas

나무 400 · 풀 3,000 · 지형 바위 60 · 코인 60 · 캐릭터 8명을 "같은 메시 100개 이상? → 움직이나? → 정점 300 미만?" 결정 트리에 흘려 각자 맞는 배칭으로 보내고, 드로콜이 3,544 → 35로 줄어드는 판단을 보여 줄 때 쓴다.

프롬프트

결정 트리(같은 메시 ≥ 100 → GPU 인스턴싱, 아니면 움직이나? 아니오 → 스태틱 배칭(메모리 ↑), 예 → 정점 < 300? 예 → 다이내믹 배칭(CPU ↑), 아니오 → 개별 드로 + SRP 배처)를 노드로 그리고, 오브젝트 토큰 5개가 1.5초 간격으로 1.3초씩 노드를 따라 내려가 잎 아래 칩으로 쌓이게 해 줘. 오른쪽 Draw Calls 패널은 3,544에서 시작해 토큰이 도착할 때마다 400→2, 3,000→3, 60→4, 60→2, 24→24로 줄어 35가 되게 해 줘.

라이브 데모 열기 — 배칭 방식 고르기 (인스턴싱 · 스태틱 · 다이내믹 · 개별)

컬링 단계별 기여 (프러스텀 → 크기별 거리 → 오클루전)

Culling stack contribution: frustum, size-based cull distances and occlusion applied in order of cost, with a remaining-object waterfall

  • Unreal
  • Unity
  • Canvas

탑뷰 장면에서 싼 테스트부터 프러스텀 → 크기별 컬 거리(소품 40 m · 중간 120 m · 큰 것 무제한) → 건물 오클루전을 차례로 적용해, 남은 객체가 단계마다 얼마나 줄어드는지 폭포 막대로 보여 줄 때 쓴다.

프롬프트

카메라 시야각 ±35°의 탑뷰에 객체 220개(소 · 중 · 대)와 건물 4개를 배치하고, 1 · 3 · 5초에 1초씩 프러스텀 밖(회색) → 크기별 거리 링 밖(노랑, 소품 40 m · 중간 120 m) → 카메라에서 건물 뒤로 드리운 보라 그림자 안(오클루전)을 차례로 흐리게 바꿔 줘. 오른쪽에 전체 → 프러스텀 → 거리 → 오클루전 단계의 남은 객체 수를 ×56 환산 숫자와 막대로 easeInOut 감소시키고 "싼 테스트부터 차례로"를 띄워 줘.

라이브 데모 열기 — 컬링 단계별 기여 (프러스텀 → 크기별 거리 → 오클루전)

파티클 예산은 개수보다 화면 면적 (오버드로 뷰)

Particle budget by screen coverage, not count: 20 near-camera smoke cards vs 2,000 tiny sparks in an overdraw view

  • Unity
  • Unreal Niagara
  • Canvas

카메라 가까이 큰 연기 20장(화면 1,460% 덮음 · 6.2 ms)과 작은 불꽃 2,000개(24% · 0.6 ms)를 일반 뷰와 가산 오버드로 뷰로 번갈아 보여, 파티클 예산을 개수가 아니라 면적 × 겹침으로 잡아야 할 때 쓴다.

프롬프트

두 게임 뷰에 A 반지름 26–58 px 연기 20장(방사형 그라디언트)과 B 1.4 px 불꽃 300개(2,000개 대표)를 그리고, 3–6.4초에는 배경을 검게 덮고 각 입자를 lighter 합성 rgba(255,60,20,.16)으로 다시 그려 겹친 곳이 빨강 → 노랑으로 타는 오버드로 뷰로 바꿔 줘. 아래에 개수 · 화면 덮음 % · GPU ms 막대를 두고 끝에 "예산 = 화면 면적 × 겹침 · 근접하면 축소 · 페이드" 규칙을 띄워 줘.

라이브 데모 열기 — 파티클 예산은 개수보다 화면 면적 (오버드로 뷰)

그림자 비용 노브 (거리 · 캐스케이드 · 작은 캐스터 · 캐시)

Shadow cost knobs: shadow distance, cascade count, small-caster culling, static far-cascade caching and map resolution

  • Unreal
  • Unity
  • Canvas

그림자 패스 5.8 ms를 거리 150 → 60 m(−1.6), 캐스케이드 4 → 3(−0.8), 화면 0.5% 미만 캐스터 제외(−0.7), 원거리 캐스케이드 정적 캐시(−0.6), 해상도 4096 → 2048(−0.2) 순으로 줄이며 디버그 뷰가 어떻게 바뀌는지 보여 줄 때 쓴다.

프롬프트

측면 장면(나무 · 돌 14개, 0–150 m 눈금)의 땅 아래에 캐스케이드 분할을 색 띠로 그리는 섀도 디버그 뷰와 오른쪽 설정 토글 5개를 두고, 고스트 커서가 1 · 2.4 · 3.8 · 5.2 · 6.6초에 토글을 켤 때마다 60 m 밖 그림자 사라짐 · 띠 4 → 3개 · 작은 돌 그림자 제거 · 마지막 띠에 빗금 "정적 캐시" · 그림자 가장자리 소프트화가 반영되고 GPU 그림자 패스가 5.8 → 1.9 ms로 easeOut 감소하게 해 줘.

라이브 데모 열기 — 그림자 비용 노브 (거리 · 캐스케이드 · 작은 캐스터 · 캐시)

그래픽 프리셋 짜기 (설정별 ms 절약 ÷ 화질 손실)

Building quality presets from a cost sheet: per-setting ms saved vs visible quality loss, swept by efficiency (loss per ms)

  • Unity
  • Unreal
  • Canvas

설정을 하나씩 끄고 잰 ms 절약과 화질 손실을 산점도에 찍고 손실/ms 기준선을 돌려 효율 좋은 것부터 Medium · Low에 넣어, 프리셋을 감이 아니라 비용표로 정할 때 쓴다.

프롬프트

x = 절약 0–4 ms, y = 화질 손실 0–10 산점도에 볼류메트릭 안개(3.1, 3) · SSR(2.2, 2) · AO(1.4, 1.4) · 모션 블러(0.4, 0.4) · 풀 밀도(1.2, 2.2) · 그림자 거리(1.8, 3.4) · 해상도 85%(2.6, 6.5) · 텍스처 품질(0.1, 7.6, 속 빈 보라 점 "VRAM 등급으로")을 찍고, 원점에서 기울기 r = 손실/ms 선을 0 → 2.05까지 6.2초 easeInOutSine으로 들어 올려 r ≤ 1.05 안에 든 것은 Medium(−7.1 ms), 그 위는 Low(−10.1 ms) 목록에 실시간으로 추가해 줘.

라이브 데모 열기 — 그래픽 프리셋 짜기 (설정별 ms 절약 ÷ 화질 손실)

텍스처 스트리밍 풀 초과 (전체 밉 강등 vs 화면 크기 우선)

Texture streaming pool over budget: uniform mip bias blurring the hero vs priority by screen size dropping small and distant textures first

  • Unreal
  • Unity
  • Canvas

새 구역 진입으로 텍스처 풀이 1,024 MB를 넘었을 때 모든 텍스처 밉을 한 단계 내려 영웅까지 흐려지고 324 MB를 남기는 대응과, 화면 비중이 작고 먼 텍스처부터 내려 1,010 MB에 맞추는 대응을 비교할 때 쓴다.

프롬프트

풀 막대(1,024 MB 흰 선, 초과분 빨강)와 게임 뷰(영웅 · 성벽 · 바닥 · 원경 산 · 상자 텍스처를 64 px 원본에서 밉마다 절반 크기 캔버스로 캐시해 imageSmoothing 끄고 확대)를 두고, 1초에 "+260 MB 요청"으로 1,120 MB가 된 뒤 2.4초에 A는 모든 밉 +1(700 MB, "영웅까지 흐려짐"), B는 원경 산 mip 2 · 성벽 · 상자 mip 1 · 영웅과 바닥 mip 0(1,010 MB)으로 바꿔 줘. 오른쪽 표에 텍스처별 화면 비중 % · 현재 mip · 해상도를 보여 줘.

라이브 데모 열기 — 텍스처 스트리밍 풀 초과 (전체 밉 강등 vs 화면 크기 우선)

분기 예측 (무작위 vs 정렬 vs 분기 없는 코드)

Branch prediction in a hot loop: random data mispredicting ~50 % vs sorted data vs a branchless mask, with a live 2-bit predictor

  • C++
  • C#
  • Canvas

if (v >= 128) sum += v 루프를 무작위 데이터 · 정렬된 데이터 · 마스크 연산으로 돌리며 2비트 예측기 상태와 예측 실패를 눈으로 따라가, 핫 루프에서 분기 실패 비용(11.4 vs 2.1 vs 2.4 ms)을 판단할 때 쓴다.

프롬프트

0–255 값 48개 막대와 128 기준선을 두고 스캔 헤드가 2.5초에 한 번 훑을 때마다 실제 2비트 포화 카운터(SN · WN · WT · ST)를 시뮬레이션해 막대 아래에 맞음 초록 점 / 틀림 빨간 X를 찍고 실패율 %를 세 줘. 3.3초마다 A 무작위(약 50%) → B 정렬(약 4%) → C 분기 없음(m = -(v >= 128); sum += v & m)으로 바꾸고, 오른쪽 결과 막대에 1M개 합산 11.4 · 2.1 · 2.4 ms를 차례로 채워 줘.

라이브 데모 열기 — 분기 예측 (무작위 vs 정렬 vs 분기 없는 코드)

스레드별 프레임 예산 (합산 금지 · 헤드룸 15%)

Per-thread frame budgets: main, render and GPU run pipelined in parallel, so frame time is the max lane, not the sum, with 15 % headroom

  • Unreal
  • Unity
  • Canvas

로직 · 물리 · 애니 · AI · 렌더 스레드 · GPU 비용을 한 줄로 더해 35.1 ms("30 fps")라고 오판하는 경우와, 메인 · 렌더 · GPU 레인으로 나눠 max = 15.1 ms이고 GPU만 헤드룸 14.1 ms를 넘는다고 읽는 경우를 비교할 때 쓴다.

프롬프트

0–40 ms 축에 블록 6개(로직 4.2 · 물리 2.1 · 애니 2.6 · AI 1.3 · 렌더 스레드 9.8 · GPU 15.1 ms)를 A에서는 한 줄로 이어 35.1 ms 빨간 숫자를 띄우고, 5.1초부터 1.1초 easeInOutCubic으로 메인(N) · 렌더(N−1) · GPU(N−2) 세 레인으로 날아가 각각 0에서 시작하게 해 줘. 16.6 ms 초록 예산선과 16.6 × 0.85 = 14.1 ms 노란 헤드룸 점선을 긋고 레인별 합계를 초록 / 노랑으로 표시한 뒤 "프레임 = max(…) = 15.1 ms, GPU부터 0.9 ms 줄인다"를 써 줘.

라이브 데모 열기 — 스레드별 프레임 예산 (합산 금지 · 헤드룸 15%)

할당 없는 프레임 (프레임당 0 B 규칙 · 할당 출처 제거)

Zero-allocation gameplay frames: hunting per-frame GC allocations line by line until the managed heap stops growing and GC spikes disappear

  • Unity
  • C#
  • Canvas

Update() 안의 문자열 연결 · LINQ · RaycastAll · 코루틴 · 리스트 용량 증가 · 로그가 만드는 프레임당 920 B를 한 줄씩 없애며 관리 힙 톱니와 GC 스파이크가 사라지는 과정을 보여, 게임플레이 프레임 0 B 규칙을 설명할 때 쓴다.

프롬프트

왼쪽 코드 패널에 할당 출처 6줄(64 · 152 · 400 · 88 · 120 · 96 B/frame 태그)을 두고 2–7초에 1초마다 한 줄씩 취소선과 초록 대체안(숫자 캐시, for 루프, RaycastNonAlloc, 상태 플래그, 용량 미리 확보, 개발 빌드 전용 로그)을 펼쳐 B/frame을 0으로 만들어 줘. 오른쪽 위 관리 힙 선은 할당률에 비례해 차오르다 임계에서 GC로 15%까지 떨어지며 빨간 삼각형을 남기고, 아래 프레임 그래프는 GC가 난 0.1초 구간만 31–36 ms 스파이크가 되게 600스텝 고정 시뮬레이션으로 미리 계산해 줘.

라이브 데모 열기 — 할당 없는 프레임 (프레임당 0 B 규칙 · 할당 출처 제거)

목표 프레임 정하기 (P99 기준 · 30 / 40 / 60 고정)

Choosing a locked frame-rate target from the benchmark P99: 60 vs 40 (120 Hz) vs 30 fps, plus refresh-rate divisibility

  • Canvas
  • Unreal
  • Unity

최악 장면 벤치 프레임 3,000장의 분포에 60 · 40 · 30 fps 예산선을 차례로 대 보고, P99가 들어가는 가장 높은 목표를 고르되 화면 주사율로 나누어떨어지는지까지 확인해 성능 모드 목표를 정할 때 쓴다.

프롬프트

10–36 ms 0.5 ms 구간 히스토그램(평균 17.6 · σ 1.9 ms 정규분포에 16% 확률로 +2.5–5.7 ms 꼬리, 3,000장)을 캐시하고, 예산선을 16.7 → 25.0 → 33.3 ms로 2.4초마다 0.7초 easeInOutCubic으로 옮기며 선 왼쪽 막대는 초록, 오른쪽은 빨강으로 칠해 줘. 오른쪽 판정표에 목표별 예산 안 비율(28.3 · 99.4 · 100%)과 P99 24.6 ms 통과 여부를 ✓/✕로 쌓고, 아래 120 Hz · 60 Hz 리프레시 눈금 위에 프레임 표시 시점을 찍어 40 fps가 120 Hz에선 3칸마다 고르게, 60 Hz에선 1 · 2칸 교대(빨강)가 되는 것을 보여 준 뒤 "120 Hz → 40 고정 · 60 Hz → 30 고정 · VRR은 옵션" 결론을 띄워 줘.

라이브 데모 열기 — 목표 프레임 정하기 (P99 기준 · 30 / 40 / 60 고정)

셰이더 비용 읽기 (텍스처 샘플 · ALU · 발산 분기 · 레지스터)

Reading pixel-shader cost: texture samples, ALU count, divergent branches and register pressure limiting wave occupancy

  • HLSL
  • Unreal
  • Unity
  • Canvas

픽셀 셰이더를 줄 단위로 훑으며 텍스처 샘플 · ALU · 픽셀마다 갈리는 분기 · VGPR 수를 세고, 레지스터가 웨이브 점유율을 2/10으로 떨어뜨려 샘플 대기를 못 가리는 셰이더(3.1 ms)를 채널 패킹 · 미리 굽기 · 상수 분기로 1.2 ms까지 줄이는 판단을 보여 줄 때 쓴다.

프롬프트

왼쪽 코드 패널에서 하이라이트가 약 0.36초마다 한 줄씩 내려가며 TEX 1 · ALU 120 · 발산 같은 비용 태그를 붙이고 오른쪽 지표(텍스처 샘플 8 · ALU 225 · VGPR 96)가 누적되게, 점유율 칸 10개 중 2칸만 노랗게 차게 해 줘. 아래에는 32레인 웨이브를 그려 A는 노이즈 조건으로 레인이 주황 / 파랑으로 갈려 SSS 120 + else 60 + 공통 85 사이클을 모두 실행하는 막대를, 5초 뒤 B는 ORM 1장 · 블러 미리 굽기 · uniform 분기로 샘플 3 · ALU 125 · VGPR 48 · 점유율 5/10 · 한 경로만 실행되게 바꾸고 예상 GPU 3.1 → 1.2 ms를 띄워 줘.

라이브 데모 열기 — 셰이더 비용 읽기 (텍스처 샘플 · ALU · 발산 분기 · 레지스터)

정점 · 픽셀 바운드와 작은 삼각형 (2×2 쿼드 낭비)

Triangle-bound vs pixel-bound: tiny triangles wasting 2×2 quad helper lanes, diagnosed with a half-resolution test and a LOD test

  • Unreal
  • Unity
  • RenderDoc
  • Canvas

원경 바위를 화면 픽셀 격자로 확대해 1–2 px짜리 삼각형마다 2×2 쿼드 4레인이 셰이딩되는 낭비(쿼드 효율 약 29%)와 LOD 한 단계 뒤의 효율(약 63%)을 비교하고, 해상도 ½ · LOD +1 두 테스트로 병목이 삼각형인지 픽셀인지 가를 때 쓴다.

프롬프트

20×14 화면 픽셀(셀 8 px)에 타원 바위 마스크를 두고 한 변 1.6 px(A) / 9.5 px(B) 격자 삼각형으로 덮은 뒤 픽셀마다 삼각형 id를 미리 계산해 2.2초 동안 삼각형 순서대로 칠하고, 삼각형별로 닿은 2×2 쿼드 수 × 4레인과 실제 덮은 픽셀 수로 쿼드 효율(A 약 29% · B 약 63%)을 계산해 줘. 2.6초부터 삼각형 하나를 0.55초마다 골라 그 쿼드에 흰 테두리, 덮지 않은 헬퍼 레인에 빨간 X를 그리고, 오른쪽에는 해상도 ½(9.6 → 9.1 ms)과 메시 LOD +1(9.6 → 4.3 ms) 막대를 0.8초 easeInOut으로 줄여 "삼각형 바운드 → LOD 거리 당김", B에서는 "픽셀 바운드" 판정과 "삼각형당 10 px 미만이면 LOD" 규칙을 띄워 줘.

라이브 데모 열기 — 정점 · 픽셀 바운드와 작은 삼각형 (2×2 쿼드 낭비)

렌더 타깃 대역폭 (포맷 바이트 × 해상도 × 접근 횟수)

Render-target bandwidth budget: bytes per pixel × resolution × reads/writes per frame, fat 16F/32F targets vs right-sized formats at 4K60

  • Unreal
  • Unity
  • DirectX 12
  • Canvas

4K 60 fps에서 G-버퍼 · 속도 · 깊이 · HDR 타깃의 포맷 바이트 × 접근 횟수로 프레임당 1.5 GB · 89 GB/s가 나오는 구성을, 정밀도가 필요한 곳만 남겨 0.6 GB · 35 GB/s로 줄이는 판단을 표와 대역폭 미터로 보여 줄 때 쓴다.

프롬프트

렌더 타깃 6줄(GBuffer A · B · C RGBA16F 8 B, Velocity RG32F 8 B, Depth D32S8 8 B, HDR RGBA32F 16 B, 접근 ×3 · 3 · 2 · 2 · 4 · 5)로 MB/프레임 = B/px × 접근 × 3840 × 2160을 계산해 합계 1,519 MB, 60 fps 89.0 GB/s, 448 GB/s × 70% 기준 4.7 ms를 보여 주고, 4.4초부터 0.5초 간격으로 각 줄의 포맷 칩을 세로로 뒤집어 RGBA8 · RGB10A2 · RGBA8 · RG16F · D24S8 · R11G11B10F(모두 4 B)로 바꿔 601 MB · 35.2 GB/s · 1.9 ms까지 숫자를 실시간으로 줄여 줘. 오른쪽 세로 미터는 초록 → 노랑 → 빨강 그라디언트에 "RT 몫 25%" 점선을, 아래에는 대역폭에 비례한 개수의 점이 VRAM ⇄ GPU 버스를 흐르게 해 줘.

라이브 데모 열기 — 렌더 타깃 대역폭 (포맷 바이트 × 해상도 × 접근 횟수)

포스트 이펙트 단계별 비용 (½ 해상도 · 우버 패스)

Post-processing cost per pass: full-resolution separate passes vs half-resolution bloom / DOF / motion blur and one merged uber pass

  • Unreal
  • Unity URP
  • Canvas

1440p 포스트 스택 9패스(블룸 · 피사계심도 · 모션 블러 · TAA · 색수차 · 비네트 · 그레인 · 톤매핑 · 샤픈) 7.3 ms를 패스별로 재고, 무거운 셋은 ½ 해상도로 · 가벼운 다섯은 한 번 읽는 우버 패스로 합쳐 3.5 ms로 줄이는 판단을 보여 줄 때 쓴다.

프롬프트

오른쪽 패스 목록 9줄에 ms 막대(블룸 1.2 · DOF 2.4 · 모션 블러 1.1 · TAA 0.9 · 색수차 0.35 · 비네트 0.3 · 그레인 0.3 · 톤매핑 0.4 · 샤픈 0.35, 합계 7.30 ms)를 두고, 4.6초부터 0.45초 간격으로 앞의 셋에 "½" 칩을 붙이며 0.6 · 0.9 · 0.6 ms로 줄인 뒤 2.1초에 아래 다섯 줄을 0.9초 easeInOut으로 한 줄로 모아 "우버 패스 0.50 ms"로 바꿔 합계 3.50 ms가 되게 해 줘. 왼쪽 위 게임 뷰에는 블룸 글로와 비네트를, 아래에는 풀스크린 패스 수 9 → 5를 블록으로(½ 패스는 반 높이 초록) 그리고 포스트 예산 4.0 ms 기준으로 합계 색을 빨강 → 초록으로 바꿔 줘.

라이브 데모 열기 — 포스트 이펙트 단계별 비용 (½ 해상도 · 우버 패스)

CPU ↔ GPU 동기화 정지 (즉시 리드백 vs 2프레임 뒤 읽기)

CPU–GPU sync stall: reading back a query or buffer in the same frame serialises CPU and GPU, vs a ring of buffers read N−2 frames later

  • DirectX 12
  • Vulkan
  • Unity
  • Canvas

오클루전 쿼리 · 피킹 · GPU 개수 같은 결과를 같은 프레임에 GetData로 읽으면 CPU가 GPU 완료를 기다리고 GPU는 다음 제출을 기다려 프레임이 10 + 9 = 19 ms로 직렬화되는 것을, 2프레임 뒤 링 버퍼 읽기로 max = 10 ms가 되는 것과 타임라인으로 비교할 때 쓴다.

프롬프트

0–60 ms 시간축에 CPU · GPU · 결과 세 레인을 두고 재생 헤드가 3.9초 동안 훑게 해 줘: A는 프레임마다 CPU 10 ms 블록 뒤 빨간 빗금 9 ms(GetData 대기), GPU는 CPU 제출 뒤 9 ms 작업과 그 앞 회색 빗금 유휴가 이어져 19 ms 주기(CPU 대기 47% · GPU 유휴 53%)가 되고, 5초 뒤 B는 CPU가 10 ms 블록을 쉬지 않고 이어 가며 GPU가 한 프레임 늦게 따라오고 결과 레인에는 N−2 프레임 결과를 점선 화살표로 바로 읽는 초록 블록이 찍혀 10 ms 주기가 되게 해 줘. 아래에 프레임 시간 · 대기율과 "2–3 프레임 뒤에 읽기 · 펜스 확인 후 Map · 프레임 수만큼 링" 규칙을 체크로 띄워 줘.

라이브 데모 열기 — CPU ↔ GPU 동기화 정지 (즉시 리드백 vs 2프레임 뒤 읽기)

스크립트 Tick 호출 비용 (액터 1,000개 vs 매니저 루프)

Script tick call overhead: 1,000 per-actor VM ticks paying entry and marshalling costs vs one native manager loop over contiguous data

  • Unreal Blueprint
  • Unity
  • C#
  • Canvas

회전 코인 1,000개가 각자 스크립트 Tick을 돌 때 호출마다 VM 진입 1.1 µs · 경계 마샬링 0.6 µs가 본문 0.35 µs보다 커서 2.05 ms가 되는 것을, 같은 로직을 매니저 한 번의 배열 루프로 옮겨 0.14 ms로 줄이는 판단을 보여 줄 때 쓴다.

프롬프트

왼쪽에 40 × 25 점 격자로 코인 1,000개를 캐시하고 A에서는 노란 하이라이트가 틱 순서대로 훑어 가며, 오른쪽 0–2.4 ms 프레임 막대를 빨강(오버헤드 83%) · 초록(본문 17%) 줄무늬 100칸으로 1.2초 easeOut으로 채워 2.05 ms를 보여 줘. 아래 확대 띠에는 호출 6번을 µs 단위로 VM 진입 1.1 · 경계 마샬링 0.6 · 본문 0.35 블록으로 그리고, 5초 뒤 B는 진입 2.0 µs 한 번 + 본문 0.12 µs × N 연속 블록, 격자 전체가 한 번에 초록, 프레임 막대 0.14 ms(−93%), 코드 패널은 "CoinSystem.Tick: for (i < N) spin[i] += dt * 180"으로 바꿔 줘.

라이브 데모 열기 — 스크립트 Tick 호출 비용 (액터 1,000개 vs 매니저 루프)

로그 · 문자열 비용 (필터돼도 포맷 실행 · 출시 빌드 제거)

Logging cost: filtered debug logs still format and allocate strings, vs a level guard vs compiling the call out of shipping builds

  • C#
  • C++
  • Unity
  • Unreal

레벨 필터가 Warning이어도 Log.Debug 인자의 문자열 연결이 프레임당 600회 실행돼 1.9 ms · 74 KB 할당과 19프레임마다 GC를 만드는 것을, 레벨 검사(0.04 ms)와 출시 빌드 매크로 제거(0 ms)로 바꾸는 규칙을 보여 줄 때 쓴다.

프롬프트

위에 같은 로그의 세 작성법(문자열 연결 그대로 · if (Log.On(Debug)) 가드 · DEV_LOG 매크로)을 코드로 두고 3.3초마다 하이라이트를 A → B → C로 옮기며, 아래 60프레임 프레임 타임 그래프는 A에서 13.5 ms 바탕에 19프레임마다 24–27 ms GC 스파이크와 "GC" 태그, B · C에서는 평평한 11.6 ms가 되게 2.6초 동안 그려 줘. 오른쪽 비용 패널에 A 1.90 ms · 할당 74 KB, B 0.04 ms · 0 KB, C 0.00 ms를 easeOut 막대로 차례로 채우고 "개발 빌드: B · 출시 빌드: C · 파일 쓰기는 별도 스레드" 규칙을 써 줘.

라이브 데모 열기 — 로그 · 문자열 비용 (필터돼도 포맷 실행 · 출시 빌드 제거)

작은 파일 다수 vs 팩 파일 (열기 · 탐색 · 순차 읽기)

Many small loose files vs one pack file in load order: per-file open and seek overhead vs sequential reads

  • Unreal
  • Unity
  • C++
  • Canvas

76 MB를 낱개 파일 4,200개로 읽으면 열기 · 닫기 0.21 ms와 탐색이 파일마다 붙어 SSD 0.93 s · HDD 35.1 s가 되고, 로드 순서대로 묶은 팩 하나면 0.06 s · 0.9 s가 되는 차이를 저장 장치 위치 지도와 타임라인으로 보여 줄 때 쓴다.

프롬프트

위 패널에 LBA 0 → 끝 칸 64개를 두고 A는 미리 섞은 순서로 칸이 노랗게 켜지며 헤드 삼각형이 이리저리 점프(최근 6개 경로선)하고, B는 왼쪽부터 초록으로 연속 스윕되게 3.6초 동안 진행해 줘. 아래 0–1.0 s 타임라인은 A에서 "열기 · 메타" 레인 빨간 블록 86%와 "읽기" 레인 초록 14%가 120칸(1칸 = 35 파일) 번갈아 0.93 s까지 이어지고, B는 열기 1회 뒤 0.06 s짜리 초록 막대 하나로 끝나게, 오른쪽 표에는 SSD 0.93 → 0.06 s · HDD 35.1 → 0.9 s · 열기 4,200 → 1회를 띄워 줘.

라이브 데모 열기 — 작은 파일 다수 vs 팩 파일 (열기 · 탐색 · 순차 읽기)

압축 코덱 vs 로딩 속도 (저장 장치별 교차점)

Compression codec vs load time by storage throughput: load = max(read compressed, decompress on 4 cores), with crossovers between none, LZ4-, zstd- and LZMA-class codecs

  • Unreal
  • Unity
  • C++
  • Canvas

2 GB 에셋을 무압축 · LZ4 계열 · zstd 계열 · LZMA 계열로 저장했을 때 로딩 시간 = max(압축본 읽기, 4코어 해제) 곡선을 log-log로 그려, HDD에선 고압축 · SATA SSD에선 중간 · NVMe에선 가벼운 코덱이 이기는 교차점을 보여 줄 때 쓴다.

프롬프트

x = 저장 장치 50–8,000 MB/s, y = 0.1–40 s log-log 차트에 코덱 4개(압축률 1.0 · 2.1 · 2.9 · 3.4, 4코어 해제 속도 ∞ · 11,200 · 3,600 · 440 MB/s)의 t = max(2000 / 압축률 / io, 2000 / 해제 속도) 곡선을 캐시하고, 점선 커서를 HDD 120 → SATA 520 → NVMe 3,500 MB/s로 3초마다 0.9초 easeInOut으로 옮겨 각 곡선 교점에 점, 최단 코덱엔 글로를 그려 줘. 오른쪽 표에 코덱별 설치 용량(2.00 · 0.95 · 0.69 · 0.59 GB)과 현재 장치 로딩 시간(HDD 16.7 · 7.9 · 5.7 · 4.9 s, NVMe 0.57 · 0.27 · 0.56 · 4.5 s)을 쓰고 최단 행을 강조해 줘.

라이브 데모 열기 — 압축 코덱 vs 로딩 속도 (저장 장치별 교차점)

메모리 피크 vs 평균 (레벨 전환 이중 상주)

Memory peak vs average during a level transition: loading the next level before unloading (double residency, duplicated shared assets) vs a small transition map

  • Unreal
  • Unity
  • Canvas

레벨 A가 남은 채 B를 다 불러 공유 에셋까지 두 벌이 되는 전환은 평균 4.2 GB여도 피크 6.3 GB로 실기기 한도 4.5 GB를 넘고, A 해제 → 0.3 GB 전환 맵 → B 로드 순서면 피크 4.0 GB로 통과하는 것을 누적 영역 그래프로 보여 줄 때 쓴다.

프롬프트

0–24 s × 0–7 GB 누적 영역 그래프(엔진 상주 0.9 · 공유 에셋 0.8 · 레벨 A 전용 1.8 · 전환 맵 · 레벨 B)를 72샘플로 그리고 재생 헤드가 3.9초 동안 왼쪽부터 드러내게 해 줘: A는 6–13.5 s에 B 2.8 GB가 easeInOut으로 차오른 뒤 14–16 s에야 A를 내려 피크 6.3 GB 빨간 태그와 "개발 키트만 통과", B는 6–8 s에 A 전용을 내리고 7–8 s 전환 맵 0.3 GB, 8.5–15 s에 B 전용 2.0 GB만 올려 피크 4.0 GB 초록 태그. 4.5 GB 빨간 점선 한도와 오른쪽 평균 · 피크 · 한도 숫자를 실시간으로 계산해 줘.

라이브 데모 열기 — 메모리 피크 vs 평균 (레벨 전환 이중 상주)

메모리 숫자 세 가지 (관리 힙 · 엔진 추적 · OS 커밋)

Memory accounting: profiler managed heap vs engine-tracked allocations vs OS-reported process commit, and why budgets use the OS number

  • Unity
  • Unreal
  • C#
  • Canvas

프로파일러의 관리 힙 0.21 GB, 엔진 태그 할당 2.14 GB, 플랫폼이 보는 프로세스 커밋 3.06 GB가 같은 순간에 다른 이유(힙 예약 · 드라이버 · 코드 · 미추적 SDK · 단편화)를 세 막대로 쌓아, 예산과 OOM 판정은 OS 숫자로 해야 할 때 쓴다.

프롬프트

세 세로 막대(프로파일러 · 엔진 추적 · OS 커밋, 0–3.2 GB)에 항목 7개(관리 힙 사용 210 · 관리 힙 예약 300 · 에셋 1,470 · 엔진 기타 160 · 드라이버 · 코드 · 스택 540 · 미추적 SDK 150 · 단편화 · 여유 230 MB)를 0.5초 간격 easeOut으로 쌓되 각 항목이 집계되는 막대에만 채워 0.21 / 2.14 / 3.06 GB를 만들고, OS 막대에만 3.0 GB 빨간 한도선과 "대시보드는 210 MB · 실기기는 3.06 GB로 종료" 토스트를 띄워 줘. 5.6초부터 1.4초 easeInOut으로 힙 예약 300 → 120, 에셋 1,470 → 1,400, 단편화 230 → 110을 줄여 OS 2.69 GB로 한도 안에 넣고 "예산 · OOM 판정은 OS 커밋 기준"으로 끝내 줘.

라이브 데모 열기 — 메모리 숫자 세 가지 (관리 힙 · 엔진 추적 · OS 커밋)

최소 사양 기기 측정 (스펙 비율 환산 금지 · 병목 이동)

Measuring on min-spec hardware: spec-ratio extrapolation from a dev PC predicts GPU-bound, the real device turns out CPU-bound

  • Unreal
  • Unity
  • Canvas

개발 PC 실측(CPU 6.2 · GPU 7.8 ms)에 스펙 비율 ×2.0 · ×2.6을 곱해 GPU 병목을 예측했지만 4코어 최소 사양 실측은 CPU 31.5 ms로 병목이 바뀌는 것을 세 패널로 보여, 저사양 판단은 실기기 측정으로만 해야 할 때 쓴다.

프롬프트

세 패널(개발 PC · 스펙 비율 환산 · 최소 사양 실측)에 CPU · GPU 가로 막대(0–36 ms, 16.7 ms 초록 예산선)를 0.3 · 1.8 · 3.6초에 1.1초 easeOutCubic으로 키워 6.2 / 7.8 → 12.4 / 20.3("GPU 병목 예측") → 31.5 / 18.9("CPU 병목")가 되게 하고 패널 사이에 화살표를 띄워 줘. 5초에 실측 패널 아래 "잡 직렬화 +9.1 · 메모리 +6.0" 칩과 "해상도를 낮춰도 해결 안 됨", "병목이 GPU → CPU로 바뀐다" 토스트를 띄우고, 6.2초부터 아래에 "최소 사양 실기기에서 주 1회 · 같은 벤치 경로 · 실제 HDD · 기기마다 따로 기록" 규칙을 0.5초 간격으로 켜 줘.

라이브 데모 열기 — 최소 사양 기기 측정 (스펙 비율 환산 금지 · 병목 이동)

최적화 효과 보고 (1회 평균 vs 반복 중앙값 · P95)

Reporting a performance win: a lucky single-run average vs 10-run medians with 95 % intervals and before / after frame-time percentiles

  • Canvas
  • Unity
  • Unreal

운 좋은 1회 측정끼리 비교한 "평균 −7.7%" 보고와, 10회 반복의 중앙값 ± 95% 구간 · 3,000프레임 분포의 P50 · P95 · 33 ms 초과 횟수로 쓴 보고를 나란히 놓아, 히치 수정 효과가 꼬리에서 드러나는 보고 형식을 정할 때 쓴다.

프롬프트

A에서는 전 / 후 행에 1회 측정 점 16.9 → 15.6 ms를 곡선 화살표와 "−7.7 %" 태그로 잇고 2초 뒤 나머지 9회 점을 흐리게 흩뿌려 "다시 돌리면 −1 % ~ −8 %"를 띄워 줘. 4.6초부터 B는 10회 점 위에 중앙값 흰 막대와 ± 0.27 ms 구간 수염을, 오른쪽에는 3,000프레임씩 10–40 ms 히스토그램(전: 회색 외곽선, 후: 초록 채움, 제곱근 높이)과 P50 · P95 이동선을 그리고, 보고 패널에 P50 15.7 → 15.5 · P95 24.3 → 17.8 ms · 33 ms 초과 11 → 0회를 0.4초 간격으로 띄워 줘.

라이브 데모 열기 — 최적화 효과 보고 (1회 평균 vs 반복 중앙값 · P95)

최적화 우선순위 (ms 이득 ÷ 작업일 · 예산 도달까지만)

Optimisation priority: ordering candidate tasks by expected ms gained per engineer-day until the budget gap closes, vs biggest-gain-first

  • Canvas
  • Jira
  • Unreal
  • Unity

3.2 ms 예산 초과를 메울 후보 작업 10개를 작업일 × 이득 ms 산점도(테두리 = 위험도)에 찍고, 큰 이득부터 고르면 렌더러 멀티스레드 하나에 18일, ms/일 순으로 고르면 작은 작업 3개로 5.5일에 예산에 닿는 것을 누적 곡선으로 비교할 때 쓴다.

프롬프트

x = 작업일 0–20, y = 이득 0–4 ms 산점도에 작업 10개(그림자 정리 2일 1.6 · 파티클 근접 축소 1.5일 0.9 · 셰이더 원경 LOD 3일 1.1 · 애니 본 LOD 4일 0.8 · 렌더러 멀티스레드 18일 3.4 · UI 캔버스 분리 1일 0.4 · 물리 → 잡 12일 1.8 · 오클루전 배치 2.5일 0.7 · 텍스처 풀 조정 0.5일 0.2 · 포스트 ½ 해상도 2일 1.0 ms)를 위험도 링(초록 · 노랑 · 빨강)과 함께 찍고, A는 이득 큰 순, 4.8초 뒤 B는 ms/일 순으로 오른쪽 목록 6줄을 정렬해 선택된 작업을 차례로 강조해 줘. 아래 누적 곡선(0–40일 × 0–6 ms, 3.2 ms 초록 점선)에 A 18일 · B 5.5일 도달 태그를 붙이고 B에서는 A 곡선을 흐리게 겹쳐 비교해 줘.

라이브 데모 열기 — 최적화 우선순위 (ms 이득 ÷ 작업일 · 예산 도달까지만)

원격 성능 텔레메트리 (세션 평균 vs 버킷 · 등급별 백분위)

Remote performance telemetry: per-session average FPS averaged again vs frame-time histogram buckets merged per device tier into P50 / P95

  • Unity
  • Unreal
  • BigQuery
  • Canvas

세션마다 평균 FPS 하나를 보내 다시 평균하면 57.8 fps "정상"으로 보이지만, 프레임 타임 버킷 6칸을 보내 기기 등급별로 합산하면 하위 등급 P95 50 ms · 33 ms 초과 프레임 22%가 드러나는 수집 설계를 보여 줄 때 쓴다.

프롬프트

왼쪽에 상 · 중 · 하 등급 기기 아이콘 8개씩과 서버를 두고 패킷이 easeInOutQuad로 날아가게 하되, A는 { avgFps: 61 } 숫자 하나 패킷과 대시보드 큰 숫자 57.8 · "정상 범위"를, 4.8초 뒤 B는 버킷 6칸(<16.7 · <20 · <25 · <33.3 · <50 · ≥50 ms) 미니 막대 패킷을 보내 등급별 히스토그램(상 78/15/5/1.5/0.4/0.1 %, 중 52/28/13/5/1.6/0.4 %, 하 12/20/24/22/17/5 %)을 0.5초 간격으로 세워 줘. 각 등급에 버킷 안 선형 보간으로 계산한 P50 · P95를 쓰고 하 등급 P95 50 ms를 빨간 토스트로 띄워 줘.

라이브 데모 열기 — 원격 성능 텔레메트리 (세션 평균 vs 버킷 · 등급별 백분위)

잡 크기 정하기 (너무 잘게 · 너무 크게 · 64개 묶음)

Job granularity: one job per item drowning in scheduling overhead vs a few coarse jobs leaving workers idle vs batches of 64 with work stealing

  • Unity Jobs
  • C++
  • Unreal
  • Canvas

1만 개 항목(단일 스레드 4.0 ms)을 워커 8개에 나눌 때 항목마다 잡(오버헤드 0.8 µs × 10,000 → 1.5 ms), 종류마다 잡 4개(불균형 → 1.6 ms · 사용률 31%), 64개 묶음 157잡(0.54 ms)을 레인 타임라인으로 비교해 잡 크기 기준을 정할 때 쓴다.

프롬프트

워커 W0–W7 레인 8개(0–2.0 ms, 이상적 0.5 ms 초록 점선)를 두고 3.3초마다 단계를 바꿔 재생 헤드가 2.2초 동안 그리게 해 줘: 1단계는 레인마다 빨강(스케줄 · 큐 오버헤드) 67% · 초록 33% 줄무늬 90칸이 1.5 ms까지, 2단계는 W0–W3에 파티클 1.6 · 애니 1.1 · AI 0.8 · 오디오 0.5 ms 블록과 나머지 빗금 유휴로 1.6 ms, 3단계는 레인마다 25.6 µs ± 15% 블록 20개와 0.8 µs 빨간 틈으로 0.54 ms에 끝나게. 아래에 잡 수 · 완료 ms · 사용률 · 오버헤드 %와 "잡 1개 ≈ 수십 µs · 잡 수 ≥ 워커 × 4 · 일 훔치기" 규칙을 써 줘.

라이브 데모 열기 — 잡 크기 정하기 (너무 잘게 · 너무 크게 · 64개 묶음)

SIMD 벡터화 (스칼라 · 4-wide · 8-wide · 꼬리 마스크)

SIMD vectorisation of a hot loop: scalar vs SSE 4-wide vs AVX 8-wide with a masked tail, and why the real speed-up stops below 8×

  • C++
  • Burst
  • ISPC
  • Canvas

pos += vel * dt 루프의 원소 30개를 같은 클럭에서 스칼라 30클럭 · SSE 8클럭 · AVX 4클럭(마지막 6개는 마스크)으로 처리하는 모습과 입자 1M개 3.2 · 0.95 · 0.56 ms 결과를 보여, 이론 ×8이 메모리 대역폭에서 ×5.7로 멈추는 것까지 판단할 때 쓴다.

프롬프트

원소 30칸 행 3개(스칼라 · SSE 4-wide · AVX 8-wide)를 두고 클럭 0–30을 5.6초에 걸쳐 올리며 행마다 클럭당 1 · 4 · 8칸을 색으로 채우고 현재 처리 묶음에 흰 테두리를 그려, AVX는 4클럭 · SSE는 8클럭 · 스칼라는 30클럭에 끝나게 해 줘. 남는 레인(AVX 2칸 · SSE 2칸)은 점선 칸으로 그리고 "꼬리 6개는 마스크" 태그를, 아래 코드에는 스칼라 루프와 _mm256_load_ps · _mm256_fmadd_ps 루프를, 6.2초부터 입자 1M개 결과 막대 3.20 · 0.95 · 0.56 ms를 easeOut으로 채운 뒤 "이론 ×8 · 실제 ×5.7 · 메모리 대역폭이 상한"을 띄워 줘.

라이브 데모 열기 — SIMD 벡터화 (스칼라 · 4-wide · 8-wide · 꼬리 마스크)

정점 포맷 압축 (72 B → 28 B · 양자화 · 옥타 노멀)

Vertex format compression: an all-float 72-byte vertex vs a 28-byte quantised layout (unorm16 positions, octahedral normals and tangents, half UVs, RGBA8 colour)

  • Unreal
  • Unity
  • DirectX 12
  • Canvas

위치 · 노멀 · 탄젠트 · UV 두 벌 · 색을 모두 float로 둔 72 B 정점을 필드별 허용 오차(위치 0.06 mm · 노멀 0.01° · UV 1/2048)를 확인하며 28 B로 줄여, 1.5M 정점 메시 103 → 40 MB · 정점 페치 38.9 → 15.1 GB/s가 되는 판단을 보여 줄 때 쓴다.

프롬프트

정점 1개 바이트 막대(0–72 B 눈금)에 위치 float3 12 · 노멀 float3 12 · 탄젠트 float4 16 · UV0 · UV1 float2 8 · 색 float4 16 B를 색 블록으로 두고, 4초부터 0.45초 간격으로 각 블록을 0.5초 easeInOut으로 unorm16×3+pad 8 · 옥타 snorm16×2 4 · 옥타 4 · half2 4 · half2 4 · RGBA8 4 B로 줄여 총 28 B가 되게 해 줘. 아래 표에 필드별 포맷 · 바이트 · 오차(0.06 mm @ 4 m 박스, 0.01°, 1/2048 = 4K에서 2텍셀, 1/255)를, 오른쪽에 1.5M 정점 메시 메모리 103 → 40 MB와 9M 정점/프레임 × 60 fps 페치 대역폭 38.9 → 15.1 GB/s를 실시간 계산하고 "깊이 · 그림자는 위치 스트림만 (8 B)"을 써 줘.

라이브 데모 열기 — 정점 포맷 압축 (72 B → 28 B · 양자화 · 옥타 노멀)

예산 위반 경고 · 소유자 자동 배정 (중복 묶기 · SLA · 상향)

Routing performance-budget violations: one broadcast mail to everyone vs dedupe by (level, system), owner by system tag, SLA and auto-escalation

  • Jira
  • Jenkins
  • Canvas

야간 벤치의 레벨 × 시스템 예산 위반 9건을 42명 메일로 매일 보내면 읽음률만 61 → 5%로 떨어지고 위반은 그대로 남지만, (레벨, 시스템) 키로 묶어 시스템 태그 소유 표로 팀 당번에게 티켓을 배정하고 SLA 3일 · 초과 시 리드 상향을 걸면 칸이 하나씩 초록으로 바뀌는 운영 절차를 보여 줄 때 쓴다.

프롬프트

왼쪽에 레벨 5 × 시스템 6 격자를 두고 위반 9칸에 +0.4–1.4 ms 빨간 칸을 표시해, A에서는 0.9초마다 밤 #1–#5 메일 카드("[성능] 예산 위반 9건 · perf-all 42명 · 읽음 61 → 34 → 18 → 9 → 5%")가 쌓이고 격자는 그대로인 채 "모두에게 보냄 = 아무도 안 맡음" 토스트를 띄워 줘. 4.8초 뒤 B는 소유 표(그림자 → 렌더팀 · 파티클 → VFX팀 · 애니 → 애니팀 · AI → 게임플레이팀 · UI → UI팀 · 물리 → 엔진팀)와 티켓 카드 3장(항구 · 그림자 +1.4 ms 등, 팀 당번 · SLA 3일 · 재발 +n)을 backOut으로 밀어 넣고, 밤이 지날 때마다 해결된 칸을 초록으로, 티켓을 "해결 · 재측정 통과"로 바꾼 뒤 "3일 넘으면 리드에게 자동 상향"을 써 줘.

라이브 데모 열기 — 예산 위반 경고 · 소유자 자동 배정 (중복 묶기 · SLA · 상향)