Merge "Statsd implementation of puller API" (339650b1) · Commits · e / os / android_frameworks_base

cmds/statsd/Android.bp

+2 −0

Original line number	Diff line number	Diff line
		@@ -69,9 +69,11 @@ cc_defaults {
		"src/external/GpuStatsPuller.cpp",
		"src/external/Perfetto.cpp",
		"src/external/PowerStatsPuller.cpp",
		"src/external/PullResultReceiver.cpp",
		"src/external/puller_util.cpp",
		"src/external/ResourceHealthManagerPuller.cpp",
		"src/external/StatsCallbackPuller.cpp",
		"src/external/StatsCallbackPullerDeprecated.cpp",
		"src/external/StatsCompanionServicePuller.cpp",
		"src/external/StatsPuller.cpp",
		"src/external/StatsPullerManager.cpp",

cmds/statsd/src/StatsService.cpp

+4 −0

Original line number	Diff line number	Diff line
		@@ -1293,7 +1293,11 @@ Status StatsService::registerPullerCallback(int32_t atomTag,
		Status StatsService::registerPullAtomCallback(int32_t uid, int32_t atomTag, int64_t coolDownNs,
		int64_t timeoutNs, const std::vector<int32_t>& additiveFields,
		const sp<android::os::IPullAtomCallback>& pullerCallback) {
		ENFORCE_UID(AID_SYSTEM);

		VLOG("StatsService::registerPuller called.");
		mPullerManager->RegisterPullAtomCallback(uid, atomTag, coolDownNs, timeoutNs, additiveFields,
		pullerCallback);
		return Status::ok();
		}

cmds/statsd/src/external/PullResultReceiver.cpp

0 → 100644

+43 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		#include "PullResultReceiver.h"

		using namespace android::binder;
		using namespace android::util;
		using namespace std;

		namespace android {
		namespace os {
		namespace statsd {

		PullResultReceiver::PullResultReceiver(
		std::function<void(int32_t, bool, const vector<android::util::StatsEvent>&)> pullFinishCb)
		: pullFinishCallback(std::move(pullFinishCb)) {
		}

		Status PullResultReceiver::pullFinished(int32_t atomTag, bool success,
		const vector<StatsEvent>& output) {
		pullFinishCallback(atomTag, success, output);
		return Status::ok();
		}

		PullResultReceiver::~PullResultReceiver() {
		}

		} // namespace statsd
		} // namespace os
		} // namespace android
		No newline at end of file

cmds/statsd/src/external/PullResultReceiver.h

0 → 100644

+43 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		#include <android/os/BnPullAtomResultReceiver.h>

		using namespace std;

		namespace android {
		namespace os {
		namespace statsd {

		class PullResultReceiver : public BnPullAtomResultReceiver {
		public:
		PullResultReceiver(function<void(int32_t, bool, const vector<android::util::StatsEvent>&)>
		pullFinishCallback);
		~PullResultReceiver();

		/**
		* Binder call for finishing a pull.
		*/
		binder::Status pullFinished(int32_t atomTag, bool success,
		const vector<android::util::StatsEvent>& output) override;

		private:
		function<void(int32_t, bool, const vector<android::util::StatsEvent>&)> pullFinishCallback;
		};

		} // namespace statsd
		} // namespace os
		} // namespace android

cmds/statsd/src/external/StatsCallbackPuller.cpp

+58 −15

Original line number	Diff line number	Diff line
		@@ -17,20 +17,26 @@
		#define DEBUG false // STOPSHIP if true
		#include "Log.h"

		#include <android/os/IStatsPullerCallback.h>

		#include "StatsCallbackPuller.h"

		#include <android/os/IPullAtomCallback.h>
		#include <android/util/StatsEvent.h>

		#include "PullResultReceiver.h"
		#include "StatsPullerManager.h"
		#include "logd/LogEvent.h"
		#include "stats_log_util.h"

		using namespace android::binder;
		using namespace android::util;
		using namespace std;

		namespace android {
		namespace os {
		namespace statsd {

		StatsCallbackPuller::StatsCallbackPuller(int tagId, const sp<IStatsPullerCallback>& callback) :
		StatsPuller(tagId), mCallback(callback) {
		StatsCallbackPuller::StatsCallbackPuller(int tagId, const sp<IPullAtomCallback>& callback)
		: StatsPuller(tagId), mCallback(callback) {
		VLOG("StatsCallbackPuller created for tag %d", tagId);
		}

		@@ -40,20 +46,57 @@ bool StatsCallbackPuller::PullInternal(vector<shared_ptr<LogEvent>>* data) {
		ALOGW("No callback registered");
		return false;
		}
		int64_t wallClockTimeNs = getWallClockNs();
		int64_t elapsedTimeNs = getElapsedRealtimeNs();
		vector<StatsLogEventWrapper> returned_value;
		Status status = mCallback->pullData(mTagId, elapsedTimeNs, wallClockTimeNs, &returned_value);

		// Shared variables needed in the result receiver.
		shared_ptr<mutex> cv_mutex = make_shared<mutex>();
		shared_ptr<condition_variable> cv = make_shared<condition_variable>();
		shared_ptr<bool> pullFinish = make_shared<bool>(false);
		shared_ptr<bool> pullSuccess = make_shared<bool>(false);
		shared_ptr<vector<shared_ptr<LogEvent>>> sharedData =
		make_shared<vector<shared_ptr<LogEvent>>>();

		sp<PullResultReceiver> resultReceiver = new PullResultReceiver(
		[cv_mutex, cv, pullFinish, pullSuccess, sharedData](
		int32_t atomTag, bool success, const vector<StatsEvent>& output) {
		// This is the result of the pull, executing in a statsd binder thread.
		// The pull could have taken a long time, and we should only modify
		// data (the output param) if the pointer is in scope and the pull did not time out.
		{
		lock_guard<mutex> lk(*cv_mutex);
		// TODO: fill the shared vector of LogEvents once StatsEvent is complete.
		*pullSuccess = success;
		*pullFinish = true;
		}
		cv->notify_one();
		});

		// Initiate the pull.
		Status status = mCallback->onPullAtom(mTagId, resultReceiver);
		if (!status.isOk()) {
		ALOGW("StatsCallbackPuller::pull failed for %d", mTagId);
		return false;
		}
		data->clear();
		for (const StatsLogEventWrapper& it: returned_value) {
		LogEvent::createLogEvents(it, *data);

		{
		unique_lock<mutex> unique_lk(*cv_mutex);
		int64_t pullTimeoutNs =
		StatsPullerManager::kAllPullAtomInfo.at({.atomTag = mTagId}).pullTimeoutNs;
		// Wait until the pull finishes, or until the pull timeout.
		cv->wait_for(unique_lk, chrono::nanoseconds(pullTimeoutNs),
		[pullFinish] { return *pullFinish; });
		if (!*pullFinish) {
		// Note: The parent stats puller will also note that there was a timeout and that the
		// cache should be cleared. Once we migrate all pullers to this callback, we could
		// consolidate the logic.
		return true;
		} else {
		// Only copy the data if we did not timeout and the pull was successful.
		if (pullSuccess) {
		data = std::move(sharedData);
		}
		VLOG("StatsCallbackPuller::pull succeeded for %d", mTagId);
		return true;
		return *pullSuccess;
		}
		}
		}

		} // namespace statsd