Recomposed
Performance

프로파일러를 읽는 방법

Nov 5, 2026 · 2 min read

프로파일러를 읽는 방법

직관

한 번도 써본 적 없는 프로파일러를, 한 번도 프로파일링해본 적 없는 플랫폼에서 열어도 탭들은 이미 익숙해 보입니다. 하나의 집계 숫자, 트리를 순회하는 두 가지 방법, 넓은 색상 차트. 이건 우연이 아닙니다.

거의 모든 CPU 프로파일러는 UI를 그리기 전에 레코딩을 같은 형태로 환원합니다. 각 노드가 두 개의 숫자, 과 을 갖는 콜 트리입니다. 화면에 있는 그 외의 모든 것은 이 두 숫자로부터 만들어진 또 다른 뷰일 뿐입니다.

  • Summary: 선택된 범위에 대한 하나의 집계 숫자. "느린가"에는 답하지만 "어디서"에는 답하지 않습니다.
  • Top-down: 루트에서 리프까지 이어지는 트리. "이 비용이 큰 작업을 호출한 게 무엇인가"에 답합니다.
  • Bottom-up: 같은 트리를 리프에서 루트로, 자체 시간 기준으로 정렬한 것. "누가 호출했는지와 무관하게 무엇이 비용이 큰가"에 답합니다.
  • Flame chart: 같은 트리를 다시, 중첩된 막대로 그린 것으로, 너비가 시간에 비례합니다.

네 가지 뷰, 하나의 기반 트리. 이 형태를 한 번 익히면 탭들은 더 이상 도구마다 다른 사소한 지식이 아니게 됩니다. 앞으로 열게 될 모든 프로파일러에 던지는 질문은 결국 같은 네 가지입니다.

아래에서 계속 사용할 예제는 의도치 않게 이차(quadratic) 시간 복잡도가 된 함수 하나로, 이 글 전체에서 Android Studio의 Perfetto 기반 System Trace로 보여줍니다. 뷰 자체는 Android에만 해당하는 것이 아닙니다. Chrome DevTools와 Xcode Instruments도 같은 형태를 다른 탭 이름으로 보여주며, 이는 뒤의 비교 표에서 다룹니다.

// ❌ List.contains()는 선형 탐색이며, id마다 한 번씩 호출되므로
// 리스트가 커질수록 전체 함수의 비용은 O(n²)가 됩니다
fun dedupe(ids: List<String>): List<String> {
    val result = mutableListOf<String>()
    for (id in ids) {
        if (id !in result) result.add(id)
    }
    return result
}
 
// ✅ Set의 포함 여부 확인은 O(1)이므로, 전체 함수는 O(n)으로 떨어집니다
fun dedupe(ids: List<String>): List<String> {
    val seen = mutableSetOf<String>()
    val result = mutableListOf<String>()
    for (id in ids) {
        if (seen.add(id)) result.add(id)
    }
    return result
}

dedupe는 앞으로 나올 모든 스크린샷에서 AndroidOwner:onTouch나 Compose:recompose 같은 프레임워크 호출과 마찬가지로 자신만의 이름이 붙은 행으로 등장합니다. 이런 프레임워크 호출들은 프레임워크에 의해 자동으로 계측됩니다. 직접 호출 지점을 감싸주기 전까지는 여러분의 코드는 그렇지 않습니다:

import androidx.tracing.trace
 
trace("dedupe") { dedupe(ids) }

이것이 androidx.tracing의 trace()로, android.os.Trace.beginSection("dedupe") / Trace.endSection()을 감싸는 얇은 래퍼이며 짝이 되는 종료 호출을 대신 처리해줍니다. 이게 없어도 dedupe의 시간은 여전히 존재하지만, 실제로 이름을 확인할 수 있는 호출자 쪽으로 조용히 합쳐져 버립니다. 이것이 바로 이 글 전체가 다루는 집계(aggregation) 문제이며, 어떤 프로파일러 탭보다도 한 단계 앞서 일어나는 일입니다.

그대로 배포해도 안전합니다. R8은 beginSection 같은 실제 플랫폼 호출이 부작용(side effect)이 없다는 것을 증명할 수 없기 때문에 이 호출들을 제거하지 않으며, 그래서 어느 쪽이든 릴리스 APK에 그대로 남습니다.

