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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   

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

   

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

   

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

   

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

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

   

ข้อควรระวัง

ค่าใช้จ่ายเพิ่มเติมของขนาด 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 ปกติจะทำโดยอัตโนมัติ

เพิ่มทรัพยากร 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. เพิ่มทรัพยากร Dependency ต่อไปนี้ลงในโมดูลทดสอบ Macrobenchmark

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

2. เพิ่มandroidx.benchmark.fullTracing.enable=trueอาร์กิวเมนต์การวัดคุม ก่อนเรียกใช้การเปรียบเทียบ ดูข้อมูลเพิ่มเติมเกี่ยวกับอาร์กิวเมนต์การวัดคุม Macrobenchmark ได้ที่อาร์กิวเมนต์การวัดคุม Macrobenchmark

ความคิดเห็น

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