Android Academy · Pelajaran

Mengukur Prestasi

Pemprofil, surihan dan penanda aras.

Pelajaran 1 daripada 413 langkah

Mengukur Prestasi ialah pelajaran Android Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Android Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Android Academy merangkumi sejumlah 4 pelajaran.

Ukur Sebelum Mengoptimumkan

Peraturan emas untuk kerja prestasi: ukur dahulu, jangan sekali-kali meneka. Gerak hati manusia tentang perkara yang perlahan hampir selalu tersasar.

Dalam pelajaran ini, anda akan mempelajari alat yang disediakan Android untuk melihat prestasi: penganalisis prestasi, surihan sistem dan penanda aras mikro. Setelah anda boleh mengukur, setiap pengoptimuman menjadi keputusan berasaskan data dan bukannya sangkaan.

Penganalisis prestasi memaparkan CPU, memori dan tenaga dalam masa nyata.
Surihan sistem mendedahkan dengan tepat ke mana perginya masa setiap bingkai.
Penanda aras memberikan angka yang boleh diulang dan dibandingkan antara binaan.

Bajet Bingkai 16ms

Pada skrin 60Hz, sistem melukis bingkai baharu setiap 16.67ms. Jika aplikasi anda tidak dapat menyediakan bingkai dalam tempoh tersebut, bingkai itu akan digugurkan dan pengguna akan merasakan kegagapan. Pada peranti 120Hz, bajet ini mengecil kepada kira-kira 8ms.

Kerja prestasi sebenarnya berkisar tentang kekal dalam bajet ini. Komen di bawah menunjukkan pengiraan yang perlu anda ingat.

// 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)))
}

Pemprofil Android Studio

Pemprofil Android Studio (View > Tool Windows > Profiler) dilampirkan pada aplikasi yang sedang berjalan dan memaparkan garis masa langsung untuk CPU, Memori, Tenaga dan Rangkaian.

CPU: rakam jejak kaedah dan jejak sistem untuk mencari laluan kod yang paling sibuk.
Memori: pantau peruntukan dan ambil longgokan timbunan untuk mencari kebocoran.
Tenaga: kenal pasti wakelock dan tugas berlebihan yang menghabiskan bateri.

Sentiasa profilkan binaan gaya keluaran pada peranti sebenar. Binaan nyahpepijat dan emulator memberikan nombor yang mengelirukan kerana pengoptimuman dinyahdayakan.

Penanda Aras Makro untuk Senario Sebenar

Pustaka Jetpack Macrobenchmark mengukur keseluruhan perjalanan pengguna (permulaan, penatalan, navigasi) pada peranti sebenar dan melaporkan metrik yang stabil seperti pemasaan bingkai dan masa permulaan.

Anda menulis ujian yang melancarkan aplikasi dan menjalankan suatu aliran; pustaka ini menjalankannya berkali-kali dan memberikan nombor 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()
    }
}

Penanda Aras Mikro untuk Kod Utama

Apabila anda perlu mengetahui kelajuan satu fungsi, gunakan pustaka Microbenchmark. Pustaka ini menjalankan kod anda dalam gelung rapat, memanaskan JIT, dan melaporkan nanosaat bagi setiap operasi selepas hingar disingkirkan.

Gunakannya untuk penghurai, pensiri, pengisihan atau apa-apa pembantu terikat CPU yang kerap 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())
        }
    }
}

Pengesanan Sistem dengan Perfetto

Pengesanan sistem menangkap perkara yang dilakukan oleh setiap utas dan sistem, bingkai demi bingkai. Pemprofil CPU Android Studio boleh merakamnya, dan anda juga boleh menangkapnya dengan adb lalu membukanya dalam Perfetto (ui.perfetto.dev).

Jejak menunjukkan bingkai merah yang digeruni, kerja pada utas utama dan masa yang digunakan dalam GPU. Ini ialah alat terbaik untuk mendiagnosis kegagapan.

# 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

Bahagian Jejak Tersuai

Secara lalai, jejak menunjukkan kerja rangka kerja. Untuk melabelkan kod anda sendiri, bungkus kod itu dalam bahagian jejak bernama. Nama ini kemudiannya muncul sebagai blok berlabel dalam Perfetto, menjadikan bahagian paling sibuk anda mudah dikenal pasti.