어느 쪽이든 비용은 저렴합니다. beginSection/endSection은 실제 작업을 수행하기 전에 내부 활성화 플래그를 먼저 확인합니다.

Android 12(API 31) 이전에는 OS가 한 걸음 더 나아가, 디버그 불가능한 릴리스 빌드에서는(또는 API 29부터는 명시적으로 profileable로 표시되지 않은 경우) 앱 수준의 트레이싱을 비활성화합니다. 그보다 더 이전 버전에서는 이 호출이 무조건 완전한 no-op입니다.

API 31부터는 모든 앱에서 트레이싱이 항상 활성화되어 있지만, 이는 무언가가 실제로 트레이스를 캡처하고 있을 때 데이터를 낼 수 있다는 의미일 뿐이며, 기본적으로 항상 기록 중이라는 뜻은 아닙니다.

캡처 작업 선택하기

FIG. 01
Android Studio 프로파일러의 작업 선택 화면. 이 중 세 가지가 이 글에서 다루는 콜 트리를 만들어냅니다. View Live Telemetry는 기록되지 않는 실시간 모니터이고, 나머지는 메모리 작업입니다. 여기서는 이 세 가지만 다룹니다.

이 글의 모든 뷰는 콜 트리에서 나오지만, 콜 트리는 먼저 기록되어야 합니다. Android Studio만 해도 콜 트리를 기록하는 세 가지 다른 방법을 제공합니다:

  • System Trace (Capture System Activities): 여러분 자신의 호출뿐 아니라 프레임 파이프라인(Choreographer, vsync)을 포함한 시스템 전체를 담습니다. 이 글의 모든 스크린샷 뒤에 있는 작업이며, 가장 먼저 선택해야 할 기본값입니다.
  • Find CPU Hotspots, Callstack Sample: 고정된 간격으로 콜 스택을 샘플링하며, Kotlin/Java 코드와 (simpleperf를 통한) 네이티브 코드를 모두 다룹니다. 계측 기반 트레이싱보다 오버헤드가 낮지만, 샘플링 간격보다 짧은 호출은 놓칠 수 있다는 비용이 있습니다.
  • Find CPU Hotspots, Java/Kotlin Method Recording: 위의 dedupe처럼 직접 감싼 호출뿐 아니라 모든 메서드 호출에 실제 타임스탬프를 붙여 계측합니다. 이 정밀함은 오버헤드가 커서 Android는 한 번의 녹화를 5초 이하로 권장하며, 절대적인 타이밍을 왜곡하므로 이 숫자는 프레임 예산 숫자가 아니라 상대적인(이번 실행 대 저번 실행) 값으로 취급해야 합니다.

선택 화면의 나머지 다섯 작업은 같은 콜 트리를 얻는 다른 방법이 아니라, 전혀 다른 문제를 해결합니다:

  • View Live Telemetry: 녹화가 아니라 CPU, 스레드, 메모리, 상호작용에 대한 실시간 판독값으로, 무엇을 캡처할 가치가 있는지 판단하는 데 씁니다.
  • Analyze Memory Usage (Heap Dump): 메모리에 살아 있는 모든 객체의 스냅샷으로, 클래스별 유지(retained)/직접(shallow) 크기를 보여줍니다.
  • Find Memory Leaks with LeakCanary: LeakCanary 자체의 누수 분석으로, 기기가 아니라 개발 머신에서 실행됩니다.
  • Track Memory Consumption (Java/Kotlin Allocations): 하나의 스냅샷이 아니라 일정 시간 구간에 걸친 모든 할당과 해제를 보여줍니다.
  • Track Memory Consumption (Native Allocations): 네이티브 C/C++ 힙에 대한 동일한 할당 타임라인으로, 기본적으로 샘플링됩니다.

이 다섯 가지는 모두 콜 트리가 아니라 메모리 그래프나 실시간 게이지 같은 다른 데이터 형태를 만듭니다. 이 글의 모델은 여기에는 적용되지 않습니다.

