Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

เซสชันที่ช้า

ใน Android Vitals เซสชันที่ช้าคือเซสชันที่มีเฟรมช้ามากกว่า 25% เฟรมที่แสดงผลช้าคือเฟรมที่แสดงผลช้ากว่า 50 มิลลิวินาทีหลังจากเฟรมก่อนหน้า (เทียบเท่ากับ 20 FPS) นอกจากนี้ Android Vitals ยังรายงานเมตริกเซสชันที่ช้าตัวที่ 2 โดยมีเป้าหมายอยู่ที่ 34 มิลลิวินาที (เทียบเท่ากับ 30 FPS) คุณสามารถใช้ข้อมูลเซสชันที่ช้า เพื่อทำความเข้าใจประสิทธิภาพอัตราเฟรมของเกมซึ่งส่งผลต่อความลื่นไหลของเกมสำหรับผู้ใช้

Play จะเริ่มพาผู้ใช้ออกจากเกมที่มีอัตราเฟรม 20 FPS ในโทรศัพท์ให้ทันเวลา โปรดทราบว่า Android Vitals จะเริ่มตรวจสอบอัตราเฟรมหลังจากที่เกมทำงานไปแล้ว 1 นาทีเท่านั้น

ดูรายละเอียดเพิ่มเติมเกี่ยวกับเมตริกได้ที่ศูนย์ช่วยเหลือ

กราฟิกที่คล้ายแผนภูมิวงกลมซึ่งแสดงจำนวนเฟรมที่ช้าและเฟรมที่ไม่ช้า — **รูปที่ 1** เซสชันที่ช้าใน Android Vitals

หมายเหตุ: เมตริกเซสชันที่ช้าคำนวณด้วยข้อมูลที่เก็บรวบรวมมาจาก SurfaceFlinger เพื่อให้เห็นภาพมากขึ้นก็คือ อัตราเฟรมของเซสชันเป็นค่าประมาณโดยอิงจากเวลาระหว่างการวาดเฟรมบนแพลตฟอร์มที่แอปเป็นเจ้าของ อัตราเฟรมโดยประมาณมีเฟรมที่แสดงภาพโดย OpenGL, Vulkan ตลอดจนชุดเครื่องมือ Android UI เมตริกนี้ใช้ได้กับเกมเท่านั้น หากแอปของคุณใช้ชุดเครื่องมือ UI ที่อิงตาม View ซึ่งส่วนที่ผู้ใช้มองเห็นได้ของแอปจะดึงมาจาก Canvas หรือลำดับชั้น View โปรดดูการแสดงผลช้า

วิธีวัด FPS และตรวจหาเฟรมที่ช้า

คำสั่ง dumpsys SurfaceFlinger --timestats ของ Android จะแสดง FPS เฉลี่ยและฮิสโตแกรมเวลาการแสดงผลต่อการแสดงผลสำหรับเลเยอร์ทั้งหมดที่แสดงผลอยู่ เวลาปัจจุบันถึงปัจจุบันของเฟรมคือช่วงเวลาระหว่างเฟรมปัจจุบันกับเฟรมก่อนหน้าที่วาด ทำตามขั้นตอนต่อไปนี้เพื่อใช้คำสั่งในการรวบรวม FPS ของเกม

เรียกใช้คำสั่งที่มีแฟล็ก enable และ clear เพื่อเริ่มบันทึกข้อมูล
```
adb shell dumpsys SurfaceFlinger --timestats -clear -enable
```
เมื่อเล่นเกมเป็นเวลานานพอแล้ว ให้เรียกใช้คำสั่งอีกครั้งโดยมีแฟล็ก dump เพื่อดัมป์ข้อมูล
```
adb shell dumpsys SurfaceFlinger --timestats -dump
```
ข้อมูลที่ดัมพ์จะแสดงเฟรมทั้งหมดและpresentToPresent ฮิสโตแกรมสำหรับเลเยอร์ทั้งหมดที่แสดงผลโดย SurfaceFlinger คุณต้องค้นหาส่วนของเกมโดยกรองตามlayerName ดังนี้
```
layerName = SurfaceView[com.google.test/com.devrel.MainActivity]@0(BLAST)#132833
```
คุณสามารถคำนวณอัตราเฟรมที่ช้าของเซสชันได้โดยอิงตามข้อมูลของแต่ละเลเยอร์

