Examples with ServiceState com.android.internal.app.procstats.ServiceState used on opensource projects

Example 6 with ServiceState

use of com.android.internal.app.procstats.ServiceState in project platform_frameworks_base by android.

the class ProcessStats method readFromParcel.

public void readFromParcel(Parcel in) {
    final boolean hadData = mPackages.getMap().size() > 0 || mProcesses.getMap().size() > 0;
    if (hadData) {
        resetSafely();
    }
    if (!readCheckedInt(in, MAGIC, "magic number")) {
        return;
    }
    int version = in.readInt();
    if (version != PARCEL_VERSION) {
        mReadError = "bad version: " + version;
        return;
    }
    if (!readCheckedInt(in, STATE_COUNT, "state count")) {
        return;
    }
    if (!readCheckedInt(in, ADJ_COUNT, "adj count")) {
        return;
    }
    if (!readCheckedInt(in, PSS_COUNT, "pss count")) {
        return;
    }
    if (!readCheckedInt(in, SYS_MEM_USAGE_COUNT, "sys mem usage count")) {
        return;
    }
    if (!readCheckedInt(in, SparseMappingTable.ARRAY_SIZE, "longs size")) {
        return;
    }
    mIndexToCommonString = new ArrayList<String>();
    mTimePeriodStartClock = in.readLong();
    buildTimePeriodStartClockStr();
    mTimePeriodStartRealtime = in.readLong();
    mTimePeriodEndRealtime = in.readLong();
    mTimePeriodStartUptime = in.readLong();
    mTimePeriodEndUptime = in.readLong();
    mRuntime = in.readString();
    mHasSwappedOutPss = in.readInt() != 0;
    mFlags = in.readInt();
    mTableData.readFromParcel(in);
    readCompactedLongArray(in, version, mMemFactorDurations, mMemFactorDurations.length);
    if (!mSysMemUsage.readFromParcel(in)) {
        return;
    }
    int NPROC = in.readInt();
    if (NPROC < 0) {
        mReadError = "bad process count: " + NPROC;
        return;
    }
    while (NPROC > 0) {
        NPROC--;
        final String procName = readCommonString(in, version);
        if (procName == null) {
            mReadError = "bad process name";
            return;
        }
        int NUID = in.readInt();
        if (NUID < 0) {
            mReadError = "bad uid count: " + NUID;
            return;
        }
        while (NUID > 0) {
            NUID--;
            final int uid = in.readInt();
            if (uid < 0) {
                mReadError = "bad uid: " + uid;
                return;
            }
            final String pkgName = readCommonString(in, version);
            if (pkgName == null) {
                mReadError = "bad process package name";
                return;
            }
            final int vers = in.readInt();
            ProcessState proc = hadData ? mProcesses.get(procName, uid) : null;
            if (proc != null) {
                if (!proc.readFromParcel(in, false)) {
                    return;
                }
            } else {
                proc = new ProcessState(this, pkgName, uid, vers, procName);
                if (!proc.readFromParcel(in, true)) {
                    return;
                }
            }
            if (DEBUG_PARCEL)
                Slog.d(TAG, "Adding process: " + procName + " " + uid + " " + proc);
            mProcesses.put(procName, uid, proc);
        }
    }
    if (DEBUG_PARCEL)
        Slog.d(TAG, "Read " + mProcesses.getMap().size() + " processes");
    int NPKG = in.readInt();
    if (NPKG < 0) {
        mReadError = "bad package count: " + NPKG;
        return;
    }
    while (NPKG > 0) {
        NPKG--;
        final String pkgName = readCommonString(in, version);
        if (pkgName == null) {
            mReadError = "bad package name";
            return;
        }
        int NUID = in.readInt();
        if (NUID < 0) {
            mReadError = "bad uid count: " + NUID;
            return;
        }
        while (NUID > 0) {
            NUID--;
            final int uid = in.readInt();
            if (uid < 0) {
                mReadError = "bad uid: " + uid;
                return;
            }
            int NVERS = in.readInt();
            if (NVERS < 0) {
                mReadError = "bad versions count: " + NVERS;
                return;
            }
            while (NVERS > 0) {
                NVERS--;
                final int vers = in.readInt();
                PackageState pkgState = new PackageState(pkgName, uid);
                SparseArray<PackageState> vpkg = mPackages.get(pkgName, uid);
                if (vpkg == null) {
                    vpkg = new SparseArray<PackageState>();
                    mPackages.put(pkgName, uid, vpkg);
                }
                vpkg.put(vers, pkgState);
                int NPROCS = in.readInt();
                if (NPROCS < 0) {
                    mReadError = "bad package process count: " + NPROCS;
                    return;
                }
                while (NPROCS > 0) {
                    NPROCS--;
                    String procName = readCommonString(in, version);
                    if (procName == null) {
                        mReadError = "bad package process name";
                        return;
                    }
                    int hasProc = in.readInt();
                    if (DEBUG_PARCEL)
                        Slog.d(TAG, "Reading package " + pkgName + " " + uid + " process " + procName + " hasProc=" + hasProc);
                    ProcessState commonProc = mProcesses.get(procName, uid);
                    if (DEBUG_PARCEL)
                        Slog.d(TAG, "Got common proc " + procName + " " + uid + ": " + commonProc);
                    if (commonProc == null) {
                        mReadError = "no common proc: " + procName;
                        return;
                    }
                    if (hasProc != 0) {
                        // The process for this package is unique to the package; we
                        // need to load it.  We don't need to do anything about it if
                        // it is not unique because if someone later looks for it
                        // they will find and use it from the global procs.
                        ProcessState proc = hadData ? pkgState.mProcesses.get(procName) : null;
                        if (proc != null) {
                            if (!proc.readFromParcel(in, false)) {
                                return;
                            }
                        } else {
                            proc = new ProcessState(commonProc, pkgName, uid, vers, procName, 0);
                            if (!proc.readFromParcel(in, true)) {
                                return;
                            }
                        }
                        if (DEBUG_PARCEL)
                            Slog.d(TAG, "Adding package " + pkgName + " process: " + procName + " " + uid + " " + proc);
                        pkgState.mProcesses.put(procName, proc);
                    } else {
                        if (DEBUG_PARCEL)
                            Slog.d(TAG, "Adding package " + pkgName + " process: " + procName + " " + uid + " " + commonProc);
                        pkgState.mProcesses.put(procName, commonProc);
                    }
                }
                int NSRVS = in.readInt();
                if (NSRVS < 0) {
                    mReadError = "bad package service count: " + NSRVS;
                    return;
                }
                while (NSRVS > 0) {
                    NSRVS--;
                    String serviceName = in.readString();
                    if (serviceName == null) {
                        mReadError = "bad package service name";
                        return;
                    }
                    String processName = version > 9 ? readCommonString(in, version) : null;
                    ServiceState serv = hadData ? pkgState.mServices.get(serviceName) : null;
                    if (serv == null) {
                        serv = new ServiceState(this, pkgName, serviceName, processName, null);
                    }
                    if (!serv.readFromParcel(in)) {
                        return;
                    }
                    if (DEBUG_PARCEL)
                        Slog.d(TAG, "Adding package " + pkgName + " service: " + serviceName + " " + uid + " " + serv);
                    pkgState.mServices.put(serviceName, serv);
                }
            }
        }
    }
    // Fragmentation info
    final int NPAGETYPES = in.readInt();
    mPageTypeZones.clear();
    mPageTypeZones.ensureCapacity(NPAGETYPES);
    mPageTypeLabels.clear();
    mPageTypeLabels.ensureCapacity(NPAGETYPES);
    mPageTypeSizes.clear();
    mPageTypeSizes.ensureCapacity(NPAGETYPES);
    for (int i = 0; i < NPAGETYPES; i++) {
        mPageTypeZones.add(in.readInt());
        mPageTypeLabels.add(in.readString());
        mPageTypeSizes.add(in.createIntArray());
    }
    mIndexToCommonString = null;
    if (DEBUG_PARCEL)
        Slog.d(TAG, "Successfully read procstats!");
}