이 글의 dedupe() 버그에는 처음부터 System Trace가 맞는 선택입니다. 핵심은 호출을 가로질러 점점 늘어나는 지속 시간을 잡아내는 것이고, 이는 짧은 계측 구간이 아니라 전체 녹화에 걸쳐 시간순으로 정렬된 모습을 볼 수 있어야만 드러납니다. 질문이 더 좁을 때는, 즉 "이게 정확히 몇 번 호출되었는가"를 늘어나는 dur 열을 눈으로 훑는 대신 숫자로 확인하고 싶을 때는 대신 Method Recording을 쓰세요.

마흔 개 중 어떤 스레드

System Trace는 그 구간 동안 스케줄된 모든 스레드를 기록하며, 여러분 앱의 스레드만이 아닙니다. 실제 기기에서 Threads 패널을 펼치면 수십 개의 행이 보이는데, 대부분은 여러분의 코드를 전혀 건드리지 않는 시스템 관리 작업입니다.

UI 렌더링 버그에는 세 가지가 중요합니다:

  • 메인 스레드, 여러분 앱 프로세스의 이름을 따릅니다(이 글의 스크린샷에서는 mi.composeplay2): Choreographer, 입력 디스패치, measure/layout/draw, 그리고 다른 스레드로 넘기지 않은 여러분 자신의 코드를 실행합니다. AndroidOwner:onTouch와 dedupe 모두 여기에 있습니다.
  • RenderThread: 메인 스레드가 만든 드로우 명령을 받아 GPU로 전달합니다. Android 5.0(Lollipop)부터 메인 스레드에서 분리되어 있으며, 그래서 느린 프레임은 메인 스레드의 잘못일 수도, RenderThread의 잘못일 수도, 둘 다일 수도 있습니다.
  • GPU completion: 위 두 스레드가 이미 넘긴 프레임에 대해 GPU 자체가 얼마나 걸렸는지를 나타냅니다. 가장 먼저 확인할 곳은 아니지만, 다른 두 곳에서 눈에 띄는 지연이 보이지 않을 때 이를 배제하는 데 씁니다.

그 외의 모든 것은 몇 가지 범주에 속하며, 그중 앱 버그가 숨어 있는 경우는 거의 없습니다:

  • Binder:<pid>_<n>: 시스템 서비스를 오가는 호출을 처리하는 스레드 풀입니다. 프로세스 간 통신 자체가 병목으로 의심될 때만 열어볼 가치가 있습니다.
  • HeapTaskDaemon, Jit thread pool, Signal Catcher, Profile Saver: ART 런타임의 관리 작업, 가비지 컬렉션, JIT 컴파일, 크래시 시그널 처리, 프로필 저장입니다. 이들을 직접 열어볼 필요보다는, 여러분 자신의 스레드에 미치는 영향(뒤의 Events 탭 섹션에서 다루는 간격처럼 GC 일시정지가 CPU 시간을 빼앗는 것)을 훨씬 더 자주 보게 될 것입니다.
  • 여러분 자신의 백그라운드 스레드, 앱이 생성했다면(코루틴 디스패처의 워커 풀, 커스텀 ExecutorService 등): 추적 중인 버그가 실제로 메인 스레드를 벗어났을 때만 확인할 가치가 있습니다.

그 위에 있는 개요 그래프가 아니라 스레드 행을 클릭하는 것이, 이 글의 다른 모든 뷰를 그 하나의 스레드로 필터링하는 동작입니다. Summary, Top-down, Bottom-up, Events 탭은 모두 현재 선택된 스레드의 데이터를 읽습니다.

Summary: 숫자 하나, 위치 없음

FIG. 02
dedupe() 버스트에 대한 Summary이며, 시간 범위와 스레드가 모두 선택되어 있습니다. 조상 디스패치 호출들이 여전히 더 큰 Wall Duration을 기록하고 있음에도, dedupe는 이미 Self Time 열을 지배하고 있습니다.

시간 범위만 선택하면 Summary는 거의 비어 있는 채로 Time Range와 Duration만 남습니다. 스레드까지 선택하면 "Longest running events" 표가 채워지는데, 이는 해당 선택 구간에서 개별적으로 가장 큰 작업 덩어리들입니다.

dedupe의 12번 호출 중 여섯 건만으로도 그 상위 10개 목록의 절반 이상을 채우며, 각각의 Self Time은 위에 있는 프레임워크 디스패치 호출들보다 훨씬 큽니다. 그래도 이 프레임워크 호출들은 여전히 더 큰 Wall Duration을 기록하는데, 이는 그들의 Duration이 dedupe 자체의 시간에 그들이 한 다른 모든 일을 더한 것이기 때문입니다.

