แนวคิดพื้นฐาน

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

ประสิทธิภาพลดลงอย่างรวดเร็ว

การใช้หน่วยความจำในตัวมันเองไม่ใช่สิ่งที่ดีหรือไม่ดี สิ่งสำคัญคือคุณใช้หน่วยความจำเพื่ออะไร อย่างไรก็ตาม เมื่อหน่วยความจำที่ใช้ได้ในอุปกรณ์ใกล้จะหมด คุณจะพบว่า "ประสิทธิภาพลดลงอย่างรวดเร็ว" ในที่สุด

กราฟแสดงประสิทธิภาพที่เสถียรจนถึงเกณฑ์หน่วยความจำหนึ่งๆ ตามด้วยการลดลงอย่างรวดเร็วเมื่อระบบเริ่มเกิดการ Thrashing และหยุดกระบวนการทำงาน

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

สแต็ก Android

แต่ละเลเยอร์ของสแต็ก Android มีมุมมองหน่วยความจำที่ไม่ซ้ำกันของตัวเอง ดังนี้

แผนภาพบล็อกของสแต็กหน่วยความจำ Android แสดงแอปพลิเคชัน Java ที่ด้านบน, ART ด้านล่าง และเคอร์เนล Linux ที่มีหน้าจริงที่ด้านล่าง

  1. แอปพลิเคชัน (Java/Kotlin): นักพัฒนาแอปจะเห็นออบเจ็กต์ Java ที่จัดสรรในฮีป Java เป็นหลัก
  2. Android Runtime (ART): ART จัดการฮีป Java/Kotlin โดยใช้หน้าหน่วยความจำเสมือนจากเคอร์เนล เดิมเรียกว่า Dalvik (บางครั้งมีการใช้คำนี้แทนกัน)
  3. เคอร์เนล Linux: เคอร์เนลจะเห็นหน่วยความจำในแง่ของหน้าจริงและเสมือน โดยปกติแล้ว หน้าหน่วยความจำจะมีขนาด 4 KB แต่ Android ก็รองรับหน้าหน่วยความจำขนาด 16 KB ด้วย เคอร์เนลไม่รู้จัก "ออบเจ็กต์ Java"

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

ประเภทหน่วยความจำ: แบบไม่ระบุตัวตนเทียบกับแบบมีไฟล์สำรอง

ก่อนที่จะเจาะลึกถึงวิธีที่ระบบปฏิบัติการเรียกคืนหน่วยความจำ คุณต้องเข้าใจหน้าหน่วยความจำ 2 หมวดหมู่พื้นฐานใน Linux ดังนี้

  1. หน่วยความจำแบบไม่ระบุชื่อ (anon): หน่วยความจำที่ไม่ได้สำรองข้อมูลโดยไฟล์ในพื้นที่เก็บข้อมูล ซึ่งรวมถึงหน่วยความจำที่จัดสรรโดย malloc C/C++ (เช่น ตัวจัดสรร Scudo) และหน่วยความจำที่จัดสรรสำหรับออบเจ็กต์ Java ในฮีป Java/Kotlin เนื่องจากหน่วยความจำนี้ไม่มีไฟล์ต้นฉบับให้กลับไป ระบบปฏิบัติการจึงต้องเก็บไว้ใน RAM หรือบีบอัดและสลับไปยัง ZRAM เมื่ออยู่ภายใต้แรงกดดัน
  2. หน่วยความจำที่ใช้ไฟล์เป็นแบ็กอัป (file): หน่วยความจำที่แมปโดยตรงจากไฟล์ในพื้นที่เก็บข้อมูล ซึ่งรวมถึงโค้ดสั่งการ (ไฟล์ DEX, ไลบรารีแบบเนทีฟ .so) และแบบอักษร

ไฟล์ที่แมปหน่วยความจำ (mmap)

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

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

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

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

โมเดลกระบวนการ Zygote