Example 7 with ServiceState

use of com.android.internal.app.procstats.ServiceState in project platform_frameworks_base by android.

the class ProcessStats method add.

public void add(ProcessStats other) {
    ArrayMap<String, SparseArray<SparseArray<PackageState>>> pkgMap = other.mPackages.getMap();
    for (int ip = 0; ip < pkgMap.size(); ip++) {
        final String pkgName = pkgMap.keyAt(ip);
        final SparseArray<SparseArray<PackageState>> uids = pkgMap.valueAt(ip);
        for (int iu = 0; iu < uids.size(); iu++) {
            final int uid = uids.keyAt(iu);
            final SparseArray<PackageState> versions = uids.valueAt(iu);
            for (int iv = 0; iv < versions.size(); iv++) {
                final int vers = versions.keyAt(iv);
                final PackageState otherState = versions.valueAt(iv);
                final int NPROCS = otherState.mProcesses.size();
                final int NSRVS = otherState.mServices.size();
                for (int iproc = 0; iproc < NPROCS; iproc++) {
                    ProcessState otherProc = otherState.mProcesses.valueAt(iproc);
                    if (otherProc.getCommonProcess() != otherProc) {
                        if (DEBUG)
                            Slog.d(TAG, "Adding pkg " + pkgName + " uid " + uid + " vers " + vers + " proc " + otherProc.getName());
                        ProcessState thisProc = getProcessStateLocked(pkgName, uid, vers, otherProc.getName());
                        if (thisProc.getCommonProcess() == thisProc) {
                            if (DEBUG)
                                Slog.d(TAG, "Existing process is single-package, splitting");
                            thisProc.setMultiPackage(true);
                            long now = SystemClock.uptimeMillis();
                            final PackageState pkgState = getPackageStateLocked(pkgName, uid, vers);
                            thisProc = thisProc.clone(now);
                            pkgState.mProcesses.put(thisProc.getName(), thisProc);
                        }
                        thisProc.add(otherProc);
                    }
                }
                for (int isvc = 0; isvc < NSRVS; isvc++) {
                    ServiceState otherSvc = otherState.mServices.valueAt(isvc);
                    if (DEBUG)
                        Slog.d(TAG, "Adding pkg " + pkgName + " uid " + uid + " service " + otherSvc.getName());
                    ServiceState thisSvc = getServiceStateLocked(pkgName, uid, vers, otherSvc.getProcessName(), otherSvc.getName());
                    thisSvc.add(otherSvc);
                }
            }
        }
    }
    ArrayMap<String, SparseArray<ProcessState>> procMap = other.mProcesses.getMap();
    for (int ip = 0; ip < procMap.size(); ip++) {
        SparseArray<ProcessState> uids = procMap.valueAt(ip);
        for (int iu = 0; iu < uids.size(); iu++) {
            int uid = uids.keyAt(iu);
            ProcessState otherProc = uids.valueAt(iu);
            final String name = otherProc.getName();
            final String pkg = otherProc.getPackage();
            final int vers = otherProc.getVersion();
            ProcessState thisProc = mProcesses.get(name, uid);
            if (DEBUG)
                Slog.d(TAG, "Adding uid " + uid + " proc " + name);
            if (thisProc == null) {
                if (DEBUG)
                    Slog.d(TAG, "Creating new process!");
                thisProc = new ProcessState(this, pkg, uid, vers, name);
                mProcesses.put(name, uid, thisProc);
                PackageState thisState = getPackageStateLocked(pkg, uid, vers);
                if (!thisState.mProcesses.containsKey(name)) {
                    thisState.mProcesses.put(name, thisProc);
                }
            }
            thisProc.add(otherProc);
        }
    }
    for (int i = 0; i < ADJ_COUNT; i++) {
        if (DEBUG)
            Slog.d(TAG, "Total duration #" + i + " inc by " + other.mMemFactorDurations[i] + " from " + mMemFactorDurations[i]);
        mMemFactorDurations[i] += other.mMemFactorDurations[i];
    }
    mSysMemUsage.mergeStats(other.mSysMemUsage);
    if (other.mTimePeriodStartClock < mTimePeriodStartClock) {
        mTimePeriodStartClock = other.mTimePeriodStartClock;
        mTimePeriodStartClockStr = other.mTimePeriodStartClockStr;
    }
    mTimePeriodEndRealtime += other.mTimePeriodEndRealtime - other.mTimePeriodStartRealtime;
    mTimePeriodEndUptime += other.mTimePeriodEndUptime - other.mTimePeriodStartUptime;
    mHasSwappedOutPss |= other.mHasSwappedOutPss;
}