실제로 그곳의 각 행은 하나가 아니라 네 개의 숫자를, 서로 독립된 두 축이 겹쳐진 형태로 담고 있습니다:

열축측정 대상
Wall DurationTotal, wall-clock이 호출과 그것이 호출한 모든 것에 대한 실제 경과 시간
Wall Self TimeSelf, wall-clock이 호출 자체의 코드가 걸린 실제 경과 시간(호출한 것들은 제외)
CPU DurationTotal, CPU-onlyCPU 코어가 이 호출과 그 호출들을 실행하는 데 실제로 사용 중이던 시간
CPU Self TimeSelf, CPU-only같은 CPU 전용 측정값이지만, 이 호출 자체의 코드만

두 축 모두 특정 앱이 아니라 코드의 형태에서 비롯됩니다. AndroidOwner:onTouch와 dedupe는 위 스크린샷에 나온 실제 이름이며, 실제 콜 스택에 묻히는 대신 메커니즘이 두 줄로 드러나도록 여기서는 단순화한 예시로 다시 세워봤습니다:

fun onTouch(event: MotionEvent) = trace("AndroidOwner:onTouch") {
    recordGesture(event)   // 그냥 호출일 뿐, 아래 것과 동일
    dedupe(ids)             // 이 역시 여기서 보기엔 그냥 호출일 뿐. onTouch 자체의
                            // 본문 안에는 차이를 나타내는 게 전혀 없다
}
 
fun dedupe(ids: List<String>) = trace("dedupe") {   // <- 바로 이것이 차이점이다:
                                                      //    dedupe는 자기 자신만의
                                                      //    섹션을 열지만, recordGesture는
                                                      //    절대 그렇게 하지 않는다
    for (id in ids) {
        if (id !in result) result.add(id)   // 실제 작업: Wall Duration, CPU Duration
    }
    // GC 일시정지는 이 안 어디에서든 발생할 수 있다. 스레드가 중단되므로
    // 여전히 Wall Duration에는 포함되지만 CPU Duration에는 포함되지 않는다
}

두 호출은 onTouch 안에서 보면 똑같이 생겼고, 같은 줄 모양으로 바로 옆에 붙어 있습니다. 둘을 가르는 것은 코드 상의 위치가 아니라, 호출된 쪽이 자기 자신의 트레이스 섹션을 여는지 여부입니다.

recordGesture()는 절대 그렇게 하지 않으므로, 아무리 오래 걸려도 그 시간은 onTouch의 Self Time 안에 계속 접혀 있습니다. dedupe()는 아래의 자기 정의 안에서 그렇게 하므로, 실행이 그 안으로 들어가는 순간부터 프로파일러는 그 시간을 대신 dedupe 자신의 섹션에 집계하기 시작합니다.

onTouch의 Duration은 여전히 GC 일시정지를 포함해 모든 것을 담고 있지만, 그 Self Time은 자식 섹션으로 넘어가지 않은 부분인 recordGesture()만을 다룹니다.

Duration 대 Self는 직관 섹션이 처음에 다룬 것과 같은 구분, 즉 총 시간 대 자체 시간입니다. 이것이 바로 다음에 나올 Top-down과 Bottom-up이 이 동일한 콜 트리에서 읽어내는 것입니다.

Wall 대 CPU는 두 번째 축입니다. Wall-clock은 실제로 지나간 모든 마이크로초를 셉니다. CPU 시간은 코어가 이 호출을 실제로 실행하고 있던 마이크로초만 셉니다. CPU 시간은 wall 시간을 절대 넘어설 수 없으며, 둘 사이의 차이가 바로 스레드가 스케줄 해제되거나, 블록되거나, 호출 중간에 일시정지된 시간입니다. 위 코드 조각의 GC 일시정지는 그 차이의 구체적인 한 사례이며, 더 뒤의 Events 탭 섹션에서 다시 다룹니다.

그래도 이건 이 특정 버그를 보기 위한 뷰는 아직 아닙니다. 이 표는 최대 10행까지만 보여주고 호출 순서가 아니라 지속 시간으로 정렬하므로, 열두 번의 호출 중 가장 큰 몇 개만 목록에 오르고, 실행된 순서대로도 아닙니다.