เช่น เปอร์เซ็นต์เฟรมที่ช้า 20 FPS = (ผลรวมของค่าตั้งแต่ 54 มิลลิวินาทีถึง 1, 000 มิลลิวินาที) / totalFrames x 100
```
totalFrames = 274
...
presentToPresent histogram:
0ms=0 1ms=0 2ms=0 3ms=0 4ms=0 5ms=0 6ms=0 7ms=0 8ms=0 9ms=0 10ms=0 11ms=0 12ms=0
13ms=0 14ms=0 15ms=0 16ms=1 17ms=0 18ms=0 19ms=0 20ms=0 21ms=0 22ms=0 23ms=0
24ms=0 25ms=0 26ms=0 27ms=0 28ms=0 29ms=0 30ms=0 31ms=0 32ms=0 33ms=269 34ms=0
36ms=0 38ms=0 40ms=0 42ms=0 44ms=0 46ms=0 48ms=0 50ms=1 54ms=0 58ms=0 62ms=0
66ms=0 70ms=1 74ms=0 78ms=0 82ms=0 86ms=0 90ms=0 94ms=0 98ms=0 102ms=0 106ms=0
110ms=0 114ms=0 118ms=0 122ms=0 126ms=0 130ms=0 134ms=0 138ms=0 142ms=0 146ms=0
150ms=0 200ms=0 250ms=0 300ms=0 350ms=0 400ms=0 450ms=0 500ms=0 550ms=0 600ms=0
650ms=0 700ms=0 750ms=0 800ms=0 850ms=0 900ms=0 950ms=0 1000ms=0
```
FPS เฉลี่ยของแต่ละเลเยอร์จะแสดงในดัมพ์ด้วย ดังนี้
```
...
averageFPS = 30.179
...
```
หลังจากรวบรวมข้อมูลทั้งหมดแล้ว ให้ปิดใช้ timestats โดยใช้แฟล็ก disable ดังนี้
```
adb shell dumpsys SurfaceFlinger --timestats -disable
```

สาเหตุและวิธีแก้ปัญหาเฟรมช้า

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

ใช้ Android Frame Pacing (Swappy), Vulkan และ ADPF เพื่อแก้ไขปัญหาเหล่านี้และปรับปรุงประสิทธิภาพของเกม

Swappy คืออะไร

ไลบรารี Frame Pacing ของ Android หรือที่เรียกว่า Swappy เป็นส่วนหนึ่งของไลบรารี AGDK Swappy ช่วยให้เกม OpenGL และ Vulkan แสดงผลได้อย่างราบรื่นและมีจังหวะเฟรมที่ถูกต้องใน Android

การกำหนดอัตราเฟรมคือการซิงค์ตรรกะของเกมและลูปการแสดงผลกับระบบย่อยการแสดงผลของระบบปฏิบัติการและฮาร์ดแวร์การแสดงผลที่เกี่ยวข้อง ระบบย่อยการแสดงผลของ Android ได้รับการออกแบบมาเพื่อหลีกเลี่ยงข้อบกพร่องด้านภาพ (เรียกว่าการฉีกขาด) ที่อาจเกิดขึ้นเมื่อฮาร์ดแวร์การแสดงผลเปลี่ยนไปใช้เฟรมใหม่ระหว่างการอัปเดต เพื่อหลีกเลี่ยงอาร์ติแฟกต์เหล่านี้ ระบบย่อยการแสดงผลจะทำสิ่งต่อไปนี้

บัฟเฟอร์เฟรมที่ผ่านมาภายใน
ตรวจจับการส่งเฟรมล่าช้า
แสดงเฟรมที่ผ่านมาซ้ำเมื่อตรวจพบเฟรมที่ล่าช้า

ดูวิธีที่ Mir 2 ใช้ Swappy เพื่อลดอัตราเซสชันที่ช้าจาก 40% เหลือ 10%

วิธีใช้ Swappy ในโปรเจ็กต์ที่มาพร้อมเครื่อง

ดูคำแนะนำต่อไปนี้เพื่อผสานรวมไลบรารี Android Frame Pacing เข้ากับเกมของคุณ

