vibrator/common/StatsBase.cpp - platform/hardware/google/pixel - Git at Google

 /*
  * Copyright (C) 2021 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.
  */

 #include "StatsBase.h"

 #include <aidl/android/frameworks/stats/IStats.h>
 #include <android/binder_manager.h>
 #include <hardware/google/pixel/pixelstats/pixelatoms.pb.h>
 #include <log/log.h>
 #include <utils/Trace.h>

 #include <chrono>
 #include <sstream>

 using ::aidl::android::frameworks::stats::IStats;
 using ::aidl::android::frameworks::stats::VendorAtom;
 using ::aidl::android::frameworks::stats::VendorAtomValue;

 namespace PixelAtoms = ::android::hardware::google::pixel::PixelAtoms;

 #ifndef ARRAY_SIZE
 #define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))
 #endif

 #ifdef TRACE_STATS
 static const char *kAtomLookup[] = {"HAPTICS_PLAYCOUNTS", "HAPTICS_LATENCIES", "HAPTICS_ERRORS",
                                     "INVALID"};

 const char *atomToString(uint32_t atomId) {
     switch (atomId) {
         case PixelAtoms::Atom::kVibratorPlaycountReported:
             return kAtomLookup[0];
             break;
         case PixelAtoms::Atom::kVibratorLatencyReported:
             return kAtomLookup[1];
             break;
         case PixelAtoms::Atom::kVibratorErrorsReported:
             return kAtomLookup[2];
             break;
         default:
             return kAtomLookup[ARRAY_SIZE(kAtomLookup) - 1];
             break;
     }
 }

 #define STATS_TRACE(...)   \
     ATRACE_NAME(__func__); \
     ALOGD(__VA_ARGS__)
 #else
 #define STATS_TRACE(...) ATRACE_NAME(__func__)
 #define atomToString(x)
 #endif

 namespace aidl {
 namespace android {
 namespace hardware {
 namespace vibrator {

 #ifdef FAST_LOG
 static constexpr auto UPLOAD_INTERVAL = std::chrono::minutes(1);
 #else
 static constexpr auto UPLOAD_INTERVAL = std::chrono::hours(24);
 #endif

 static void reportVendorAtom(const std::shared_ptr<IStats> &statsClient, const VendorAtom &atom) {
     STATS_TRACE("   reportVendorAtom(statsClient, atom: %s)", atomToString(atom.atomId));
     const ndk::ScopedAStatus status = statsClient->reportVendorAtom(atom);
     if (status.isOk()) {
         ALOGI("Vendor atom [id = %d] reported.", atom.atomId);
     } else {
         ALOGE("Failed to report atom [id = %d].", atom.atomId);
     }
 }

 static std::string dumpData(const std::vector<int32_t> &data) {
     std::stringstream stream;
     for (auto datum : data) {
         stream << " " << datum;
     }
     return stream.str();
 }

 StatsBase::StatsBase(const std::string &instance)
     : mReporterThread([this]() { runReporterThread(); }),
       kStatsInstanceName(std::string() + IStats::descriptor + "/" + instance) {}

 StatsBase::~StatsBase() {}

 void StatsBase::debug(int fd) {
     STATS_TRACE("debug(fd: %d)", fd);

     dprintf(fd, "Stats:\n");
     {
         std::scoped_lock<std::mutex> lock(mDataAccess);
         dprintf(fd, "  Waveform Counts:%s\n", dumpData(mWaveformCounts).c_str());
         dprintf(fd, "  Duration Counts:%s\n", dumpData(mDurationCounts).c_str());
         dprintf(fd, "  Min Latencies:%s\n", dumpData(mMinLatencies).c_str());
         dprintf(fd, "  Max Latencies:%s\n", dumpData(mMaxLatencies).c_str());
         dprintf(fd, "  Latency Totals:%s\n", dumpData(mLatencyTotals).c_str());
         dprintf(fd, "  Latency Counts:%s\n", dumpData(mLatencyCounts).c_str());
         dprintf(fd, "  Error Counts: %s\n", dumpData(mErrorCounts).c_str());
     }
 }

 void StatsBase::reportVendorAtomAsync(const VendorAtom &atom) {
     STATS_TRACE("reportVendorAtomAsync(atom: %s)", atomToString(atom.atomId));
     std::scoped_lock<std::mutex> lock(mAtomQueueAccess);
     mAtomQueue.push_back(atom);
     mAtomQueueUpdated.notify_all();
 }

 void StatsBase::uploadDiagnostics() {
     STATS_TRACE("uploadDiagnostics()");
     uploadPlaycountAtoms();
     uploadLatencyAtoms();
     uploadErrorAtoms();
 }

 std::shared_ptr<IStats> StatsBase::waitForStatsService() const {
     STATS_TRACE("waitForStatsService()");
     if (!AServiceManager_isDeclared(kStatsInstanceName.c_str())) {
         ALOGE("IStats service '%s' is not registered.", kStatsInstanceName.c_str());
         return nullptr;
     }

     ALOGI("Waiting for IStats service '%s' to come up.", kStatsInstanceName.c_str());
     std::shared_ptr<IStats> client = IStats::fromBinder(
             ndk::SpAIBinder(AServiceManager_waitForService(kStatsInstanceName.c_str())));
     if (!client) {
         ALOGE("Failed to get IStats service '%s'.", kStatsInstanceName.c_str());
         return nullptr;
     }
     ALOGI("IStats service online.");
     return client;
 }

 void StatsBase::runReporterThread() {
     STATS_TRACE("runReporterThread()");
     using clock = std::chrono::steady_clock;
     auto nextUpload = clock::now() + UPLOAD_INTERVAL;
     auto status = std::cv_status::no_timeout;

     while (!mTerminateReporterThread) {
         drainAtomQueue();
         {
             std::unique_lock<std::mutex> lock(mAtomQueueAccess);
             if (!mAtomQueue.empty())
                 continue;
             status = mAtomQueueUpdated.wait_until(lock, nextUpload);
         }

         if (status == std::cv_status::timeout) {
             nextUpload = clock::now() + UPLOAD_INTERVAL;
             uploadDiagnostics();
         }
     }
 }

 void StatsBase::drainAtomQueue() {
     STATS_TRACE("drainAtomQueue()");
     std::vector<VendorAtom> tempQueue;
     {
         std::unique_lock<std::mutex> lock(mAtomQueueAccess);
         std::swap(mAtomQueue, tempQueue);
     }

     std::shared_ptr<IStats> client = waitForStatsService();
     if (!client) {
         ALOGE("Failed to get IStats service. Atoms are dropped.");
         return;
     }

     for (const VendorAtom &atom : tempQueue) {
         reportVendorAtom(client, atom);
     }
 }

 void StatsBase::uploadPlaycountAtoms() {
     STATS_TRACE("uploadPlaycountAtoms()");
     VendorAtom playcountAtom = vibratorPlaycountAtom();
     reportVendorAtomAsync(playcountAtom);
     clearData(&mWaveformCounts);
     clearData(&mDurationCounts);
 }

 void StatsBase::uploadLatencyAtoms() {
     STATS_TRACE("uploadLatencyAtoms()");
     VendorAtom latencyAtom = vibratorLatencyAtom();
     reportVendorAtomAsync(latencyAtom);
     clearData(&mMinLatencies);
     clearData(&mMaxLatencies);
     clearData(&mLatencyTotals);
     clearData(&mLatencyCounts);
 }

 void StatsBase::uploadErrorAtoms() {
     STATS_TRACE("uploadErrorAtoms()");
     VendorAtom errorAtom = vibratorErrorAtom();
     reportVendorAtomAsync(errorAtom);
     clearData(&mErrorCounts);
 }

 void StatsBase::clearData(std::vector<int32_t> *data) {
     STATS_TRACE("clearData(data)");
     if (data) {
         std::scoped_lock<std::mutex> lock(mDataAccess);
         std::fill((*data).begin(), (*data).end(), 0);
     }
 }

 VendorAtom StatsBase::vibratorPlaycountAtom() {
     STATS_TRACE("vibratorPlaycountAtom()");
     std::vector<VendorAtomValue> values(2);

     {
         std::scoped_lock<std::mutex> lock(mDataAccess);
         values[0].set<VendorAtomValue::repeatedIntValue>(mWaveformCounts);
         values[1].set<VendorAtomValue::repeatedIntValue>(mDurationCounts);
     }

     return VendorAtom{
             .reverseDomainName = "",
             .atomId = PixelAtoms::Atom::kVibratorPlaycountReported,
             .values = std::move(values),
     };
 }

 VendorAtom StatsBase::vibratorLatencyAtom() {
     STATS_TRACE("vibratorLatencyAtom()");
     std::vector<VendorAtomValue> values(3);
     std::vector<int32_t> avgLatencies;

     {
         std::scoped_lock<std::mutex> lock(mDataAccess);
         for (uint32_t i = 0; i < mLatencyCounts.size(); i++) {
             int32_t avg = 0;
             if (mLatencyCounts[0] > 0) {
                 avg = mLatencyTotals[i] / mLatencyCounts[i];
             }
             avgLatencies.push_back(avg);
         }

         values[0].set<VendorAtomValue::repeatedIntValue>(mMinLatencies);
         values[1].set<VendorAtomValue::repeatedIntValue>(mMaxLatencies);
     }
     values[2].set<VendorAtomValue::repeatedIntValue>(avgLatencies);

     return VendorAtom{
             .reverseDomainName = "",
             .atomId = PixelAtoms::Atom::kVibratorLatencyReported,
             .values = std::move(values),
     };
 }

 VendorAtom StatsBase::vibratorErrorAtom() {
     STATS_TRACE("vibratorErrorAtom()");
     std::vector<VendorAtomValue> values(1);

     {
         std::scoped_lock<std::mutex> lock(mDataAccess);
         values[0].set<VendorAtomValue::repeatedIntValue>(mErrorCounts);
     }

     return VendorAtom{
             .reverseDomainName = "",
             .atomId = PixelAtoms::Atom::kVibratorErrorsReported,
             .values = std::move(values),
     };
 }

 }  // namespace vibrator
 }  // namespace hardware
 }  // namespace android
 }  // namespace aidl
	/*
	* Copyright (C) 2021 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.
	*/

	#include "StatsBase.h"

	#include <aidl/android/frameworks/stats/IStats.h>
	#include <android/binder_manager.h>
	#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h>
	#include <log/log.h>
	#include <utils/Trace.h>

	#include <chrono>
	#include <sstream>

	using ::aidl::android::frameworks::stats::IStats;
	using ::aidl::android::frameworks::stats::VendorAtom;
	using ::aidl::android::frameworks::stats::VendorAtomValue;

	namespace PixelAtoms = ::android::hardware::google::pixel::PixelAtoms;

	#ifndef ARRAY_SIZE
	#define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))
	#endif

	#ifdef TRACE_STATS
	static const char *kAtomLookup[] = {"HAPTICS_PLAYCOUNTS", "HAPTICS_LATENCIES", "HAPTICS_ERRORS",
	"INVALID"};

	const char *atomToString(uint32_t atomId) {
	switch (atomId) {
	case PixelAtoms::Atom::kVibratorPlaycountReported:
	return kAtomLookup[0];
	break;
	case PixelAtoms::Atom::kVibratorLatencyReported:
	return kAtomLookup[1];
	break;
	case PixelAtoms::Atom::kVibratorErrorsReported:
	return kAtomLookup[2];
	break;
	default:
	return kAtomLookup[ARRAY_SIZE(kAtomLookup) - 1];
	break;
	}
	}

	#define STATS_TRACE(...) \
	ATRACE_NAME(__func__); \
	ALOGD(__VA_ARGS__)
	#else
	#define STATS_TRACE(...) ATRACE_NAME(__func__)
	#define atomToString(x)
	#endif

	namespace aidl {
	namespace android {
	namespace hardware {
	namespace vibrator {

	#ifdef FAST_LOG
	static constexpr auto UPLOAD_INTERVAL = std::chrono::minutes(1);
	#else
	static constexpr auto UPLOAD_INTERVAL = std::chrono::hours(24);
	#endif

	static void reportVendorAtom(const std::shared_ptr<IStats> &statsClient, const VendorAtom &atom) {
	STATS_TRACE(" reportVendorAtom(statsClient, atom: %s)", atomToString(atom.atomId));
	const ndk::ScopedAStatus status = statsClient->reportVendorAtom(atom);
	if (status.isOk()) {
	ALOGI("Vendor atom [id = %d] reported.", atom.atomId);
	} else {
	ALOGE("Failed to report atom [id = %d].", atom.atomId);
	}
	}

	static std::string dumpData(const std::vector<int32_t> &data) {
	std::stringstream stream;
	for (auto datum : data) {
	stream << " " << datum;
	}
	return stream.str();
	}

	StatsBase::StatsBase(const std::string &instance)
	: mReporterThread([this]() { runReporterThread(); }),
	kStatsInstanceName(std::string() + IStats::descriptor + "/" + instance) {}

	StatsBase::~StatsBase() {}

	void StatsBase::debug(int fd) {
	STATS_TRACE("debug(fd: %d)", fd);

	dprintf(fd, "Stats:\n");
	{
	std::scoped_lock<std::mutex> lock(mDataAccess);
	dprintf(fd, " Waveform Counts:%s\n", dumpData(mWaveformCounts).c_str());
	dprintf(fd, " Duration Counts:%s\n", dumpData(mDurationCounts).c_str());
	dprintf(fd, " Min Latencies:%s\n", dumpData(mMinLatencies).c_str());
	dprintf(fd, " Max Latencies:%s\n", dumpData(mMaxLatencies).c_str());
	dprintf(fd, " Latency Totals:%s\n", dumpData(mLatencyTotals).c_str());
	dprintf(fd, " Latency Counts:%s\n", dumpData(mLatencyCounts).c_str());
	dprintf(fd, " Error Counts: %s\n", dumpData(mErrorCounts).c_str());
	}
	}

	void StatsBase::reportVendorAtomAsync(const VendorAtom &atom) {
	STATS_TRACE("reportVendorAtomAsync(atom: %s)", atomToString(atom.atomId));
	std::scoped_lock<std::mutex> lock(mAtomQueueAccess);
	mAtomQueue.push_back(atom);
	mAtomQueueUpdated.notify_all();
	}

	void StatsBase::uploadDiagnostics() {
	STATS_TRACE("uploadDiagnostics()");
	uploadPlaycountAtoms();
	uploadLatencyAtoms();
	uploadErrorAtoms();
	}

	std::shared_ptr<IStats> StatsBase::waitForStatsService() const {
	STATS_TRACE("waitForStatsService()");
	if (!AServiceManager_isDeclared(kStatsInstanceName.c_str())) {
	ALOGE("IStats service '%s' is not registered.", kStatsInstanceName.c_str());
	return nullptr;
	}

	ALOGI("Waiting for IStats service '%s' to come up.", kStatsInstanceName.c_str());
	std::shared_ptr<IStats> client = IStats::fromBinder(
	ndk::SpAIBinder(AServiceManager_waitForService(kStatsInstanceName.c_str())));
	if (!client) {
	ALOGE("Failed to get IStats service '%s'.", kStatsInstanceName.c_str());
	return nullptr;
	}
	ALOGI("IStats service online.");
	return client;
	}

	void StatsBase::runReporterThread() {
	STATS_TRACE("runReporterThread()");
	using clock = std::chrono::steady_clock;
	auto nextUpload = clock::now() + UPLOAD_INTERVAL;
	auto status = std::cv_status::no_timeout;

	while (!mTerminateReporterThread) {
	drainAtomQueue();
	{
	std::unique_lock<std::mutex> lock(mAtomQueueAccess);
	if (!mAtomQueue.empty())
	continue;
	status = mAtomQueueUpdated.wait_until(lock, nextUpload);
	}

	if (status == std::cv_status::timeout) {
	nextUpload = clock::now() + UPLOAD_INTERVAL;
	uploadDiagnostics();
	}
	}
	}

	void StatsBase::drainAtomQueue() {
	STATS_TRACE("drainAtomQueue()");
	std::vector<VendorAtom> tempQueue;
	{
	std::unique_lock<std::mutex> lock(mAtomQueueAccess);
	std::swap(mAtomQueue, tempQueue);
	}

	std::shared_ptr<IStats> client = waitForStatsService();
	if (!client) {
	ALOGE("Failed to get IStats service. Atoms are dropped.");
	return;
	}

	for (const VendorAtom &atom : tempQueue) {
	reportVendorAtom(client, atom);
	}
	}

	void StatsBase::uploadPlaycountAtoms() {
	STATS_TRACE("uploadPlaycountAtoms()");
	VendorAtom playcountAtom = vibratorPlaycountAtom();
	reportVendorAtomAsync(playcountAtom);
	clearData(&mWaveformCounts);
	clearData(&mDurationCounts);
	}

	void StatsBase::uploadLatencyAtoms() {
	STATS_TRACE("uploadLatencyAtoms()");
	VendorAtom latencyAtom = vibratorLatencyAtom();
	reportVendorAtomAsync(latencyAtom);
	clearData(&mMinLatencies);
	clearData(&mMaxLatencies);
	clearData(&mLatencyTotals);
	clearData(&mLatencyCounts);
	}

	void StatsBase::uploadErrorAtoms() {
	STATS_TRACE("uploadErrorAtoms()");
	VendorAtom errorAtom = vibratorErrorAtom();
	reportVendorAtomAsync(errorAtom);
	clearData(&mErrorCounts);
	}

	void StatsBase::clearData(std::vector<int32_t> *data) {
	STATS_TRACE("clearData(data)");
	if (data) {
	std::scoped_lock<std::mutex> lock(mDataAccess);
	std::fill((data).begin(), (data).end(), 0);
	}
	}

	VendorAtom StatsBase::vibratorPlaycountAtom() {
	STATS_TRACE("vibratorPlaycountAtom()");
	std::vector<VendorAtomValue> values(2);

	{
	std::scoped_lock<std::mutex> lock(mDataAccess);
	values[0].set<VendorAtomValue::repeatedIntValue>(mWaveformCounts);
	values[1].set<VendorAtomValue::repeatedIntValue>(mDurationCounts);
	}

	return VendorAtom{
	.reverseDomainName = "",
	.atomId = PixelAtoms::Atom::kVibratorPlaycountReported,
	.values = std::move(values),
	};
	}

	VendorAtom StatsBase::vibratorLatencyAtom() {
	STATS_TRACE("vibratorLatencyAtom()");
	std::vector<VendorAtomValue> values(3);
	std::vector<int32_t> avgLatencies;

	{
	std::scoped_lock<std::mutex> lock(mDataAccess);
	for (uint32_t i = 0; i < mLatencyCounts.size(); i++) {
	int32_t avg = 0;
	if (mLatencyCounts[0] > 0) {
	avg = mLatencyTotals[i] / mLatencyCounts[i];
	}
	avgLatencies.push_back(avg);
	}

	values[0].set<VendorAtomValue::repeatedIntValue>(mMinLatencies);
	values[1].set<VendorAtomValue::repeatedIntValue>(mMaxLatencies);
	}
	values[2].set<VendorAtomValue::repeatedIntValue>(avgLatencies);

	return VendorAtom{
	.reverseDomainName = "",
	.atomId = PixelAtoms::Atom::kVibratorLatencyReported,
	.values = std::move(values),
	};
	}

	VendorAtom StatsBase::vibratorErrorAtom() {
	STATS_TRACE("vibratorErrorAtom()");
	std::vector<VendorAtomValue> values(1);

	{
	std::scoped_lock<std::mutex> lock(mDataAccess);
	values[0].set<VendorAtomValue::repeatedIntValue>(mErrorCounts);
	}

	return VendorAtom{
	.reverseDomainName = "",
	.atomId = PixelAtoms::Atom::kVibratorErrorsReported,
	.values = std::move(values),
	};
	}

	} // namespace vibrator
	} // namespace hardware
	} // namespace android
	} // namespace aidl