เครื่องมือประเมินอย่างรวดเร็ว

เมื่อต้องการตรวจสอบการใช้งานหน่วยความจำ ให้เริ่มด้วยเครื่องมือประเมินระดับสูงเพื่อระบุว่าหน่วยความจำหมวดหมู่ใดมีความสำคัญมากที่สุด

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) ในตัวอย่าง dumpsys Native 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.high Refaults จะนับหน้าเว็บที่ถูกสลับออกหรือถูกนำออก แล้วจำเป็นต้องใช้หน้าเว็บนั้นอีกครั้ง หากตัวเลขเหล่านี้เพิ่มขึ้นขณะที่คุณใช้แอป แสดงว่าขีดจำกัดนั้นเข้มงวดกว่าชุดการทำงานของแอป

เมื่อใช้แฟล็ก -a หรือ -v ส่วนนี้จะแสดงตัวนับข้อมูลดิบทั้งหมดจาก memory.stat และ memory.events ด้วย

แบบฝึกหัด: การคัดแยกอย่างรวดเร็วด้วย meminfo

แบบฝึกหัดนี้แสดงให้เห็นว่าการจัดสรรประเภทต่างๆ ปรากฏใน meminfo อย่างไร

  1. เปิดแอป:

    adb shell am start -W -n com.android.memorylab/.MainActivity
    
  2. ตรวจสอบหน่วยความจำพื้นฐาน

    adb shell dumpsys meminfo -s com.android.memorylab
    

    (แฟล็ก -s จะแสดงข้อมูลสรุปสั้นๆ ที่กระชับเกี่ยวกับหมวดหมู่หน่วยความจำ)

  3. จัดสรรหน่วยความจำ Java: แตะปุ่มจัดสรรหน่วยความจำ Java (10 MB) 3 ครั้งในแอป

  4. สังเกตการเปลี่ยนแปลง: เรียกใช้ meminfo -s อีกครั้ง คุณควรเห็นค่า Java Heap เพิ่มขึ้นประมาณ 30,000 KB (30 MB)

  5. จัดสรรหน่วยความจำเนทีฟ: แตะปุ่มจัดสรรหน่วยความจำเนทีฟ (1 GB แบบบีบอัดไม่ได้) 1 ครั้ง

  6. สังเกตการเปลี่ยนแปลง: เรียกใช้ meminfo -s อีกครั้ง ตอนนี้ค่า Native Heap ควรแสดงค่าที่เพิ่มขึ้นอย่างมาก (~1,000,000 KB)

  7. เปรียบเทียบกับ 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

ดูวิธีระบุการแมปหน่วยความจำที่เฉพาะเจาะจงและแยกความแตกต่างระหว่างหน่วยความจำที่สะอาดและสกปรก

  1. Mmap Clean Memory: แตะปุ่ม Mmap Clean Anon Memory (10MB) ในแอป MemoryLab 1 ครั้ง
  2. ดูรหัสกระบวนการ: UI ของแอปจะแสดง PID หรือจะค้นหาด้วยคำสั่งนี้ก็ได้

    adb shell pidof com.android.memorylab
    
  3. ตรวจสอบด้วย showmap:

    # Replace <PID> with the actual process ID from the previous step
    adb shell showmap <PID> | grep "memorylab-clean"
    
  4. ระบุการแมป: คุณควรเห็นการแมปที่ไม่ระบุชื่อซึ่งมีป้ายกำกับว่า [anon:memorylab-clean] โดยมีขนาดเสมือนเท่ากับ 10240 KB พอดี โปรดทราบว่าค่า private dirty สำหรับแผนที่นี้มีแนวโน้มที่จะเป็น 0 นี่คือหน่วยความจำแบบไม่ระบุชื่อที่ "สะอาด" เนื่องจากเราใช้ mmap เพื่อสำรองพื้นที่เสมือน แต่ยังไม่ได้เขียนลงในหน่วยความจำ (จึงไม่มีการใช้ RAM จริง)

  5. การเปรียบเทียบฮีปแบบเนทีฟ: เปรียบเทียบกับ[anon:scudo:primary] การแมปซึ่งจะปรากฏใน showmap หากคุณเรียกใช้หลังจากขั้นตอนที่ 5 ของแบบฝึกหัด meminfo เนื่องจากการจัดสรรแบบเนทีฟขนาด 1 GB นั้นเขียนลงในทุกหน้าจริงๆ หน้าเหล่านั้นจึงเป็นหน้า "สกปรก" และจะแสดงอย่างชัดเจนในคอลัมน์ private dirty

  6. เคล็ดลับมือโปร (ออบเจ็กต์ขนาดใหญ่): สังเกตการจัดสรรฮีป 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) จะเริ่มสิ้นสุดกระบวนการเบื้องหลัง จากนั้นคุณสามารถดูสถิติต่อแพ็กเกจเพื่อดูว่าแอปใดมีการใช้งานหน่วยความจำสูง โดยเฉพาะเมื่ออุปกรณ์อยู่ในสถานะที่มีภาระงานสูงเหล่านี้


← แนวคิด | ↑ ขึ้น | Java →