Example 8 with ServiceState

use of com.android.internal.app.procstats.ServiceState in project platform_frameworks_base by android.

the class ProcessStats method resetSafely.

public void resetSafely() {
    if (DEBUG)
        Slog.d(TAG, "Safely resetting state of " + mTimePeriodStartClockStr);
    resetCommon();
    // First initialize use count of all common processes.
    final long now = SystemClock.uptimeMillis();
    final ArrayMap<String, SparseArray<ProcessState>> procMap = mProcesses.getMap();
    for (int ip = procMap.size() - 1; ip >= 0; ip--) {
        final SparseArray<ProcessState> uids = procMap.valueAt(ip);
        for (int iu = uids.size() - 1; iu >= 0; iu--) {
            uids.valueAt(iu).tmpNumInUse = 0;
        }
    }
    // Next reset or prune all per-package processes, and for the ones that are reset
    // track this back to the common processes.
    final ArrayMap<String, SparseArray<SparseArray<PackageState>>> pkgMap = mPackages.getMap();
    for (int ip = pkgMap.size() - 1; ip >= 0; ip--) {
        final SparseArray<SparseArray<PackageState>> uids = pkgMap.valueAt(ip);
        for (int iu = uids.size() - 1; iu >= 0; iu--) {
            final SparseArray<PackageState> vpkgs = uids.valueAt(iu);
            for (int iv = vpkgs.size() - 1; iv >= 0; iv--) {
                final PackageState pkgState = vpkgs.valueAt(iv);
                for (int iproc = pkgState.mProcesses.size() - 1; iproc >= 0; iproc--) {
                    final ProcessState ps = pkgState.mProcesses.valueAt(iproc);
                    if (ps.isInUse()) {
                        ps.resetSafely(now);
                        ps.getCommonProcess().tmpNumInUse++;
                        ps.getCommonProcess().tmpFoundSubProc = ps;
                    } else {
                        pkgState.mProcesses.valueAt(iproc).makeDead();
                        pkgState.mProcesses.removeAt(iproc);
                    }
                }
                for (int isvc = pkgState.mServices.size() - 1; isvc >= 0; isvc--) {
                    final ServiceState ss = pkgState.mServices.valueAt(isvc);
                    if (ss.isInUse()) {
                        ss.resetSafely(now);
                    } else {
                        pkgState.mServices.removeAt(isvc);
                    }
                }
                if (pkgState.mProcesses.size() <= 0 && pkgState.mServices.size() <= 0) {
                    vpkgs.removeAt(iv);
                }
            }
            if (vpkgs.size() <= 0) {
                uids.removeAt(iu);
            }
        }
        if (uids.size() <= 0) {
            pkgMap.removeAt(ip);
        }
    }
    // Finally prune out any common processes that are no longer in use.
    for (int ip = procMap.size() - 1; ip >= 0; ip--) {
        final SparseArray<ProcessState> uids = procMap.valueAt(ip);
        for (int iu = uids.size() - 1; iu >= 0; iu--) {
            ProcessState ps = uids.valueAt(iu);
            if (ps.isInUse() || ps.tmpNumInUse > 0) {
                // using it).
                if (!ps.isActive() && ps.isMultiPackage() && ps.tmpNumInUse == 1) {
                    // Here we go...
                    ps = ps.tmpFoundSubProc;
                    ps.makeStandalone();
                    uids.setValueAt(iu, ps);
                } else {
                    ps.resetSafely(now);
                }
            } else {
                ps.makeDead();
                uids.removeAt(iu);
            }
        }
        if (uids.size() <= 0) {
            procMap.removeAt(ip);
        }
    }
    mStartTime = now;
    if (DEBUG)
        Slog.d(TAG, "State reset; now " + mTimePeriodStartClockStr);
}

