libs/battery/MultiStateCounter.h

/*
 * Copyright (C) 2021 The Android Open Source Project
 * Android BPF library - public API
 *
 * 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.
 */

#pragma once

#include <inttypes.h>
#include <log/log.h>
#include <time.h>
#include <sstream>
#include <string>

/**
 * An object that can track changes of some value over time, taking into account an additional
 * dimension: the object's state.  As the tracked value changes, the deltas are distributed
 * among the object states in accordance with the time spent in those states.
 */
namespace android {
namespace battery {

typedef uint16_t state_t;

template <class T>
class MultiStateCounter {
    uint16_t stateCount;
    state_t currentState;
    time_t lastStateChangeTimestamp;
    T emptyValue;
    T lastValue;
    time_t lastUpdateTimestamp;
    T deltaValue;

    struct State {
        time_t timeInStateSinceUpdate;
        T counter;
    };

    State* states;

public:
    MultiStateCounter(uint16_t stateCount, state_t initialState, const T& emptyValue,
                      time_t timestamp);

    virtual ~MultiStateCounter();

    void setState(state_t state, time_t timestamp);

    void updateValue(const T& value, time_t timestamp);

    const T& getCount(state_t state);

    std::string toString();

private:
    /**
     * Subtracts previousValue from newValue and returns the result in outValue.
     * Returns true iff the combination of previousValue and newValue is valid
     * (newValue >= prevValue)
     */
    bool delta(const T& previousValue, const T& newValue, T* outValue) const;

    /**
     * Adds value2 to value1 and stores the result in value1.  Denominator is
     * guaranteed to be non-zero.
     */
    void add(T* value1, const T& value2, const uint64_t numerator,
             const uint64_t denominator) const;

    std::string valueToString(const T& value) const;
};

// ---------------------- MultiStateCounter Implementation -------------------------
// Since MultiStateCounter is a template, the implementation must be inlined.

template <class T>
MultiStateCounter<T>::MultiStateCounter(uint16_t stateCount, state_t initialState,
                                        const T& emptyValue, time_t timestamp)
      : stateCount(stateCount),
        currentState(initialState),
        lastStateChangeTimestamp(timestamp),
        emptyValue(emptyValue),
        lastValue(emptyValue),
        lastUpdateTimestamp(timestamp),
        deltaValue(emptyValue) {
    states = new State[stateCount];
    for (int i = 0; i < stateCount; i++) {
        states[i].timeInStateSinceUpdate = 0;
        states[i].counter = emptyValue;
    }
}

template <class T>
MultiStateCounter<T>::~MultiStateCounter() {
    delete[] states;
};

template <class T>
void MultiStateCounter<T>::setState(state_t state, time_t timestamp) {
    if (timestamp >= lastStateChangeTimestamp) {
        states[currentState].timeInStateSinceUpdate += timestamp - lastStateChangeTimestamp;
    } else {
        ALOGE("setState is called with an earlier timestamp: %lu, previous timestamp: %lu\n",
              (unsigned long)timestamp, (unsigned long)lastStateChangeTimestamp);
        // The accumulated durations have become unreliable. For example, if the timestamp
        // sequence was 1000, 2000, 1000, 3000, if we accumulated the positive deltas,
        // we would get 4000, which is greater than (last - first). This could lead to
        // counts exceeding 100%.
        for (int i = 0; i < stateCount; i++) {
            states[i].timeInStateSinceUpdate = 0;
        }
    }
    currentState = state;
    lastStateChangeTimestamp = timestamp;
}

template <class T>
void MultiStateCounter<T>::updateValue(const T& value, time_t timestamp) {
    // Confirm the current state for the side-effect of updating the time-in-state
    // counter for the current state.
    setState(currentState, timestamp);

    if (timestamp > lastUpdateTimestamp) {
        if (delta(lastValue, value, &deltaValue)) {
            time_t timeSinceUpdate = timestamp - lastUpdateTimestamp;
            for (int i = 0; i < stateCount; i++) {
                time_t timeInState = states[i].timeInStateSinceUpdate;
                if (timeInState) {
                    add(&states[i].counter, deltaValue, timeInState, timeSinceUpdate);
                    states[i].timeInStateSinceUpdate = 0;
                }
            }
        } else {
            std::stringstream str;
            str << "updateValue is called with a value " << valueToString(value)
                << ", which is lower than the previous value " << valueToString(lastValue) << "\n";
            ALOGE("%s", str.str().c_str());
        }
    } else if (timestamp < lastUpdateTimestamp) {
        ALOGE("updateValue is called with an earlier timestamp: %lu, previous timestamp: %lu\n",
              (unsigned long)timestamp, (unsigned long)lastUpdateTimestamp);
    }
    lastValue = value;
    lastUpdateTimestamp = timestamp;
}

template <class T>
const T& MultiStateCounter<T>::getCount(state_t state) {
    return states[state].counter;
}

template <class T>
std::string MultiStateCounter<T>::toString() {
    std::stringstream str;
    str << "currentState: " << currentState
        << " lastStateChangeTimestamp: " << lastStateChangeTimestamp
        << " lastUpdateTimestamp: " << lastUpdateTimestamp << " states: [";
    for (int i = 0; i < stateCount; i++) {
        if (i != 0) {
            str << ", ";
        }
        str << i << ": time: " << states[i].timeInStateSinceUpdate
            << " counter: " << valueToString(states[i].counter);
    }
    str << "]";
    return str.str();
}

} // namespace battery
} // namespace android