การติดตามการเรียบเรียง

ร่องรอยมักเป็นแหล่งข้อมูลที่ดีที่สุดเมื่อต้องการตรวจสอบปัญหาด้านประสิทธิภาพเป็นครั้งแรก ข้อมูลเหล่านี้ช่วยให้คุณสร้างสมมติฐานเกี่ยวกับปัญหาและจุดเริ่มต้นในการค้นหา

การติดตามใน Android รองรับการติดตาม 2 ระดับ ได้แก่ การติดตามระบบและการติดตามเมธอด

เนื่องจากการติดตามระบบจะติดตามเฉพาะพื้นที่ที่ทําเครื่องหมายไว้สําหรับการติดตามโดยเฉพาะ จึงมีค่าใช้จ่ายเพิ่มเติมต่ำและไม่ส่งผลต่อประสิทธิภาพของแอปมากนัก การติดตามระบบเหมาะสําหรับดูระยะเวลาที่ส่วนใดส่วนหนึ่งของโค้ดใช้เวลาในการทํางาน

การติดตามเมธอดจะติดตามการเรียกฟังก์ชันทุกรายการในแอป ซึ่งใช้ทรัพยากรมากและส่งผลต่อประสิทธิภาพของแอปอย่างมาก แต่จะช่วยให้คุณเห็นภาพรวมทั้งหมดของสิ่งที่เกิดขึ้น ฟังก์ชันที่มีการเรียกใช้ และความถี่ในการเรียกใช้

โดยค่าเริ่มต้น การติดตามระบบจะไม่รวมฟังก์ชันคอมโพสิเบิลแต่ละรายการ ซึ่งจะแสดงในการติดตามเมธอด

ขณะนี้เรากำลังทดสอบฟังก์ชันการติดตามระบบใหม่เพื่อแสดงฟังก์ชันที่คอมโพสิเบิลภายในการติดตามระบบ วิธีการนี้ลดการแทรกแซงจากระบบการติดตาม โดยมีการติดตามเมธอดในระดับรายละเอียดขององค์ประกอบ

ตั้งค่าการติดตามองค์ประกอบ

หากต้องการลองใช้การติดตามการคอมโพสิชันใหม่ในโปรเจ็กต์ คุณต้องอัปเดตเป็นเวอร์ชันต่อไปนี้เป็นอย่างน้อย

• Android Studio Flamingo
• UI ของ Compose: 1.3.0
• คอมไพเลอร์ Compose: 1.3.0

อุปกรณ์หรือโปรแกรมจำลองที่คุณใช้ติดตามต้องอยู่ที่ระดับ API ขั้นต่ำ 30 ด้วย

นอกจากนี้ คุณยังต้องเพิ่มการพึ่งพาใหม่ในเครื่องมือติดตามรันไทม์ของ Compose ดังนี้

implementation("androidx.compose.runtime:runtime-tracing:1.7.5")

หากใช้ Compose BOM คุณไม่จำเป็นต้องระบุเวอร์ชัน

val composeBom = platform("androidx.compose:compose-bom:2024.10.01")
implementation(composeBom)
// ...

// dependency without a version
implementation("androidx.compose.runtime:runtime-tracing")

เมื่อใช้การพึ่งพานี้ เมื่อทำการติดตามระบบที่มีการคอมโพสิชันใหม่ คุณจะเห็นฟังก์ชันที่คอมโพสิชันได้โดยอัตโนมัติ

ทำการติดตามระบบ

หากต้องการติดตามระบบและดูการติดตามการคอมโพสิชันใหม่ในการใช้งาน ให้ทําตามขั้นตอนต่อไปนี้

1. เปิดเครื่องมือวิเคราะห์โปรไฟล์

   

2. คลิกไทม์ไลน์ CPU

   

3. ไปยัง UI ที่ต้องการติดตามในแอป แล้วเลือกระบบ ติดตามและบันทึก

   

4. ใช้แอปเพื่อทำให้เกิดการจัดองค์ประกอบใหม่และหยุดบันทึก เมื่อการติดตามได้รับการประมวลผลและปรากฏขึ้นแล้ว คุณควรจะเห็นคอมโพสิเบิลในการติดตามการคอมโพสิชันใหม่ คุณสามารถใช้แป้นพิมพ์และเมาส์เพื่อซูมและเลื่อนไปรอบๆ ร่องรอยได้ หากไม่คุ้นเคยกับการไปยังส่วนต่างๆ ของร่องรอย โปรดดูเอกสารประกอบบันทึกร่องรอย

   

   การดับเบิลคลิกคอมโพสิเบิลในแผนภูมิจะนำคุณไปยังซอร์สโค้ดของคอมโพสิเบิลนั้น

5. คุณยังดูคอมโพสิเบิลในแผนภูมิเปลวไฟพร้อมกับหมายเลขไฟล์และบรรทัดได้ด้วย

   

ข้อจำกัด

ค่าใช้จ่ายเพิ่มเติมเกี่ยวกับขนาด APK