dedupe라는 이름의 무언가가 비용이 크다는 것은 알 수 있습니다. 하지만 이 표만으로는 그 비용이 일정한지, 점점 커지는지, 아니면 무작위인지는 알 수 없습니다. Summary는 처음부터 순서가 아니라 크기만 보존하도록 만들어졌기 때문입니다.

Top-down: 무엇이 이걸 호출했는가

FIG. 03
같은 트레이스에 대한 Top Down. 여기서 dedupe는 단일 행이며, Total 1,194,813µs, 스레드 선택 시간의 61.18%, 자체 자식이 없으므로 Self가 Total과 같습니다.

Top-down은 콜 트리의 루트(여기서는 스레드 자체)에서 시작해 그것이 호출한 대상으로 아래로 확장됩니다. 각 행은 해당 노드에 대한 두 숫자를 보여줍니다:

  • Total: 자신 더하기 그 아래의 모든 것
  • Self: 그 노드 자체만, 호출한 것은 제외

dispatchInputEvent → deliverInputEvent → ViewPostImeInputStage → AndroidOwner:onTouch를 따라 dedupe까지 내려가는 것은 "내 코드의 대략 어디서 이게 일어났는지는 알고 있으니, 거기까지 간 경로를 보여줘"라는 질문을 위한 뷰입니다.

이 단일 dedupe 행은 직관 섹션에서 말한 집계가 구체화된 모습이기도 합니다. 그 Total, 1,194,813µs는 (어느 정도 반올림을 감안하면) Events 탭이 개별적으로 나열한 열두 번의 호출 지속 시간을 모두 합한 값입니다. 원시 이벤트를 보는 것을 멈추고 트리를 읽기 시작한 순간, Top-down은 같은 콜 스택을 공유하는 열두 번의 호출을 하나의 행으로 접어버렸습니다.

Bottom-up: 호출자와 무관하게 무엇이 비용이 큰가

FIG. 04
같은 트레이스에 대한 Bottom Up. dedupe의 Self 열인 1,194,813µs는 스레드 자체의 귀속되지 않은 자체 시간(429,887µs, 이름 붙은 섹션 밖에서 이 스레드가 보낸 시간)과 다른 모든 함수의 자체 시간을 합친 것보다 큽니다.

Bottom-up은 Top-down의 방향을 뒤집습니다. 각 행은 함수이고, 이를 펼치면 자식(callee)이 아니라 *호출자(caller)*가 보입니다. 한 행의 Self와 Total 수치는 하나의 경로만이 아니라 녹화 전체에서 그 함수가 호출된 모든 곳을 합산한 것입니다. 이것이 "아직 어떤 호출자가 문제인지는 모르겠고, 그냥 가장 비용이 큰 함수 하나를 알고 싶다"는 질문을 위한 뷰입니다.

트리 상의 위치는 완전히 무시하고 Self 열만 바로 훑어보면 이 트레이스의 버그가 명백해집니다. dedupe 하나만으로도 스레드 자체의 귀속되지 않은 시간(429,887µs)과 다른 모든 함수의 자체 시간을 합친 것보다 더 많은 자체 시간(1,194,813µs)을 차지합니다. 어떤 화면이나 제스처가 트리거했든 dedupe()가 Bottom-up에서 이렇게 높게 나타난다면, 이는 특정 호출자가 어떻게 쓰고 있는지가 아니라 함수 자체를 가리키는 것입니다.

Flame chart: 같은 트리를, 너비로 그린 것

FIG. 05
같은 트레이스에 대한 Flame Chart. 열두 번의 dedupe 호출 모두가 동일한 콜 스택을 공유하기 때문에, 위에 있는 하나의 넓은 막대로 합쳐지며, 그 아래의 AndroidOwner:onTouch와 너비가 같습니다. 오른쪽의 얇은 막대들은 dedupe의 조각이 아니라 스레드 다른 곳에 있는 무관한 리프들입니다.

