Examples with MemInfoReader com.android.internal.util.MemInfoReader used on opensource projects

Example 1 with MemInfoReader

use of com.android.internal.util.MemInfoReader in project platform_frameworks_base by android.

the class ActivityManagerService method reportMemUsage.

void reportMemUsage(ArrayList<ProcessMemInfo> memInfos) {
    final SparseArray<ProcessMemInfo> infoMap = new SparseArray<>(memInfos.size());
    for (int i = 0, N = memInfos.size(); i < N; i++) {
        ProcessMemInfo mi = memInfos.get(i);
        infoMap.put(mi.pid, mi);
    }
    updateCpuStatsNow();
    long[] memtrackTmp = new long[1];
    final List<ProcessCpuTracker.Stats> stats;
    // Get a list of Stats that have vsize > 0
    synchronized (mProcessCpuTracker) {
        stats = mProcessCpuTracker.getStats((st) -> {
            return st.vsize > 0;
        });
    }
    final int statsCount = stats.size();
    for (int i = 0; i < statsCount; i++) {
        ProcessCpuTracker.Stats st = stats.get(i);
        long pss = Debug.getPss(st.pid, null, memtrackTmp);
        if (pss > 0) {
            if (infoMap.indexOfKey(st.pid) < 0) {
                ProcessMemInfo mi = new ProcessMemInfo(st.name, st.pid, ProcessList.NATIVE_ADJ, -1, "native", null);
                mi.pss = pss;
                mi.memtrack = memtrackTmp[0];
                memInfos.add(mi);
            }
        }
    }
    long totalPss = 0;
    long totalMemtrack = 0;
    for (int i = 0, N = memInfos.size(); i < N; i++) {
        ProcessMemInfo mi = memInfos.get(i);
        if (mi.pss == 0) {
            mi.pss = Debug.getPss(mi.pid, null, memtrackTmp);
            mi.memtrack = memtrackTmp[0];
        }
        totalPss += mi.pss;
        totalMemtrack += mi.memtrack;
    }
    Collections.sort(memInfos, new Comparator<ProcessMemInfo>() {

        @Override
        public int compare(ProcessMemInfo lhs, ProcessMemInfo rhs) {
            if (lhs.oomAdj != rhs.oomAdj) {
                return lhs.oomAdj < rhs.oomAdj ? -1 : 1;
            }
            if (lhs.pss != rhs.pss) {
                return lhs.pss < rhs.pss ? 1 : -1;
            }
            return 0;
        }
    });
    StringBuilder tag = new StringBuilder(128);
    StringBuilder stack = new StringBuilder(128);
    tag.append("Low on memory -- ");
    appendMemBucket(tag, totalPss, "total", false);
    appendMemBucket(stack, totalPss, "total", true);
    StringBuilder fullNativeBuilder = new StringBuilder(1024);
    StringBuilder shortNativeBuilder = new StringBuilder(1024);
    StringBuilder fullJavaBuilder = new StringBuilder(1024);
    boolean firstLine = true;
    int lastOomAdj = Integer.MIN_VALUE;
    long extraNativeRam = 0;
    long extraNativeMemtrack = 0;
    long cachedPss = 0;
    for (int i = 0, N = memInfos.size(); i < N; i++) {
        ProcessMemInfo mi = memInfos.get(i);
        if (mi.oomAdj >= ProcessList.CACHED_APP_MIN_ADJ) {
            cachedPss += mi.pss;
        }
        if (mi.oomAdj != ProcessList.NATIVE_ADJ && (mi.oomAdj < ProcessList.SERVICE_ADJ || mi.oomAdj == ProcessList.HOME_APP_ADJ || mi.oomAdj == ProcessList.PREVIOUS_APP_ADJ)) {
            if (lastOomAdj != mi.oomAdj) {
                lastOomAdj = mi.oomAdj;
                if (mi.oomAdj <= ProcessList.FOREGROUND_APP_ADJ) {
                    tag.append(" / ");
                }
                if (mi.oomAdj >= ProcessList.FOREGROUND_APP_ADJ) {
                    if (firstLine) {
                        stack.append(":");
                        firstLine = false;
                    }
                    stack.append("\n\t at ");
                } else {
                    stack.append("$");
                }
            } else {
                tag.append(" ");
                stack.append("$");
            }
            if (mi.oomAdj <= ProcessList.FOREGROUND_APP_ADJ) {
                appendMemBucket(tag, mi.pss, mi.name, false);
            }
            appendMemBucket(stack, mi.pss, mi.name, true);
            if (mi.oomAdj >= ProcessList.FOREGROUND_APP_ADJ && ((i + 1) >= N || memInfos.get(i + 1).oomAdj != lastOomAdj)) {
                stack.append("(");
                for (int k = 0; k < DUMP_MEM_OOM_ADJ.length; k++) {
                    if (DUMP_MEM_OOM_ADJ[k] == mi.oomAdj) {
                        stack.append(DUMP_MEM_OOM_LABEL[k]);
                        stack.append(":");
                        stack.append(DUMP_MEM_OOM_ADJ[k]);
                    }
                }
                stack.append(")");
            }
        }
        appendMemInfo(fullNativeBuilder, mi);
        if (mi.oomAdj == ProcessList.NATIVE_ADJ) {
            // The short form only has native processes that are >= 512K.
            if (mi.pss >= 512) {
                appendMemInfo(shortNativeBuilder, mi);
            } else {
                extraNativeRam += mi.pss;
                extraNativeMemtrack += mi.memtrack;
            }
        } else {
            // from smaller native processes let's dump a summary of that.
            if (extraNativeRam > 0) {
                appendBasicMemEntry(shortNativeBuilder, ProcessList.NATIVE_ADJ, -1, extraNativeRam, extraNativeMemtrack, "(Other native)");
                shortNativeBuilder.append('\n');
                extraNativeRam = 0;
            }
            appendMemInfo(fullJavaBuilder, mi);
        }
    }
    fullJavaBuilder.append("           ");
    ProcessList.appendRamKb(fullJavaBuilder, totalPss);
    fullJavaBuilder.append(": TOTAL");
    if (totalMemtrack > 0) {
        fullJavaBuilder.append(" (");
        fullJavaBuilder.append(stringifyKBSize(totalMemtrack));
        fullJavaBuilder.append(" memtrack)");
    } else {
    }
    fullJavaBuilder.append("\n");
    MemInfoReader memInfo = new MemInfoReader();
    memInfo.readMemInfo();
    final long[] infos = memInfo.getRawInfo();
    StringBuilder memInfoBuilder = new StringBuilder(1024);
    Debug.getMemInfo(infos);
    memInfoBuilder.append("  MemInfo: ");
    memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_SLAB])).append(" slab, ");
    memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_SHMEM])).append(" shmem, ");
    memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_VM_ALLOC_USED])).append(" vm alloc, ");
    memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_PAGE_TABLES])).append(" page tables ");
    memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_KERNEL_STACK])).append(" kernel stack\n");
    memInfoBuilder.append("           ");
    memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_BUFFERS])).append(" buffers, ");
    memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_CACHED])).append(" cached, ");
    memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_MAPPED])).append(" mapped, ");
    memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_FREE])).append(" free\n");
    if (infos[Debug.MEMINFO_ZRAM_TOTAL] != 0) {
        memInfoBuilder.append("  ZRAM: ");
        memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_ZRAM_TOTAL]));
        memInfoBuilder.append(" RAM, ");
        memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_SWAP_TOTAL]));
        memInfoBuilder.append(" swap total, ");
        memInfoBuilder.append(stringifyKBSize(infos[Debug.MEMINFO_SWAP_FREE]));
        memInfoBuilder.append(" swap free\n");
    }
    final long[] ksm = getKsmInfo();
    if (ksm[KSM_SHARING] != 0 || ksm[KSM_SHARED] != 0 || ksm[KSM_UNSHARED] != 0 || ksm[KSM_VOLATILE] != 0) {
        memInfoBuilder.append("  KSM: ");
        memInfoBuilder.append(stringifyKBSize(ksm[KSM_SHARING]));
        memInfoBuilder.append(" saved from shared ");
        memInfoBuilder.append(stringifyKBSize(ksm[KSM_SHARED]));
        memInfoBuilder.append("\n       ");
        memInfoBuilder.append(stringifyKBSize(ksm[KSM_UNSHARED]));
        memInfoBuilder.append(" unshared; ");
        memInfoBuilder.append(stringifyKBSize(ksm[KSM_VOLATILE]));
        memInfoBuilder.append(" volatile\n");
    }
    memInfoBuilder.append("  Free RAM: ");
    memInfoBuilder.append(stringifyKBSize(cachedPss + memInfo.getCachedSizeKb() + memInfo.getFreeSizeKb()));
    memInfoBuilder.append("\n");
    memInfoBuilder.append("  Used RAM: ");
    memInfoBuilder.append(stringifyKBSize(totalPss - cachedPss + memInfo.getKernelUsedSizeKb()));
    memInfoBuilder.append("\n");
    memInfoBuilder.append("  Lost RAM: ");
    memInfoBuilder.append(stringifyKBSize(memInfo.getTotalSizeKb() - totalPss - memInfo.getFreeSizeKb() - memInfo.getCachedSizeKb() - memInfo.getKernelUsedSizeKb() - memInfo.getZramTotalSizeKb()));
    memInfoBuilder.append("\n");
    Slog.i(TAG, "Low on memory:");
    Slog.i(TAG, shortNativeBuilder.toString());
    Slog.i(TAG, fullJavaBuilder.toString());
    Slog.i(TAG, memInfoBuilder.toString());
    StringBuilder dropBuilder = new StringBuilder(1024);
    /*
        StringWriter oomSw = new StringWriter();
        PrintWriter oomPw = new FastPrintWriter(oomSw, false, 256);
        StringWriter catSw = new StringWriter();
        PrintWriter catPw = new FastPrintWriter(catSw, false, 256);
        String[] emptyArgs = new String[] { };
        dumpApplicationMemoryUsage(null, oomPw, "  ", emptyArgs, true, catPw);
        oomPw.flush();
        String oomString = oomSw.toString();
        */
    dropBuilder.append("Low on memory:");
    dropBuilder.append(stack);
    dropBuilder.append('\n');
    dropBuilder.append(fullNativeBuilder);
    dropBuilder.append(fullJavaBuilder);
    dropBuilder.append('\n');
    dropBuilder.append(memInfoBuilder);
    dropBuilder.append('\n');
    /*
        dropBuilder.append(oomString);
        dropBuilder.append('\n');
        */
    StringWriter catSw = new StringWriter();
    synchronized (ActivityManagerService.this) {
        PrintWriter catPw = new FastPrintWriter(catSw, false, 256);
        String[] emptyArgs = new String[] {};
        catPw.println();
        dumpProcessesLocked(null, catPw, emptyArgs, 0, false, null);
        catPw.println();
        mServices.newServiceDumperLocked(null, catPw, emptyArgs, 0, false, null).dumpLocked();
        catPw.println();
        dumpActivitiesLocked(null, catPw, emptyArgs, 0, false, false, null);
        catPw.flush();
    }
    dropBuilder.append(catSw.toString());
    addErrorToDropBox("lowmem", null, "system_server", null, null, tag.toString(), dropBuilder.toString(), null, null);
    //Slog.i(TAG, dropBuilder.toString());
    synchronized (ActivityManagerService.this) {
        long now = SystemClock.uptimeMillis();
        if (mLastMemUsageReportTime < now) {
            mLastMemUsageReportTime = now;
        }
    }
}