Android ลดต้นทุนในการเริ่มแอปพลิเคชันใหม่โดยใช้กระบวนการที่เรียกว่า Zygote

  1. Zygote จะเริ่มทำงานเมื่อเปิดเครื่องและโหลดคลาสและทรัพยากรเฟรมเวิร์กทั่วไปไว้ล่วงหน้าในหน่วยความจำ จากมุมมองของเคอร์เนล หน่วยความจำนี้จะกลายเป็นหน่วยความจำสกปรกที่ไม่ระบุชื่อ แต่เป็นหน่วยความจำเฉพาะสำหรับกระบวนการ Zygote
  2. เมื่อแอปพลิเคชันใหม่เริ่มทำงาน ระบบจะแยกกระบวนการ Zygote
  3. กระบวนการย่อยใหม่จะรับช่วงหน่วยความจำของ Zygote โดยใช้การแมปที่ใช้ร่วมกันกับความหมายของ Copy-on-Write (COW)

แผนภาพแสดงกระบวนการ Zygote ที่แชร์หน้าหน่วยความจำกับกระบวนการย่อยที่แยกใหม่โดยใช้ความหมายของ Copy-on-Write

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

RSS, PSS, USS และ memcg

เนื่องจากมีการแชร์หน่วยความจำระหว่างกระบวนการต่างๆ เป็นจำนวนมาก โดยหลักๆ แล้วผ่านโมเดล Zygote จึงมีหลายวิธีในการพิจารณาการใช้งานหน่วยความจำของกระบวนการ RSS, PSS และ USS จะนับหน้าเว็บที่แมปไว้ในพื้นที่ที่อยู่ของกระบวนการ ดังนี้

แผนภาพแสดงความแตกต่างระหว่าง Resident Set Size (RSS), Proportional Set Size (PSS) และ Unique Set Size (USS) ซึ่งแสดงวิธีพิจารณาหน้าหน่วยความจำที่ใช้ร่วมกัน

  • RSS (Resident Set Size): จำนวนหน้าทั้งหมดที่กระบวนการมีใน RAM ซึ่งจะประเมินการใช้งานสูงเกินจริงเนื่องจากนับหน้าเว็บที่แชร์หลายครั้ง (1 ครั้งสำหรับทุกกระบวนการที่แชร์หน้าเว็บ)
  • PSS (Proportional Set Size): ปริมาณหน่วยความจำทั้งหมดที่ใช้เฉพาะสำหรับกระบวนการนั้นๆ บวกกับสัดส่วนของหน่วยความจำที่ใช้ร่วมกัน หากมีการแชร์หน้าเว็บโดย 5 กระบวนการ แต่ละกระบวนการจะถูกเรียกเก็บเงิน 1/5 ของหน้าเว็บนั้น
  • USS (Unique Set Size): ปริมาณหน่วยความจำที่ใช้เฉพาะสำหรับกระบวนการนั้นๆ นี่คือหน่วยความจำที่จะส่งคืนไปยังระบบหากกระบวนการถูกหยุด

memcg: การบันทึกการใช้งานของเคอร์เนลเอง

นอกจากนี้ เคอร์เนลยังเก็บยอดรวมหน่วยความจำที่แต่ละกระบวนการใช้ ไม่ว่าหน่วยความจำนั้นจะได้รับการแมปหรือไม่ก็ตาม ใน Android ทุกกระบวนการของแอปจะอยู่ในกลุ่มควบคุมหน่วยความจำ (memcg) ของตัวเอง ซึ่งฝังอยู่ภายใน memcg สำหรับทั้งแอป (ดูลำดับชั้น memcg ของ Android) เมื่อใดก็ตามที่มีการจัดสรรหน้าหน่วยความจำ เคอร์เนลจะเรียกเก็บเงินจาก memcg ของกระบวนการที่จัดสรร การเรียกเก็บเงินทั้งหมดอยู่ในไฟล์ memory.current ของ memcg