flame chart는 정확히 같은 콜 트리를 그림으로 그립니다. 각 노드는 수평 막대이고, 너비는 시간에 비례하며, 부모 위에 쌓이고, 루트는 맨 아래에 있습니다. 숫자를 하나도 읽지 않아도 더 넓은 막대가 시각적으로 더 비용이 크다는 것을 알 수 있습니다.

dedupe가 열두 번 호출된다고 해서 여기서 열두 개의 막대가 생기지는 않습니다. Top-down과 마찬가지입니다. 그 스택을 공유하는 모든 호출은 위에 있는 하나의 막대로 접힙니다.

같은 이름을 공유하는 두 가지 다른 것

Android Studio와 Perfetto의 Flame Chart 탭은 같은 스택을 가진 모든 호출을 하나의 막대로 합칩니다. 이는 Top-down과 Bottom-up이 하는 것과 같은 집계이며, 다만 숫자 대신 너비로 그려질 뿐입니다. Chrome DevTools의 메인 스레드 트랙은 비슷해 보이지만 전혀 합쳐지지 않습니다. 각 박스는 실제 시간순 위치에 있는 하나의 실제 호출입니다.

둘 중 하나를 다른 것으로 잘못 읽는 건 쉽게 일어나는 실수입니다. Chrome 스타일 트랙은 눈으로 봐도 버그가 시간에 따라 점점 커지는 모습을 보여줄 수 있습니다. 합쳐진 flame chart 탭은 그럴 수 없는데, 그려지기 전에 이미 모든 호출이 하나의 막대로 접혔기 때문입니다.

이 중 어느 것도 주지 않는 단 한 가지

FIG. 06
이름순으로 정렬된 dedupe() 12번 호출, 실행된 순서와 동일합니다. Duration은 1.72ms에서 273.88ms 피크까지 올라간 뒤 150-190ms 범위에 자리 잡는데, 이것이 바로 위의 네 가지 집계 뷰에서는 보이지 않던 이차 폭증(quadratic blowup, GC 노이즈가 겹쳐진 상태)입니다.

dedupe()를 점점 커지는 리스트에 대해 실행하면서 매 호출마다 조금씩 더 긴 입력을 준다고 해봅시다. Summary는 하나의 합계를 줍니다. Top-down과 Bottom-up은 호출마다가 아니라 고유한 호출 경로마다 하나의 Total/Self 쌍을 줍니다. 합쳐진 Flame Chart 탭은 모든 호출을 하나의 막대로 접습니다.

네 가지 뷰 모두 의도치 않게 이차 복잡도가 된 함수를 현장에서 잡아낼 수 있었던 단 하나의 정보, 즉 각 개별 호출 자체의 지속 시간을 일어난 순서대로 보여주는 정보를 이미 버린 상태입니다.

그 데이터는 여전히 존재합니다. 모든 프로파일러는 호출마다 타임스탬프와 지속 시간을 기록하지만, 네 가지 집계 뷰 중 어느 것도 그것을 보여주기로 선택하지 않았을 뿐입니다.

Android Studio에서 해법은 쿼리가 아니라 정렬입니다. (스레드를 선택하면 Bottom Up 옆에 나타나는) Events 탭은 그 스레드의 이름 붙은 모든 섹션을 나열합니다. Name으로 정렬하면 모든 dedupe 호출이 Start Time 순서로 함께 모이고, 그 옆에 바로 Wall Duration이 붙습니다. SQL은 전혀 필요 없습니다.

위에서 아래로 읽었을 때, 지속 시간 열이 평평하면 호출당 비용이 일정하다는 뜻입니다. 점점 올라가면 이차 폭증이며, 집계를 멈추고 각 호출을 개별적으로 보는 순간 바로 눈에 보입니다.

다만 이 상승은 완벽하게 매끄럽지는 않은데, Summary 섹션에서 다룬 Wall 대 CPU 구분이 그 이유를 설명해줍니다. dedupe()는 매 호출마다 점점 커지는 리스트를 할당하고, 어느 크기를 넘어서면 실제 가비지 컬렉션 일시정지가 발생합니다. 이는 스레드가 연산을 하는 시간이 아니라 스케줄 해제된 채 머무는 시간입니다.