Example 2 with MemInfoReader

use of com.android.internal.util.MemInfoReader in project android_packages_apps_Snap by LineageOS.

the class DrawAutoHDR method isLongshotNeedCancel.

// TODO: need to check cached background apps memory and longshot ION memory
private boolean isLongshotNeedCancel() {
    if (PERSIST_SKIP_MEM_CHECK == true) {
        return false;
    }
    if (Storage.getAvailableSpace() <= Storage.LOW_STORAGE_THRESHOLD_BYTES) {
        Log.w(TAG, "current storage is full");
        return true;
    }
    if (SECONDARY_SERVER_MEM == 0) {
        ActivityManager am = (ActivityManager) mActivity.getSystemService(Context.ACTIVITY_SERVICE);
        ActivityManager.MemoryInfo memInfo = new ActivityManager.MemoryInfo();
        am.getMemoryInfo(memInfo);
        SECONDARY_SERVER_MEM = memInfo.secondaryServerThreshold;
    }
    long totalMemory = Runtime.getRuntime().totalMemory();
    long maxMemory = Runtime.getRuntime().maxMemory();
    long remainMemory = maxMemory - totalMemory;
    MemInfoReader reader = new MemInfoReader();
    reader.readMemInfo();
    long[] info = reader.getRawInfo();
    long availMem = (info[Debug.MEMINFO_FREE] + info[Debug.MEMINFO_CACHED]) * 1024;
    if (availMem <= SECONDARY_SERVER_MEM || remainMemory <= LONGSHOT_CANCEL_THRESHOLD) {
        Log.e(TAG, "cancel longshot: free=" + info[Debug.MEMINFO_FREE] * 1024 + " cached=" + info[Debug.MEMINFO_CACHED] * 1024 + " threshold=" + SECONDARY_SERVER_MEM);
        mLongshotActive = false;
        RotateTextToast.makeText(mActivity, R.string.msg_cancel_longshot_for_limited_memory, Toast.LENGTH_SHORT).show();
        return true;
    }
    return false;
}