วิธีใช้ Swappy ในเกมเอนจิน Unity

Unity ได้ผสานรวม Android Frame Pacing เข้ากับเครื่องมือของตนแล้ว หากต้องการเปิดใช้ฟีเจอร์นี้ใน Unity 2019.2 ขึ้นไป ให้เลือกช่องทำเครื่องหมาย "การกำหนดจังหวะเฟรมที่เพิ่มประสิทธิภาพ" ในส่วนการตั้งค่าโปรเจ็กต์ > โปรแกรมเล่น > การตั้งค่าสำหรับ Android > ความละเอียดและการนำเสนอ

หน้าต่างการตั้งค่าโปรเจ็กต์ Unity ซึ่งแสดงช่องทำเครื่องหมาย "การกำหนดอัตราเฟรมที่เพิ่มประสิทธิภาพ" — **รูปที่ 2** เปิดใช้ Frame Pacing ใน Unity Engine

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

วิธีใช้ Swappy ในเกมเอนจิน Unreal

Unreal 4.25 ขึ้นไปผสานรวมไลบรารี Android Frame Pacing ซึ่งเป็นส่วนหนึ่งของ Android Game Development Kit บทความการเว้นระยะเฟรมบนอุปกรณ์เคลื่อนที่จะอธิบายวิธีเปิดใช้ไลบรารีการเว้นระยะเฟรมของ Android และวิธีควบคุมการเว้นระยะเฟรมจากโค้ด C++

Vulkan คืออะไร

Vulkan เป็น API กราฟิก 3 มิติข้ามแพลตฟอร์มที่ทันสมัยซึ่งออกแบบมาเพื่อลดการแยกส่วนระหว่างฮาร์ดแวร์กราฟิกของอุปกรณ์กับเกมของคุณ Vulkan เป็น API กราฟิกระดับต่ำหลักใน Android ซึ่งมาแทนที่ OpenGL ES Android ยังคงรองรับ OpenGL ES แต่จะไม่มีการพัฒนาฟีเจอร์เพิ่มเติมอีกต่อไป

Vulkan มีข้อดีเหนือ OpenGL ES ดังนี้

สถาปัตยกรรมที่มีประสิทธิภาพมากขึ้นซึ่งมีค่าใช้จ่ายในการดำเนินการ CPU ต่ำลงในไดรเวอร์กราฟิก
กลยุทธ์การเพิ่มประสิทธิภาพใหม่เพื่อปรับปรุงประสิทธิภาพ CPU
ฟีเจอร์กราฟิกใหม่ที่ไม่มีใน OpenGL ES เช่น Bindless API และ Ray Tracing

วิธีใช้ Vulkan ในโปรเจ็กต์ Android แบบเนทีฟ

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

วิธีใช้ Vulkan ในเกมเอนจิน Unity

หากต้องการเปิดใช้การเลือกอุปกรณ์อัตโนมัติใน Unity ให้ทำตามขั้นตอนเพื่อกำหนดค่า Auto Graphics API

หน้าต่างการตั้งค่าโปรเจ็กต์ Unity ที่เปิดใช้ Auto Graphics API — **รูปที่ 3** เปิดใช้ Unity Auto Graphics API

หรือจะเปิดใช้ Vulkan ด้วยตนเองก็ได้โดยปิดใช้ Auto Graphics API และกำหนดให้ Vulkan มีลำดับความสำคัญสูงสุดในรายการ Graphics APIs หากคุณใช้ Unity 2021.1 หรือเวอร์ชันก่อนหน้า วิธีนี้เป็นวิธีเดียวที่จะใช้ Vulkan ได้

หน้าต่างการตั้งค่าโปรเจ็กต์ Unity ที่มี Vulkan เป็นลำดับความสำคัญแรกในรายการ Graphics API — **รูปที่ 4** เลือก Vulkan เป็น Graphics API หลักใน Unity ด้วยตนเอง

ใช้ปลั๊กอินเอนจิน VkQuality Unity เพื่อให้คำแนะนำเกี่ยวกับ Graphics API สำหรับเกมของคุณที่จะใช้ในอุปกรณ์ที่เฉพาะเจาะจงเมื่อเปิดตัว