แม้ว่าเราจะพยายามลดค่าใช้จ่ายเพิ่มเติมของฟีเจอร์นี้ให้เหลือน้อยที่สุดแล้ว แต่ขนาด APK ของแอป Compose จะเพิ่มขึ้นจากสตริงการติดตามที่คอมไพเลอร์ Compose ฝังไว้ใน APK การเพิ่มขนาดนี้อาจค่อนข้างน้อยหากแอปของคุณไม่ได้ใช้ Compose มากนัก หรืออาจเพิ่มขึ้นมากสำหรับแอป Compose แบบสมบูรณ์ นอกจากนี้ สตริงการติดตามเหล่านี้จะไม่ได้รับการสร้างความสับสนเพื่อให้ปรากฏในเครื่องมือการติดตามตามที่แสดงไว้ก่อนหน้านี้ คอมไพเลอร์ Compose จะแทรกแอตทริบิวต์เหล่านี้ลงในแอปทั้งหมดโดยเริ่มจากเวอร์ชัน 1.3.0

คุณนำสตริงการติดตามออกจากบิลด์เวอร์ชันที่ใช้งานจริงได้โดยเพิ่มกฎ ProGuard ต่อไปนี้

-assumenosideeffects public class androidx.compose.runtime.ComposerKt {

   boolean isTraceInProgress();

   void traceEventStart(int,int,int,java.lang.String);

   void traceEventStart(int,java.lang.String);

   void traceEventEnd();

}

ฟังก์ชันเหล่านี้อาจเปลี่ยนแปลงในอนาคต แต่เราจะกล่าวถึงการเปลี่ยนแปลงทั้งหมดในบันทึกประจำรุ่นของ Compose

โปรดทราบว่าการคงไฟล์เหล่านี้ไว้แม้จะมีค่าใช้จ่ายด้านขนาด APK บ้าง แต่ก็เป็นการรับประกันว่า APK ที่สร้างโปรไฟล์เป็น APK เดียวกับที่ผู้ใช้แอปเรียกใช้

การกำหนดเวลาที่แม่นยำ

คุณต้องทำให้แอป profileable และ non-debuggable เป็นไปตามแอปพลิเคชันที่โปรไฟล์ได้เพื่อให้การโปรไฟล์แม่นยำ เช่นเดียวกับการทดสอบประสิทธิภาพ

บันทึกการติดตามจากเทอร์มินัล

คุณสามารถบันทึกการติดตามการคอมโพสิชันจากเทอร์มินัลได้ โดยคุณต้องทำตามขั้นตอนที่ Android Studio มักจะทำให้คุณโดยอัตโนมัติ

เพิ่มการพึ่งพา

ก่อนอื่น ให้เพิ่มข้อกําหนดเพิ่มเติมลงในแอป

implementation("androidx.tracing:tracing-perfetto:1.0.0")
implementation("androidx.tracing:tracing-perfetto-binary:1.0.0")

สร้างคำสั่งบันทึก

1. สร้างคำสั่งบันทึกโดยใช้ Perfetto

2. เพิ่มส่วนแหล่งข้อมูล track_event ด้วยตนเองตามตัวอย่างต่อไปนี้

   adb shell perfetto \
     -c - --txt \
     -o /data/misc/perfetto-traces/trace \
   <<EOF
   buffers: {
       size_kb: 63488
       fill_policy: RING_BUFFER
   }
   buffers: {
       size_kb: 2048
       fill_policy: RING_BUFFER
   }
   data_sources: {
       config {
           name: "track_event"
       }
   }
   duration_ms: 10000
   flush_period_ms: 30000
   incremental_state_config {
       clear_period_ms: 5000
   }
   EOF

บันทึกการติดตาม

1. เปิดแอปและเตรียมส่วนที่ต้องการติดตาม

2. เปิดใช้การติดตามในแอปโดยการออกการออกอากาศ

   # set app package variable, e.g. com.google.samples.apps.nowinandroid.debug
   # can be found through `adb shell ps -ef` or `adb shell cmd package list packages`
   package=<your app process>
   
   # issue a broadcast to enable tracing
   adb shell am broadcast \
   -a androidx.tracing.perfetto.action.ENABLE_TRACING \
   $package/androidx.tracing.perfetto.TracingReceiver
   

3. เริ่มคำสั่งบันทึกที่คุณสร้างไว้ก่อนหน้านี้

เปิดการติดตาม

1. adb pull <location> การติดตามจากอุปกรณ์ (ตำแหน่งที่ระบุในคำสั่ง record)

2. เปิดใน Perfetto

บันทึกการติดตามด้วย Jetpack Macrobenchmark

คุณสามารถวัดประสิทธิภาพด้วย Jetpack Macrobenchmark ซึ่งจะแสดงร่องรอยเป็นผลลัพธ์ หากต้องการเปิดใช้การติดตามการเขียนโค้ดด้วยการทดสอบประสิทธิภาพแบบแมโคร คุณต้องทําดังนี้

1. เพิ่มข้อกําหนดเพิ่มเติมเหล่านี้ลงในข้อบังคับการทดสอบ Macrobenchmark

   implementation("androidx.tracing:tracing-perfetto:1.0.0")
   implementation("androidx.tracing:tracing-perfetto-binary:1.0.0")
   

2. เพิ่มandroidx.benchmark.fullTracing.enable=trueอาร์กิวเมนต์เครื่องมือวัดก่อนเรียกใช้การเปรียบเทียบ ดูข้อมูลเพิ่มเติมเกี่ยวกับอาร์กิวเมนต์เครื่องมือวัดประสิทธิภาพการทำงานแบบแมโคร

ความคิดเห็น

เรายินดีรับฟังความคิดเห็นของคุณเกี่ยวกับฟีเจอร์นี้ ข้อบกพร่องที่พบ และคำขอต่างๆ คุณส่งความคิดเห็นถึงเราได้ผ่านเครื่องมือติดตามปัญหา