การบันทึกการใช้งาน memcg แตกต่างจาก RSS, PSS และ USS ในประเด็นสำคัญบางประการ ดังนี้

  • ระบบจะเรียกเก็บเงินจากแต่ละหน้าเพียงครั้งเดียว โดยเรียกเก็บจาก memcg ของกระบวนการที่นำหน้านั้นเข้าสู่หน่วยความจำเป็นครั้งแรก การเรียกเก็บเงินจะยังคงอยู่แม้ว่ากระบวนการอื่นๆ จะแมปหน้าเดียวกันในภายหลัง ระบบจะเรียกเก็บเงินจาก Zygote สำหรับหน้าที่ Zygote โหลดไว้ล่วงหน้า ไม่ใช่แอปของคุณ เมื่อแอปเขียนลงในหน้าใดหน้าหนึ่งเหล่านี้ ระบบจะเรียกเก็บเงินจากแอปของคุณสำหรับสำเนาส่วนตัว
  • ซึ่งรวมถึงหน่วยความจำที่เมตริกตารางหน้าเว็บมองไม่เห็น memory.current นับหน้าไฟล์ที่แอปอ่านโดยไม่แมป (เช่น หน้าฐานข้อมูลที่อ่านด้วย read หรือ pread)
  • ระบบจะติดตามการสลับแยกต่างหาก หน่วยความจำที่บีบอัดเป็น ZRAM จะย้ายออกจาก memory.current และเข้าไปใน memory.swap.current คุณจึงดูทั้ง 2 อย่างได้โดยไม่ต้องคาดเดา
  • การอ่านมีค่าใช้จ่ายต่ำ ตัวนับจะอัปเดตอยู่เสมอ และการอ่านตัวนับจะไม่ล็อกหรือสแกนพื้นที่ที่อยู่ของแอป
  • เป็นขีดจำกัดของระบบ ขีดจำกัดหน่วยความจำและงบประมาณหน่วยความจำที่ Android ใช้กับแอปพลิเคชัน Android จะดำเนินการกับการเรียกเก็บเงิน memcg

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

ควรใช้เมตริกใดเมื่อใด

การเลือกเมตริกหน่วยความจำที่เหมาะสมขึ้นอยู่กับสิ่งที่คุณพยายามวัดและสภาพแวดล้อมที่คุณวัด ในอุปกรณ์ที่ใช้ Android 17 QPR2 (ระดับ API 37.2) ขึ้นไป ให้เริ่มด้วย memcg เมื่อติดตามแอปของคุณเอง

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