Example 3 with MemInfoReader

use of com.android.internal.util.MemInfoReader in project platform_frameworks_base by android.

the class ActivityManagerService method dumpApplicationMemoryUsage.

final void dumpApplicationMemoryUsage(FileDescriptor fd, PrintWriter pw, String prefix, String[] args, boolean brief, PrintWriter categoryPw) {
    boolean dumpDetails = false;
    boolean dumpFullDetails = false;
    boolean dumpDalvik = false;
    boolean dumpSummaryOnly = false;
    boolean dumpUnreachable = false;
    boolean oomOnly = false;
    boolean isCompact = false;
    boolean localOnly = false;
    boolean packages = false;
    boolean isCheckinRequest = false;
    boolean dumpSwapPss = false;
    int opti = 0;
    while (opti < args.length) {
        String opt = args[opti];
        if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') {
            break;
        }
        opti++;
        if ("-a".equals(opt)) {
            dumpDetails = true;
            dumpFullDetails = true;
            dumpDalvik = true;
            dumpSwapPss = true;
        } else if ("-d".equals(opt)) {
            dumpDalvik = true;
        } else if ("-c".equals(opt)) {
            isCompact = true;
        } else if ("-s".equals(opt)) {
            dumpDetails = true;
            dumpSummaryOnly = true;
        } else if ("-S".equals(opt)) {
            dumpSwapPss = true;
        } else if ("--unreachable".equals(opt)) {
            dumpUnreachable = true;
        } else if ("--oom".equals(opt)) {
            oomOnly = true;
        } else if ("--local".equals(opt)) {
            localOnly = true;
        } else if ("--package".equals(opt)) {
            packages = true;
        } else if ("--checkin".equals(opt)) {
            isCheckinRequest = true;
        } else if ("-h".equals(opt)) {
            pw.println("meminfo dump options: [-a] [-d] [-c] [-s] [--oom] [process]");
            pw.println("  -a: include all available information for each process.");
            pw.println("  -d: include dalvik details.");
            pw.println("  -c: dump in a compact machine-parseable representation.");
            pw.println("  -s: dump only summary of application memory usage.");
            pw.println("  -S: dump also SwapPss.");
            pw.println("  --oom: only show processes organized by oom adj.");
            pw.println("  --local: only collect details locally, don't call process.");
            pw.println("  --package: interpret process arg as package, dumping all");
            pw.println("             processes that have loaded that package.");
            pw.println("  --checkin: dump data for a checkin");
            pw.println("If [process] is specified it can be the name or ");
            pw.println("pid of a specific process to dump.");
            return;
        } else {
            pw.println("Unknown argument: " + opt + "; use -h for help");
        }
    }
    long uptime = SystemClock.uptimeMillis();
    long realtime = SystemClock.elapsedRealtime();
    final long[] tmpLong = new long[1];
    ArrayList<ProcessRecord> procs = collectProcesses(pw, opti, packages, args);
    if (procs == null) {
        // No Java processes.  Maybe they want to print a native process.
        if (args != null && args.length > opti && args[opti].charAt(0) != '-') {
            ArrayList<ProcessCpuTracker.Stats> nativeProcs = new ArrayList<ProcessCpuTracker.Stats>();
            updateCpuStatsNow();
            int findPid = -1;
            try {
                findPid = Integer.parseInt(args[opti]);
            } catch (NumberFormatException e) {
            }
            synchronized (mProcessCpuTracker) {
                final int N = mProcessCpuTracker.countStats();
                for (int i = 0; i < N; i++) {
                    ProcessCpuTracker.Stats st = mProcessCpuTracker.getStats(i);
                    if (st.pid == findPid || (st.baseName != null && st.baseName.equals(args[opti]))) {
                        nativeProcs.add(st);
                    }
                }
            }
            if (nativeProcs.size() > 0) {
                dumpApplicationMemoryUsageHeader(pw, uptime, realtime, isCheckinRequest, isCompact);
                Debug.MemoryInfo mi = null;
                for (int i = nativeProcs.size() - 1; i >= 0; i--) {
                    final ProcessCpuTracker.Stats r = nativeProcs.get(i);
                    final int pid = r.pid;
                    if (!isCheckinRequest && dumpDetails) {
                        pw.println("\n** MEMINFO in pid " + pid + " [" + r.baseName + "] **");
                    }
                    if (mi == null) {
                        mi = new Debug.MemoryInfo();
                    }
                    if (dumpDetails || (!brief && !oomOnly)) {
                        Debug.getMemoryInfo(pid, mi);
                    } else {
                        mi.dalvikPss = (int) Debug.getPss(pid, tmpLong, null);
                        mi.dalvikPrivateDirty = (int) tmpLong[0];
                    }
                    ActivityThread.dumpMemInfoTable(pw, mi, isCheckinRequest, dumpFullDetails, dumpDalvik, dumpSummaryOnly, pid, r.baseName, 0, 0, 0, 0, 0, 0);
                    if (isCheckinRequest) {
                        pw.println();
                    }
                }
                return;
            }
        }
        pw.println("No process found for: " + args[opti]);
        return;
    }
    if (!brief && !oomOnly && (procs.size() == 1 || isCheckinRequest || packages)) {
        dumpDetails = true;
    }
    dumpApplicationMemoryUsageHeader(pw, uptime, realtime, isCheckinRequest, isCompact);
    String[] innerArgs = new String[args.length - opti];
    System.arraycopy(args, opti, innerArgs, 0, args.length - opti);
    ArrayList<MemItem> procMems = new ArrayList<MemItem>();
    final SparseArray<MemItem> procMemsMap = new SparseArray<MemItem>();
    long nativePss = 0;
    long nativeSwapPss = 0;
    long dalvikPss = 0;
    long dalvikSwapPss = 0;
    long[] dalvikSubitemPss = dumpDalvik ? new long[Debug.MemoryInfo.NUM_DVK_STATS] : EmptyArray.LONG;
    long[] dalvikSubitemSwapPss = dumpDalvik ? new long[Debug.MemoryInfo.NUM_DVK_STATS] : EmptyArray.LONG;
    long otherPss = 0;
    long otherSwapPss = 0;
    long[] miscPss = new long[Debug.MemoryInfo.NUM_OTHER_STATS];
    long[] miscSwapPss = new long[Debug.MemoryInfo.NUM_OTHER_STATS];
    long[] oomPss = new long[DUMP_MEM_OOM_LABEL.length];
    long[] oomSwapPss = new long[DUMP_MEM_OOM_LABEL.length];
    ArrayList<MemItem>[] oomProcs = (ArrayList<MemItem>[]) new ArrayList[DUMP_MEM_OOM_LABEL.length];
    long totalPss = 0;
    long totalSwapPss = 0;
    long cachedPss = 0;
    long cachedSwapPss = 0;
    boolean hasSwapPss = false;
    Debug.MemoryInfo mi = null;
    for (int i = procs.size() - 1; i >= 0; i--) {
        final ProcessRecord r = procs.get(i);
        final IApplicationThread thread;
        final int pid;
        final int oomAdj;
        final boolean hasActivities;
        synchronized (this) {
            thread = r.thread;
            pid = r.pid;
            oomAdj = r.getSetAdjWithServices();
            hasActivities = r.activities.size() > 0;
        }
        if (thread != null) {
            if (!isCheckinRequest && dumpDetails) {
                pw.println("\n** MEMINFO in pid " + pid + " [" + r.processName + "] **");
            }
            if (mi == null) {
                mi = new Debug.MemoryInfo();
            }
            if (dumpDetails || (!brief && !oomOnly)) {
                Debug.getMemoryInfo(pid, mi);
                hasSwapPss = mi.hasSwappedOutPss;
            } else {
                mi.dalvikPss = (int) Debug.getPss(pid, tmpLong, null);
                mi.dalvikPrivateDirty = (int) tmpLong[0];
            }
            if (dumpDetails) {
                if (localOnly) {
                    ActivityThread.dumpMemInfoTable(pw, mi, isCheckinRequest, dumpFullDetails, dumpDalvik, dumpSummaryOnly, pid, r.processName, 0, 0, 0, 0, 0, 0);
                    if (isCheckinRequest) {
                        pw.println();
                    }
                } else {
                    try {
                        pw.flush();
                        thread.dumpMemInfo(fd, mi, isCheckinRequest, dumpFullDetails, dumpDalvik, dumpSummaryOnly, dumpUnreachable, innerArgs);
                    } catch (RemoteException e) {
                        if (!isCheckinRequest) {
                            pw.println("Got RemoteException!");
                            pw.flush();
                        }
                    }
                }
            }
            final long myTotalPss = mi.getTotalPss();
            final long myTotalUss = mi.getTotalUss();
            final long myTotalSwapPss = mi.getTotalSwappedOutPss();
            synchronized (this) {
                if (r.thread != null && oomAdj == r.getSetAdjWithServices()) {
                    // Record this for posterity if the process has been stable.
                    r.baseProcessTracker.addPss(myTotalPss, myTotalUss, true, r.pkgList);
                }
            }
            if (!isCheckinRequest && mi != null) {
                totalPss += myTotalPss;
                totalSwapPss += myTotalSwapPss;
                MemItem pssItem = new MemItem(r.processName + " (pid " + pid + (hasActivities ? " / activities)" : ")"), r.processName, myTotalPss, myTotalSwapPss, pid, hasActivities);
                procMems.add(pssItem);
                procMemsMap.put(pid, pssItem);
                nativePss += mi.nativePss;
                nativeSwapPss += mi.nativeSwappedOutPss;
                dalvikPss += mi.dalvikPss;
                dalvikSwapPss += mi.dalvikSwappedOutPss;
                for (int j = 0; j < dalvikSubitemPss.length; j++) {
                    dalvikSubitemPss[j] += mi.getOtherPss(Debug.MemoryInfo.NUM_OTHER_STATS + j);
                    dalvikSubitemSwapPss[j] += mi.getOtherSwappedOutPss(Debug.MemoryInfo.NUM_OTHER_STATS + j);
                }
                otherPss += mi.otherPss;
                otherSwapPss += mi.otherSwappedOutPss;
                for (int j = 0; j < Debug.MemoryInfo.NUM_OTHER_STATS; j++) {
                    long mem = mi.getOtherPss(j);
                    miscPss[j] += mem;
                    otherPss -= mem;
                    mem = mi.getOtherSwappedOutPss(j);
                    miscSwapPss[j] += mem;
                    otherSwapPss -= mem;
                }
                if (oomAdj >= ProcessList.CACHED_APP_MIN_ADJ) {
                    cachedPss += myTotalPss;
                    cachedSwapPss += myTotalSwapPss;
                }
                for (int oomIndex = 0; oomIndex < oomPss.length; oomIndex++) {
                    if (oomIndex == (oomPss.length - 1) || (oomAdj >= DUMP_MEM_OOM_ADJ[oomIndex] && oomAdj < DUMP_MEM_OOM_ADJ[oomIndex + 1])) {
                        oomPss[oomIndex] += myTotalPss;
                        oomSwapPss[oomIndex] += myTotalSwapPss;
                        if (oomProcs[oomIndex] == null) {
                            oomProcs[oomIndex] = new ArrayList<MemItem>();
                        }
                        oomProcs[oomIndex].add(pssItem);
                        break;
                    }
                }
            }
        }
    }
    long nativeProcTotalPss = 0;
    if (!isCheckinRequest && procs.size() > 1 && !packages) {
        // If we are showing aggregations, also look for native processes to
        // include so that our aggregations are more accurate.
        updateCpuStatsNow();
        mi = null;
        synchronized (mProcessCpuTracker) {
            final int N = mProcessCpuTracker.countStats();
            for (int i = 0; i < N; i++) {
                ProcessCpuTracker.Stats st = mProcessCpuTracker.getStats(i);
                if (st.vsize > 0 && procMemsMap.indexOfKey(st.pid) < 0) {
                    if (mi == null) {
                        mi = new Debug.MemoryInfo();
                    }
                    if (!brief && !oomOnly) {
                        Debug.getMemoryInfo(st.pid, mi);
                    } else {
                        mi.nativePss = (int) Debug.getPss(st.pid, tmpLong, null);
                        mi.nativePrivateDirty = (int) tmpLong[0];
                    }
                    final long myTotalPss = mi.getTotalPss();
                    final long myTotalSwapPss = mi.getTotalSwappedOutPss();
                    totalPss += myTotalPss;
                    nativeProcTotalPss += myTotalPss;
                    MemItem pssItem = new MemItem(st.name + " (pid " + st.pid + ")", st.name, myTotalPss, mi.getSummaryTotalSwapPss(), st.pid, false);
                    procMems.add(pssItem);
                    nativePss += mi.nativePss;
                    nativeSwapPss += mi.nativeSwappedOutPss;
                    dalvikPss += mi.dalvikPss;
                    dalvikSwapPss += mi.dalvikSwappedOutPss;
                    for (int j = 0; j < dalvikSubitemPss.length; j++) {
                        dalvikSubitemPss[j] += mi.getOtherPss(Debug.MemoryInfo.NUM_OTHER_STATS + j);
                        dalvikSubitemSwapPss[j] += mi.getOtherSwappedOutPss(Debug.MemoryInfo.NUM_OTHER_STATS + j);
                    }
                    otherPss += mi.otherPss;
                    otherSwapPss += mi.otherSwappedOutPss;
                    for (int j = 0; j < Debug.MemoryInfo.NUM_OTHER_STATS; j++) {
                        long mem = mi.getOtherPss(j);
                        miscPss[j] += mem;
                        otherPss -= mem;
                        mem = mi.getOtherSwappedOutPss(j);
                        miscSwapPss[j] += mem;
                        otherSwapPss -= mem;
                    }
                    oomPss[0] += myTotalPss;
                    oomSwapPss[0] += myTotalSwapPss;
                    if (oomProcs[0] == null) {
                        oomProcs[0] = new ArrayList<MemItem>();
                    }
                    oomProcs[0].add(pssItem);
                }
            }
        }
        ArrayList<MemItem> catMems = new ArrayList<MemItem>();
        catMems.add(new MemItem("Native", "Native", nativePss, nativeSwapPss, -1));
        final MemItem dalvikItem = new MemItem("Dalvik", "Dalvik", dalvikPss, dalvikSwapPss, -2);
        if (dalvikSubitemPss.length > 0) {
            dalvikItem.subitems = new ArrayList<MemItem>();
            for (int j = 0; j < dalvikSubitemPss.length; j++) {
                final String name = Debug.MemoryInfo.getOtherLabel(Debug.MemoryInfo.NUM_OTHER_STATS + j);
                dalvikItem.subitems.add(new MemItem(name, name, dalvikSubitemPss[j], dalvikSubitemSwapPss[j], j));
            }
        }
        catMems.add(dalvikItem);
        catMems.add(new MemItem("Unknown", "Unknown", otherPss, otherSwapPss, -3));
        for (int j = 0; j < Debug.MemoryInfo.NUM_OTHER_STATS; j++) {
            String label = Debug.MemoryInfo.getOtherLabel(j);
            catMems.add(new MemItem(label, label, miscPss[j], miscSwapPss[j], j));
        }
        ArrayList<MemItem> oomMems = new ArrayList<MemItem>();
        for (int j = 0; j < oomPss.length; j++) {
            if (oomPss[j] != 0) {
                String label = isCompact ? DUMP_MEM_OOM_COMPACT_LABEL[j] : DUMP_MEM_OOM_LABEL[j];
                MemItem item = new MemItem(label, label, oomPss[j], oomSwapPss[j], DUMP_MEM_OOM_ADJ[j]);
                item.subitems = oomProcs[j];
                oomMems.add(item);
            }
        }
        dumpSwapPss = dumpSwapPss && hasSwapPss && totalSwapPss != 0;
        if (!brief && !oomOnly && !isCompact) {
            pw.println();
            pw.println("Total PSS by process:");
            dumpMemItems(pw, "  ", "proc", procMems, true, isCompact, dumpSwapPss);
            pw.println();
        }
        if (!isCompact) {
            pw.println("Total PSS by OOM adjustment:");
        }
        dumpMemItems(pw, "  ", "oom", oomMems, false, isCompact, dumpSwapPss);
        if (!brief && !oomOnly) {
            PrintWriter out = categoryPw != null ? categoryPw : pw;
            if (!isCompact) {
                out.println();
                out.println("Total PSS by category:");
            }
            dumpMemItems(out, "  ", "cat", catMems, true, isCompact, dumpSwapPss);
        }
        if (!isCompact) {
            pw.println();
        }
        MemInfoReader memInfo = new MemInfoReader();
        memInfo.readMemInfo();
        if (nativeProcTotalPss > 0) {
            synchronized (this) {
                final long cachedKb = memInfo.getCachedSizeKb();
                final long freeKb = memInfo.getFreeSizeKb();
                final long zramKb = memInfo.getZramTotalSizeKb();
                final long kernelKb = memInfo.getKernelUsedSizeKb();
                EventLogTags.writeAmMeminfo(cachedKb * 1024, freeKb * 1024, zramKb * 1024, kernelKb * 1024, nativeProcTotalPss * 1024);
                mProcessStats.addSysMemUsageLocked(cachedKb, freeKb, zramKb, kernelKb, nativeProcTotalPss);
            }
        }
        if (!brief) {
            if (!isCompact) {
                pw.print("Total RAM: ");
                pw.print(stringifyKBSize(memInfo.getTotalSizeKb()));
                pw.print(" (status ");
                switch(mLastMemoryLevel) {
                    case ProcessStats.ADJ_MEM_FACTOR_NORMAL:
                        pw.println("normal)");
                        break;
                    case ProcessStats.ADJ_MEM_FACTOR_MODERATE:
                        pw.println("moderate)");
                        break;
                    case ProcessStats.ADJ_MEM_FACTOR_LOW:
                        pw.println("low)");
                        break;
                    case ProcessStats.ADJ_MEM_FACTOR_CRITICAL:
                        pw.println("critical)");
                        break;
                    default:
                        pw.print(mLastMemoryLevel);
                        pw.println(")");
                        break;
                }
                pw.print(" Free RAM: ");
                pw.print(stringifyKBSize(cachedPss + memInfo.getCachedSizeKb() + memInfo.getFreeSizeKb()));
                pw.print(" (");
                pw.print(stringifyKBSize(cachedPss));
                pw.print(" cached pss + ");
                pw.print(stringifyKBSize(memInfo.getCachedSizeKb()));
                pw.print(" cached kernel + ");
                pw.print(stringifyKBSize(memInfo.getFreeSizeKb()));
                pw.println(" free)");
            } else {
                pw.print("ram,");
                pw.print(memInfo.getTotalSizeKb());
                pw.print(",");
                pw.print(cachedPss + memInfo.getCachedSizeKb() + memInfo.getFreeSizeKb());
                pw.print(",");
                pw.println(totalPss - cachedPss);
            }
        }
        long lostRAM = memInfo.getTotalSizeKb() - (totalPss - totalSwapPss) - memInfo.getFreeSizeKb() - memInfo.getCachedSizeKb() - memInfo.getKernelUsedSizeKb() - memInfo.getZramTotalSizeKb();
        if (!isCompact) {
            pw.print(" Used RAM: ");
            pw.print(stringifyKBSize(totalPss - cachedPss + memInfo.getKernelUsedSizeKb()));
            pw.print(" (");
            pw.print(stringifyKBSize(totalPss - cachedPss));
            pw.print(" used pss + ");
            pw.print(stringifyKBSize(memInfo.getKernelUsedSizeKb()));
            pw.print(" kernel)\n");
            pw.print(" Lost RAM: ");
            pw.println(stringifyKBSize(lostRAM));
        } else {
            pw.print("lostram,");
            pw.println(lostRAM);
        }
        if (!brief) {
            if (memInfo.getZramTotalSizeKb() != 0) {
                if (!isCompact) {
                    pw.print("     ZRAM: ");
                    pw.print(stringifyKBSize(memInfo.getZramTotalSizeKb()));
                    pw.print(" physical used for ");
                    pw.print(stringifyKBSize(memInfo.getSwapTotalSizeKb() - memInfo.getSwapFreeSizeKb()));
                    pw.print(" in swap (");
                    pw.print(stringifyKBSize(memInfo.getSwapTotalSizeKb()));
                    pw.println(" total swap)");
                } else {
                    pw.print("zram,");
                    pw.print(memInfo.getZramTotalSizeKb());
                    pw.print(",");
                    pw.print(memInfo.getSwapTotalSizeKb());
                    pw.print(",");
                    pw.println(memInfo.getSwapFreeSizeKb());
                }
            }
            final long[] ksm = getKsmInfo();
            if (!isCompact) {
                if (ksm[KSM_SHARING] != 0 || ksm[KSM_SHARED] != 0 || ksm[KSM_UNSHARED] != 0 || ksm[KSM_VOLATILE] != 0) {
                    pw.print("      KSM: ");
                    pw.print(stringifyKBSize(ksm[KSM_SHARING]));
                    pw.print(" saved from shared ");
                    pw.print(stringifyKBSize(ksm[KSM_SHARED]));
                    pw.print("           ");
                    pw.print(stringifyKBSize(ksm[KSM_UNSHARED]));
                    pw.print(" unshared; ");
                    pw.print(stringifyKBSize(ksm[KSM_VOLATILE]));
                    pw.println(" volatile");
                }
                pw.print("   Tuning: ");
                pw.print(ActivityManager.staticGetMemoryClass());
                pw.print(" (large ");
                pw.print(ActivityManager.staticGetLargeMemoryClass());
                pw.print("), oom ");
                pw.print(stringifySize(mProcessList.getMemLevel(ProcessList.CACHED_APP_MAX_ADJ), 1024));
                pw.print(", restore limit ");
                pw.print(stringifyKBSize(mProcessList.getCachedRestoreThresholdKb()));
                if (ActivityManager.isLowRamDeviceStatic()) {
                    pw.print(" (low-ram)");
                }
                if (ActivityManager.isHighEndGfx()) {
                    pw.print(" (high-end-gfx)");
                }
                pw.println();
            } else {
                pw.print("ksm,");
                pw.print(ksm[KSM_SHARING]);
                pw.print(",");
                pw.print(ksm[KSM_SHARED]);
                pw.print(",");
                pw.print(ksm[KSM_UNSHARED]);
                pw.print(",");
                pw.println(ksm[KSM_VOLATILE]);
                pw.print("tuning,");
                pw.print(ActivityManager.staticGetMemoryClass());
                pw.print(',');
                pw.print(ActivityManager.staticGetLargeMemoryClass());
                pw.print(',');
                pw.print(mProcessList.getMemLevel(ProcessList.CACHED_APP_MAX_ADJ) / 1024);
                if (ActivityManager.isLowRamDeviceStatic()) {
                    pw.print(",low-ram");
                }
                if (ActivityManager.isHighEndGfx()) {
                    pw.print(",high-end-gfx");
                }
                pw.println();
            }
        }
    }
}

