You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
206 lines
7.6 KiB
206 lines
7.6 KiB
/*
|
|
* Copyright (C) 2020 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.
|
|
*/
|
|
|
|
#ifndef ANDROID_AUDIO_THREADMETRICS_H
|
|
#define ANDROID_AUDIO_THREADMETRICS_H
|
|
|
|
#include <mutex>
|
|
|
|
namespace android {
|
|
|
|
/**
|
|
* ThreadMetrics handles the AudioFlinger thread log statistics.
|
|
*
|
|
* We aggregate metrics for a particular device for proper analysis.
|
|
* This includes power, performance, and usage metrics.
|
|
*
|
|
* This class is thread-safe with a lock for safety. There is no risk of deadlock
|
|
* as this class only executes external one-way calls in Mediametrics and does not
|
|
* call any other AudioFlinger class.
|
|
*
|
|
* Terminology:
|
|
* An AudioInterval is a contiguous playback segment.
|
|
* An AudioIntervalGroup is a group of continuous playback segments on the same device.
|
|
*
|
|
* We currently deliver metrics based on an AudioIntervalGroup.
|
|
*/
|
|
class ThreadMetrics final {
|
|
public:
|
|
ThreadMetrics(std::string metricsId, bool isOut)
|
|
: mMetricsId(std::move(metricsId))
|
|
, mIsOut(isOut)
|
|
{}
|
|
|
|
~ThreadMetrics() {
|
|
logEndInterval(); // close any open interval groups
|
|
std::lock_guard l(mLock);
|
|
deliverCumulativeMetrics(AMEDIAMETRICS_PROP_EVENT_VALUE_ENDAUDIOINTERVALGROUP);
|
|
mediametrics::LogItem(mMetricsId)
|
|
.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_DTOR)
|
|
.record();
|
|
}
|
|
|
|
// Called under the following circumstances
|
|
// 1) Upon a createPatch and we are not in standby
|
|
// 2) We come out of standby
|
|
void logBeginInterval() {
|
|
std::lock_guard l(mLock);
|
|
// The devices we look for change depend on whether the Thread is input or output.
|
|
const std::string& patchDevices = mIsOut ? mCreatePatchOutDevices : mCreatePatchInDevices;
|
|
if (mDevices != patchDevices) {
|
|
deliverCumulativeMetrics(AMEDIAMETRICS_PROP_EVENT_VALUE_ENDAUDIOINTERVALGROUP);
|
|
mDevices = patchDevices; // set after endAudioIntervalGroup
|
|
resetIntervalGroupMetrics();
|
|
deliverDeviceMetrics(
|
|
AMEDIAMETRICS_PROP_EVENT_VALUE_BEGINAUDIOINTERVALGROUP, mDevices.c_str());
|
|
}
|
|
if (mIntervalStartTimeNs == 0) {
|
|
++mIntervalCount;
|
|
mIntervalStartTimeNs = systemTime();
|
|
}
|
|
}
|
|
|
|
void logConstructor(pid_t pid, const char *threadType, int32_t id) const {
|
|
mediametrics::LogItem(mMetricsId)
|
|
.setPid(pid)
|
|
.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
|
|
.set(AMEDIAMETRICS_PROP_TYPE, threadType)
|
|
.set(AMEDIAMETRICS_PROP_THREADID, id)
|
|
.record();
|
|
}
|
|
|
|
void logCreatePatch(const std::string& inDevices, const std::string& outDevices) {
|
|
std::lock_guard l(mLock);
|
|
mCreatePatchInDevices = inDevices;
|
|
mCreatePatchOutDevices = outDevices;
|
|
mediametrics::LogItem(mMetricsId)
|
|
.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CREATEAUDIOPATCH)
|
|
.set(AMEDIAMETRICS_PROP_INPUTDEVICES, inDevices)
|
|
.set(AMEDIAMETRICS_PROP_OUTPUTDEVICES, outDevices)
|
|
.record();
|
|
}
|
|
|
|
// Called when we are removed from the Thread.
|
|
void logEndInterval() {
|
|
std::lock_guard l(mLock);
|
|
if (mIntervalStartTimeNs != 0) {
|
|
const int64_t elapsedTimeNs = systemTime() - mIntervalStartTimeNs;
|
|
mIntervalStartTimeNs = 0;
|
|
mCumulativeTimeNs += elapsedTimeNs;
|
|
mDeviceTimeNs += elapsedTimeNs;
|
|
}
|
|
}
|
|
|
|
void logThrottleMs(double throttleMs) const {
|
|
mediametrics::LogItem(mMetricsId)
|
|
// ms units always double
|
|
.set(AMEDIAMETRICS_PROP_THROTTLEMS, (double)throttleMs)
|
|
.record();
|
|
}
|
|
|
|
void logLatency(double latencyMs) {
|
|
mediametrics::LogItem(mMetricsId)
|
|
.set(AMEDIAMETRICS_PROP_LATENCYMS, latencyMs)
|
|
.record();
|
|
std::lock_guard l(mLock);
|
|
mDeviceLatencyMs.add(latencyMs);
|
|
}
|
|
|
|
void logUnderrunFrames(size_t frames) {
|
|
std::lock_guard l(mLock);
|
|
if (mLastUnderrun == false && frames > 0) {
|
|
++mUnderrunCount; // count non-continguous underrun sequences.
|
|
}
|
|
mLastUnderrun = (frames > 0);
|
|
mUnderrunFrames += frames;
|
|
}
|
|
|
|
const std::string& getMetricsId() const {
|
|
return mMetricsId;
|
|
}
|
|
|
|
private:
|
|
// no lock required - all arguments and constants.
|
|
void deliverDeviceMetrics(const char *eventName, const char *devices) const {
|
|
mediametrics::LogItem(mMetricsId)
|
|
.set(AMEDIAMETRICS_PROP_EVENT, eventName)
|
|
.set(mIsOut ? AMEDIAMETRICS_PROP_OUTPUTDEVICES
|
|
: AMEDIAMETRICS_PROP_INPUTDEVICES, devices)
|
|
.record();
|
|
}
|
|
|
|
void deliverCumulativeMetrics(const char *eventName) const REQUIRES(mLock) {
|
|
if (mIntervalCount > 0) {
|
|
mediametrics::LogItem item(mMetricsId);
|
|
item.set(AMEDIAMETRICS_PROP_CUMULATIVETIMENS, mCumulativeTimeNs)
|
|
.set(AMEDIAMETRICS_PROP_DEVICETIMENS, mDeviceTimeNs)
|
|
.set(AMEDIAMETRICS_PROP_EVENT, eventName)
|
|
.set(AMEDIAMETRICS_PROP_INTERVALCOUNT, (int32_t)mIntervalCount);
|
|
if (mDeviceLatencyMs.getN() > 0) {
|
|
item.set(AMEDIAMETRICS_PROP_DEVICELATENCYMS, mDeviceLatencyMs.getMean());
|
|
}
|
|
if (mUnderrunCount > 0) {
|
|
item.set(AMEDIAMETRICS_PROP_UNDERRUN, (int32_t)mUnderrunCount)
|
|
.set(AMEDIAMETRICS_PROP_UNDERRUNFRAMES, (int64_t)mUnderrunFrames);
|
|
}
|
|
item.record();
|
|
}
|
|
}
|
|
|
|
void resetIntervalGroupMetrics() REQUIRES(mLock) {
|
|
// mDevices is not reset by clear
|
|
|
|
mIntervalCount = 0;
|
|
mIntervalStartTimeNs = 0;
|
|
// mCumulativeTimeNs is not reset by clear.
|
|
mDeviceTimeNs = 0;
|
|
|
|
mDeviceLatencyMs.reset();
|
|
|
|
mLastUnderrun = false;
|
|
mUnderrunCount = 0;
|
|
mUnderrunFrames = 0;
|
|
}
|
|
|
|
const std::string mMetricsId;
|
|
const bool mIsOut; // if true, than a playback track, otherwise used for record.
|
|
|
|
mutable std::mutex mLock;
|
|
|
|
// Devices in the interval group.
|
|
std::string mDevices GUARDED_BY(mLock); // last input or output devices based on mIsOut.
|
|
std::string mCreatePatchInDevices GUARDED_BY(mLock);
|
|
std::string mCreatePatchOutDevices GUARDED_BY(mLock);
|
|
|
|
// Number of intervals and playing time
|
|
int32_t mIntervalCount GUARDED_BY(mLock) = 0;
|
|
int64_t mIntervalStartTimeNs GUARDED_BY(mLock) = 0;
|
|
int64_t mCumulativeTimeNs GUARDED_BY(mLock) = 0;
|
|
int64_t mDeviceTimeNs GUARDED_BY(mLock) = 0;
|
|
|
|
// latency and startup for each interval.
|
|
audio_utils::Statistics<double> mDeviceLatencyMs GUARDED_BY(mLock);
|
|
|
|
// underrun count and frames
|
|
bool mLastUnderrun GUARDED_BY(mLock) = false; // checks consecutive underruns
|
|
int64_t mUnderrunCount GUARDED_BY(mLock) = 0; // number of consecutive underruns
|
|
int64_t mUnderrunFrames GUARDED_BY(mLock) = 0; // total estimated frames underrun
|
|
};
|
|
|
|
} // namespace android
|
|
|
|
#endif // ANDROID_AUDIO_THREADMETRICS_H
|