memcg (การเรียกเก็บเงินกลุ่มควบคุมหน่วยความจำ)

  • เหมาะสำหรับ: การติดตามการใช้งานหน่วยความจำของแอปแต่ละแอปเมื่อเวลาผ่านไป, ในเส้นทางของผู้ใช้ที่สำคัญ (CUJ) หรือระหว่างเวอร์ชันแอปต่างๆ ในอุปกรณ์ที่ใช้ Android 17 QPR2 ขึ้นไป นอกจากนี้ยังเป็นเมตริกที่ควรจับตามองเมื่อคุณปรับเทียบงบประมาณหน่วยความจำ เนื่องจากเป็นตัวเลขที่งบประมาณจำกัดไว้
  • เหตุผล: เช่นเดียวกับ RSS ค่าใช้จ่าย memcg จะไม่เปลี่ยนแปลงเมื่อแอปอื่นๆ เริ่มหรือหยุดแชร์หน้ากับแอปของคุณ แต่ต่างจาก RSS ตรงที่ memcg จะไม่นับหน้าซ้ำ คุณจึงสามารถรวมค่าใช้จ่ายของกระบวนการที่ทำงานอยู่ทั้งหมดของแอปได้ memcg ของทั้งแอปอาจสูงกว่าผลรวมนั้น เนื่องจากจะเก็บหน้าไฟล์ที่แคชไว้จากกระบวนการที่ออกจนกว่าเคอร์เนลจะเรียกคืน นอกจากนี้ยังนับหน่วยความจำที่ RSS, PSS และ USS พลาดไป เช่น แคชไฟล์ที่ไม่ได้แมป การอ่านข้อมูลนี้ใช้ทรัพยากรน้อยมาก เนื่องจากเคอร์เนลจะอัปเดตตัวนับเมื่อมีการเรียกเก็บเงินจากหน้าเว็บ
  • วิธีอ่าน: อ่าน memory.current, memory.swap.current และ memory.stat ในไดเรกทอรี memcg ของกระบวนการ (ดูสถิติ memcg) ใน Android 18 ขึ้นไป dumpsys meminfo จะพิมพ์ข้อมูลดังกล่าวด้วย จากภายในแอป ให้ใช้ MemoryBudgetManager
  • แนวทางปฏิบัติแนะนำสำหรับการวัดผลในภาคสนาม: ด้วยเหตุผลเดียวกับที่อธิบายไว้ใน RSS ให้ติดตามหน่วยความจำแบบไม่ระบุตัวตน + Swap ซึ่งก็คือช่อง anon ของ memory.stat บวกกับ memory.swap.current ช่อง file ของ memory.stat มีหน้าไฟล์ที่แอปของคุณอ่านครั้งเดียวและเคอร์เนลยังไม่ได้เรียกคืน ดังนั้น memory.current จึงอาจยังคงสูงอยู่เป็นระยะเวลาหนึ่งหลังจากที่แอปของคุณหยุดใช้หน่วยความจำนั้น
  • ข้อควรระวัง: เนื่องจากระบบจะเรียกเก็บเงินหน้าเว็บจากกระบวนการที่เข้าถึงหน้าเว็บนั้นก่อน แอปของคุณจึงถูกเรียกเก็บเงินสำหรับหน้าไฟล์ที่แชร์ (เช่น แบบอักษรหรือคลังที่ใช้ร่วมกัน) ที่แอปอ่านก่อนกระบวนการอื่นๆ ในทางกลับกัน ระบบอาจเรียกเก็บเงินจากกระบวนการอื่นสำหรับหน้าเว็บที่แอปของคุณใช้ด้วย คาดว่าอุปกรณ์และการเรียกใช้หน่วยความจำที่สำรองข้อมูลไว้ในไฟล์จะมีความแตกต่างกันเล็กน้อย และใช้ anon และสลับเมื่อเปรียบเทียบ

PSS (Proportional Set Size)

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

