หน้านี้ได้รับการแปลโดย Cloud Translation API

เซสชันที่ช้า (เกมเท่านั้น)

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

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

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

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

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

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

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

เรียกใช้คําสั่งที่มี Flag 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 is as below:
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 โดยใช้ Flag disable
```
adb shell dumpsys SurfaceFlinger --timestats -disable
```

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

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

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

Swappy คืออะไร

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

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

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

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

วิธีใช้ Swappy ในโปรเจ็กต์เนทีฟ

ดูคู่มือต่อไปนี้เพื่อผสานรวมไลบรารีการกำหนดเฟรมของ Android เข้ากับเกม

วิธีใช้ Swappy ในเครื่องมือสร้างเกม Unity

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

กล่องโต้ตอบการตั้งค่าโปรเจ็กต์ — **รูปที่ 2** เปิดใช้การกำหนดเฟรมใน Unity Engine

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

วิธีใช้ Swappy ใน Unreal Game Engine

Unreal 4.25 ขึ้นไปผสานรวมไลบรารีการกำหนดอัตราการแสดงเฟรมของ Android ซึ่งเป็นส่วนหนึ่งของ 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 เช่น API แบบไม่มีการเชื่อมโยงและการเรย์แคสต์

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

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

วิธีใช้ Vulkan ในเครื่องมือเกม Unity

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

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

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

วิธีใช้ Vulkan ในเครื่องมือเกม Unreal

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

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

ADPF คืออะไร

เฟรมเวิร์กประสิทธิภาพแบบไดนามิกของ Android (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 เนทีฟ

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

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

วิธีใช้ ADPF ในเครื่องมือสร้างเกม Unity

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

ผู้ให้บริการ Adaptive Performance สำหรับ Android จะนำคุณผ่านขั้นตอนการติดตั้งใช้งาน ADPF ใน Unity

วิธีใช้ ADPF ในเครื่องมือสร้างเกม Unreal

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

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

การแสดงผลช้า

การทำงานขณะล็อกบางส่วนที่ค้าง