xref: /frameworks/base/core/java/com/android/internal/app/procstats/PssTable.java

/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.internal.app.procstats;

import static com.android.internal.app.procstats.ProcessStats.PSS_RSS_AVERAGE;
import static com.android.internal.app.procstats.ProcessStats.PSS_RSS_MAXIMUM;
import static com.android.internal.app.procstats.ProcessStats.PSS_RSS_MINIMUM;
import static com.android.internal.app.procstats.ProcessStats.PSS_SAMPLE_COUNT;
import static com.android.internal.app.procstats.ProcessStats.PSS_MINIMUM;
import static com.android.internal.app.procstats.ProcessStats.PSS_AVERAGE;
import static com.android.internal.app.procstats.ProcessStats.PSS_MAXIMUM;
import static com.android.internal.app.procstats.ProcessStats.PSS_USS_MINIMUM;
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;

/**
 * Class to accumulate PSS data.
 */
public class PssTable extends SparseMappingTable.Table {
    /**
     * Construct the PssTable with 'tableData' as backing store
     * for the longs data.
     */
    public PssTable(SparseMappingTable tableData) {
        super(tableData);
    }

    /**
     * Merge the the values from the other table into this one.
     */
    public void mergeStats(PssTable that) {
        final int N = that.getKeyCount();
        for (int i=0; i<N; i++) {
            final int key = that.getKeyAt(i);
            final int state = SparseMappingTable.getIdFromKey(key);
            mergeStats(state, (int)that.getValue(key, PSS_SAMPLE_COUNT),
                    that.getValue(key, PSS_MINIMUM),
                    that.getValue(key, PSS_AVERAGE),
                    that.getValue(key, PSS_MAXIMUM),
                    that.getValue(key, PSS_USS_MINIMUM),
                    that.getValue(key, PSS_USS_AVERAGE),
                    that.getValue(key, PSS_USS_MAXIMUM),
                    that.getValue(key, PSS_RSS_MINIMUM),
                    that.getValue(key, PSS_RSS_AVERAGE),
                    that.getValue(key, PSS_RSS_MAXIMUM));
        }
    }

    /**
     * Merge the supplied PSS data in.  The new min pss will be the minimum of the existing
     * one and the new one, the average will now incorporate the new average, etc.
     */
    public void mergeStats(int state, int inCount, long minPss, long avgPss, long maxPss,
            long minUss, long avgUss, long maxUss, long minRss, long avgRss, long maxRss) {
        final int key = getOrAddKey((byte)state, PSS_COUNT);
        final long count = getValue(key, PSS_SAMPLE_COUNT);
        if (count == 0) {
            setValue(key, PSS_SAMPLE_COUNT, inCount);
            setValue(key, PSS_MINIMUM, minPss);
            setValue(key, PSS_AVERAGE, avgPss);
            setValue(key, PSS_MAXIMUM, maxPss);
            setValue(key, PSS_USS_MINIMUM, minUss);
            setValue(key, PSS_USS_AVERAGE, avgUss);
            setValue(key, PSS_USS_MAXIMUM, maxUss);
            setValue(key, PSS_RSS_MINIMUM, minRss);
            setValue(key, PSS_RSS_AVERAGE, avgRss);
            setValue(key, PSS_RSS_MAXIMUM, maxRss);
        } else {
            setValue(key, PSS_SAMPLE_COUNT, count + inCount);

            long val;

            val = getValue(key, PSS_MINIMUM);
            if (val > minPss) {
                setValue(key, PSS_MINIMUM, minPss);
            }

            val = getValue(key, PSS_AVERAGE);
            setValue(key, PSS_AVERAGE,
                    (long)(((val*(double)count)+(avgPss*(double)inCount)) / (count+inCount)));

            val = getValue(key, PSS_MAXIMUM);
            if (val < maxPss) {
                setValue(key, PSS_MAXIMUM, maxPss);
            }

            val = getValue(key, PSS_USS_MINIMUM);
            if (val > minUss) {
                setValue(key, PSS_USS_MINIMUM, minUss);
            }

            val = getValue(key, PSS_USS_AVERAGE);
            setValue(key, PSS_USS_AVERAGE,
                    (long)(((val*(double)count)+(avgUss*(double)inCount)) / (count+inCount)));

            val = getValue(key, PSS_USS_MAXIMUM);
            if (val < maxUss) {
                setValue(key, PSS_USS_MAXIMUM, maxUss);
            }

            val = getValue(key, PSS_RSS_MINIMUM);
            if (val > minUss) {
                setValue(key, PSS_RSS_MINIMUM, minUss);
            }

            val = getValue(key, PSS_RSS_AVERAGE);
            setValue(key, PSS_RSS_AVERAGE,
                    (long)(((val*(double)count)+(avgUss*(double)inCount)) / (count+inCount)));

            val = getValue(key, PSS_RSS_MAXIMUM);
            if (val < maxUss) {
                setValue(key, PSS_RSS_MAXIMUM, maxUss);
            }
        }
    }
}