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

Example 86 with FastPrintWriter

use of com.android.internal.util.FastPrintWriter in project android_frameworks_base by DirtyUnicorns.

the class CompilerStats method write.

// I/O
// The encoding is simple:
//
// 1) The first line is a line consisting of the version header and the version number.
//
// 2) The rest of the file is package data.
// 2.1) A package is started by any line not starting with "-";
// 2.2) Any line starting with "-" is code path data. The format is:
//      '-'{code-path}':'{compile-time}
public void write(Writer out) {
    @SuppressWarnings("resource") FastPrintWriter fpw = new FastPrintWriter(out);
    fpw.print(COMPILER_STATS_VERSION_HEADER);
    fpw.println(COMPILER_STATS_VERSION);
    synchronized (packageStats) {
        for (PackageStats pkg : packageStats.values()) {
            synchronized (pkg.compileTimePerCodePath) {
                if (!pkg.compileTimePerCodePath.isEmpty()) {
                    fpw.println(pkg.getPackageName());
                    for (Map.Entry<String, Long> e : pkg.compileTimePerCodePath.entrySet()) {
                        fpw.println("-" + e.getKey() + ":" + e.getValue());
                    }
                }
            }
        }
    }
    fpw.flush();
}

Example 87 with FastPrintWriter

use of com.android.internal.util.FastPrintWriter in project android_frameworks_base by DirtyUnicorns.

the class IntentResolver method buildResolveList.

private void buildResolveList(Intent intent, FastImmutableArraySet<String> categories, boolean debug, boolean defaultOnly, String resolvedType, String scheme, F[] src, List<R> dest, int userId) {
    final String action = intent.getAction();
    final Uri data = intent.getData();
    final String packageName = intent.getPackage();
    final boolean excludingStopped = intent.isExcludingStopped();
    final Printer logPrinter;
    final PrintWriter logPrintWriter;
    if (debug) {
        logPrinter = new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM);
        logPrintWriter = new FastPrintWriter(logPrinter);
    } else {
        logPrinter = null;
        logPrintWriter = null;
    }
    final int N = src != null ? src.length : 0;
    boolean hasNonDefaults = false;
    int i;
    F filter;
    for (i = 0; i < N && (filter = src[i]) != null; i++) {
        int match;
        if (debug)
            Slog.v(TAG, "Matching against filter " + filter);
        if (excludingStopped && isFilterStopped(filter, userId)) {
            if (debug) {
                Slog.v(TAG, "  Filter's target is stopped; skipping");
            }
            continue;
        }
        // Is delivery being limited to filters owned by a particular package?
        if (packageName != null && !isPackageForFilter(packageName, filter)) {
            if (debug) {
                Slog.v(TAG, "  Filter is not from package " + packageName + "; skipping");
            }
            continue;
        }
        // Are we verified ?
        if (filter.getAutoVerify()) {
            if (localVerificationLOGV || debug) {
                Slog.v(TAG, "  Filter verified: " + isFilterVerified(filter));
                int authorities = filter.countDataAuthorities();
                for (int z = 0; z < authorities; z++) {
                    Slog.v(TAG, "   " + filter.getDataAuthority(z).getHost());
                }
            }
        }
        // Do we already have this one?
        if (!allowFilterResult(filter, dest)) {
            if (debug) {
                Slog.v(TAG, "  Filter's target already added");
            }
            continue;
        }
        match = filter.match(action, resolvedType, scheme, data, categories, TAG);
        if (match >= 0) {
            if (debug)
                Slog.v(TAG, "  Filter matched!  match=0x" + Integer.toHexString(match) + " hasDefault=" + filter.hasCategory(Intent.CATEGORY_DEFAULT));
            if (!defaultOnly || filter.hasCategory(Intent.CATEGORY_DEFAULT)) {
                final R oneResult = newResult(filter, match, userId);
                if (oneResult != null) {
                    dest.add(oneResult);
                    if (debug) {
                        dumpFilter(logPrintWriter, "    ", filter);
                        logPrintWriter.flush();
                        filter.dump(logPrinter, "    ");
                    }
                }
            } else {
                hasNonDefaults = true;
            }
        } else {
            if (debug) {
                String reason;
                switch(match) {
                    case IntentFilter.NO_MATCH_ACTION:
                        reason = "action";
                        break;
                    case IntentFilter.NO_MATCH_CATEGORY:
                        reason = "category";
                        break;
                    case IntentFilter.NO_MATCH_DATA:
                        reason = "data";
                        break;
                    case IntentFilter.NO_MATCH_TYPE:
                        reason = "type";
                        break;
                    default:
                        reason = "unknown reason";
                        break;
                }
                Slog.v(TAG, "  Filter did not match: " + reason);
            }
        }
    }
    if (debug && hasNonDefaults) {
        if (dest.size() == 0) {
            Slog.v(TAG, "resolveIntent failed: found match, but none with CATEGORY_DEFAULT");
        } else if (dest.size() > 1) {
            Slog.v(TAG, "resolveIntent: multiple matches, only some with CATEGORY_DEFAULT");
        }
    }
}

Example 88 with FastPrintWriter

use of com.android.internal.util.FastPrintWriter in project android_frameworks_base by DirtyUnicorns.

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 89 with FastPrintWriter

use of com.android.internal.util.FastPrintWriter in project android_frameworks_base by DirtyUnicorns.

the class ActivityThread method handleDumpService.

private void handleDumpService(DumpComponentInfo info) {
    final StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
    try {
        Service s = mServices.get(info.token);
        if (s != null) {
            PrintWriter pw = new FastPrintWriter(new FileOutputStream(info.fd.getFileDescriptor()));
            s.dump(info.fd.getFileDescriptor(), pw, info.args);
            pw.flush();
        }
    } finally {
        IoUtils.closeQuietly(info.fd);
        StrictMode.setThreadPolicy(oldPolicy);
    }
}

Example 90 with FastPrintWriter

use of com.android.internal.util.FastPrintWriter in project android_frameworks_base by DirtyUnicorns.

the class ActivityThread method handleDumpActivity.

private void handleDumpActivity(DumpComponentInfo info) {
    final StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
    try {
        ActivityClientRecord r = mActivities.get(info.token);
        if (r != null && r.activity != null) {
            PrintWriter pw = new FastPrintWriter(new FileOutputStream(info.fd.getFileDescriptor()));
            r.activity.dump(info.prefix, info.fd.getFileDescriptor(), pw, info.args);
            pw.flush();
        }
    } finally {
        IoUtils.closeQuietly(info.fd);
        StrictMode.setThreadPolicy(oldPolicy);
    }
}