Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit eaed0ba6 authored by Dianne Hackborn's avatar Dianne Hackborn
Browse files

Flesh out procstats protobufs to have ALL THE INFO! 

This involved re-arranging some of the protobuf structs.
What is there now is kind-of awkward, but I didn't want to go
through and just completely change the whole thing.

Bug: 110957691
Test: atest CtsStatsdHostTestCases:ProcStatsValidationTests
Change-Id: I1d59c15c4d0f3dbdea2cf71307debfcafed7938a
parent 07d80168

core/java/com/android/internal/app/procstats/AssociationState.java

+52 −0
Original line number Diff line number Diff line
@@ -20,9 +20,12 @@ package com.android.internal.app.procstats; 
import android.os.Parcel;

import android.os.SystemClock;

import android.os.UserHandle;

import android.service.procstats.ProcessStatsAssociationStateProto;

import android.service.procstats.ProcessStatsStateProto;

import android.util.ArrayMap;

import android.util.Slog;

import android.util.TimeUtils;

import android.util.proto.ProtoOutputStream;



import java.io.PrintWriter;

import java.util.ArrayList;
@@ -656,6 +659,55 @@ public final class AssociationState { 
        }

    }



    public void writeToProto(ProtoOutputStream proto, long fieldId, long now) {

        final long token = proto.start(fieldId);



        proto.write(ProcessStatsAssociationStateProto.COMPONENT_NAME, mName);

        final int NSRC = mSources.size();

        for (int isrc = 0; isrc < NSRC; isrc++) {

            final SourceKey key = mSources.keyAt(isrc);

            final SourceState src = mSources.valueAt(isrc);

            final long sourceToken = proto.start(ProcessStatsAssociationStateProto.SOURCES);

            proto.write(ProcessStatsAssociationStateProto.Source.PROCESS, key.mProcess);

            proto.write(ProcessStatsAssociationStateProto.Source.UID, key.mUid);

            proto.write(ProcessStatsAssociationStateProto.Source.TOTAL_COUNT, src.mCount);

            long duration = src.mDuration;

            if (src.mNesting > 0) {

                duration += now - src.mStartUptime;

            }

            proto.write(ProcessStatsAssociationStateProto.Source.TOTAL_DURATION_MS, duration);

            if (src.mActiveCount != 0) {

                proto.write(ProcessStatsAssociationStateProto.Source.ACTIVE_COUNT,

                        src.mActiveCount);

            }

            final long timeNow = src.mActiveStartUptime != 0 ? (now-src.mActiveStartUptime) : 0;

            if (src.mDurations != null) {

                final int N = src.mDurations.getKeyCount();

                for (int i=0; i<N; i++) {

                    final int dkey = src.mDurations.getKeyAt(i);

                    duration = src.mDurations.getValue(dkey);

                    if (dkey == src.mActiveProcState) {

                        duration += timeNow;

                    }

                    final int procState = SparseMappingTable.getIdFromKey(dkey);

                    DumpUtils.printProcStateDurationProto(proto,

                            ProcessStatsAssociationStateProto.Source.ACTIVE_STATES,

                            procState, duration);

                }

            } else {

                duration = src.mActiveDuration + timeNow;

                if (duration != 0) {

                    DumpUtils.printProcStateDurationProto(proto,

                            ProcessStatsAssociationStateProto.Source.ACTIVE_STATES,

                            src.mActiveProcState, duration);

                }

            }

            proto.end(sourceToken);

        }



        proto.end(token);

    }



    public String toString() {

        return "AssociationState{" + Integer.toHexString(System.identityHashCode(this))

                + " " + mName + " pkg=" + mPackageState.mPackageName + " proc="

core/java/com/android/internal/app/procstats/DumpUtils.java

+38 −38
Original line number Diff line number Diff line
@@ -16,32 +16,15 @@ 


package com.android.internal.app.procstats;



import android.os.Parcel;

import android.os.Parcelable;

import android.os.SystemClock;

import android.os.SystemProperties;

import android.os.UserHandle;

import android.service.procstats.ProcessStatsProto;

import android.text.format.DateFormat;

import android.util.ArrayMap;

import android.util.ArraySet;

import android.util.DebugUtils;

import android.util.Log;

import android.util.Slog;

import android.util.SparseArray;

import android.service.procstats.ProcessStatsStateProto;

import android.util.TimeUtils;

import android.util.proto.ProtoOutputStream;



import static com.android.internal.app.procstats.ProcessStats.*;



import java.io.IOException;

import java.io.InputStream;

import java.io.PrintWriter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.Objects;



/**

 * Utilities for dumping.
@@ -124,20 +107,20 @@ public final class DumpUtils { 
        STATE_TAGS[STATE_CACHED_EMPTY]              = "e";



        STATE_PROTO_ENUMS = new int[STATE_COUNT];

        STATE_PROTO_ENUMS[STATE_PERSISTENT] = ProcessStatsProto.State.PERSISTENT;

        STATE_PROTO_ENUMS[STATE_TOP] = ProcessStatsProto.State.TOP;

        STATE_PROTO_ENUMS[STATE_IMPORTANT_FOREGROUND] = ProcessStatsProto.State.IMPORTANT_FOREGROUND;

        STATE_PROTO_ENUMS[STATE_IMPORTANT_BACKGROUND] = ProcessStatsProto.State.IMPORTANT_BACKGROUND;

        STATE_PROTO_ENUMS[STATE_BACKUP] = ProcessStatsProto.State.BACKUP;

        STATE_PROTO_ENUMS[STATE_SERVICE] = ProcessStatsProto.State.SERVICE;

        STATE_PROTO_ENUMS[STATE_SERVICE_RESTARTING] = ProcessStatsProto.State.SERVICE_RESTARTING;

        STATE_PROTO_ENUMS[STATE_RECEIVER] = ProcessStatsProto.State.RECEIVER;

        STATE_PROTO_ENUMS[STATE_HEAVY_WEIGHT] = ProcessStatsProto.State.HEAVY_WEIGHT;

        STATE_PROTO_ENUMS[STATE_HOME] = ProcessStatsProto.State.HOME;

        STATE_PROTO_ENUMS[STATE_LAST_ACTIVITY] = ProcessStatsProto.State.LAST_ACTIVITY;

        STATE_PROTO_ENUMS[STATE_CACHED_ACTIVITY] = ProcessStatsProto.State.CACHED_ACTIVITY;

        STATE_PROTO_ENUMS[STATE_CACHED_ACTIVITY_CLIENT] = ProcessStatsProto.State.CACHED_ACTIVITY_CLIENT;

        STATE_PROTO_ENUMS[STATE_CACHED_EMPTY] = ProcessStatsProto.State.CACHED_EMPTY;

        STATE_PROTO_ENUMS[STATE_PERSISTENT] = ProcessStatsStateProto.PERSISTENT;

        STATE_PROTO_ENUMS[STATE_TOP] = ProcessStatsStateProto.TOP;

        STATE_PROTO_ENUMS[STATE_IMPORTANT_FOREGROUND] = ProcessStatsStateProto.IMPORTANT_FOREGROUND;

        STATE_PROTO_ENUMS[STATE_IMPORTANT_BACKGROUND] = ProcessStatsStateProto.IMPORTANT_BACKGROUND;

        STATE_PROTO_ENUMS[STATE_BACKUP] = ProcessStatsStateProto.BACKUP;

        STATE_PROTO_ENUMS[STATE_SERVICE] = ProcessStatsStateProto.SERVICE;

        STATE_PROTO_ENUMS[STATE_SERVICE_RESTARTING] = ProcessStatsStateProto.SERVICE_RESTARTING;

        STATE_PROTO_ENUMS[STATE_RECEIVER] = ProcessStatsStateProto.RECEIVER;

        STATE_PROTO_ENUMS[STATE_HEAVY_WEIGHT] = ProcessStatsStateProto.HEAVY_WEIGHT;

        STATE_PROTO_ENUMS[STATE_HOME] = ProcessStatsStateProto.HOME;

        STATE_PROTO_ENUMS[STATE_LAST_ACTIVITY] = ProcessStatsStateProto.LAST_ACTIVITY;

        STATE_PROTO_ENUMS[STATE_CACHED_ACTIVITY] = ProcessStatsStateProto.CACHED_ACTIVITY;

        STATE_PROTO_ENUMS[STATE_CACHED_ACTIVITY_CLIENT] = ProcessStatsStateProto.CACHED_ACTIVITY_CLIENT;

        STATE_PROTO_ENUMS[STATE_CACHED_EMPTY] = ProcessStatsStateProto.CACHED_EMPTY;

    }



    public static final String[] ADJ_SCREEN_NAMES_CSV = new String[] {
@@ -155,8 +138,8 @@ public final class DumpUtils { 
    };



    static final int[] ADJ_SCREEN_PROTO_ENUMS = new int[] {

            ProcessStatsProto.State.OFF,

            ProcessStatsProto.State.ON

            ProcessStatsStateProto.OFF,

            ProcessStatsStateProto.ON

    };



    static final String[] ADJ_MEM_TAGS = new String[] {
@@ -164,10 +147,10 @@ public final class DumpUtils { 
    };



    static final int[] ADJ_MEM_PROTO_ENUMS = new int[] {

            ProcessStatsProto.State.NORMAL,

            ProcessStatsProto.State.MODERATE,

            ProcessStatsProto.State.LOW,

            ProcessStatsProto.State.CRITICAL

            ProcessStatsStateProto.NORMAL,

            ProcessStatsStateProto.MODERATE,

            ProcessStatsStateProto.LOW,

            ProcessStatsStateProto.CRITICAL

    };



    static final String CSV_SEP = "\t";
@@ -281,6 +264,23 @@ public final class DumpUtils { 
        printArrayEntry(pw, ADJ_MEM_TAGS, state, 1);

    }



    public static void printProcStateAdjTagProto(ProtoOutputStream proto, long screenId, long memId,

            int state) {

        state = printProto(proto, screenId, ADJ_SCREEN_PROTO_ENUMS,

                state, ADJ_SCREEN_MOD * STATE_COUNT);

        printProto(proto, memId, ADJ_MEM_PROTO_ENUMS, state, STATE_COUNT);

    }



    public static void printProcStateDurationProto(ProtoOutputStream proto, long fieldId,

            int procState, long duration) {

        final long stateToken = proto.start(fieldId);

        DumpUtils.printProto(proto, ProcessStatsStateProto.PROCESS_STATE,

                DumpUtils.STATE_PROTO_ENUMS, procState, 1);

        proto.write(ProcessStatsStateProto.DURATION_MS, duration);

        proto.end(stateToken);



    }



    public static void printProcStateTagAndValue(PrintWriter pw, int state, long value) {

        pw.print(',');

        printProcStateTag(pw, state);

core/java/com/android/internal/app/procstats/ProcessState.java

+10 −9
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ import android.os.Parcel; 
import android.os.SystemClock;

import android.os.UserHandle;

import android.service.procstats.ProcessStatsProto;

import android.service.procstats.ProcessStatsStateProto;

import android.util.ArrayMap;

import android.util.DebugUtils;

import android.util.Log;
@@ -1377,14 +1378,14 @@ public final class ProcessState { 
            }

            final long stateToken = proto.start(ProcessStatsProto.STATES);

            DumpUtils.printProcStateTagProto(proto,

                    ProcessStatsProto.State.SCREEN_STATE,

                    ProcessStatsProto.State.MEMORY_STATE,

                    ProcessStatsProto.State.PROCESS_STATE,

                    ProcessStatsStateProto.SCREEN_STATE,

                    ProcessStatsStateProto.MEMORY_STATE,

                    ProcessStatsStateProto.PROCESS_STATE,

                    type);



            long duration = durationByState.get(type);

            durationByState.delete(type); // remove the key since it is already being dumped.

            proto.write(ProcessStatsProto.State.DURATION_MS, duration);

            proto.write(ProcessStatsStateProto.DURATION_MS, duration);



            mPssTable.writeStatsToProtoForKey(proto, key);
@@ -1394,18 +1395,18 @@ public final class ProcessState { 
        for (int i = 0; i < durationByState.size(); i++) {

            final long stateToken = proto.start(ProcessStatsProto.STATES);

            DumpUtils.printProcStateTagProto(proto,

                    ProcessStatsProto.State.SCREEN_STATE,

                    ProcessStatsProto.State.MEMORY_STATE,

                    ProcessStatsProto.State.PROCESS_STATE,

                    ProcessStatsStateProto.SCREEN_STATE,

                    ProcessStatsStateProto.MEMORY_STATE,

                    ProcessStatsStateProto.PROCESS_STATE,

                    durationByState.keyAt(i));

            proto.write(ProcessStatsProto.State.DURATION_MS, durationByState.valueAt(i));

            proto.write(ProcessStatsStateProto.DURATION_MS, durationByState.valueAt(i));

            proto.end(stateToken);

        }



        final long totalRunningDuration = getTotalRunningDuration(now);

        if (totalRunningDuration > 0) {

            final long stateToken = proto.start(ProcessStatsProto.TOTAL_RUNNING_STATE);

            proto.write(ProcessStatsProto.State.DURATION_MS, totalRunningDuration);

            proto.write(ProcessStatsStateProto.DURATION_MS, totalRunningDuration);

            if (mTotalRunningPss[PSS_SAMPLE_COUNT] != 0) {

                PssTable.writeStatsToProto(proto, mTotalRunningPss, 0);

            }

core/java/com/android/internal/app/procstats/ProcessStats.java

+48 −7
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ import android.os.Parcelable; 
import android.os.SystemClock;

import android.os.SystemProperties;

import android.os.UserHandle;

import android.service.procstats.ProcessStatsPackageProto;

import android.service.procstats.ProcessStatsSectionProto;

import android.text.format.DateFormat;

import android.util.ArrayMap;
@@ -2013,10 +2014,8 @@ public final class ProcessStats implements Parcelable { 
    }



    public void writeToProto(ProtoOutputStream proto, long fieldId, long now) {

        final ArrayMap<String, SparseArray<LongSparseArray<PackageState>>> pkgMap =

                mPackages.getMap();



        final long token = proto.start(fieldId);



        proto.write(ProcessStatsSectionProto.START_REALTIME_MS, mTimePeriodStartRealtime);

        proto.write(ProcessStatsSectionProto.END_REALTIME_MS,

                mRunning ? SystemClock.elapsedRealtime() : mTimePeriodEndRealtime);
@@ -2041,16 +2040,31 @@ public final class ProcessStats implements Parcelable { 
            proto.write(ProcessStatsSectionProto.STATUS, ProcessStatsSectionProto.STATUS_PARTIAL);

        }



        ArrayMap<String, SparseArray<ProcessState>> procMap = mProcesses.getMap();

        final 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);

            final String procName = procMap.keyAt(ip);

            final 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.writeToProto(proto, ProcessStatsSectionProto.PROCESS_STATS, procName, uid, now);

                procState.writeToProto(proto, ProcessStatsSectionProto.PROCESS_STATS, procName,

                        uid, now);

            }

        }



        final ArrayMap<String, SparseArray<LongSparseArray<PackageState>>> pkgMap =

                mPackages.getMap();

        for (int ip = 0; ip < pkgMap.size(); ip++) {

            final SparseArray<LongSparseArray<PackageState>> uids = pkgMap.valueAt(ip);

            for (int iu = 0; iu < uids.size(); iu++) {

                final LongSparseArray<PackageState> vers = uids.valueAt(iu);

                for (int iv = 0; iv < vers.size(); iv++) {

                    final PackageState pkgState = vers.valueAt(iv);

                    pkgState.writeToProto(proto, ProcessStatsSectionProto.PACKAGE_STATS, now);

                }

            }

        }



        proto.end(token);

    }
@@ -2095,6 +2109,33 @@ public final class ProcessStats implements Parcelable { 
            if (DEBUG) Slog.d(TAG, "GETASC: creating " + as + " in " + proc.getName());

            return as;

        }



        public void writeToProto(ProtoOutputStream proto, long fieldId, long now) {

            final long token = proto.start(fieldId);



            proto.write(ProcessStatsPackageProto.PACKAGE, mPackageName);

            proto.write(ProcessStatsPackageProto.UID, mUid);

            proto.write(ProcessStatsPackageProto.VERSION, mVersionCode);



            for (int ip = 0; ip < mProcesses.size(); ip++) {

                final String procName = mProcesses.keyAt(ip);

                final ProcessState procState = mProcesses.valueAt(ip);

                procState.writeToProto(proto, ProcessStatsPackageProto.PROCESS_STATS, procName,

                        mUid, now);

            }



            for (int is = 0; is < mServices.size(); is++) {

                final ServiceState serviceState = mServices.valueAt(is);

                serviceState.writeToProto(proto, ProcessStatsPackageProto.PROCESS_STATS, now);

            }



            for (int ia=0; ia<mAssociations.size(); ia++) {

                final AssociationState ascState = mAssociations.valueAt(ia);

                ascState.writeToProto(proto, ProcessStatsPackageProto.ASSOCIATION_STATS, now);

            }



            proto.end(token);

        }

    }



    public static final class ProcessDataCollection {

core/java/com/android/internal/app/procstats/PssTable.java

+5 −5
Original line number Diff line number Diff line
@@ -28,7 +28,7 @@ import static com.android.internal.app.procstats.ProcessStats.PSS_USS_AVERAGE; 
import static com.android.internal.app.procstats.ProcessStats.PSS_USS_MAXIMUM;

import static com.android.internal.app.procstats.ProcessStats.PSS_COUNT;



import android.service.procstats.ProcessStatsProto;

import android.service.procstats.ProcessStatsStateProto;

import android.util.proto.ProtoOutputStream;

import android.util.proto.ProtoUtils;
@@ -153,16 +153,16 @@ public class PssTable extends SparseMappingTable.Table { 


    public static void writeStatsToProto(ProtoOutputStream proto, final long[] stats,

            final int statsIndex) {

        proto.write(ProcessStatsProto.State.SAMPLE_SIZE, stats[statsIndex + PSS_SAMPLE_COUNT]);

        ProtoUtils.toAggStatsProto(proto, ProcessStatsProto.State.PSS,

        proto.write(ProcessStatsStateProto.SAMPLE_SIZE, stats[statsIndex + PSS_SAMPLE_COUNT]);

        ProtoUtils.toAggStatsProto(proto, ProcessStatsStateProto.PSS,

                stats[statsIndex + PSS_MINIMUM],

                stats[statsIndex + PSS_AVERAGE],

                stats[statsIndex + PSS_MAXIMUM]);

        ProtoUtils.toAggStatsProto(proto, ProcessStatsProto.State.USS,

        ProtoUtils.toAggStatsProto(proto, ProcessStatsStateProto.USS,

                stats[statsIndex + PSS_USS_MINIMUM],

                stats[statsIndex + PSS_USS_AVERAGE],

                stats[statsIndex + PSS_USS_MAXIMUM]);

        ProtoUtils.toAggStatsProto(proto, ProcessStatsProto.State.RSS,

        ProtoUtils.toAggStatsProto(proto, ProcessStatsStateProto.RSS,

                stats[statsIndex + PSS_RSS_MINIMUM],

                stats[statsIndex + PSS_RSS_AVERAGE],

                stats[statsIndex + PSS_RSS_MAXIMUM]);