Wall Duration은 그 일시정지를 포함합니다. CPU Duration은 포함하지 않습니다. 가장 큰 호출들은 가장 작은 호출들보다 눈에 띄게 더 넓은 wall 대 CPU 격차를 보이며, 이는 실제 이차 비용 위에 GC 압박이 겹쳐진 것입니다. 깨끗하고 이상화된 곡선이 실제 힙과 마주쳤을 때 실제 기기 트레이스가 보이는 모습이 바로 이것입니다.

쿼리 계층 역시 도구에 종속되지 않는다

Android Studio의 Events 탭은 하나의 트레이스를 한 번, 눈으로 볼 때는 충분합니다. 질문의 형태가 바뀌는 순간 더 이상 충분하지 않습니다:

  • 이번 실행의 dedupe 지속 시간을 지난주의 기준선과 비교하기.
  • 281개가 아니라 수만 개의 이벤트가 있는 트레이스를 가로질러 필터링하기.
  • Android Studio에서 나오지 않은 트레이스를 읽기.

SQL 계층이 실제로 존재하는 이유가 바로 이것입니다. Events가 수동으로 답하는 것과 같은 질문을 스크립트로 처리하는 것입니다.

먼저 두 가지가 필요합니다. Android Studio의 Past Recordings 탭에서 내보낸(Export recording, 모든 캡처 유형이 지원하는 것은 아닙니다) 트레이스 파일 자체와, 로컬에 설치된 trace_processor입니다:

curl -LO https://get.perfetto.dev/trace_processor
chmod +x ./trace_processor

모든 트레이스는 같은 slice 테이블을 공유하므로, query.sql은 그냥 그것에 직접 물어봅니다:

SELECT ts, dur FROM slice WHERE name = 'dedupe' ORDER BY ts;
# Android에서 캡처한 트레이스를 읽는다
trace_processor query -f query.sql android-trace.perfetto-trace
 
# Chrome DevTools가 JSON으로 내보낸 트레이스를 읽는다. 쿼리도 테이블도 동일하다
trace_processor query -f query.sql chrome-trace.json

파일은 선택 사항입니다. 한 번만 쓸 쿼리라면 파일 없이 SQL을 문자열로 바로 넘기면 됩니다:

trace_processor query android-trace.perfetto-trace \
  "SELECT ts, dur FROM slice WHERE name = 'dedupe' ORDER BY ts"

