• dumpsys meminfo 详解

    源码基于：Android R

    0. 前言

    其实，很久以前在 android 查看内存使用情况 一文中已经分析过dumpsys meminfo，但最近在统计内存数据的时候发现怎么也对不上，所以重新分析了下源码，之前在 android 查看内存使用情况 一文只是讲了个大概框架或含义。本篇博文会结合代码详细分析下AMS 下meminfo service 以及dump 的过程。

    1. meminfo 的起点dumpsys

    AMS 下的meminfo 统计是通过dumpsys 命令进行dump 的，这个是存放在 /system/bin/下的bin 文件。源码目录位于 frameworks/native/cmds/dumpsys/下，详细的请查看 android 中的dumpsys 一文。

    2. meminfo services -- MemBinder

    可以dump的这些service都是在ServiceManager里面添加上的，例如meminfo是在：frameworks/base/services/java/com/android/server/am/ActivityManagerService.java的函数setSystemProcess添加的：

    1. frameworks/base/services/core/java/com/android/server/am/AMS.java
    2.  
    3.  
    4. public void setSystemProcess() {
    5.         try {
    6.             ...
    7.  
    8.             ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
    9.                     DUMP_FLAG_PRIORITY_HIGH);
    10.  
    11.             ...
    12. }

     注意：

     通过 android 中的dumpsys 一文的step7，我们得知，如果某service(例如，meminfo) 需要通过dumpsys 命令进行dump 操作，必要将指定dump flag。这里meminfo 在addService 的时候指定了dump flag 为 DUMP_FLAG_PRIORITY_HIGH。

    下面来看下：

    1. frameworks/base/services/core/java/com/android/server/am/AMS.java
    2.  
    3.    static class MemBinder extends Binder {
    4.         ActivityManagerService mActivityManagerService;
    5.         private final PriorityDump.PriorityDumper mPriorityDumper =
    6.                 new PriorityDump.PriorityDumper() {
    7.             @Override
    8.             public void dumpHigh(FileDescriptor fd, PrintWriter pw, String[] args,
    9.                     boolean asProto) {
    10.                 dump(fd, pw, new String[] {"-a"}, asProto);
    11.             }
    12.  
    13.             @Override
    14.             public void dump(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
    15.                 mActivityManagerService.dumpApplicationMemoryUsage(
    16.                         fd, pw, "  ", args, false, null, asProto);
    17.             }
    18.         };
    19.  
    20.         MemBinder(ActivityManagerService activityManagerService) {
    21.             mActivityManagerService = activityManagerService;
    22.         }
    23.  
    24.         @Override
    25.         protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
    26.             try {
    27.                 mActivityManagerService.mOomAdjuster.mCachedAppOptimizer.enableFreezer(false);
    28.  
    29.                 if (!DumpUtils.checkDumpAndUsageStatsPermission(mActivityManagerService.mContext,
    30.                         "meminfo", pw)) return;
    31.                 PriorityDump.dump(mPriorityDumper, fd, pw, args);
    32.             } finally {
    33.                 mActivityManagerService.mOomAdjuster.mCachedAppOptimizer.enableFreezer(true);
    34.             }
    35.         }
    36.     }

    里面定义了两个成员变量：

    • mActivityManagerService：记录AMS 对象；
    • mPriorityDumper：通过其dump() 接口，连接AMS.dumpApplicationMemoryUsage()；

    真正实现的地方是在AMS 的dumpApplicationMemoryUsage() 中。

    3. dumpsys meminfo -h

    进入dumpApplicationMemoryUsage() 之后，会看到一个while 循环用来分析dumpsys meminfo 附带的参数，这里首先来看下 -h，通过此参数进一步了解 dumpsys meminfo 的其他参数选项。

    代码这里就不贴了，直接来看下终端的输出：

    1. meminfo dump options: [-a] [-d] [-c] [-s] [--oom] [process]
    2.   -a: include all available information for each process.
    3.   -d: include dalvik details.
    4.   -c: dump in a compact machine-parseable representation.
    5.   -s: dump only summary of application memory usage.
    6.   -S: dump also SwapPss.
    7.   --oom: only show processes organized by oom adj.
    8.   --local: only collect details locally, don't call process.
    9.   --package: interpret process arg as package, dumping all
    10.              processes that have loaded that package.
    11.   --checkin: dump data for a checkin
    12.   --proto: dump data to proto
    13. If [process] is specified it can be the name or
    14. pid of a specific process to dump.
    • -a：包含所有可用信息，更确切它包含了-d、-s、-S；
    • -d：需要包含dalvik 详细信息；
    • -c：dump 成一个压缩的机器解析的表达形式；
    • -s：只dump 应用内存的概要；
    • -S：将swap pss 信息也dump 出来；
    • --oom：只dump RSS/PSS 的OOM adj 信息；
    • --local：只在本地收集信息，只有在-a 或 -s 指定的时候才生效；
    • --package：dump 所有加载指定package 的进程；
    • --checkin：将数据dump 下来checkin；
    • --proto：dump proto的数据；
    • dumpsys meminfo 可以跟 [process]，此process 可以是进程名，也可以是进程pid；

    4. collectProcesses()

    当dumpsys meminfo 的命令行参数解析完之后，会调用collectProcesses() 来确认符合命令的packages 或pid：

    1. frameworks/base/services/core/java/com/android/server/am/ProcessList.java
    2.  
    3.    ArrayList collectProcessesLocked(int start, boolean allPkgs, String[] args) {
    4.         ArrayList procs;
    5.         if (args != null && args.length > start
    6.                 && args[start].charAt(0) != '-') {
    7.             procs = new ArrayList();
    8.             int pid = -1;
    9.             try {
    10.                 pid = Integer.parseInt(args[start]);
    11.             } catch (NumberFormatException e) {
    12.             }
    13.             for (int i = mLruProcesses.size() - 1; i >= 0; i--) {
    14.                 ProcessRecord proc = mLruProcesses.get(i);
    15.                 if (proc.pid > 0 && proc.pid == pid) {
    16.                     procs.add(proc);
    17.                 } else if (allPkgs && proc.pkgList != null
    18.                         && proc.pkgList.containsKey(args[start])) {
    19.                     procs.add(proc);
    20.                 } else if (proc.processName.equals(args[start])) {
    21.                     procs.add(proc);
    22.                 }
    23.             }
    24.             if (procs.size() <= 0) {
    25.                 return null;
    26.             }
    27.         } else {
    28.             procs = new ArrayList(mLruProcesses);
    29.         }
    30.         return procs;
    31.     }

    代码还是比较清晰的：

    • 如果命令行指定了pid，那么就收集这些进程；
    • 如果设定了packageName，就收集这些package；
    • 如果没有设定，则收集所有的 LRU process；

    注意，前两点有可能收集的 proc 为空，因为设定的参数有可能是假的或者无法匹配。

    这个时候终端上还提示No process：

    shift:/ # dumpsys meminfo 12345
    No process found for: 12345

    5. dumpApplicationMemoryUsage()

    这个函数的代码量太大，这里抽重点的地方剖析下。

    5.1 几个变量thread、pid、oomadj、mi

    1. frameworks/base/services/core/java/com/android/server/am/AMS.java
    2.  
    3.     private final void dumpApplicationMemoryUsage() {
    4.  
    5.         ...
    6.  
    7.         for (int i = numProcs - 1; i >= 0; i--) {
    8.             final ProcessRecord r = procs.get(i);
    9.             final IApplicationThread thread;
    10.             final int pid;
    11.             final int oomAdj;
    12.             final boolean hasActivities;
    13.             synchronized (this) {
    14.                 thread = r.thread;
    15.                 pid = r.pid;
    16.                 oomAdj = r.getSetAdjWithServices();
    17.                 hasActivities = r.hasActivities();
    18.             }
    19.             if (thread != null) {
    20.                 if (mi == null) {
    21.                     mi = new Debug.MemoryInfo();
    22.                 }

    在最开始的时候需要注意几个重点的初始化：

    • thread：指定IApplicationThread，当 --local 没有设定时（大部分不会设定），需要通过该thread  读取应用端数据，并通过pipe 方式传递给AMS。
    • oomAdj：dumpsys meminfo 中重要的一组数据，针对LMKD，详细查看 adj score的算法剖析 一文；
    • pid：当前应用的pid，dumpsys meminfo 的时候会伴随显示；
    • mi：内存数据的核心，下面会详细讲解这个变量，详细见第 5.2 节；

    5.2 Debug.MemoryInfo()

    源码目录：frameworks/base/core/java/android/os/Debug.java

    这里提供了很多的native 接口：

    1.     public static native long getNativeHeapSize();
    2.     public static native long getNativeHeapAllocatedSize();
    3.     public static native long getNativeHeapFreeSize();
    4.     public static native void getMemoryInfo(MemoryInfo memoryInfo);
    5.     public static native boolean getMemoryInfo(int pid, MemoryInfo memoryInfo);
    6.     public static native long getPss();
    7.     public static native long getPss(int pid, long[] outUssSwapPssRss, long[] outMemtrack);

    5.3 Debug.getMemoryInfo()

    接着第 5.1 节的代码继续往下看：

    1.                 if (opts.dumpDetails || (!brief && !opts.oomOnly)) {
    2.                     reportType = ProcessStats.ADD_PSS_EXTERNAL_SLOW;
    3.                     startTime = SystemClock.currentThreadTimeMillis();
    4.                     if (!Debug.getMemoryInfo(pid, mi)) {
    5.                         continue;
    6.                     }
    7.                     endTime = SystemClock.currentThreadTimeMillis();
    8.                     hasSwapPss = mi.hasSwappedOutPss;
    9.                 } else {
    10.                     reportType = ProcessStats.ADD_PSS_EXTERNAL;
    11.                     startTime = SystemClock.currentThreadTimeMillis();
    12.                     long pss = Debug.getPss(pid, tmpLong, null);
    13.                     if (pss == 0) {
    14.                         continue;
    15.                     }
    16.                     mi.dalvikPss = (int) pss;
    17.                     endTime = SystemClock.currentThreadTimeMillis();
    18.                     mi.dalvikPrivateDirty = (int) tmpLong[0];
    19.                     mi.dalvikRss = (int) tmpLong[2];
    20.                 }
    • opts.dumpDetails 主要用以获取应用的详细信息。一般在指定pid 或者 package的时候，或者直接指定命令参数 -s 的时候该变量被置为 true；
    • brief 默认值为false，从MemBinder 传递过来；
    • opts.oomOnly 只有在 --oom 指定时被置为 true；

    在没有指定 --oom 时，代码都是会走 if 的case，会通过Debug.getMemoryInfo() 获取进程的详细内存信息：

    1. frameworks/base/core/jni/android_os_Debug.cpp
    2.  
    3. static jboolean android_os_Debug_getDirtyPagesPid(JNIEnv *env, jobject clazz,
    4.         jint pid, jobject object)
    5. {
    6.     bool foundSwapPss;
    7.     stats_t stats[_NUM_HEAP];
    8.     memset(&stats, 0, sizeof(stats));
    9.  
    10.     if (!load_maps(pid, stats, &foundSwapPss)) {
    11.         return JNI_FALSE;
    12.     }
    13.  
    14.     struct graphics_memory_pss graphics_mem;
    15.     if (read_memtrack_memory(pid, &graphics_mem) == 0) {
    16.         stats[HEAP_GRAPHICS].pss = graphics_mem.graphics;
    17.         ...
    18.     }
    19.  
    20.     for (int i=_NUM_CORE_HEAP; i<_NUM_EXCLUSIVE_HEAP; i++) {
    21.         stats[HEAP_UNKNOWN].pss += stats[i].pss;
    22.         ...
    23.     }
    24.  
    25.     for (int i=0; i<_NUM_CORE_HEAP; i++) {
    26.         env->SetIntField(object, stat_fields[i].pss_field, stats[i].pss);
    27.         ...
    28.     }
    29.  
    30.     env->SetBooleanField(object, hasSwappedOutPss_field, foundSwapPss);
    31.  
    32.     ...
    33.  
    34.     for (int i=_NUM_CORE_HEAP; i<_NUM_HEAP; i++) {
    35.         ...
    36.     }
    37.  
    38.     env->ReleasePrimitiveArrayCritical(otherIntArray, otherArray, 0);
    39.     return JNI_TRUE;
    40. }
    • 通过 load_maps() 从 /proc/pid/smaps 中获取进程的内存信息；
    • 通过read_memtrack_memory() 通过libmemtrack.so 获取 graphics 的内存信息；
    • 通过 env->SetIntField() 将 UNKNOWN、dalvik、heap 所属组的信息设置到 Meminfo 中；
    • 通过otherArray 将其他信息设置到 MemoryInfo.otherStats[] 中；

    5.3.1 load_maps()

    1. static bool load_maps(int pid, stats_t* stats, bool* foundSwapPss)
    2. {
    3.     *foundSwapPss = false;
    4.     uint64_t prev_end = 0;
    5.     int prev_heap = HEAP_UNKNOWN;
    6.  
    7.     std::string smaps_path = base::StringPrintf("/proc/%d/smaps", pid);
    8.     auto vma_scan = [&](const meminfo::Vma& vma) {
    9.         ...
    10.     };
    11.  
    12.     return meminfo::ForEachVmaFromFile(smaps_path, vma_scan);
    13. }

    meminfo::ForEachVmaFromFile() 是 libmeminfo.so 接口，代码位于 /system/memory/libmeminfo/下。

    这里总结一个调用框架图：

    主要是读取进程 smaps 节点，根据属性的不同，进程的虚拟地址空间会被划分成若干个 VMA，每个VMA 通过vm_next 和vm_prev 组成双向链表，链表位于进程的 task_struct->mm_struct->mmap 中。当通过proc接口读取进程的smaps文件时，内核会首先找到该进程的vma链表头，遍历链表中的每一个vma， 通过walk_page_vma统计这块vma的使用情况，最后显示出来。

    下面是其中一块 VMA 的统计信息：

    • Rss：常驻物理内存，是进程在RAM 中实际持有的物理内存。Rss 中包含了共享库占用的内存，所以可能产生误导；
    • Pss：比例使用的物理内存，Pss 与Rss 区别是Pss 统计了共享库是平均占用内存。若一个so 占用内存30kb，这个so 被3 个进程共享，那么某一个进程Pss 统计时该so 占用的内存为 30/3 kb；
    • Private_Dirty：私有的内存数据，只不过是Dirty的，与Private_Clean 相反。Dirty 包括了page_dirty 和pte_dirty，page_dirty 就是所说的脏页(文件读到内存中被修改过，就会标记为脏页)。pte_dirty 则当 vma 用以anonymous 的时候，读写这段 vma 触发page fault 时调用do_anonymous_page，如果vma_flags 中包含 VM_WRITE，则会通过pte_mkdirty(entry) 标记；
    • Private_Clean：私有干净数据，与Private_Dirty 相反；
    • Shared_Dirty：同Private_Dirty，该内存至少有一个其他进程在引用，而且至少有一个进程在修改；
    • Shared_Clean：同Private_Clean，与Shared_Dirty 相反；
    • Swap：被交换的native 页，可称为SwapRss；
    • SwapPss：被交换的native 页，按照比例统计；

    一般情况下，在Android 中就是ZRAM，通过压缩内存页面并将其放入动态分配的内存交换区来增加系统中的可用内存量，压缩的都是匿名页。

    但下面这段vma 是文件映射的，但还有swap字段的,这是因为这个文件是通过mmap到进程地址空间的。当标记中有MAP_PRIVATE时，这表示是一个copy-on-write的映射，虽然是file-backed，但当向这个数据写入数据的时候，会把数据拷贝到匿名页里，所以看到上面的 Anonymous: 也不为0。

    5.3.2 smaps 中vma 与 HEAP 枚举对照

    [heap]

    [anon:libc_malloc]

    [anon:scudo:

    [anon:GWP-ASan

    		HEAP_NATIVE

    [anon:dalvik-*

    		HEAP_DALVIK_OTHER
    *.soHEAP_SO
    *.jarHEAP_JAR
    *.apkHEAP_APK
    *.ttfHEAP_TTF

    *.odex (*.dex)

    HEAP_DEX

    ----HEAP_DEX_APP_DEX

    *.vdex (@boot /boot  /apex)

    HEAP_DEX

    ----HEAP_DEX_BOOT_VDEX

    ----HEAP_DEX_APP_VDEX

    *.oatHEAP_OAT

    *.art

    *.art]  (@boot /boot  /apex)

    HEAP_ART

    ----HEAP_ART_BOOT

    ----HEAP_ART_APP

    /dev/HEAP_UNKNOWN_DEV
    /dev/kgsl-3d0HEAP_GL_DEV
    /dev/ashmem/CursorWindowHEAP_CURSOR

    /dev/ashmem/jit-zygote-cache

    /memfd:jit-cache

    /memfd:jit-zygote-cache

    		HEAP_DALVIK_OTHER
    /dev/ashmemHEAP_ASHMEM

    详细的which_heap 和sub_heap 看load_maps() 函数。

    5.3.3 read_memtrack_memory()

    通过本函数，获取进程在GPU 上的分配内存。

    下面是调用框架图：

     上图读取进程在GPU上分配的内存，每个厂商统计的策略可能不一样,这也是出现HAL层的原因。


    5.4 thread.dumpMemInfo()

    在第 5.1 节中列举了几个重要的变量，其中一个就是 IApplicationThread，每个进程独有。

    当然这个case 是当 opts.dumpDetails 为true，也就是针对单个应用的meminfo；

    1.        try {
    2.             TransferPipe tp = new TransferPipe();
    3.             try {
    4.                 thread.dumpMemInfo(tp.getWriteFd(),
    5.                         mi, opts.isCheckinRequest, opts.dumpFullDetails,
    6.                         opts.dumpDalvik, opts.dumpSummaryOnly, opts.dumpUnreachable, innerArgs);
    7.                 tp.go(fd, opts.dumpUnreachable ? 30000 : 5000);
    8.             } finally {
    9.                 tp.kill();
    10.             }

    创建TransferPipe 对象，里面会创建一个thread 和 一个pipe。然后将writeFd 给app 进程的ActivithThread，在ActivityThread 将解析app 进程的内存使用。当调用go() 函数时会启动TransferPipe 创建的thread，并等待pipe 通信，如果AMS 通过 readFd 获取到数据后，会通知 dumpsys 进程表示dump 完成。

    下面来看下dumpMemInfo()：

     ---->

    1. frameworks/base/core/java/android/app/ActivityThread.java
    2.  
    3.         public void dumpMemInfo(ParcelFileDescriptor pfd, Debug.MemoryInfo mem, boolean checkin,
    4.                 boolean dumpFullInfo, boolean dumpDalvik, boolean dumpSummaryOnly,
    5.                 boolean dumpUnreachable, String[] args) {
    6.             FileOutputStream fout = new FileOutputStream(pfd.getFileDescriptor());
    7.             PrintWriter pw = new FastPrintWriter(fout);
    8.             try {
    9.                 dumpMemInfo(pw, mem, checkin, dumpFullInfo, dumpDalvik, dumpSummaryOnly, dumpUnreachable);
    10.             } finally {
    11.                 pw.flush();
    12.                 IoUtils.closeQuietly(pfd);
    13.             }
    14.         }

    详细的代码这里不继续分析了，总结一个调用框架图：

    dumpMeminfo() 中会通过getRuntime() 获取app 进程dalvik 的totalMemory 和freeMemory，并计算出 dalvikAllocated，得到app 进程虚拟机内存使用情况。

    并且通过Debug.getNativeHeapSize() 等三个native 接口统计app 进程的native 使用。这里同上面第 5.3 节，依然会进入androi_os_Debug.cpp 中：

    1. frameworks/base/core/jni/android_os_Debug.cpp
    2.  
    3. static jlong android_os_Debug_getNativeHeapSize(JNIEnv *env, jobject clazz)
    4. {
    5.     struct mallinfo info = mallinfo();
    6.     return (jlong) info.usmblks;
    7. }
    8.  
    9. static jlong android_os_Debug_getNativeHeapAllocatedSize(JNIEnv *env, jobject clazz)
    10. {
    11.     struct mallinfo info = mallinfo();
    12.     return (jlong) info.uordblks;
    13. }
    14.  
    15. static jlong android_os_Debug_getNativeHeapFreeSize(JNIEnv *env, jobject clazz)
    16. {
    17.     struct mallinfo info = mallinfo();
    18.     return (jlong) info.fordblks;
    19. }

    mallinfo() 返回内存分配的统计信息，函数声明在 android/bionic/libc/include/malloc.h，函数定义在 android/bionic/libc/bionic/malloc_common.cpp：

    1. extern "C" struct mallinfo mallinfo() {
    2.   auto dispatch_table = GetDispatchTable();
    3.   if (__predict_false(dispatch_table != nullptr)) {
    4.     return dispatch_table->mallinfo();
    5.   }
    6.   return Malloc(mallinfo)();
    7. }

    mallinfo() 主要是返回一个结构体，结构体中包含了通过malloc() 和其相关的函数调用所申请的内存信息，下面是结构体mallinfo 的具体信息（其他信息见man）：

    1.    struct mallinfo {
    2.        int arena;     /* Non-mmapped space allocated (bytes) */
    3.        int ordblks;   /* Number of free chunks */
    4.        int smblks;    /* Number of free fastbin blocks */
    5.        int hblks;     /* Number of mmapped regions */
    6.        int hblkhd;    /* Space allocated in mmapped regions (bytes) */
    7.        int usmblks;   /* Maximum total allocated space (bytes) */
    8.        int fsmblks;   /* Space in freed fastbin blocks (bytes) */
    9.        int uordblks;  /* Total allocated space (bytes) */
    10.        int fordblks;  /* Total free space (bytes) */
    11.        int keepcost;  /* Top-most, releasable space (bytes) */
    12.    };

    我们这里返回的三个信息：

    • usmblks：alloc 的最大总内存（单位：字节）；
    • uordblks：总的alloc 的内存（单位：字节）；
    • fordblks：总的free 的内存（单位：字节）；

     这两个输在如下图所示： 

    5.5 MemInfoReader

    在将MemInfoReader 之前，需要回到代码最开始，了解下变量 collectNative：

    final boolean collectNative = !opts.isCheckinRequest && numProcs > 1 && !opts.packages;

    当dump 多个应用或者所有应用的meminfo 时，变量 collectNative 被置true；如果只是打印单个应用的meminfo 时该值为 false，所以最终不会打印。

    1.     MemInfoReader memInfo = new MemInfoReader();
    2.     memInfo.readMemInfo();

    详细的代码不再剖析，这里总结一个调用框架：

    输出如下图：

    6. meminfo 数据分析

    6.1 单个应用的meminfo

    1. shift:/ # dumpsys meminfo com.android.launcher3
    2. Applications Memory Usage (in Kilobytes):
    3. Uptime: 4443605 Realtime: 4443605
    4.  
    5. ** MEMINFO in pid 1834 [com.android.launcher3] **
    6.                    Pss  Private  Private     Swap      Rss     Heap     Heap     Heap
    7.                  Total    Dirty    Clean    Dirty    Total     Size    Alloc     Free
    8.                 ------   ------   ------   ------   ------   ------   ------   ------
    9.   Native Heap    13647    13548        0        0    16152    21672    16064     1962
    10.   Dalvik Heap     5338     5144        0        0     9496     6657     3329     3328
    11.  Dalvik Other     1317     1192        0        0     2376
    12.         Stack      636      636        0        0      644
    13.        Ashmem        2        0        0        0       20
    14.     Other dev      140        0      140        0      392
    15.      .so mmap     7350      232       12        0    57116
    16.     .jar mmap     2359        0       76        0    24984
    17.     .apk mmap    22108        0    15208        0    51748
    18.     .ttf mmap      110        0        0        0      376
    19.     .dex mmap      348        8      336        0      432
    20.     .oat mmap     1384        0        0        0    14560
    21.     .art mmap     2434     1608        4        0    20496
    22.    Other mmap      495       60       24        0     2896
    23.       Unknown      599      588        0        0     1128
    24.         TOTAL    58267    23016    15800        0    58267    28329    19393     5290
    25.  
    26.  App Summary
    27.                        Pss(KB)                        Rss(KB)
    28.                         ------                         ------
    29.            Java Heap:     6756                          29992
    30.          Native Heap:    13548                          16152
    31.                 Code:    15872                         149484
    32.                Stack:      636                            644
    33.             Graphics:        0                              0
    34.        Private Other:     2004
    35.               System:    19451
    36.              Unknown:                                    6544
    37.  
    38.            TOTAL PSS:    58267            TOTAL RSS:   202816      TOTAL SWAP (KB):        0
    39.  
    40.  Objects
    41.                Views:       89         ViewRootImpl:        1
    42.          AppContexts:       10           Activities:        1
    43.               Assets:       14        AssetManagers:        0
    44.        Local Binders:       34        Proxy Binders:       43
    45.        Parcel memory:       13         Parcel count:       69
    46.     Death Recipients:        1      OpenSSL Sockets:        0
    47.             WebViews:        0
    48.  
    49.  SQL
    50.          MEMORY_USED:      682
    51.   PAGECACHE_OVERFLOW:      292          MALLOC_SIZE:      117
    52.  
    53.  DATABASES
    54.       pgsz     dbsz   Lookaside(b)          cache  Dbname
    55.          4       16             20         1/14/1  /data/user/0/com.android.launcher3/databases/widgetpreviews.db
    56.          4      252             71        99/18/5  /data/user/0/com.android.launcher3/databases/app_icons.db
    57.          4       16             57         6/17/4  /data/user/0/com.android.launcher3/databases/launcher.db

    来看下其中几个主要概念：

    1.            Java Heap:    24312  dalvik heap + .art mmap
    2.          Native Heap:    62256
    3.                 Code:    66452    .so mmap + .jar mmap + .apk mmap + .ttf mmap + .dex mmap + .oat mmap
    4.                Stack:       84
    5.             Graphics:     5338    Gfx dev + EGL mtrack + GL mtrack
    6.        Private Other:     9604  TotalPrivateClean + TotalPrivateDirty - java - native - code - stack - graphics
    7.               System:    12900    TotalPss - TotalPrivateClean - TotalPrivateDirty

    https://developer.android.com/studio/profile/investigate-ram?hl=zh-cn

    • Dalvik Heap

    应用中 Dalvik 分配占用的 RAM。Pss Total 包括所有 Zygote 分配（如上述 PSS 定义所述，通过进程之间的共享内存量来衡量）。Private Dirty 数值是仅分配到您应用的堆的实际 RAM，由您自己的分配和任何 Zygote 分配页组成，这些分配页自从 Zygote 派生应用进程以来已被修改。

    • Heap Alloc

    是 Dalvik 和原生堆分配器为您的应用跟踪的内存量。此值大于 Pss Total 和 Private Dirty，因为您的进程从 Zygote 派生，且包含您的进程与所有其他进程共享的分配。

    • .so mmap 和 .dex mmap

    映射的 .so（原生）和 .dex（Dalvik 或 ART）代码占用的 RAM。Pss Total 数值包括应用之间共享的平台代码；Private Clean 是您的应用自己的代码。通常情况下，实际映射的内存更大 - 此处的 RAM 仅为应用执行的代码当前所需的 RAM。不过，.so mmap 具有较大的私有脏 RAM，因为在加载到其最终地址时对原生代码进行了修改。

    • .oat mmap

    这是代码映像占用的 RAM 量，根据多个应用通常使用的预加载类计算。此映像在所有应用之间共享，不受特定应用影响。

    • .art mmap

    这是堆映像占用的 RAM 量，根据多个应用通常使用的预加载类计算。此映像在所有应用之间共享，不受特定应用影响。尽管 ART 映像包含 Object 实例，它仍然不会计入您的堆大小。

    1. But as to what the difference is between "Pss", "PrivateDirty", and "SharedDirty"... well now the fun begins.
    2.  
    3. A lot of memory in Android (and Linux systems in general) is actually shared across multiple processes. 
    4. So how much memory a processes uses is really not clear. Add on top of that paging out to disk (let alone swap which we don't use on 
    5. Android) and it is even less clear.
    7. Thus if you were to take all of the physical RAM actually mapped in to each process, and add up all of the processes, 
    8. you would probably end up with a number much greater than the actual total RAM.
    10. The Pss number is a metric the kernel computes that takes into account memory sharing -- basically each page of RAM in a process is 
    11. scaled by a ratio of the number of other processes also using that page. This way you can (in theory) add up the pss across all 
    12. processes to see the total RAM they are using, and compare pss between processes to get a rough idea of their relative weight.
    14. The other interesting metric here is PrivateDirty, which is basically the amount of RAM inside the process that can not be paged 
    15. to disk (it is not backed by the same data on disk), and is not shared with any other processes. Another way to look at this is the 
    16. RAM that will become available to the system when that process goes away (and probably quickly subsumed into caches and other uses 
    17. of it).

    从这篇文章中得知：

    一般的android和linux系统中很多进程会共享一些mem，所以一个进程用到的mem其实不是十分清楚，因此如果将每个进程实际占用的mem加到一起，可能会发现这个结果会远远的超过实际的总的mem。

    Pss 是kernel根据共享mem计算得到的值，Pss的值是一块共享mem中一定比例的值。这样，将所有进程Pss加起来就是总的RAM值了，也可以通过进程间Pss值得到这些进程使用比重情况。

    PrivateDirty，它基本上是进程内不能被分页到磁盘的内存，也不和其他进程共享。查看进程的内存用量的另一个途径，就是当进程结束时刻，系统可用内存的变化情况（也可能会很快并入高速缓冲或其他使用该内存区的进程）。

    1.  其他类型              smap 路径名称                       描述
    2.  
    3. Ashmem              /dev/ashmem            匿名共享内存用来提供共享内存通过分配一个多个进程
    4.                                                          可以共享的带名称的内存块
    5. Other dev            /dev/                         内部driver占用的在 “Other dev”                                                 
    6. .so mmap             .so                           C 库代码占用的内存
    7. .jar mmap            .jar                          Java 文件代码占用的内存
    8. .apk mmap            .apk                          apk代码占用的内存
    9. .ttf mmap            .ttf                          ttf 文件代码占用的内存
    10. .dex mmap            .dex                          Dex 文件代码占用的内存
    11. Other mmap                                         其他文件占用的内存

    6.2 系统meminfo 统计

    1. Total RAM: 3,768,168K (status normal)
    2.  Free RAM: 2,186,985K (   64,861K cached pss +   735,736K cached kernel + 1,386,388K free)
    3.       ION:    58,408K (   53,316K mapped +      -128K unmapped +     5,220K pools)
    4.  Used RAM: 1,440,349K (1,116,469K used pss +   323,880K kernel)
    5.  Lost RAM:   140,822K
    6.      ZRAM:        12K physical used for         0K in swap (2,097,148K total swap)
    7.    Tuning: 256 (large 512), oom   640,000K, restore limit   213,333K (high-end-gfx)

    6.2.1 Total RAM

    pw.print(stringifyKBSize(memInfo.getTotalSizeKb()));

    Total RAM 就是/proc/meminfo 中的 MemTotal

    6.2.2 Free RAM

    1. pw.print(stringifyKBSize(cachedPss + memInfo.getCachedSizeKb()
    2.                                        + memInfo.getFreeSizeKb()));

     括号中的：

    • cached pss：All pss of process oom_score_adj >= 900
    • cached kernel：/proc/meminfo.Buffers + /proc/meminfo.KReclaimable +                                                                                         /proc/meminfo.Cached - /proc/meminfo.Mapped
    • free：/proc/meminfo.MemFree

    6.2.3 Used RAM

    pw.print(stringifyKBSize(totalPss - cachedPss + kernelUsed));

     括号中的

    • used pss：totalPss - cachedPss
    • KernelUsed：/proc/meminfo.Shmem + /proc/meminfo.SlabUnreclaim + VmallocUsed + /proc/meminfo.PageTables + /proc/meminfo.KernelStack + [ionHeap]

     6.2.4 Lost RAM

    1.             final long lostRAM = memInfo.getTotalSizeKb() - (totalPss - totalSwapPss)
    2.                     - memInfo.getFreeSizeKb() - memInfo.getCachedSizeKb()
    3.                     - kernelUsed - memInfo.getZramTotalSizeKb();

     Lost RAM = proc/meminfo.Memtotal - (totalPss - totalSwapPss) - /proc/meminfo.Memfree - /proc/meminfo.Cached - kernel used - zram used

    注意：

    从这里大致可以推算出

    FREE RAM + USed RAM - totalSwapPss + Lost RAM + ZRAM = Total RAM

    6.2.5 Tuning

    1.         pw.print("   Tuning: ");
    2.         pw.print(ActivityManager.staticGetMemoryClass());
    3.         pw.print(" (large ");
    4.         pw.print(ActivityManager.staticGetLargeMemoryClass());
    5.         pw.print("), oom ");
    6.         pw.print(stringifySize(
    7.                     mProcessList.getMemLevel(ProcessList.CACHED_APP_MAX_ADJ), 1024));
    8.         pw.print(", restore limit ");
    9.         pw.print(stringifyKBSize(mProcessList.getCachedRestoreThresholdKb()));
    10.         if (ActivityManager.isLowRamDeviceStatic()) {
    11.             pw.print(" (low-ram)");
    12.         }
    13.         if (ActivityManager.isHighEndGfx()) {
    14.             pw.print(" (high-end-gfx)");
    15.         }
    16.         pw.println();

    large：dalvik.vm.heapsize属性取值，单位为MB

    oom：ProcessList中mOomMinFree数组最后一个元素取值

    restore limit：ProcessList中mCachedRestoreLevel变量取值，将一个进程从cached 到background的最大值，一般是mOomMinFree 最后一个值的 1/3.

    low-ram：是否为low ram 设备，一般通过prop ro.config.low_ram，或者当ro.debuggable 使能时prop debug.force_low_ram。

    high-end-gfx：ro.config.low_ram 为false，且ro.config.avoid_gfx_accel 为false，且config config_avoidGfxAccel 的值为false。

    参考：https://blog.csdn.net/feelabclihu/article/details/105534175

  • 相关阅读:
    使用U盘同步WSL2中的git项目
    WMCTF2022 WEB
    Redux中间件redux-thunk
    基于JAVA的学校图书管理系统（Swing+GUI）
    利用python批量创建文件夹、批量创建文件、批量复制文件到指定文件夹
    C# 将本地图片插入到Excel文件中
    BAT 设置WIFI代理
    上帝视角看支付总架构解析
    Java进阶架构实战——Redis在京东到家的订单中的使用
    【重识云原生】第六章容器6.1.5节——Docker核心技术Namespace
  • 原文地址：https://blog.csdn.net/jingerppp/article/details/126269031