วิธีใช้ Vulkan ในเกมเอนจิน Unreal

หากต้องการเปิดใช้ Vulkan Graphics API ให้ไปที่การตั้งค่าโปรเจ็กต์ > แพลตฟอร์ม > Android > บิลด์ แล้วเลือกรองรับ Vulkan เมื่อเลือกทั้งรองรับ Vulkan และรองรับ OpenGL ES3.2 Unreal จะใช้ Vulkan โดยค่าเริ่มต้น หากอุปกรณ์ไม่รองรับ Vulkan, Unreal จะเปลี่ยนไปใช้ OpenGL ES 3.2

หน้าต่างการตั้งค่าโปรเจ็กต์ Unreal Engine ที่แสดงตัวเลือก Support Vulkan — **รูปที่ 5** เปิดใช้ Vulkan ใน Unreal Engine

หากคุณใช้ฟีเจอร์ Vulkan บางอย่างที่ทราบว่าทำงานได้ไม่ดีในอุปกรณ์บางรุ่น คุณสามารถปรับแต่งไฟล์ BaseDeviceProfile.ini เพื่อยกเว้นอุปกรณ์เหล่านั้นได้ ดูวิธีปรับแต่ง BaseDeviceProfile.ini ได้ที่หัวข้อการปรับแต่งโปรไฟล์อุปกรณ์และความสามารถในการปรับขนาดสำหรับ Android เนื่องจากไดรเวอร์อุปกรณ์ใหม่อาจแก้ไขอุปกรณ์ที่เคยทราบว่าไม่ดีได้ โปรดอัปเดตไฟล์ BaseDeviceProfile.ini อยู่เสมอเพื่อรับการเพิ่มประสิทธิภาพทั้งหมด

ADPF คืออะไร

Android Dynamic Performance Framework (ADPF) จะเพิ่มประสิทธิภาพเกมโดยอิงตามฟีเจอร์การจัดการความร้อน, CPU และ GPU แบบไดนามิกใน Android โดยจะเน้นไปที่เกม แต่คุณก็ใช้ฟีเจอร์นี้กับแอปอื่นๆ ที่ใช้ประสิทธิภาพสูงได้เช่นกัน

ADPF คือชุด API ที่ช่วยให้เกมและแอปที่ใช้ประสิทธิภาพสูงสามารถโต้ตอบกับระบบพลังงานและความร้อนของอุปกรณ์ Android ได้โดยตรงมากขึ้น API เหล่านี้ช่วยให้คุณตรวจสอบลักษณะการทำงานแบบไดนามิกในระบบ Android และเพิ่มประสิทธิภาพของเกมให้อยู่ในระดับที่ยั่งยืนซึ่งไม่ทำให้เกิดความร้อนเกินระดับปกติในอุปกรณ์

ฟีเจอร์หลักของ ADPF มีดังนี้

Thermal API: ตรวจสอบสถานะความร้อนของอุปกรณ์เพื่อให้แอปพลิเคชันสามารถปรับภาระงานในเชิงรุกก่อนที่จะไม่ยั่งยืน
CPU Performance Hint API: ให้คำแนะนำด้านประสิทธิภาพที่ช่วยให้ Android เลือกการตั้งค่าประสิทธิภาพที่เหมาะสม (เช่น จุดปฏิบัติการหรือแกน CPU) สำหรับภาระงาน
Game Mode API และ Game State API: ช่วยเพิ่มประสิทธิภาพการเล่นเกมโดยจัดลำดับความสำคัญของลักษณะประสิทธิภาพหรือระยะเวลาการใช้งานแบตเตอรี่ตามการตั้งค่าของผู้ใช้และการกำหนดค่าเฉพาะของเกม
โหมดประสิทธิภาพคงที่: เปิดใช้โหมดประสิทธิภาพคงที่ในอุปกรณ์ระหว่างการเปรียบเทียบเพื่อให้ได้การวัดที่ไม่เปลี่ยนแปลงตามการกำหนดความเร็วสัญญาณนาฬิกาของ CPU แบบไดนามิก
โหมดประหยัดพลังงาน: ระบุให้เซสชันทราบว่าสามารถกำหนดเวลาเทรดในเซสชันคำแนะนำด้านประสิทธิภาพได้อย่างปลอดภัยเพื่อให้ประหยัดพลังงานมากกว่าประสิทธิภาพ พร้อมใช้งานใน Android 15 (ระดับ API 35)

