Android Academy · Pelajaran

Mengukur Kinerja

Profiler, jejak, dan tolok ukur.

Mengukur Kinerja adalah pelajaran Android Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Android Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Android Academy mencakup 4 pelajaran total.

Ukur Sebelum Mengoptimalkan

Aturan emas dalam pekerjaan kinerja: ukur terlebih dahulu, jangan pernah menebak. Intuisi manusia tentang hal yang lambat hampir selalu keliru.

Dalam pelajaran ini, Anda akan mempelajari alat yang disediakan Android untuk melihat kinerja: penganalisis kinerja, rekaman jejak sistem, dan tolok ukur mikro. Setelah Anda dapat mengukur, setiap pengoptimalan menjadi keputusan berbasis data, bukan sekadar dugaan.

Penganalisis kinerja menampilkan CPU, memori, dan energi secara waktu nyata.
Rekaman jejak sistem mengungkap dengan tepat ke mana waktu setiap bingkai digunakan.
Tolok ukur memberikan angka yang dapat diulang dan dibandingkan di berbagai pembangunan.

Anggaran Waktu Frame 16 ms

Pada layar 60Hz, sistem menggambar frame baru setiap 16,67 ms. Jika aplikasi Anda tidak dapat menyiapkan frame dalam jangka waktu tersebut, frame akan terlewat dan pengguna merasakan jank (patah-patah). Pada perangkat 120Hz, anggarannya menyusut menjadi sekitar 8 ms.

Upaya meningkatkan performa pada dasarnya adalah tetap berada dalam anggaran ini. Komentar di bawah menunjukkan perhitungan yang perlu Anda pahami.

// Frame budget math
// 60 Hz  -> 1000ms / 60  = 16.67ms per frame
// 90 Hz  -> 1000ms / 90  = 11.11ms per frame
// 120 Hz -> 1000ms / 120 =  8.33ms per frame
//
// Exceed the budget on the UI thread = a dropped frame = visible jank.
fun frameBudgetMs(refreshHz: Int): Double = 1000.0 / refreshHz

fun main() {
    println("60Hz  -> %.2f ms".format(frameBudgetMs(60)))
    println("120Hz -> %.2f ms".format(frameBudgetMs(120)))
}

Profiler Android Studio

Profiler Android Studio (View > Tool Windows > Profiler) terhubung ke aplikasi yang sedang berjalan dan menampilkan linimasa langsung untuk CPU, memori, energi, dan jaringan.

CPU: rekam pelacakan metode dan pelacakan sistem untuk menemukan jalur kode yang paling membebani.
Memori: pantau alokasi dan ambil dump heap untuk menemukan kebocoran.
Energi: temukan wakelock dan tugas berlebihan yang menguras baterai.

Selalu lakukan pembuatan profil pada build bergaya rilis di perangkat nyata. Build debug dan emulator memberikan angka yang menyesatkan karena optimisasi dinonaktifkan.

Macrobenchmark untuk Skenario Nyata

Pustaka Jetpack Macrobenchmark mengukur seluruh perjalanan pengguna (startup, pengguliran, navigasi) pada perangkat nyata dan melaporkan metrik yang stabil seperti waktu frame dan waktu startup.

Anda menulis pengujian yang meluncurkan aplikasi dan menjalankan suatu alur; pustaka tersebut menjalankannya berkali-kali dan memberikan angka median serta persentil ke-99.

@RunWith(AndroidJUnit4::class)
class StartupBenchmark {
    @get:Rule val rule = MacrobenchmarkRule()

    @Test
    fun coldStartup() = rule.measureRepeated(
        packageName = "com.example.app",
        metrics = listOf(StartupTimingMetric()),
        iterations = 5,
        startupMode = StartupMode.COLD
    ) {
        pressHome()
        startActivityAndWait()
    }
}

Microbenchmark untuk Kode yang Membebani

Saat Anda perlu mengetahui seberapa cepat satu fungsi berjalan, gunakan pustaka Microbenchmark. Pustaka ini menjalankan kode Anda dalam perulangan ketat, memanaskan JIT, dan melaporkan nanodetik per operasi setelah gangguan dihilangkan.

Gunakan pustaka ini untuk pengurai, serializer, pengurutan, atau pembantu yang terikat CPU dan sering Anda panggil.

@RunWith(AndroidJUnit4::class)
class JsonParseBenchmark {
    @get:Rule val benchmarkRule = BenchmarkRule()

    @Test
    fun parseLargePayload() {
        val raw = loadSampleJson()
        benchmarkRule.measureRepeated {
            val parsed = parseUsers(raw) // code under test
            // assertEquals avoids the compiler dropping the result
            assertTrue(parsed.isNotEmpty())
        }
    }
}

Pelacakan Sistem dengan Perfetto

Pelacakan sistem merekam hal yang dilakukan setiap thread dan sistem, frame demi frame. Profiler CPU Android Studio dapat merekamnya, dan Anda juga dapat mengambilnya dengan adb lalu membukanya di Perfetto (ui.perfetto.dev).

Pelacakan menampilkan frame merah yang ditakuti, pekerjaan pada thread utama, dan waktu yang dihabiskan di GPU. Ini adalah alat terbaik untuk mendiagnosis jank.

# Record a 5-second system trace from the command line
adb shell perfetto -o /data/misc/perfetto-traces/trace.perfetto-trace \
  -t 5s sched freq idle am wm gfx view

# Pull it to your machine, then open in https://ui.perfetto.dev
adb pull /data/misc/perfetto-traces/trace.perfetto-trace

Bagian Pelacakan Kustom

