blob: 0ca463986db9e3f9037ce9dfec3a90f69fa8175a [file] [log] [blame]
/*
* Copyright (C) 2019 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.
*/
#pragma once
#include <any>
#include <map>
#include <sstream>
#include <string>
#include <android-base/thread_annotations.h>
#include <media/MediaMetricsItem.h>
namespace android::mediametrics {
/**
* The TransactionLog is used to record mediametrics::Items to present
* different views on the time information (selected by audio, and sorted by key).
*
* The TransactionLog will always present data in timestamp order. (Perhaps we
* just make this submit order).
*
* These Views have a cost in shared pointer storage, so they aren't quite free.
*
* The TransactionLog is NOT thread safe.
*/
class TransactionLog final { // made final as we have copy constructor instead of dup() override.
public:
// In long term run, the garbage collector aims to keep the
// Transaction Log between the Low Water Mark and the High Water Mark.
// low water mark
static inline constexpr size_t kLogItemsLowWater = 1700;
// high water mark
static inline constexpr size_t kLogItemsHighWater = 2000;
// Estimated max data usage is 1KB * kLogItemsHighWater.
TransactionLog() = default;
TransactionLog(size_t lowWaterMark, size_t highWaterMark)
: mLowWaterMark(lowWaterMark)
, mHighWaterMark(highWaterMark) {
LOG_ALWAYS_FATAL_IF(highWaterMark <= lowWaterMark,
"%s: required that highWaterMark:%zu > lowWaterMark:%zu",
__func__, highWaterMark, lowWaterMark);
}
// The TransactionLog copy constructor/assignment is effectively an
// instantaneous, isochronous snapshot of the other TransactionLog.
//
// The contents of the Transaction Log are shared pointers to immutable instances -
// std::shared_ptr<const mediametrics::Item>, so we use a shallow copy,
// which is more efficient in space and execution time than a deep copy,
// and gives the same results.
TransactionLog(const TransactionLog &other) {
*this = other;
}
TransactionLog& operator=(const TransactionLog &other) {
std::lock_guard lock(mLock);
mLog.clear();
mItemMap.clear();
std::lock_guard lock2(other.mLock);
mLog = other.mLog;
mItemMap = other.mItemMap;
mGarbageCollectionCount = other.mGarbageCollectionCount.load();
return *this;
}
/**
* Put an item in the TransactionLog.
*/
status_t put(const std::shared_ptr<const mediametrics::Item>& item) {
const std::string& key = item->getKey();
const int64_t time = item->getTimestamp();
std::vector<std::any> garbage; // objects destroyed after lock.
std::lock_guard lock(mLock);
(void)gc(garbage);
mLog.emplace_hint(mLog.end(), time, item);
mItemMap[key].emplace_hint(mItemMap[key].end(), time, item);
return NO_ERROR; // no errors for now.
}
/**
* Returns all records within [startTime, endTime]
*/
std::vector<std::shared_ptr<const mediametrics::Item>> get(
int64_t startTime = 0, int64_t endTime = INT64_MAX) const {
std::lock_guard lock(mLock);
return getItemsInRange(mLog, startTime, endTime);
}
/**
* Returns all records for a key within [startTime, endTime]
*/
std::vector<std::shared_ptr<const mediametrics::Item>> get(
const std::string& key,
int64_t startTime = 0, int64_t endTime = INT64_MAX) const {
std::lock_guard lock(mLock);
auto mapIt = mItemMap.find(key);
if (mapIt == mItemMap.end()) return {};
return getItemsInRange(mapIt->second, startTime, endTime);
}
/**
* Returns a pair consisting of the Transaction Log as a string
* and the number of lines in the string.
*
* The number of lines in the returned pair is used as an optimization
* for subsequent line limiting.
*
* \param lines the maximum number of lines in the string returned.
* \param sinceNs the nanoseconds since Unix epoch to start dump (0 shows all)
* \param prefix the desired key prefix to match (nullptr shows all)
*/
std::pair<std::string, int32_t> dump(
int32_t lines, int64_t sinceNs, const char *prefix = nullptr) const {
std::stringstream ss;
int32_t ll = lines;
std::lock_guard lock(mLock);
// All audio items in time order.
if (ll > 0) {
ss << "Consolidated:\n";
--ll;
}
auto [s, l] = dumpMapTimeItem(mLog, ll, sinceNs, prefix);
ss << s;
ll -= l;
// Grouped by item key (category)
if (ll > 0) {
ss << "Categorized:\n";
--ll;
}
for (auto it = prefix != nullptr ? mItemMap.lower_bound(prefix) : mItemMap.begin();
it != mItemMap.end();
++it) {
if (ll <= 0) break;
if (prefix != nullptr && !startsWith(it->first, prefix)) break;
auto [s, l] = dumpMapTimeItem(it->second, ll - 1, sinceNs, prefix);
if (l == 0) continue; // don't show empty groups (due to sinceNs).
ss << " " << it->first << "\n" << s;
ll -= l + 1;
}
return { ss.str(), lines - ll };
}
/**
* Returns number of Items in the TransactionLog.
*/
size_t size() const {
std::lock_guard lock(mLock);
return mLog.size();
}
/**
* Clears all Items from the TransactionLog.
*/
// TODO: Garbage Collector, sweep and expire old values
void clear() {
std::lock_guard lock(mLock);
mLog.clear();
mItemMap.clear();
mGarbageCollectionCount = 0;
}
size_t getGarbageCollectionCount() const {
return mGarbageCollectionCount;
}
private:
using MapTimeItem =
std::multimap<int64_t /* time */, std::shared_ptr<const mediametrics::Item>>;
static std::pair<std::string, int32_t> dumpMapTimeItem(
const MapTimeItem& mapTimeItem,
int32_t lines, int64_t sinceNs = 0, const char *prefix = nullptr) {
std::stringstream ss;
int32_t ll = lines;
// Note: for our data, mapTimeItem.lower_bound(0) == mapTimeItem.begin().
for (auto it = mapTimeItem.lower_bound(sinceNs);
it != mapTimeItem.end(); ++it) {
if (ll <= 0) break;
if (prefix != nullptr && !startsWith(it->second->getKey(), prefix)) {
continue;
}
ss << " " << it->second->toString() << "\n";
--ll;
}
return { ss.str(), lines - ll };
}
/**
* Garbage collects if the TimeMachine size exceeds the high water mark.
*
* \param garbage a type-erased vector of elements to be destroyed
* outside of lock. Move large items to be destroyed here.
*
* \return true if garbage collection was done.
*/
bool gc(std::vector<std::any>& garbage) REQUIRES(mLock) {
if (mLog.size() < mHighWaterMark) return false;
auto eraseEnd = mLog.begin();
size_t toRemove = mLog.size() - mLowWaterMark;
// remove at least those elements.
// use a stale vector with precise type to avoid type erasure overhead in garbage
std::vector<std::shared_ptr<const mediametrics::Item>> stale;
for (size_t i = 0; i < toRemove; ++i) {
stale.emplace_back(std::move(eraseEnd->second));
++eraseEnd; // amortized O(1)
}
// ensure that eraseEnd is an lower bound on timeToErase.
const int64_t timeToErase = eraseEnd->first;
while (eraseEnd != mLog.end()) {
auto it = eraseEnd;
--it; // amortized O(1)
if (it->first != timeToErase) {
break; // eraseEnd represents a unique time jump.
}
stale.emplace_back(std::move(eraseEnd->second));
++eraseEnd;
}
mLog.erase(mLog.begin(), eraseEnd); // O(ptr_diff)
size_t itemMapCount = 0;
for (auto it = mItemMap.begin(); it != mItemMap.end();) {
auto &keyHist = it->second;
auto it2 = keyHist.lower_bound(timeToErase);
if (it2 == keyHist.end()) {
garbage.emplace_back(std::move(keyHist)); // directly move keyhist to garbage
it = mItemMap.erase(it);
} else {
for (auto it3 = keyHist.begin(); it3 != it2; ++it3) {
stale.emplace_back(std::move(it3->second));
}
keyHist.erase(keyHist.begin(), it2);
itemMapCount += keyHist.size();
++it;
}
}
garbage.emplace_back(std::move(stale));
ALOGD("%s(%zu, %zu): log size:%zu item map size:%zu, item map items:%zu",
__func__, mLowWaterMark, mHighWaterMark,
mLog.size(), mItemMap.size(), itemMapCount);
++mGarbageCollectionCount;
return true;
}
static std::vector<std::shared_ptr<const mediametrics::Item>> getItemsInRange(
const MapTimeItem& map,
int64_t startTime = 0, int64_t endTime = INT64_MAX) {
auto it = map.lower_bound(startTime);
if (it == map.end()) return {};
auto it2 = map.upper_bound(endTime);
std::vector<std::shared_ptr<const mediametrics::Item>> ret;
while (it != it2) {
ret.push_back(it->second);
++it;
}
return ret;
}
const size_t mLowWaterMark = kLogItemsLowWater;
const size_t mHighWaterMark = kLogItemsHighWater;
std::atomic<size_t> mGarbageCollectionCount{};
mutable std::mutex mLock;
MapTimeItem mLog GUARDED_BY(mLock);
std::map<std::string /* item_key */, MapTimeItem> mItemMap GUARDED_BY(mLock);
};
} // namespace android::mediametrics