การแก้ปัญหา LMK ในเกม Unity เป็นกระบวนการที่เป็นระบบ ดังนี้
รับสแนปชอตหน่วยความจำ
ใช้ Unity Profiler เพื่อดูภาพรวมของหน่วยความจำที่จัดการโดย 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 เหล่านี้
ดูข้อมูลเพิ่มเติมได้ที่ข้อมูลเบื้องต้นเกี่ยวกับหน่วยความจำใน 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 หากคุณใช้ AssetBundleTypeTrees- หาก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 มีองค์ประกอบจำนวนมากหรือมีการอัปเดตบ่อยครั้ง (เช่น ทุกเฟรม) การสร้างใหม่เหล่านี้อาจทำให้เกิดการเสียหน่วยความจำอย่างมาก
- การเปลี่ยนแปลงแบบไดนามิกในองค์ประกอบ UI — เมื่อมีการอัปเดตองค์ประกอบ UI เช่น พร็อพเพอร์ตี้ข้อความ รูปภาพ หรือ
เปิดใช้ 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
}