Example 9 with ServiceState

use of com.android.internal.app.procstats.ServiceState in project android_frameworks_base by DirtyUnicorns.

the class ProcessStats method getProcessStateLocked.

public ProcessState getProcessStateLocked(String packageName, int uid, int vers, String processName) {
    final PackageState pkgState = getPackageStateLocked(packageName, uid, vers);
    ProcessState ps = pkgState.mProcesses.get(processName);
    if (ps != null) {
        return ps;
    }
    ProcessState commonProc = mProcesses.get(processName, uid);
    if (commonProc == null) {
        commonProc = new ProcessState(this, packageName, uid, vers, processName);
        mProcesses.put(processName, uid, commonProc);
        if (DEBUG)
            Slog.d(TAG, "GETPROC created new common " + commonProc);
    }
    if (!commonProc.isMultiPackage()) {
        if (packageName.equals(commonProc.getPackage()) && vers == commonProc.getVersion()) {
            // This common process is not in use by multiple packages, and
            // is for the calling package, so we can just use it directly.
            ps = commonProc;
            if (DEBUG)
                Slog.d(TAG, "GETPROC also using for pkg " + commonProc);
        } else {
            if (DEBUG)
                Slog.d(TAG, "GETPROC need to split common proc!");
            // This common process has not been in use by multiple packages,
            // but it was created for a different package than the caller.
            // We need to convert it to a multi-package process.
            commonProc.setMultiPackage(true);
            // To do this, we need to make two new process states, one a copy
            // of the current state for the process under the original package
            // name, and the second a free new process state for it as the
            // new package name.
            long now = SystemClock.uptimeMillis();
            // First let's make a copy of the current process state and put
            // that under the now unique state for its original package name.
            final PackageState commonPkgState = getPackageStateLocked(commonProc.getPackage(), uid, commonProc.getVersion());
            if (commonPkgState != null) {
                ProcessState cloned = commonProc.clone(now);
                if (DEBUG)
                    Slog.d(TAG, "GETPROC setting clone to pkg " + commonProc.getPackage() + ": " + cloned);
                commonPkgState.mProcesses.put(commonProc.getName(), cloned);
                // to point to the new package-specific process state.
                for (int i = commonPkgState.mServices.size() - 1; i >= 0; i--) {
                    ServiceState ss = commonPkgState.mServices.valueAt(i);
                    if (ss.getProcess() == commonProc) {
                        if (DEBUG)
                            Slog.d(TAG, "GETPROC switching service to cloned: " + ss);
                        ss.setProcess(cloned);
                    } else if (DEBUG) {
                        Slog.d(TAG, "GETPROC leaving proc of " + ss);
                    }
                }
            } else {
                Slog.w(TAG, "Cloning proc state: no package state " + commonProc.getPackage() + "/" + uid + " for proc " + commonProc.getName());
            }
            // And now make a fresh new process state for the new package name.
            ps = new ProcessState(commonProc, packageName, uid, vers, processName, now);
            if (DEBUG)
                Slog.d(TAG, "GETPROC created new pkg " + ps);
        }
    } else {
        // The common process is for multiple packages, we need to create a
        // separate object for the per-package data.
        ps = new ProcessState(commonProc, packageName, uid, vers, processName, SystemClock.uptimeMillis());
        if (DEBUG)
            Slog.d(TAG, "GETPROC created new pkg " + ps);
    }
    pkgState.mProcesses.put(processName, ps);
    if (DEBUG)
        Slog.d(TAG, "GETPROC adding new pkg " + ps);
    return ps;
}