Secara bawaan, pelacakan menampilkan pekerjaan framework. Untuk memberi label pada kode Anda sendiri, bungkus kode tersebut dalam bagian pelacakan bernama. Nama-nama ini kemudian muncul sebagai blok berlabel di Perfetto, sehingga bagian yang paling membebani mudah ditemukan.

Gunakan API androidx.tracing agar bagian-bagian tersebut muncul dalam pelacakan debug maupun benchmark.

import androidx.tracing.trace

fun loadDashboard(repo: Repo): Dashboard {
    return trace("loadDashboard") {
        val user = trace("fetchUser") { repo.user() }
        val feed = trace("fetchFeed") { repo.feed() }
        Dashboard(user, feed)
    }
}
// In Perfetto you will now see named slices:
// loadDashboard > fetchUser, fetchFeed

Melacak Frame yang Terlewat Saat Runtime

Profiler tidak selalu terhubung. JankStats adalah pustaka Jetpack yang melaporkan frame yang mengalami jank dari dalam aplikasi yang sedang berjalan, sehingga Anda dapat mencatatnya atau mengirimkan agregatnya ke analitik.

Pustaka ini terhubung ke jendela dan memanggil Anda kembali setiap kali sebuah frame melampaui anggarannya.

val jankStats = JankStats.createAndTrack(window) { frameData ->
    if (frameData.isJank) {
        Log.w("Jank", "Janky frame: ${frameData.frameDurationUiNanos} ns")
        analytics.logJank(frameData.frameDurationUiNanos)
    }
}

// Pause/resume with your screen lifecycle
override fun onResume() { super.onResume(); jankStats.isTrackingEnabled = true }
override fun onPause() { super.onPause(); jankStats.isTrackingEnabled = false }

Membaca Angka: Persentil

Satu nilai rata-rata dapat menyembunyikan masalah. Jika frame rata-rata Anda berdurasi 10 ms, tetapi persentil ke-99 berdurasi 40 ms, 1% frame mengalami jank dan pengguna dapat merasakannya. Selalu lihat P50, P90, P99, bukan hanya nilai rata-rata.

Benchmark melaporkan angka-angka ini untuk Anda. Pembantu di bawah menunjukkan idenya menggunakan sampel frame mentah.

fun percentile(samplesMs: List<Double>, p: Int): Double {
    val sorted = samplesMs.sorted()
    val index = ((p / 100.0) * (sorted.size - 1)).toInt()
    return sorted[index]
}

fun main() {
    val frames = listOf(8.0, 9.0, 10.0, 9.5, 11.0, 40.0, 9.0, 10.5)
    println("P50 = %.1f ms".format(percentile(frames, 50)))
    println("P99 = %.1f ms".format(percentile(frames, 99)))
}

Alur Kerja Pengukuran yang Dapat Diulang

Angka yang dapat dipercaya berasal dari proses yang disiplin. Ikuti daftar periksa ini setiap kali:

Gunakan build rilis / tidak dapat di-debug (R8 diaktifkan).
Jalankan pada perangkat fisik yang terhubung ke daya, dengan kondisi termal yang stabil.
Ulangi skenario beberapa kali dan laporkan mediannya.
Ubah satu hal pada satu waktu, lalu ukur kembali.
Bandingkan dengan baseline yang tersimpan agar Anda dapat membuktikan peningkatan.

Jika Anda melewatkan langkah-langkah ini, Anda akan mengejar gangguan alih-alih memperbaiki masalah yang sebenarnya.

Ke Mana Waktu Sebenarnya Digunakan

Sebagian besar jank Android berasal dari sejumlah kecil penyebab. Dengan mengetahuinya, Anda tahu ke mana harus mengarahkan alat:

Pekerjaan thread utama: disk/jaringan/JSON pada thread UI.
Rekomposisi berlebihan: Compose menggambar ulang terlalu banyak bagian.
Perubahan alokasi: jeda pengumpulan sampah.
Lintasan tata letak: tata letak yang bertingkat terlalu dalam atau diukur berulang kali.

Pelajaran berikutnya dalam kursus ini membahas rekomposisi, kebocoran memori, dan startup secara langsung. Pengukuran memberi tahu Anda mana yang harus diperbaiki terlebih dahulu.

Pemeriksaan Singkat

Anda menginginkan pengukuran yang stabil dan dapat diulang mengenai durasi cold startup aplikasi Anda pada perangkat nyata dalam beberapa kali proses. Alat mana yang paling sesuai?

Ringkasan: Kini Anda Dapat Mengukur

Anda belajar membuat performa menjadi terlihat sebelum mengubah apa pun:

Anggaran frame 16 ms menentukan apakah tampilan mulus atau mengalami jank.
Profiler Android Studio menampilkan CPU, memori, dan energi secara langsung.
Macrobenchmark dan Microbenchmark memberikan angka yang dapat diulang.
Pelacakan Perfetto dan bagian trace() kustom menunjukkan ke mana waktu digunakan.
JankStats melaporkan jank dari dalam aplikasi yang sedang berjalan.
Baca P50/P90/P99, buat profil build rilis pada perangkat nyata, dan ubah satu hal pada satu waktu.

Berikutnya, kita menerapkan hal ini pada salah satu sumber jank Compose terbesar: rekomposisi.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengukur Kinerja” gratis?

Ya — teks lengkap “Mengukur Kinerja” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Android Academy, upgrade ke CoddyKit PRO. Kursus Android Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mengukur Kinerja”?

Profiler, jejak, dan tolok ukur. Kamu berlatih Android Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Android Academy?

Tidak diperlukan pengalaman sebelumnya. Android Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Mengukur Kinerja” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Android Academy ini?

Ya. Setiap pelajaran Android Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Android Academy