Perfetto의 trace_processor는 Android 시스템 트레이스와 Chrome DevTools가 내보낸 JSON 트레이스(Chrome이 chrome://tracing 시절부터 사용해온 Trace Event Format) 모두를 동일한 slice/track/thread SQL 테이블로 파싱합니다. 위 쿼리는 어느 파일에 대해서도 수정 없이 그대로 동작합니다. SQL 계층은 원래부터 Android에만 국한된 것이 아니었고, 그냥 Android가 함께 제공하는 도구일 뿐입니다.

Xcode Instruments에는 이에 대응하는 것이 없습니다. xctrace export는 .trace 파일에서 구조화된 데이터를 얻어내지만, SQL이 아니라 트레이스의 목차(table of contents)에 대한 XPath를 통해 XML로 얻어냅니다:

xctrace export --input recording.trace \
  --xpath '/trace-toc/run[@number="1"]/data/table[@schema="time-profile"]' \
  --output time-profile.xml

이 방법으로도 여전히 호출별, 시간순 목록을 얻을 수 있습니다. 다만 이미 알맞은 열을 갖춘 데이터베이스에 대한 쿼리가 아니라, XML을 대상으로 직접 작성하는 스크립트일 뿐입니다.

어느 뷰를, 어느 도구에서

보여주는 것Android Studio / PerfettoChrome DevToolsXcode Instruments
선택 영역에 대한 하나의 집계 숫자SummarySummaryTop Functions
콜 트리, 루트에서 리프까지Top DownCall TreeCall Tree
콜 트리, 리프에서 루트까지, 자체 시간 기준 정렬Bottom UpBottom-UpCall Tree, Invert Call Tree 체크
합쳐진 콜 스택, 너비 = 시간Flame Chart (합쳐짐)main thread track (합쳐지지 않음, 시간순)Flame Graph
인스턴스별, 시간순, 스크립트 가능Events tab (수동), trace_processor (SQL, 스크립트 가능)trace_processor (SQL, JSON 가져오기를 통해)xctrace export (XPath → XML, SQL 없음)

프로파일러를 언제 꺼내야 하는가

프로파일러는 "이게 느린가"가 아니라 "왜 느린가"에 답합니다. 보통 그 질문은 다른 곳에서 먼저 도착합니다. CI 게이트가 회귀를 표시하거나, 동료가 제스처가 끊긴다고 말하거나, 프로덕션에서 프레임 드롭 지표가 올라가는 식으로요. 그런 신호가 생기기 전에 프로파일러를 여는 것은, 아직 실제로 확인되지 않은 문제를 위해 콜 트리를 읽는 것입니다.

이 과정은 우연이 아니라 의도적으로 느립니다. 트레이스를 캡처하고, 캡처 작업을 고르고, 네 가지 집계 뷰를 읽고, 그것들이 보여주지 않는 단 하나를 위해 쿼리를 작성하는 것은 트레이스마다 몇 분의 집중된 주의를 필요로 합니다.

그 비용은 진단을 위해 한 번이라면 타당합니다. 하지만 모든 커밋마다 돌리는 데는 맞지 않습니다.

실제 경계선은 이것입니다. 진단(왜)은 수동으로 남고, 탐지(회귀가 있었는가)는 그럴 필요가 없습니다. 의심되는 호출을 프로파일러가 이미 읽는 것과 같은 이름의 트레이스 섹션으로 감싸고, 누군가 알아챌 때까지 기다리는 대신 모든 CI 실행마다 그 지속 시간을 기록하세요:

// 이 글의 모든 프로파일러 스크린샷이 읽는 것과 같은 이름의
// 트레이스 섹션을 통해, 모든 CI 실행마다 dedupe() 자체의 지속 시간을 기록한다
@Test
fun dedupeDuration() = benchmarkRule.measureRepeated(
    packageName = "com.example.app",
    metrics = listOf(TraceSectionMetric("dedupe", TraceSectionMetric.Mode.Sum)),
    iterations = 10,
    setupBlock = { startActivityAndWait() },
) {
    triggerTheFlowThatCallsDedupe()
}

이것은 숫자를 만들어낼 뿐, 판정을 내리지는 않습니다. 각 실행 결과는 통과/실패를 결정하기 위해 여전히 저장된 기준선과 비교해야 합니다. 프로파일러는 그 비교가 실패했을 때만 열리며, "왜"에 답하기 위한 것인데, 그것이 바로 이 글의 나머지 부분이 실제로 다루는 질문입니다.

변형과 트레이드오프

  • 집계는 기본값이지 버그가 아닙니다. 네 가지 주요 뷰 각각은 반복되는 호출을 하나의 숫자로 접기 위해 특별히 존재합니다. 호출당 비용이 실제로 일정한 95%의 경우에는 그래야 "무엇이 느린가"를 1초 안에 답할 수 있기 때문입니다. 위의 이차 루프 버그는 정확히 나머지 5%에 해당하며, 호출별 순서를 집계로 없애버리는 것이 문제의 실제 형태를 숨기는 경우입니다.
  • 이 사고 모델은 특별히 CPU/wall-time 프로파일링을 위한 것입니다. self/total 시간을 갖는 콜 트리는 샘플링 및 트레이싱 CPU 프로파일러 뒤에 있는 공통 형태입니다. 힙 프로파일러의 유지 크기(retained-size) 그래프나 GPU 프레임 프로파일러의 파이프라인 단계 분해는 진짜로 다른 데이터 형태입니다. 같은 네 가지 탭 이름이 관례적으로 재사용되는 경우도 있지만, 이들은 같은 기반 트리로부터 만들어진 것이 아니므로 이 글의 매핑은 그쪽에는 적용되지 않습니다.
  • SQL 계층이 없다는 것은 사소한 이야기가 아니라 실제 비용입니다. iOS에서 인스턴스별, 시간순 답이 필요하고 XML을 직접 파싱하고 싶지 않다면, 솔직한 선택지는 xctrace export의 출력을 대상으로 스크립트를 작성하거나, 다른 무언가가 쿼리할 수 있는 형식으로 트레이스를 변환하는 것입니다. Android와 Chrome에서 trace_processor가 해주는 것과 같은 자체 제공 단축로는 없습니다.
Keep reading

Related reads

새 글을 이메일로 받아보세요