แก้ไขข้อบกพร่องของ LMK

การแก้ปัญหา LMK ในเกม Unity เป็นกระบวนการที่เป็นระบบ ดังนี้

รูปที่ 1 ขั้นตอนในการแก้ปัญหา Low Memory Kill (LMK) ในเกม Unity

รับสแนปชอตหน่วยความจำ

ใช้ Unity Profiler เพื่อดูภาพรวมของหน่วยความจำที่จัดการโดย Unity รูปที่ 2 แสดงเลเยอร์การจัดการหน่วยความจำที่ Unity ใช้เพื่อจัดการหน่วยความจำในเกม

รูปที่ 2 ภาพรวมการจัดการหน่วยความจำของ Unity

หน่วยความจำที่มีการจัดการ

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

หน่วยความจำที่ไม่มีการจัดการ C#

เลเยอร์หน่วยความจำ C# ที่ไม่มีการจัดการช่วยให้เข้าถึงเลเยอร์หน่วยความจำแบบเนทีฟได้ ซึ่งช่วยให้ควบคุมการจัดสรรหน่วยความจำได้อย่างแม่นยำขณะใช้โค้ด C# เลเยอร์การจัดการหน่วยความจำนี้เข้าถึงได้ผ่านเนมสเปซ Unity.Collections และฟังก์ชันต่างๆ เช่น UnsafeUtility.Malloc และ UnsafeUtility.Free

หน่วยความจำเนทีฟ

แกน C/C++ ภายในของ Unity ใช้ระบบหน่วยความจำแบบเนทีฟเพื่อจัดการฉาก เนื้อหา, API กราฟิก, ไดรเวอร์, ระบบย่อย และบัฟเฟอร์ปลั๊กอิน แม้ว่าการเข้าถึงโดยตรงจะถูกจำกัด แต่คุณสามารถจัดการข้อมูลได้อย่างปลอดภัยด้วย C# API ของ Unity และใช้ประโยชน์จากโค้ดแบบเนทีฟที่มีประสิทธิภาพ หน่วยความจำแบบเนทีฟไม่ค่อยต้องการการโต้ตอบโดยตรง แต่คุณสามารถตรวจสอบผลกระทบของหน่วยความจำแบบเนทีฟที่มีต่อประสิทธิภาพได้โดยใช้เครื่องมือวิเคราะห์ประสิทธิภาพ และปรับการตั้งค่าเพื่อเพิ่มประสิทธิภาพ

C# และโค้ดแบบเนทีฟจะไม่แชร์หน่วยความจำร่วมกัน ดังที่แสดงในรูปที่ 3 ข้อมูลที่ C# ต้องการจะได้รับการจัดสรรในพื้นที่หน่วยความจำที่มีการจัดการทุกครั้งที่จำเป็น