RSS (Resident Set Size)

  • เหมาะสำหรับ: การติดตามการใช้งานหน่วยความจำของแต่ละแอปเมื่อเวลาผ่านไปในเส้นทางของผู้ใช้ที่สำคัญ (CUJ) ต่างๆ หรือการเปรียบเทียบระหว่างเวอร์ชันแอป นอกจากนี้ยังเป็นตัวเลือกที่ใช้งานได้จริงที่สุดสำหรับการวัดและส่งข้อมูลทางไกลในภาคสนาม
  • เหตุผล: RSS มีความเสถียรกว่า PSS ซึ่งจะบอกคุณเกี่ยวกับหน่วยความจำที่แมปเข้ากับกระบวนการของคุณ ไม่ว่าแอปอื่นๆ จะทำอะไรอยู่ก็ตาม นอกจากนี้ RSS ยังมีค่าใช้จ่ายในการรวบรวมข้อมูลต่ำ การวัด PSS หรือ USS ต้องสแกนโครงสร้างการจัดการหน่วยความจำเคอร์เนลที่ซับซ้อนและรับล็อก ซึ่งอาจทำให้เกิดปัญหาด้านประสิทธิภาพของระบบ (เช่น UI กระตุก) หากรวบรวมบ่อยเกินไป
  • แนวทางปฏิบัติแนะนำในการวัดผลภาคสนาม: เมื่อรวบรวมข้อมูลจากอุปกรณ์ในสภาพแวดล้อมจริง โดยปกติแล้ววิธีที่ดีที่สุดคือการวัด RSS แบบไม่ระบุตัวตน + สลับ (ZRAM)
    • ทำไมจึงไม่ระบุชื่อเท่านั้น เคอร์เนลสามารถลบหน้าเว็บที่สำรองข้อมูลไฟล์ (เช่น โค้ด, ทรัพยากรแอป, แบบอักษร หรือไฟล์อื่นๆ ที่แมปหน่วยความจำ) ได้ทุกเมื่อเนื่องจากแรงกดดันของแคชหน้าเว็บทั่วทั้งระบบ การรวมหน้าไฟล์ไว้ในเมตริกเพื่อติดตามแอปหนึ่งๆ จะทำให้เกิดสัญญาณรบกวนจากการตัดสินใจด้านการจัดการหน่วยความจำของระบบปฏิบัติการ ซึ่งอาจเกิดจากแรงกดดันด้านหน่วยความจำจากแอปอื่นๆ หรือระบบ ในทางกลับกัน หน่วยความจำแบบไม่ระบุตัวตน (เช่น ฮีป Java และฮีปแบบเนทีฟ) จะควบคุมโดยแอปของคุณโดยตรง
    • เหตุใดจึงควรเพิ่มการสลับ ภายใต้แรงกดดันด้านหน่วยความจำ ระบบปฏิบัติการจะบีบอัดหน้าเว็บที่ไม่ระบุตัวตนและย้ายไปยัง ZRAM (สลับ) หากคุณวัดเฉพาะหน่วยความจำแบบไม่ระบุตัวตนที่อยู่ในระบบ เมตริกอาจแสดง "การลดลง" ของการใช้งานหน่วยความจำอย่างไม่ถูกต้อง เพียงเพราะระบบอยู่ภายใต้แรงกดดันและสลับหน้าเว็บของคุณออก การเพิ่มหน่วยความจำที่สลับจะช่วยให้คุณพิจารณาหน่วยความจำแบบไม่ระบุชื่อทั้งหมดที่แอปจัดสรรไว้ ไม่ว่าจะอยู่ใน RAM หรือ ZRAM ในปัจจุบัน
    • ใช้ memcg เมื่อทำได้ ในอุปกรณ์ที่ใช้ Android 17 QPR2 ขึ้นไป anon ใน memory.stat บวก memory.swap.current จะให้การวัดที่คล้ายกันซึ่งไม่รวมหน้าเว็บที่ไม่ระบุตัวตนที่แชร์กับ Zygote และรวบรวมได้ง่ายกว่า (ดู memcg)

USS (Unique Set Size)

  • เหมาะสำหรับ: การพิจารณาผลกระทบต่อระบบทันทีเมื่อหยุดกระบวนการทำงาน
  • เหตุผล: USS แสดงจำนวนหน่วยความจำที่แน่นอนซึ่งจะได้รับการเรียกคืนและส่งกลับไปยังระบบทันทีหากกระบวนการสิ้นสุดลง (เช่น โดย Low Memory Killer Daemon, lmkd)
  • วิธีใช้: เมตริกนี้มีประโยชน์อย่างมากเมื่อประเมินกระบวนการที่ทำงานต่อเนื่องหรือบริการที่ทำงานอยู่เบื้องหลัง หากคุณกำลังประเมินต้นทุนของกระบวนการเบื้องหลังทั้งระบบ USS จะบอกคุณอย่างชัดเจนว่าระบบต้องเสียสละหน่วยความจำเท่าใดเพื่อรักษากระบวนการนั้นๆ ไว้โดยเฉพาะ

↑ ขึ้น | เครื่องมือ →