วิธีใช้ ADPF ในโปรเจ็กต์ Android แบบเนทีฟ

Codelab การผสานรวมฟีเจอร์ความสามารถในการปรับตัวเข้ากับเกมแบบเนทีฟจะแนะนำวิธีผสานรวมฟีเจอร์ ADPF เข้ากับเกมของคุณด้วยขั้นตอนที่คุณทำตามได้ตามความสะดวก เมื่อจบ Codelab นี้ คุณจะได้ผสานรวมฟีเจอร์ต่อไปนี้

Thermal API: ฟังข้อมูลสภาพความร้อนของอุปกรณ์และตอบสนองก่อนที่อุปกรณ์จะเข้าสู่สถานะการควบคุมความร้อน
Game Mode API: ทำความเข้าใจค่ากำหนดการเพิ่มประสิทธิภาพของผู้เล่น (เพิ่มประสิทธิภาพสูงสุดหรือประหยัดแบตเตอรี่) และปรับเปลี่ยนตามความเหมาะสม
Game State API: แจ้งให้ระบบทราบสถานะของเกม (กำลังโหลด กำลังเล่น UI ฯลฯ) เพื่อให้ระบบปรับทรัพยากรตามความเหมาะสม (เพิ่ม I/O, CPU, GPU ฯลฯ)
Performance Hint API: แจ้งให้ระบบทราบถึงโมเดลการแยกชุดข้อความและภาระงานของคุณเพื่อให้ระบบจัดสรรทรัพยากรได้อย่างเหมาะสม

วิธีใช้ ADPF ในเกมเอนจิน Unity

Adaptive Performance ของ Unity เป็นเครื่องมือสำหรับนักพัฒนาเกมที่ต้องการเพิ่มประสิทธิภาพเกมบนอุปกรณ์เคลื่อนที่ โดยเฉพาะอย่างยิ่งสำหรับระบบนิเวศของ Android ที่มีความหลากหลาย ประสิทธิภาพแบบปรับอัตโนมัติช่วยให้เกมปรับตามประสิทธิภาพและลักษณะความร้อนของอุปกรณ์ได้แบบเรียลไทม์ เพื่อให้ผู้ใช้ได้รับประสบการณ์การเล่นเกมที่ราบรื่นและมีประสิทธิภาพ

ผู้ให้บริการ Android สำหรับประสิทธิภาพแบบปรับอัตโนมัติจะแนะนำขั้นตอนในการติดตั้งใช้งาน ADPF ใน Unity ดูเพิ่มเติมที่ผู้ให้บริการ ADPF Unity Adaptive Performance และ Android

หน้าต่างการตั้งค่าโปรเจ็กต์ Unity แสดงการตั้งค่าผู้ให้บริการ Android สำหรับประสิทธิภาพแบบปรับอัตโนมัติ — **รูปที่ 6** ผสานรวม ADPF ใน Unity Engine

วิธีใช้ ADPF ในเกมเอนจิน Unreal

หน้าต่าง Unreal Engine Plugins แสดงปลั๊กอิน Android Dynamic Performance Framework — **รูปที่ 7** ผสานรวม ADPF ใน Unreal Engine

ดาวน์โหลดปลั๊กอิน
คัดลอกปลั๊กอินลงในโฟลเดอร์ปลั๊กอินของโปรเจ็กต์
เปิดใช้ปลั๊กอิน ADPF Unreal Engine ในเครื่องมือแก้ไข Unreal
เปิด Unreal Editor อีกครั้ง
สร้างและเตรียมเกม

ปลั๊กอิน Android Dynamic Performance Framework (ADPF) สำหรับ Unreal Engine ช่วยให้ประสิทธิภาพคงที่และป้องกันการควบคุมปริมาณความร้อน ดาวน์โหลดปลั๊กอินจาก GitHub ปลั๊กอินนี้จะเปลี่ยนฟีเจอร์โดยการตั้งค่าค่าคอนโซล Unreal ดูรายละเอียดเพิ่มเติมได้ที่ปลั๊กอิน ADPF Unreal Engine