Example 4 with MemInfoReader

use of com.android.internal.util.MemInfoReader in project android_frameworks_base by ParanoidAndroid.

the class ActivityManager method isLargeRAM.

/**
     * Use to decide whether the running device can be considered a "large
     * RAM" device.  Exactly what memory limit large RAM is will vary, but
     * it essentially means there is plenty of RAM to have lots of background
     * processes running under decent loads.
     * @hide
     */
public static boolean isLargeRAM() {
    MemInfoReader reader = new MemInfoReader();
    reader.readMemInfo();
    if (reader.getTotalSize() >= (640 * 1024 * 1024)) {
        // which we have plenty of RAM to spare.
        return true;
    }
    return false;
}

Example 5 with MemInfoReader

use of com.android.internal.util.MemInfoReader in project android_frameworks_base by ParanoidAndroid.

the class ActivityManager method isHighEndGfx.

/**
     * Used by persistent processes to determine if they are running on a
     * higher-end device so should be okay using hardware drawing acceleration
     * (which tends to consume a lot more RAM).
     * @hide
     */
public static boolean isHighEndGfx() {
    MemInfoReader reader = new MemInfoReader();
    reader.readMemInfo();
    if (reader.getTotalSize() >= (512 * 1024 * 1024)) {
        // we can afford the overhead of graphics acceleration.
        return true;
    }
    Display display = DisplayManagerGlobal.getInstance().getRealDisplay(Display.DEFAULT_DISPLAY);
    Point p = new Point();
    display.getRealSize(p);
    int pixels = p.x * p.y;
    if (pixels >= (1024 * 600)) {
        // pixels on it that we'd really like to use hw drawing.
        return true;
    }
    return false;
}