Example 10 with ServiceState

use of com.android.internal.app.procstats.ServiceState in project android_frameworks_base by DirtyUnicorns.

the class ProcessStats method dumpCheckinLocked.

public void dumpCheckinLocked(PrintWriter pw, String reqPackage) {
    final long now = SystemClock.uptimeMillis();
    final ArrayMap<String, SparseArray<SparseArray<PackageState>>> pkgMap = mPackages.getMap();
    pw.println("vers,5");
    pw.print("period,");
    pw.print(mTimePeriodStartClockStr);
    pw.print(",");
    pw.print(mTimePeriodStartRealtime);
    pw.print(",");
    pw.print(mRunning ? SystemClock.elapsedRealtime() : mTimePeriodEndRealtime);
    boolean partial = true;
    if ((mFlags & FLAG_SHUTDOWN) != 0) {
        pw.print(",shutdown");
        partial = false;
    }
    if ((mFlags & FLAG_SYSPROPS) != 0) {
        pw.print(",sysprops");
        partial = false;
    }
    if ((mFlags & FLAG_COMPLETE) != 0) {
        pw.print(",complete");
        partial = false;
    }
    if (partial) {
        pw.print(",partial");
    }
    if (mHasSwappedOutPss) {
        pw.print(",swapped-out-pss");
    }
    pw.println();
    pw.print("config,");
    pw.println(mRuntime);
    for (int ip = 0; ip < pkgMap.size(); ip++) {
        final String pkgName = pkgMap.keyAt(ip);
        if (reqPackage != null && !reqPackage.equals(pkgName)) {
            continue;
        }
        final SparseArray<SparseArray<PackageState>> uids = pkgMap.valueAt(ip);
        for (int iu = 0; iu < uids.size(); iu++) {
            final int uid = uids.keyAt(iu);
            final SparseArray<PackageState> vpkgs = uids.valueAt(iu);
            for (int iv = 0; iv < vpkgs.size(); iv++) {
                final int vers = vpkgs.keyAt(iv);
                final PackageState pkgState = vpkgs.valueAt(iv);
                final int NPROCS = pkgState.mProcesses.size();
                final int NSRVS = pkgState.mServices.size();
                for (int iproc = 0; iproc < NPROCS; iproc++) {
                    ProcessState proc = pkgState.mProcesses.valueAt(iproc);
                    proc.dumpPackageProcCheckin(pw, pkgName, uid, vers, pkgState.mProcesses.keyAt(iproc), now);
                }
                for (int isvc = 0; isvc < NSRVS; isvc++) {
                    final String serviceName = DumpUtils.collapseString(pkgName, pkgState.mServices.keyAt(isvc));
                    final ServiceState svc = pkgState.mServices.valueAt(isvc);
                    svc.dumpTimesCheckin(pw, pkgName, uid, vers, serviceName, now);
                }
            }
        }
    }
    ArrayMap<String, SparseArray<ProcessState>> procMap = mProcesses.getMap();
    for (int ip = 0; ip < procMap.size(); ip++) {
        String procName = procMap.keyAt(ip);
        SparseArray<ProcessState> uids = procMap.valueAt(ip);
        for (int iu = 0; iu < uids.size(); iu++) {
            final int uid = uids.keyAt(iu);
            final ProcessState procState = uids.valueAt(iu);
            procState.dumpProcCheckin(pw, procName, uid, now);
        }
    }
    pw.print("total");
    DumpUtils.dumpAdjTimesCheckin(pw, ",", mMemFactorDurations, mMemFactor, mStartTime, now);
    pw.println();
    final int sysMemUsageCount = mSysMemUsage.getKeyCount();
    if (sysMemUsageCount > 0) {
        pw.print("sysmemusage");
        for (int i = 0; i < sysMemUsageCount; i++) {
            final int key = mSysMemUsage.getKeyAt(i);
            final int type = SparseMappingTable.getIdFromKey(key);
            pw.print(",");
            DumpUtils.printProcStateTag(pw, type);
            for (int j = SYS_MEM_USAGE_SAMPLE_COUNT; j < SYS_MEM_USAGE_COUNT; j++) {
                if (j > SYS_MEM_USAGE_CACHED_MINIMUM) {
                    pw.print(":");
                }
                pw.print(mSysMemUsage.getValue(key, j));
            }
        }
    }
    pw.println();
    TotalMemoryUseCollection totalMem = new TotalMemoryUseCollection(ALL_SCREEN_ADJ, ALL_MEM_ADJ);
    computeTotalMemoryUse(totalMem, now);
    pw.print("weights,");
    pw.print(totalMem.totalTime);
    pw.print(",");
    pw.print(totalMem.sysMemCachedWeight);
    pw.print(":");
    pw.print(totalMem.sysMemSamples);
    pw.print(",");
    pw.print(totalMem.sysMemFreeWeight);
    pw.print(":");
    pw.print(totalMem.sysMemSamples);
    pw.print(",");
    pw.print(totalMem.sysMemZRamWeight);
    pw.print(":");
    pw.print(totalMem.sysMemSamples);
    pw.print(",");
    pw.print(totalMem.sysMemKernelWeight);
    pw.print(":");
    pw.print(totalMem.sysMemSamples);
    pw.print(",");
    pw.print(totalMem.sysMemNativeWeight);
    pw.print(":");
    pw.print(totalMem.sysMemSamples);
    for (int i = 0; i < STATE_COUNT; i++) {
        pw.print(",");
        pw.print(totalMem.processStateWeight[i]);
        pw.print(":");
        pw.print(totalMem.processStateSamples[i]);
    }
    pw.println();
    final int NPAGETYPES = mPageTypeLabels.size();
    for (int i = 0; i < NPAGETYPES; i++) {
        pw.print("availablepages,");
        pw.print(mPageTypeLabels.get(i));
        pw.print(",");
        pw.print(mPageTypeZones.get(i));
        pw.print(",");
        final int[] sizes = mPageTypeSizes.get(i);
        final int N = sizes == null ? 0 : sizes.length;
        for (int j = 0; j < N; j++) {
            if (j != 0) {
                pw.print(",");
            }
            pw.print(sizes[j]);
        }
        pw.println();
    }
}