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

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

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

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

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

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

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

การตั้งค่าการติดตามการเรียบเรียง

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

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

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

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

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

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

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

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

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

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

หากต้องการบันทึกการติดตามระบบและดูการติดตามการจัดองค์ประกอบใหม่ที่ทำงานอยู่ ให้ทำตามขั้นตอนต่อไปนี้

1. เปิดโปรไฟล์เลอร์

   

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

   

3. ไปที่ UI ที่ต้องการติดตามในแอป แล้วเลือกSystem Trace และRecord

   

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

   

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

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

   

ข้อควรระวัง

ค่าใช้จ่ายเพิ่มเติมของขนาด APK

แม้ว่าเราจะพยายามลดค่าใช้จ่ายของฟีเจอร์นี้ให้ได้มากที่สุด แต่ขนาด APK ของแอป Compose จะเพิ่มขึ้นเนื่องจากสตริงการติดตาม ที่ฝังอยู่ใน APK โดยคอมไพเลอร์ Compose การเพิ่มขนาดนี้อาจมีขนาดเล็กค่อนข้างมากหากแอปไม่ได้ใช้ 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 ปกติจะทำโดยอัตโนมัติ

เพิ่มทรัพยากร Dependency

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

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> การติดตามจากอุปกรณ์ (ตำแหน่งที่ระบุใน คำสั่งบันทึก)

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 ก่อนเรียกใช้การเปรียบเทียบ ดูข้อมูลเพิ่มเติมเกี่ยวกับอาร์กิวเมนต์การวัดประสิทธิภาพมาโครได้ที่อาร์กิวเมนต์การวัดประสิทธิภาพมาโคร

ความคิดเห็น

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