Gunakan API androidx.tracing supaya bahagian tersebut muncul dalam jejak nyahpepijatan dan penanda aras.

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

Menjejak Bingkai yang Digugurkan Semasa Masa Jalan

Anda tidak sentiasa mempunyai pemprofil yang dilampirkan. JankStats ialah pustaka Jetpack yang melaporkan bingkai yang tergagap dari dalam aplikasi anda yang sedang berjalan, supaya anda boleh mencatatnya atau menghantar agregat kepada analitis.

Pustaka ini bersambung pada tetingkap dan memanggil anda semula setiap kali bingkai melebihi bajetnya.

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 Nombor: Persentil

Satu purata sahaja menyembunyikan masalah. Jika purata bingkai anda ialah 10ms tetapi persentil ke-99 ialah 40ms, 1% bingkai mengalami kegagapan dan pengguna dapat merasakannya. Sentiasa lihat P50, P90, P99, bukan min sahaja.

Penanda aras melaporkan nilai ini untuk anda. Pembantu di bawah menunjukkan konsep tersebut pada sampel bingkai 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)))
}

Aliran Kerja Pengukuran yang Boleh Diulang

Nombor yang boleh dipercayai datang daripada proses yang berdisiplin. Ikuti senarai semak ini setiap kali:

Gunakan binaan keluaran / tidak boleh dinyahpepijat (R8 didayakan).
Jalankan pada peranti fizikal yang disambungkan kepada kuasa, dengan keadaan terma yang stabil.
Ulang senario itu beberapa kali dan laporkan median.
Ubah satu perkara pada satu masa dan ukur semula.
Bandingkan dengan garis dasar yang disimpan supaya anda boleh membuktikan peningkatan.

Jika anda melangkau langkah ini, anda akan mengejar hingar dan bukannya membaiki masalah sebenar.

Ke Mana Sebenarnya Masa Digunakan

Kebanyakan kegagapan Android berpunca daripada beberapa sebab utama. Mengetahuinya membantu anda menentukan alat yang perlu digunakan:

Kerja utas utama: cakera/rangkaian/JSON pada utas UI.
Penggubahan semula berlebihan: Compose melukis semula terlalu banyak perkara.
Lonjakan peruntukan: jeda kutipan sampah.
Laluan reka letak: reka letak yang bersarang secara mendalam atau diukur berulang kali.

Pelajaran seterusnya dalam kursus ini menangani penggubahan semula, kebocoran memori dan permulaan secara langsung. Pengukuran memberitahu anda perkara yang perlu dibaiki dahulu.

Semakan Pantas

Anda mahu mengukur secara stabil dan berulang berapa lama permulaan sejuk aplikasi anda pada peranti sebenar merentasi beberapa larian. Alat manakah yang paling sesuai?

Jawab dalam pelajaran interaktif

Ulang Kaji: Kini Anda Boleh Mengukur

Anda telah belajar menjadikan prestasi kelihatan sebelum mengubah apa-apa:

Bajet bingkai 16ms menentukan kelancaran atau kegagapan.
Pemprofil Android Studio menunjukkan CPU, memori dan tenaga secara langsung.
Penanda aras makro dan mikro memberikan nombor yang boleh diulang.
Jejak Perfetto dan bahagian trace() tersuai mendedahkan ke mana masa digunakan.
JankStats melaporkan kegagapan dari dalam aplikasi yang sedang berjalan.
Baca P50/P90/P99, profilkan binaan keluaran pada peranti sebenar dan ubah satu perkara pada satu masa.

Seterusnya, kita akan menerapkan perkara ini pada salah satu punca terbesar kegagapan Compose: penggubahan semula.

Percuma untuk bermula

Pelajari Kotlin dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 36
Pelajaran: 152

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mengukur Prestasi” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Android Academy, termasuk “Mengukur Prestasi”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Android Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mengukur Prestasi”?

Pemprofil, surihan dan penanda aras. Anda berlatih Android Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Android Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Android Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Mengukur Prestasi” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Android Academy ini?

Ya. Setiap pelajaran Android Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Android Academy