เมื่อต้องการตรวจสอบการใช้งานหน่วยความจำ ให้เริ่มด้วยเครื่องมือประเมินระดับสูงเพื่อระบุว่าหน่วยความจำหมวดหมู่ใดมีความสำคัญมากที่สุด
dumpsys meminfo
วิธีที่ใช้กันมากที่สุดในการดูภาพรวมการใช้งานหน่วยความจำของแอปพลิเคชันคือ dumpsys meminfo หากต้องการดูรายละเอียดทั้งหมดรวมถึงการแมปหน่วยความจำทั้งหมด การใส่แฟล็ก -a มักจะมีประโยชน์
adb shell dumpsys meminfo -a <package_name_or_pid>
ต่อไปนี้เป็นตัวอย่างเอาต์พุตจากแอปพลิเคชันภายใต้แรงกดดันด้านหน่วยความจำ (สังเกต SwapPss ที่สูง)
** MEMINFO in pid 4562 [com.android.memorylab] **
Pss Private Private SwapPss Rss Heap Heap Heap
Total Dirty Clean Dirty Total Size Alloc Free
------ ------ ------ ------ ------ ------ ------ ------
Native Heap 394 268 64 17440 4264 29416 18128 8040
Dalvik Heap 165 8 0 672 8196 40949 32757 8192
Dalvik Other 47 28 0 604 1132
Stack 112 108 4 312 120
...
TOTAL 33197 580 788 21920 167776 70365 50885 16232
App Summary
Pss(KB) Rss(KB)
------ ------
Java Heap: 12 32608
Native Heap: 268 4264
Code: 724 125672
Stack: 108 120
Graphics: 0 0
Private Other: 256
System: 31829
Unknown: 5112
TOTAL PSS: 33197 TOTAL RSS: 167776 TOTAL SWAP PSS: 21920
Objects
Views: 15 ViewRootImpl: 1
AppContexts: 5 Activities: 1
...
การตีความข้อมูล
- Pss Total: ขนาดชุดตามสัดส่วน ค่านี้คือผลรวมของ
Private Dirty + Private Clean+ ส่วนแบ่งหน่วยความจำที่เท่ากันของกระบวนการซึ่งแชร์กับกระบวนการอื่นๆ (เช่น อิมเมจบูต Zygote) เมตริกนี้เป็นเมตริกที่ดีที่สุดสำหรับ "แอปนี้ใช้หน่วยความจำเท่าใด" - Private Dirty: RAM ที่มีเพียงกระบวนการของคุณเท่านั้นที่ใช้และมีการแก้ไข (หรือเป็นหน่วยความจำที่ไม่ระบุชื่อ) นี่คือตัวเลขที่สำคัญที่สุดสำหรับการค้นหาการรั่วไหลเนื่องจากไม่สามารถลดหน่วยความจำนี้ได้
- Private Clean: RAM ที่มีเพียงกระบวนการของคุณเท่านั้นที่ใช้ แต่เป็นสำเนาที่ไม่มีการแก้ไขของไฟล์ในพื้นที่เก็บข้อมูล (เช่น ไฟล์ DEX) ระบบปฏิบัติการอาจยกเลิกได้หากหน่วยความจำเหลือน้อย
SwapPss: หน่วยความจำที่บีบอัดและสลับเป็น ZRAM ซึ่งอาจเกิดขึ้นเนื่องจากระบบมีหน่วยความจำไม่เพียงพอหรือเนื่องจาก Android Runtime ได้ระบุกระบวนการเบื้องหลังที่จะบีบอัด (ย้ายหน้าเว็บที่ไม่ได้ใช้หรือไม่ทำงานไปยัง ZRAM) ในตัวอย่าง
dumpsysNative HeapและDalvik Heapเกือบทั้งหมดถูกย้ายไปยัง ZRAMประเด็นสำคัญ: ค่า Java Heap และ Native Heap ในส่วน "สรุปแอป" แสดงถึงหน่วยความจำประจำ (ทางกายภาพ) หากหน่วยความจำของแอปพลิเคชันถูกบีบอัดเป็น ZRAM ค่าสรุปที่เฉพาะเจาะจงเหล่านี้อาจปรากฏต่ำกว่าที่คาดไว้มาก โปรดตรวจสอบคอลัมน์ TOTAL SWAP PSS หรือคอลัมน์
SwapPssโดยละเอียดเสมอเพื่อให้เห็นภาพรวมทั้งหมดสรุปแอป: การจัดหมวดหมู่ระดับสูงขึ้นซึ่งรวมแถวรายละเอียดไว้ในที่เก็บข้อมูลที่เข้าใจได้
ออบเจ็กต์: มีประโยชน์สำหรับการติดตามอินสแตนซ์
ActivitiesและViewRootImplที่รั่วไหล หากคุณออกจากแอปและบังคับให้ GC ทำงาน จำนวนActivitiesควรกลับไปเป็น 0
ส่วนงบประมาณหน่วยความจำ
ใน Android 18 ขึ้นไป dumpsys meminfo จะพิมพ์ส่วนงบประมาณหน่วยความจำด้วยเมื่อดัมพ์แอปเดียว ส่วนนี้จะอ่านสถิติ memcg ของกระบวนการและของทั้งแอป (แพ็กเกจ) คุณจึงไม่ต้องค้นหาไฟล์ cgroup ด้วยตนเอง ต่อไปนี้เป็นส่วนจากแอปตัวอย่าง MemoryLab ในเบื้องหน้า หลังจากแตะจัดสรรหน่วยความจำ Java (10 MB) 3 ครั้ง
Memory Budget
Process(KB) Package(KB)
----------- -----------
Current Usage: 83820 87976
Limit: none 4718592
Limit Source: none MemoryLimiter
Peak Usage: 85136 89292
Swap Used: 0 0
Usage Breakdown
Anonymous: 81700 81700
File: 96 4200
File Mapped: 16 616
Shared Memory: 16 16
Kernel: 1580 1632
Page Tables: 640 640
Slab: 439 458
Pressure & Reclaim
Throttle Events: 0 0
Refaults (Anon): 0 0
Refaults (File): 0 0
- การใช้งานปัจจุบัน: หน่วยความจำที่เรียกเก็บไปยัง memcg (
memory.current) ซึ่งเป็นจำนวนที่จำกัดโดยงบประมาณหน่วยความจำ ในตัวอย่างนี้ ค่าเพิ่มขึ้นประมาณ 36,700 KB หลังจากการจัดสรร Java ขนาด 10 MB 3 ครั้ง ซึ่งสอดคล้องกับ TOTAL PSS ผลรวมของแพ็กเกจจะสูงกว่าผลรวมของกระบวนการ แม้แต่สำหรับแอปที่มีกระบวนการเดียว เมื่อหน้าไฟล์ที่แคชไว้จากการเรียกใช้ก่อนหน้านี้ยังไม่ได้รับการเรียกคืน - ขีดจำกัด: เกณฑ์การเรียกคืน (
memory.high) ที่มีผลในขณะนี้ หรือnoneหากไม่มี ในตัวอย่าง แพ็กเกจมีขีดจำกัดหน่วยความจำของระบบ และกระบวนการไม่มีขีดจำกัดของตัวเอง - แหล่งที่มาของขีดจำกัด: แหล่งที่มาของขีดจำกัด
AndroidManifestคือ<memory-budget>ที่ประกาศไว้ในไฟล์ Manifest ของแอปMemoryBudgetManagerคือบัดเจ็ตที่แอปตั้งค่าไว้ที่รันไทม์MemoryLimiterคือขีดจำกัดหน่วยความจำของระบบ และam memory-limiterคือการลบล้างด้วยตนเองที่ตั้งค่าไว้ด้วยadb - การใช้งานสูงสุด: การเรียกเก็บเงินสูงสุดนับตั้งแต่สร้าง memcg (
memory.peak) ซึ่งจะแสดงN/Aในเคอร์เนลที่ไม่รองรับ - Swap ที่ใช้: หน่วยความจำที่บีบอัดเป็น ZRAM (
memory.swap.current) - รายละเอียดการใช้งาน: ช่องหลักของ
memory.statเช่น หน่วยความจำแบบไม่ระบุตัวตนและหน่วยความจำที่สำรองข้อมูลไฟล์ - ความดันและการเรียกคืน: เหตุการณ์การจำกัดปริมาณจะนับจำนวนครั้งที่ memcg เกินขีดจำกัด
memory.highRefaults จะนับหน้าเว็บที่ถูกสลับออกหรือถูกนำออก แล้วจำเป็นต้องใช้หน้าเว็บนั้นอีกครั้ง หากตัวเลขเหล่านี้เพิ่มขึ้นขณะที่คุณใช้แอป แสดงว่าขีดจำกัดนั้นเข้มงวดกว่าชุดการทำงานของแอป
เมื่อใช้แฟล็ก -a หรือ -v ส่วนนี้จะแสดงตัวนับข้อมูลดิบทั้งหมดจาก memory.stat และ memory.events ด้วย
แบบฝึกหัด: การคัดแยกอย่างรวดเร็วด้วย meminfo
แบบฝึกหัดนี้แสดงให้เห็นว่าการจัดสรรประเภทต่างๆ ปรากฏใน meminfo อย่างไร
เปิดแอป:
adb shell am start -W -n com.android.memorylab/.MainActivityตรวจสอบหน่วยความจำพื้นฐาน
adb shell dumpsys meminfo -s com.android.memorylab(แฟล็ก
-sจะแสดงข้อมูลสรุปสั้นๆ ที่กระชับเกี่ยวกับหมวดหมู่หน่วยความจำ)จัดสรรหน่วยความจำ Java: แตะปุ่มจัดสรรหน่วยความจำ Java (10 MB) 3 ครั้งในแอป
สังเกตการเปลี่ยนแปลง: เรียกใช้
meminfo -sอีกครั้ง คุณควรเห็นค่า Java Heap เพิ่มขึ้นประมาณ 30,000 KB (30 MB)จัดสรรหน่วยความจำเนทีฟ: แตะปุ่มจัดสรรหน่วยความจำเนทีฟ (1 GB แบบบีบอัดไม่ได้) 1 ครั้ง
สังเกตการเปลี่ยนแปลง: เรียกใช้
meminfo -sอีกครั้ง ตอนนี้ค่า Native Heap ควรแสดงค่าที่เพิ่มขึ้นอย่างมาก (~1,000,000 KB)เปรียบเทียบกับ memcg (Android 18 ขึ้นไป): ดูส่วนงบประมาณหน่วยความจำที่ท้ายเอาต์พุต
meminfo -sการใช้งานปัจจุบันจะเพิ่มขึ้นพร้อมกับ TOTAL PSS หลังจากการจัดสรรแต่ละครั้ง เนื่องจากทั้งการจัดสรร Java และการจัดสรรแบบเนทีฟจะเรียกเก็บเงินจาก memcg ของแอป
มุมมองทั่วโลก
หากต้องการดูการใช้งานหน่วยความจำทั่วทั้งระบบ ให้เรียกใช้คำสั่งต่อไปนี้
adb shell dumpsys meminfo
ซึ่งจะแสดงข้อมูลสรุปการใช้งาน RAM รวมถึง RAM ทั้งหมด, RAM ที่ว่าง และรายการกระบวนการที่จัดเรียงตาม PSS
เมตริกหลักของระบบ
- ZRAM: สว็อปที่บีบอัดใน RAM
- DMA-BUF: บัฟเฟอร์หน่วยความจำกราฟิกและหน่วยความจำที่ใช้ร่วมกัน Android เวอร์ชันใหม่ๆ ใช้ DMA-BUF อย่างกว้างขวางสำหรับการแสดงผล UI หากยอดรวม
DMA-BUFสูงมาก ให้ตรวจสอบกระบวนการที่ใช้กราฟิกมากโดยใช้/sys/kernel/debug/dma_buf/bufinfo - RAM ที่สูญหาย: หน่วยความจำที่เคอร์เนลหรือกระบวนการใดๆ ไม่ได้พิจารณา (เช่น พื้นที่ที่สงวนไว้สำหรับฮาร์ดแวร์)
สถิติ memcg
กระบวนการของแอปทุกกระบวนการมีกลุ่มควบคุมหน่วยความจำ (memcg) ของตัวเอง และเคอร์เนลจะเก็บยอดรวมของหน่วยความจำที่เรียกเก็บจากกลุ่มควบคุมหน่วยความจำนั้น (ดูวิธีที่การบันทึกการใช้งานนี้แตกต่างจาก RSS และ PSS ได้ที่ memcg) การอ่านไฟล์เหล่านี้ใช้ทรัพยากรน้อยและไม่รบกวนแอป คุณจึงสุ่มตัวอย่างไฟล์เหล่านี้ได้ทุกวินาทีขณะเรียกใช้โฟลว์ผู้ใช้
ค้นหาเส้นทาง memcg ของกระบวนการจากบรรทัด 0:: ของ /proc/<PID>/cgroup แทนที่จะฮาร์ดโค้ดเส้นทาง ส่งคำสั่งอุปกรณ์แต่ละรายการไปยัง adb shell เป็นสตริงที่อยู่ในเครื่องหมายคำพูดเดี่ยวเพื่อให้เชลล์ของอุปกรณ์เห็นเครื่องหมายคำพูด ดังนี้
PID=$(adb shell pidof -s <package_name>)
CG=/sys/fs/cgroup$(adb shell "sed -n 's/^0:://p' /proc/$PID/cgroup")
adb shell "cat $CG/memory.current $CG/memory.swap.current"
adb shell "grep -E '^(anon|file|workingset_refault_.*) ' $CG/memory.stat"
ไฟล์คีย์มีดังนี้
memory.current: หน่วยความจำที่ใช้ไปกับกระบวนการ (หน่วยเป็นไบต์) ซึ่งเป็นจำนวนที่งบประมาณหน่วยความจำจำกัดไว้memory.swap.current: หน่วยความจำที่บีบอัดเป็น ZRAM (หน่วยเป็นไบต์)memory.stat: รายละเอียดการเรียกเก็บเงินในหน่วยไบต์สำหรับขนาดanonคือหน่วยความจำที่ไม่ระบุชื่อ เช่น Java และฮีปเนทีฟfileคือแคชของหน้าเว็บที่สำรองข้อมูลไว้ในไฟล์ เช่น โค้ดและทรัพยากรworkingset_refault_anonและworkingset_refault_fileจะนับหน้าเว็บที่ถูกสลับออกหรือถูกขับออก แล้วจำเป็นต้องใช้อีกครั้ง จำนวนการเกิดข้อผิดพลาดซ้ำที่เพิ่มขึ้นหมายความว่ากระบวนการมีหน่วยความจำไม่เพียงพอmemory.events: จำนวนเหตุการณ์ที่ถึงขีดจำกัดหน่วยความจำhighจะนับจำนวนครั้งที่กระบวนการถูกจำกัดเนื่องจากเกินขีดจำกัดmemory.high
ไดเรกทอรีระดับบนของ memcg ของกระบวนการเป็นของทั้งแอป (UID ของแอป) ไฟล์ของแอปประกอบด้วยหน่วยความจำของกระบวนการทำงานทั้งหมดของแอป รวมถึงหน้าไฟล์ที่แคชไว้ซึ่งเหลือจากกระบวนการก่อนหน้าของแอปที่ออกไปแล้วและยังไม่ได้เรียกคืน ดังนี้
adb shell "cat $CG/../memory.current"
แอปสามารถค้นหาการใช้งาน cgroup ของตนเองในกระบวนการผ่าน MemoryBudgetManager ได้ หากคุณได้รับข้อผิดพลาดเกี่ยวกับสิทธิ์เมื่อตรวจสอบไฟล์ cgroup ของแอปจาก adb shell ให้เรียกใช้ adb root ในบิลด์ userdebug หรืออิมเมจโปรแกรมจำลองที่ไม่มี Google Play แล้วลองอีกครั้ง
ดูคำแนะนำแบบทีละขั้นตอนเกี่ยวกับไฟล์เหล่านี้ด้วยแอปตัวอย่าง MemoryLab ได้ที่แบบฝึกหัดภาคปฏิบัติ: สำรวจ memcg
showmap
หากต้องการดูรายละเอียดการแมปหน่วยความจำของกระบวนการอย่างละเอียดยิ่งขึ้น ให้ใช้ showmap เครื่องมือนี้จะอ่านจาก /proc/<pid>/smaps
adb shell showmap <pid>
showmap แสดงรายการแผนผังหน่วยความจำทุกรายการในกระบวนการ การแมปคีย์ที่ควรมองหา ได้แก่
[anon:scudo:primary]หรือ[anon:libc_malloc]: ฮีปแบบเนทีฟ Android เวอร์ชันใหม่ๆ จะใช้ตัวจัดสรร Scudo*.art: รูปภาพฮีปของ Java (เช่น อิมเมจบูต)[anon:dalvik-main space]: ฮีป Java หลัก*.so: คลังที่ใช้ร่วมกัน*.{oat,dex,odex,vdex}: โค้ด DEX ที่คอมไพล์แล้ว
คุณสามารถจัดเรียงเอาต์พุตเพื่อค้นหาผู้ใช้หน่วยความจำส่วนตัวที่ใหญ่ที่สุดได้โดยทำดังนี้
# Sort by private clean + private dirty memory
adb shell showmap <pid> | awk '{print $6+$7, $0}' | sort -rn | head -n 10
ตัวอย่างเอาต์พุต
virtual shared shared private private Anon Shmem File Shared Private
size RSS PSS clean dirty clean dirty swap swapPSS HugePages PmdMapped PmdMapped Hugetlb Hugetlb Locked # object
-------- -------- -------- -------- -------- -------- -------- -------- -------- --------- --------- --------- -------- -------- -------- ---- ------------------------------
2776 18176 5784 2823 0 3008 308 2468 4700 4700 0 0 0 0 0 0 47 [anon:scudo:primary]
560 952 876 657 316 0 560 0 12 12 0 0 0 0 0 0 8 /data/app/.../base.apk
448 393216 448 448 0 0 0 448 0 0 0 0 0 0 0 0 2 [anon:dalvik-main space]
...
แบบฝึกหัด: ข้อมูลเจาะลึกด้วย showmap
ดูวิธีระบุการแมปหน่วยความจำที่เฉพาะเจาะจงและแยกความแตกต่างระหว่างหน่วยความจำที่สะอาดและสกปรก
- Mmap Clean Memory: แตะปุ่ม Mmap Clean Anon Memory (10MB) ในแอป MemoryLab 1 ครั้ง
ดูรหัสกระบวนการ: UI ของแอปจะแสดง PID หรือจะค้นหาด้วยคำสั่งนี้ก็ได้
adb shell pidof com.android.memorylabตรวจสอบด้วย showmap:
# Replace <PID> with the actual process ID from the previous step adb shell showmap <PID> | grep "memorylab-clean"ระบุการแมป: คุณควรเห็นการแมปที่ไม่ระบุชื่อซึ่งมีป้ายกำกับว่า
[anon:memorylab-clean]โดยมีขนาดเสมือนเท่ากับ 10240 KB พอดี โปรดทราบว่าค่า private dirty สำหรับแผนที่นี้มีแนวโน้มที่จะเป็น 0 นี่คือหน่วยความจำแบบไม่ระบุชื่อที่ "สะอาด" เนื่องจากเราใช้mmapเพื่อสำรองพื้นที่เสมือน แต่ยังไม่ได้เขียนลงในหน่วยความจำ (จึงไม่มีการใช้ RAM จริง)การเปรียบเทียบฮีปแบบเนทีฟ: เปรียบเทียบกับ
[anon:scudo:primary]การแมปซึ่งจะปรากฏในshowmapหากคุณเรียกใช้หลังจากขั้นตอนที่ 5 ของแบบฝึกหัดmeminfoเนื่องจากการจัดสรรแบบเนทีฟขนาด 1 GB นั้นเขียนลงในทุกหน้าจริงๆ หน้าเหล่านั้นจึงเป็นหน้า "สกปรก" และจะแสดงอย่างชัดเจนในคอลัมน์ private dirtyเคล็ดลับมือโปร (ออบเจ็กต์ขนาดใหญ่): สังเกตการจัดสรรฮีป Java จากแบบฝึกหัด
meminfoเนื่องจากเป็นอาร์เรย์ไบต์ขนาด 10 MB จึงมีแนวโน้มที่จะปรากฏในshowmapเป็น[anon:dalvik-free list large object space]Android Runtime (ART) จะวางออบเจ็กต์ที่มีขนาดใหญ่กว่า 12 KB ไว้ใน Large Object Space (LOS) แยกต่างหากเพื่อหลีกเลี่ยงการกระจาย Fragment ในฮีปหลัก
procstats
แม้ว่า meminfo จะแสดงภาพรวม ณ เวลาหนึ่งๆ แต่ procstats จะแสดงข้อมูลย้อนหลังโดยการสุ่มตัวอย่างสถานะและการใช้หน่วยความจำของแอปพลิเคชันที่ทำงานอยู่ทั้งหมดเป็นระยะๆ เครื่องมือนี้เป็นเครื่องมือหลักที่ใช้ในการตรวจสอบประสิทธิภาพของหน่วยความจำในระยะยาว และเป็นสิ่งที่ขับเคลื่อนการรายงานการใช้งานหน่วยความจำในการตั้งค่า Android
# View stats for the last 3 hours
adb shell dumpsys procstats --hours 3
ทำความเข้าใจสถานะต่างๆ
ผลลัพธ์ของ procstats อาจมีจำนวนมากจนเกินไป ส่วนที่สำคัญที่สุดคือเมตริกในวงเล็บข้างสถานะกระบวนการแต่ละรายการ ดังนี้
Top: 100% (54MB-64MB-67MB / 49MB-58MB-61MB / 110MB-120MB-130MB over 4)
รูปแบบคือ (% เวลาในสถานะ) (minPss-avgPss-maxPss / minUss-avgUss-maxUss / minRss-avgRss-maxRss over samples)
- Pss (Proportional Set Size): หน่วยความจำที่ใช้ร่วมกันจะแบ่งตามสัดส่วนระหว่างกระบวนการต่างๆ
- Uss (Unique Set Size): หน่วยความจำที่ใช้โดยกระบวนการนี้เท่านั้น (เทียบเท่ากับ Private Clean + Private Dirty)
- Rss (Resident Set Size): หน่วยความจำกายภาพทั้งหมดที่ใช้ รวมถึงหน้าเว็บที่แชร์ทั้งหมด (มีแนวโน้มที่จะนับเกิน)
ความสำคัญ
- แอปที่เสถียร: ค่าต่ำสุด/ค่าเฉลี่ย/ค่าสูงสุดอยู่ใกล้กัน
- หน่วยความจำรั่วไหล: ค่าสูงสุดสูงกว่าค่าต่ำสุดอย่างมาก และค่าเฉลี่ยเพิ่มขึ้นเมื่อเวลาผ่านไปเมื่อจำนวนตัวอย่างเพิ่มขึ้น
- การใช้งานที่พุ่งสูงขึ้น: ค่าสูงสุดสูงกว่าค่าเฉลี่ยมาก ซึ่งบ่งชี้ถึงการดำเนินการที่หนักหน่วงชั่วคราว (เช่น การประมวลผลรูปภาพ) ที่อาจทำให้เกิด OOM หากเกิดขึ้นในเวลาที่ไม่เหมาะสม
สถานะกระบวนการ
procstats ติดตามแอปในสถานะต่างๆ (มักใช้ตัวย่อ) ดังนี้
- คงอยู่: กระบวนการที่สำคัญต่อระบบซึ่งทำงานอยู่เสมอ
- ด้านบน: ปัจจุบันแอปอยู่ในเบื้องหน้าและผู้ใช้มองเห็นได้
- ImpFg (Important Foreground): กระบวนการเบื้องหลังที่สำคัญ (เช่น IME) หรือแอปที่มีบริการที่ทำงานอยู่เบื้องหน้า
- ImpBg (กระบวนการเบื้องหลังที่สำคัญ): กระบวนการเบื้องหลังที่ถือว่าสำคัญต่อระบบ
- Fgs / BFgs: บริการที่ทำงานอยู่เบื้องหน้าหรือบริการที่ทำงานอยู่เบื้องหน้าที่เชื่อมโยง
- Service / ServRst: บริการที่ทำงานอยู่เบื้องหลังหรือบริการที่กำลังรีสตาร์ทอยู่
- แคช / LastAct: แอปที่แคชไว้ในเบื้องหลังเพื่อให้รีสตาร์ทได้อย่างรวดเร็ว ระบบสามารถปิดแอปเหล่านี้ได้อย่างปลอดภัย
สถานะหน่วยความจำของอุปกรณ์และสถิติรันไทม์
procstats ยังติดตามระยะเวลาที่อุปกรณ์ทั้งหมดใช้ภายใต้แรงกดดันด้านหน่วยความจำด้วย มองหาส่วนสถิติรันไทม์
Run time Stats:
SOff/Norm: +1h10m15s
SOn/Norm: +15m20s
Low: +2m10s
Crit: +45s
- SOff / SOn: หน้าจอปิดเทียบกับหน้าจอเปิด
- Norm / Mod / Low / Crit: ระดับแรงดันหน่วยความจำ (ปกติ, ปานกลาง, ต่ำ, วิกฤต)
หากอุปกรณ์ใช้เวลาส่วนใหญ่อยู่ในสถานะต่ำหรือวิกฤต อุปกรณ์จะทำงานช้าลงเนื่องจากเคอร์เนลจะเรียกคืนหน่วยความจำอย่างหนักหน่วง และ Low Memory Killer (LMK) จะเริ่มสิ้นสุดกระบวนการเบื้องหลัง จากนั้นคุณสามารถดูสถิติต่อแพ็กเกจเพื่อดูว่าแอปใดมีการใช้งานหน่วยความจำสูง โดยเฉพาะเมื่ออุปกรณ์อยู่ในสถานะที่มีภาระงานสูงเหล่านี้