เพื่อให้โค้ดของเกมที่มีการจัดการ (C#) เข้าถึงข้อมูลหน่วยความจำแบบเนทีฟของเครื่องมือได้ เช่น การเรียกใช้ GameObject.transform จะทำการเรียกใช้แบบเนทีฟเพื่อเข้าถึงข้อมูลหน่วยความจำในพื้นที่เนทีฟ แล้วส่งคืนค่าไปยัง C# โดยใช้ Bindings การเชื่อมโยงช่วยให้มั่นใจได้ว่ามีการใช้รูปแบบการเรียกที่เหมาะสมสำหรับแต่ละแพลตฟอร์ม และจัดการการจัดระเบียบประเภทที่มีการจัดการให้เป็นประเภทที่เทียบเท่าแบบเนทีฟโดยอัตโนมัติ

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

รูปที่ 3 การเข้าถึงหน่วยความจำแบบเนทีฟจากโค้ดที่มีการจัดการ C#

ดูข้อมูลเพิ่มเติมได้ที่ข้อมูลเบื้องต้นเกี่ยวกับหน่วยความจำใน Unity

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

จัดการเนื้อหา

ส่วนนี้เป็นส่วนที่ส่งผลกระทบมากที่สุดและดำเนินการได้มากที่สุดในการใช้หน่วยความจำ โดยเร็วที่สุด

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

ตรวจหาชิ้นงานที่ซ้ำกัน

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

พื้นผิว

วิเคราะห์การรองรับอุปกรณ์ของเกมและเลือกรูปแบบพื้นผิวที่ถูกต้อง คุณสามารถแยกแพ็กเกจพื้นผิวสำหรับอุปกรณ์ระดับไฮเอนด์และโลว์เอนด์ได้โดยใช้ Play Asset Delivery, Addressable หรือกระบวนการที่ต้องทำด้วยตนเองมากขึ้นด้วย AssetBundle

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

  • บีบอัดพื้นผิวด้วยรูปแบบ ASTC เพื่อลดหน่วยความจำที่ใช้ และทดสอบด้วยอัตราการบล็อกที่สูงขึ้น เช่น 8x8

    หากจำเป็นต้องใช้ ETC2 ให้แพ็กพื้นผิวใน Atlas การวางพื้นผิวหลายรายการลงในพื้นผิวเดียวจะช่วยให้มั่นใจได้ว่าพื้นผิวมีขนาดเป็นเลขยกกำลังของ 2 (POT) ซึ่งจะช่วยลดคำสั่งประมวลผลและเร่งการแสดงผลได้

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

  • ใช้การแพ็กช่องพื้นผิวเพื่อประหยัดหน่วยความจำของพื้นผิว

เมชและโมเดล

เริ่มด้วยการตรวจสอบการตั้งค่าพื้นฐาน (หน้า 27) และยืนยันการตั้งค่าการนำเข้า Mesh ต่อไปนี้

  • ผสานเมชที่ซ้ำซ้อนและมีขนาดเล็กลง
  • ลดจำนวนจุดยอดมุมสำหรับออบเจ็กต์ในฉาก (เช่น ออบเจ็กต์แบบคงที่หรืออยู่ไกล)
  • สร้างกลุ่มระดับรายละเอียด (LOD) สำหรับชิ้นงานที่มีเรขาคณิตสูง

วัสดุและเฉดสี

  • ตัดตัวแปรเฉดสีที่ไม่ได้ใช้ออกแบบเป็นโปรแกรมในระหว่างกระบวนการบิลด์
  • รวมตัวแปรเฉดสีที่ใช้บ่อยไว้ใน Uber Shader เพื่อหลีกเลี่ยงการทำซ้ำเฉดสี
  • เปิดใช้การโหลดเฉดสีแบบไดนามิกเพื่อแก้ไขปัญหาหน่วยความจำที่ใช้จำนวนมากของเฉดสีที่โหลดไว้ล่วงหน้าใน VRAM/RAM อย่างไรก็ตาม โปรดระวังหากการคอมไพล์ตัวปรับแสงเงาทำให้เฟรมสะดุด
  • ใช้การโหลดเฉดสีแบบไดนามิกเพื่อป้องกันไม่ให้โหลดตัวแปรทั้งหมด ดูข้อมูลเพิ่มเติมได้ที่บล็อกโพสต์การปรับปรุงเวลาบิลด์ของเฉดสีและการใช้งานหน่วยความจำ
  • ใช้อินสแตนซ์ของวัสดุอย่างเหมาะสมโดยใช้ประโยชน์จาก MaterialPropertyBlocks

เสียง

เริ่มด้วยการตรวจสอบการตั้งค่าพื้นฐาน (หน้า 41) และยืนยันการตั้งค่าการนำเข้า Mesh ต่อไปนี้

  • นำการอ้างอิง AudioClip ที่ไม่ได้ใช้หรือซ้ำซ้อนออกเมื่อใช้เครื่องมือเสียงของบุคคลที่สาม เช่น FMOD หรือ Wwise
  • โหลดข้อมูลเสียงล่วงหน้า ปิดใช้การโหลดล่วงหน้าสำหรับคลิปที่ไม่จำเป็นต้องใช้ทันทีในระหว่างรันไทม์หรือการเริ่มต้นฉาก ซึ่งจะช่วยลดโอเวอร์เฮดของหน่วยความจำระหว่างการเริ่มต้นฉาก

ภาพเคลื่อนไหว

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

คุณปรับการตั้งค่าการบีบอัดได้ในการตั้งค่าการนำเข้าภาพเคลื่อนไหวในแท็บริกหรือภาพเคลื่อนไหว

  • ใช้คลิปภาพเคลื่อนไหวซ้ำแทนการทำซ้ำคลิปภาพเคลื่อนไหวสำหรับออบเจ็กต์ต่างๆ

    ใช้ Animator Override Controllers เพื่อนำ Animator Controller กลับมาใช้ซ้ำและแทนที่คลิปที่เฉพาะเจาะจงสำหรับตัวละครต่างๆ

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

  • เพิ่มประสิทธิภาพโครงกระดูก: ใช้กระดูกในโครงสร้างให้น้อยลงเพื่อลดความซับซ้อนและการใช้หน่วยความจำ

    • หลีกเลี่ยงการใช้กระดูกมากเกินไปสำหรับวัตถุขนาดเล็กหรือวัตถุที่ไม่มีการเคลื่อนไหว
    • หากไม่ได้ใช้หรือสร้างภาพเคลื่อนไหวให้กระดูกบางชิ้น ให้นำกระดูกชิ้นนั้นออกจากโครงสร้าง
  • ลดความยาวของคลิปภาพเคลื่อนไหว

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

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

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

ฉาก

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

  • ใช้ Object Pooling ของ Unity เพื่อนำอินสแตนซ์ GameObject กลับมาใช้ซ้ำสำหรับองค์ประกอบเกมเพลย์ที่เกิดซ้ำ เนื่องจาก Object Pooling ใช้สแต็กเพื่อเก็บคอลเล็กชันอินสแตนซ์ออบเจ็กต์สำหรับการนำกลับมาใช้ซ้ำและไม่ปลอดภัยต่อเธรด การลด Instantiate และ Destroy จะช่วยปรับปรุงทั้งประสิทธิภาพของ CPU และความเสถียรของหน่วยความจำ
  • การนำชิ้นงานออก
    • ยกเลิกการโหลดชิ้นงานอย่างมีกลยุทธ์ในช่วงเวลาที่ไม่สำคัญ เช่น หน้าจอเริ่มต้น (Splash Screen) หรือหน้าจอโหลด
    • การใช้ Resources.UnloadUnusedAssets บ่อยครั้งทำให้การประมวลผล CPU เพิ่มขึ้นอย่างรวดเร็วเนื่องจากการดำเนินการตรวจสอบทรัพยากร Dependency ภายในขนาดใหญ่
    • ตรวจสอบการเพิ่มขึ้นอย่างรวดเร็วของ CPU ในเครื่องหมายโปรไฟล์ GC.MarkDependencies ลดหรือนำความถี่ในการดำเนินการออก และยกเลิกการโหลดทรัพยากรที่เฉพาะเจาะจงด้วยตนเองแทนโดยใช้ Resources.UnloadAsset แทนที่จะใช้ Resources.UnloadUnusedAssets() ที่ครอบคลุมทั้งหมด
  • ปรับโครงสร้างฉากแทนที่จะใช้ Resources.UnloadUnusedAssets อย่างต่อเนื่อง
  • การเรียกใช้ Resources.UnloadUnusedAssets() สำหรับ Addressables อาจยกเลิกการโหลด Bundle ที่โหลดแบบไดนามิกโดยไม่ตั้งใจ จัดการวงจรของชิ้นงานที่โหลดแบบไดนามิกอย่างระมัดระวัง

เบ็ดเตล็ด

  • การกระจาย Fragment ที่เกิดจากการเปลี่ยนฉาก - เมื่อมีการเรียกใช้เมธอด Resources.UnloadUnusedAssets() Unity จะทำสิ่งต่อไปนี้

    • เพิ่มหน่วยความจำสำหรับชิ้นงานที่ไม่ได้ใช้งานแล้ว
    • เรียกใช้การดำเนินการที่คล้ายกับ Garbage Collector เพื่อตรวจสอบฮีปออบเจ็กต์ที่มีการจัดการและแบบเนทีฟเพื่อหาชิ้นงานที่ไม่ได้ใช้และยกเลิกการโหลด
    • ล้างหน่วยความจำพื้นผิว, Mesh และเนื้อหา หากไม่มีการอ้างอิงที่ใช้งานอยู่
  • AssetBundle หรือ Addressable - การเปลี่ยนแปลงในส่วนนี้มีความซับซ้อนและต้องอาศัยความร่วมมือจากทีมเพื่อนำกลยุทธ์ไปใช้ อย่างไรก็ตาม เมื่อเข้าใจกลยุทธ์เหล่านี้แล้ว กลยุทธ์เหล่านี้จะช่วยปรับปรุงการใช้งานหน่วยความจำ ลดขนาดการดาวน์โหลด และลดค่าใช้จ่ายในระบบคลาวด์ได้อย่างมาก ดูข้อมูลเพิ่มเติมเกี่ยวกับการจัดการเนื้อหาใน Unity ได้ที่ Addressables

  • ทรัพยากร Dependency ที่แชร์แบบรวมศูนย์ &mdash: จัดกลุ่มทรัพยากร Dependency ที่แชร์ เช่น ตัวปรับเฉดสี พื้นผิว และแบบอักษร อย่างเป็นระบบลงในแพ็กเกจเฉพาะหรือกลุ่ม Addressable ซึ่งจะช่วยลดการทำซ้ำและช่วยให้มั่นใจได้ว่าระบบจะยกเลิกการโหลดเนื้อหาที่ไม่จำเป็นได้อย่างมีประสิทธิภาพ

  • ใช้ Addressables สำหรับการติดตามทรัพยากร Dependency - Addressables ช่วยให้การโหลดและการยกเลิกการโหลดง่ายขึ้น โดยสามารถยกเลิกการโหลดทรัพยากร Dependency ที่ไม่มีการอ้างอิงอีกต่อไปได้โดยอัตโนมัติ การเปลี่ยนไปใช้ Addressables สำหรับการจัดการเนื้อหาและการแก้ไขทรัพยากร Dependency อาจเป็นโซลูชันที่เหมาะสม ทั้งนี้ขึ้นอยู่กับกรณีเฉพาะของเกม วิเคราะห์เชนทรัพยากร Dependency ด้วยเครื่องมือวิเคราะห์เพื่อระบุทรัพยากร Dependency หรือรายการที่ซ้ำกันซึ่งไม่จำเป็น หรือดูเครื่องมือข้อมูลของ Unity หากคุณใช้ AssetBundle

  • TypeTrees - หาก Addressables และ AssetBundles ของเกมสร้างและติดตั้งใช้งานโดยใช้ Unity เวอร์ชันเดียวกับเพลเยอร์ และไม่จำเป็นต้องเข้ากันได้แบบย้อนหลังกับบิลด์เพลเยอร์อื่นๆ ให้พิจารณาปิดใช้การเขียน TypeTree ซึ่งจะช่วยลดขนาดแพ็กเกจและหน่วยความจำที่ใช้สำหรับออบเจ็กต์ไฟล์ที่เรียงลำดับแล้ว แก้ไขกระบวนการบิลด์ในการตั้งค่าแพ็กเกจ Addressables ในเครื่อง ContentBuildFlags เป็น DisableWriteTypeTree

เขียนโค้ดที่เหมาะกับ Garbage Collector

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

ดูเทคนิคที่เป็นประโยชน์ในการลดความถี่ของการจัดสรรฮีปที่มีการจัดการได้ที่คู่มือ Unity และดูตัวอย่างได้ที่ UnityPerformanceTuningBible หน้า 271

  • ลดการจัดสรรตัวเก็บขยะ:

    • หลีกเลี่ยง LINQ, Lambda และ Closure ซึ่งจัดสรรหน่วยความจำฮีป
    • ใช้ StringBuilder สำหรับสตริงที่เปลี่ยนแปลงได้แทนการเชื่อมโยงสตริง
    • นำคอลเล็กชันกลับมาใช้ใหม่โดยเรียกใช้ COLLECTIONS.Clear() แทนการสร้างอินสแตนซ์ใหม่

    ดูข้อมูลเพิ่มเติมได้ใน eBook สุดยอดคู่มือการทำโปรไฟล์เกม Unity

  • จัดการการอัปเดต UI Canvas

    • การเปลี่ยนแปลงแบบไดนามิกในองค์ประกอบ UI — เมื่อมีการอัปเดตองค์ประกอบ UI เช่น พร็อพเพอร์ตี้ข้อความ รูปภาพ หรือ RectTransform (เช่น การเปลี่ยนเนื้อหาข้อความ การปรับขนาดองค์ประกอบ หรือการเคลื่อนไหวตำแหน่ง) เครื่องมืออาจจัดสรรหน่วยความจำสำหรับออบเจ็กต์ชั่วคราว
    • การจัดสรรสตริง — องค์ประกอบ UI เช่น Text มักต้องมีการอัปเดตสตริง เนื่องจากสตริงไม่สามารถเปลี่ยนแปลงได้ในภาษาโปรแกรมส่วนใหญ่
    • Canvas ที่มีการเปลี่ยนแปลง - เมื่อมีการเปลี่ยนแปลงบางอย่างใน Canvas (เช่น การปรับขนาด การเปิดและปิดใช้องค์ประกอบ หรือการแก้ไขพร็อพเพอร์ตี้เลย์เอาต์) ระบบอาจทำเครื่องหมาย Canvas ทั้งหมดหรือบางส่วนว่ามีการเปลี่ยนแปลงและสร้างใหม่ ซึ่งอาจทำให้เกิดการสร้างโครงสร้างข้อมูลชั่วคราว (เช่น ข้อมูล Mesh, บัฟเฟอร์จุดยอด หรือการคำนวณเลย์เอาต์) ซึ่งจะเพิ่มการสร้างขยะ
    • การอัปเดตที่ซับซ้อนหรือบ่อยครั้ง - หาก Canvas มีองค์ประกอบจำนวนมากหรือมีการอัปเดตบ่อยครั้ง (เช่น ทุกเฟรม) การสร้างใหม่เหล่านี้อาจทำให้เกิดการเสียหน่วยความจำอย่างมาก
  • เปิดใช้ GC แบบเพิ่มขึ้นเพื่อลดการเพิ่มขึ้นอย่างรวดเร็วของการเก็บรวบรวมข้อมูลขนาดใหญ่โดยกระจายการล้างข้อมูลการจัดสรรไปยังหลายเฟรม โปรไฟล์เพื่อยืนยันว่าตัวเลือกนี้ช่วยปรับปรุงประสิทธิภาพและหน่วยความจำที่ใช้ของเกมหรือไม่

  • หากเกมของคุณต้องใช้แนวทางที่มีการควบคุม ให้ตั้งค่าโหมด Garbage Collection เป็นแบบแมนนวล จากนั้นเมื่อเปลี่ยนระดับหรือในช่วงเวลาอื่นที่ไม่มีเกมเพลย์ที่ดำเนินอยู่ ให้เรียกใช้การเก็บขยะ

  • เรียกใช้การเก็บหน่วยความจำแอปด้วยตนเอง GC.Collect() สำหรับการเปลี่ยนสถานะเกม (เช่น การเปลี่ยนเลเวล)

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

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

    ใช้ Profiler Marker เพื่อส่งไปยังเครื่องมือการรายงานประสิทธิภาพสำหรับแนวทางแบบอัตโนมัติ

หลีกเลี่ยงหน่วยความจำรั่วไหลและการกระจาย Fragment

หน่วยความจำรั่วไหล

ในโค้ด C# เมื่อมีการอ้างอิงถึง Unity Object หลังจากที่ออบเจ็กต์ถูกทำลาย ออบเจ็กต์ Wrapper ที่มีการจัดการหรือที่เรียกว่า Managed Shell จะยังคงอยู่ในหน่วยความจำ ระบบจะปล่อยหน่วยความจำแบบเนทีฟที่เชื่อมโยงกับการอ้างอิงเมื่อยกเลิกการโหลดฉาก หรือเมื่อ GameObject ที่หน่วยความจำเชื่อมโยงอยู่ หรือออบเจ็กต์หลักใดๆ ถูกทำลายผ่านเมธอด Destroy() อย่างไรก็ตาม หากไม่มีการล้างการอ้างอิงอื่นๆ ไปยัง Scene หรือ GameObject หน่วยความจำที่มีการจัดการอาจยังคงเป็นออบเจ็กต์ Shell ที่รั่วไหล ดูรายละเอียดเพิ่มเติมเกี่ยวกับ Managed Shell Objects ได้ที่คู่มือ Managed Shell Objects

นอกจากนี้ หน่วยความจำรั่วไหลอาจเกิดจากการสมัครรับข้อมูลเหตุการณ์, แลมบ์ดาและ Closure, การเชื่อมโยงสตริง และการจัดการออบเจ็กต์ที่รวมกันอย่างไม่เหมาะสม ดังนี้

  • หากต้องการเริ่มต้นใช้งาน โปรดดูหัวข้อค้นหาหน่วยความจำรั่วไหลเพื่อเปรียบเทียบสแนปชอตหน่วยความจำของ Unity อย่างเหมาะสม
  • ตรวจสอบการสมัครรับข้อมูลเหตุการณ์และหน่วยความจำรั่วไหล หากออบเจ็กต์สมัครรับข้อมูลเหตุการณ์ (เช่น โดยผู้รับมอบสิทธิ์หรือ UnityEvents) แต่ไม่ได้ยกเลิกการสมัครรับข้อมูลอย่างถูกต้องก่อนที่จะถูกทำลาย ผู้จัดการหรือผู้เผยแพร่เหตุการณ์อาจเก็บการอ้างอิงไปยังออบเจ็กต์เหล่านั้นไว้ ซึ่งจะป้องกันไม่ให้มีการรวบรวมขยะจากออบเจ็กต์เหล่านั้น และทำให้หน่วยความจำรั่วไหล
  • ตรวจสอบเหตุการณ์คลาสส่วนกลางหรือคลาสซิงเกิลตันที่ไม่ได้ยกเลิกการลงทะเบียนเมื่อมีการทำลายออบเจ็กต์ เช่น ยกเลิกการสมัครหรือยกเลิกการเชื่อมต่อผู้รับมอบสิทธิ์ในตัวทำลายออบเจ็กต์
  • ตรวจสอบว่าการทำลายออบเจ็กต์ที่รวมไว้จะทำให้การอ้างอิงถึงคอมโพเนนต์ Text Mesh, พื้นผิว และ GameObject ระดับบนสุดเป็นค่าว่างโดยสมบูรณ์
  • โปรดทราบว่าเมื่อเปรียบเทียบสแนปชอตของเครื่องมือสร้างโปรไฟล์หน่วยความจำของ Unity และสังเกตความแตกต่างในการใช้หน่วยความจำโดยไม่มีสาเหตุที่ชัดเจน ความแตกต่างดังกล่าวอาจเกิดจากไดรเวอร์กราฟิกหรือระบบปฏิบัติการเอง

การกระจาย Fragment ของหน่วยความจำ

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

ปัญหานี้จะสร้างปัญหาอย่างยิ่งเมื่อมีการจัดสรรขนาดใหญ่ที่มีอายุสั้นใกล้กับรายการที่มีอายุยาวนาน

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

ผู้สังเกตการณ์และผู้จัดการกิจกรรม

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

รหัส

  • บางครั้ง Coroutine จะจัดสรรหน่วยความจำ ซึ่งหลีกเลี่ยงได้โดยการแคชคำสั่ง "return" ของ IEnumerator แทนการประกาศใหม่ทุกครั้ง
  • ตรวจสอบสถานะวงจรของออบเจ็กต์ที่รวมกลุ่มอย่างต่อเนื่องเพื่อหลีกเลี่ยงการเก็บการอ้างอิงที่ไม่มีอยู่จริงUnityEngine.Object

ชิ้นงาน

  • ใช้ระบบสำรองแบบไดนามิกสำหรับประสบการณ์การเล่นเกมที่ขับเคลื่อนด้วยข้อความเพื่อหลีกเลี่ยงการโหลดแบบอักษรทั้งหมดล่วงหน้าสำหรับกรณีที่มีหลายภาษา
  • จัดระเบียบเนื้อหา (เช่น พื้นผิวและอนุภาค) ไว้ด้วยกันตามประเภทและวงจรที่คาดไว้
  • รวมชิ้นงานที่มีแอตทริบิวต์วงจรที่ไม่มีการใช้งาน เช่น รูปภาพ UI ที่ซ้ำซ้อนและเมชแบบคงที่

การจัดสรรตามอายุการใช้งาน

  • จัดสรรเนื้อหาที่มีอายุการใช้งานยาวนานเมื่อเริ่มต้นวงจรของแอปพลิเคชันเพื่อให้แน่ใจว่ามีการจัดสรรที่กะทัดรัด
  • ใช้ NativeCollections หรือ Allocator ที่กำหนดเองสำหรับโครงสร้างข้อมูลที่ใช้หน่วยความจำมากหรือชั่วคราว (เช่น คลัสเตอร์ฟิสิกส์)

ไฟล์ปฏิบัติการและปลั๊กอินของเกมยังส่งผลต่อการใช้งานหน่วยความจำด้วย

ข้อมูลเมตา IL2CPP

IL2CPP จะสร้างข้อมูลเมตาสำหรับทุกประเภท (เช่น คลาส, เจเนอริก และตัวแทน) ณ เวลาบิลด์ ซึ่งจะใช้ในรันไทม์สำหรับการสะท้อน การตรวจสอบประเภท และการดำเนินการอื่นๆ ที่เฉพาะเจาะจงสำหรับรันไทม์ ข้อมูลเมตานี้จะจัดเก็บไว้ในหน่วยความจำและอาจส่งผลต่อหน่วยความจำที่ใช้ทั้งหมดของแอปพลิเคชันอย่างมาก แคชข้อมูลเมตาของ IL2CPP มีส่วนสำคัญต่อเวลาในการเริ่มต้นและการโหลด นอกจากนี้ IL2CPP ยังไม่กรองข้อมูลเมตาบางอย่างที่ซ้ำกันออก (เช่น ประเภททั่วไปหรือข้อมูลที่เรียงลำดับ) ซึ่งอาจส่งผลให้มีการใช้งานหน่วยความจำมากเกินไป ปัญหานี้จะยิ่งรุนแรงขึ้นเมื่อมีการใช้ประเภทซ้ำๆ หรือซ้ำซ้อนในโปรเจ็กต์

คุณลดข้อมูลเมตา IL2CPP ได้โดยทำดังนี้

  • หลีกเลี่ยงการใช้ Reflection API เนื่องจากอาจเป็นสาเหตุสำคัญของการจัดสรรข้อมูลเมตา IL2CPP
  • การปิดใช้แพ็กเกจในตัว
  • การใช้การแชร์ทั่วไปแบบเต็มรูปแบบของ Unity 2022 ซึ่งน่าจะช่วยลดค่าใช้จ่ายเพิ่มเติมที่เกิดจาก Generics อย่างไรก็ตาม หากต้องการลดการจัดสรรให้มากยิ่งขึ้น ให้ลดการใช้ Generics

การตัดโค้ด

นอกจากการลดขนาดของบิลด์แล้ว การตัดโค้ดยังช่วยลดการใช้งานหน่วยความจำด้วย เมื่อสร้างโดยใช้แบ็กเอนด์การเขียนสคริปต์ IL2CPP การตัดไบต์โค้ดที่มีการจัดการ (ซึ่งเปิดใช้งานโดยค่าเริ่มต้น) จะนำโค้ดที่ไม่ได้ใช้ออกจากแอสเซมบลีที่มีการจัดการ กระบวนการนี้ทำงานโดยการกำหนดแอสเซมบลีรูท แล้วใช้การวิเคราะห์โค้ดแบบคงที่เพื่อระบุโค้ดที่มีการจัดการอื่นๆ ที่แอสเซมบลีรูทเหล่านั้นใช้ ระบบจะนำโค้ดที่เข้าถึงไม่ได้ออก ดูข้อมูลเพิ่มเติมเกี่ยวกับการตัดโค้ดที่มีการจัดการได้ที่บล็อกโพสต์ TTales from the optimization trenches: Better managed code stripping with Unity 2020 LTS และเอกสารประกอบการตัดโค้ดที่มีการจัดการ

เครื่องมือจัดสรรแบบเนทีฟ

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

จัดการปลั๊กอินและ SDK แบบเนทีฟ

  • ค้นหาปลั๊กอินที่มีปัญหา — นำปลั๊กอินแต่ละรายการออกและเปรียบเทียบสแนปชอตหน่วยความจำของเกม ซึ่งรวมถึงการปิดใช้ฟังก์ชันการทำงานของโค้ดจำนวนมากด้วยสัญลักษณ์ที่กำหนดสคริปต์และการเปลี่ยนโครงสร้างภายในโค้ดของคลาสที่เชื่อมโยงกันอย่างมากด้วยอินเทอร์เฟซ ดูLevel up your code with game programming patternsเพื่ออำนวยความสะดวกในกระบวนการปิดใช้ทรัพยากร Dependency ภายนอกโดยไม่ทำให้เกมเล่นไม่ได้

  • ติดต่อผู้เขียนปลั๊กอินหรือ SDK - ปลั๊กอินส่วนใหญ่ไม่ใช่โอเพนซอร์ส

  • จำลองการใช้งานหน่วยความจำของปลั๊กอิน — คุณสามารถเขียนปลั๊กอินขนาดเล็ก (ใช้ปลั๊กอิน Unity นี้เป็นข้อมูลอ้างอิง) ที่ทำการจัดสรรหน่วยความจำได้ ตรวจสอบสแนปชอตหน่วยความจำโดยใช้ Android Studio (เนื่องจาก Unity ไม่ได้ติดตามการจัดสรรเหล่านี้) หรือเรียกใช้คลาส MemoryInfo และเมธอด Runtime.totalMemory() ในโปรเจ็กต์เดียวกัน

ปลั๊กอิน Unity จะจัดสรรหน่วยความจำ Java และหน่วยความจำแบบเนทีฟ โดยมีวิธีการดังนี้

Java

byte[] largeObject = new byte[1024 * 1024 * megaBytes];
list.add(largeObject);

เนทีฟ

char* buffer = new char[megabytes * 1024 * 1024];

// Random data to fill the buffer
for (int i = 1; i < megabytes * 1024 * 1024; ++i) {
   buffer[i] = 'A' + (i % 26); // Fill with letters A-Z
}