Merge "Add EventMetric and a single use case." (eefbdd95) · Commits · e / os / android_frameworks_av

drm/libmediadrm/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@ cc_library {
		"PluginMetricsReporting.cpp",
		"SharedLibrary.cpp",
		"DrmHal.cpp",
		"DrmMetrics.cpp",
		"CryptoHal.cpp",
		"protos/plugin_metrics.proto",
		],

drm/libmediadrm/DrmHal.cpp

+13 −23

Original line number	Diff line number	Diff line
		@@ -30,6 +30,7 @@
		#include <media/DrmHal.h>
		#include <media/DrmSessionClientInterface.h>
		#include <media/DrmSessionManager.h>
		#include <media/EventMetric.h>
		#include <media/PluginMetricsReporting.h>
		#include <media/drm/DrmAPI.h>
		#include <media/stagefright/foundation/ADebug.h>
		@@ -227,7 +228,6 @@ private:
		DrmHal::DrmHal()
		: mDrmSessionClient(new DrmSessionClient(this)),
		mFactories(makeDrmFactories()),
		mOpenSessionCounter("/drm/mediadrm/open_session", "status"),
		mInitCheck((mFactories.size() == 0) ? ERROR_UNSUPPORTED : NO_INIT) {
		}

		@@ -519,7 +519,7 @@ status_t DrmHal::openSession(Vector<uint8_t> &sessionId) {
		mOpenSessions.push(sessionId);
		}

		mOpenSessionCounter.Increment(err);
		mMetrics.mOpenSessionCounter.Increment(err);
		return err;
		}

		@@ -551,6 +551,7 @@ status_t DrmHal::getKeyRequest(Vector<uint8_t> const &sessionId,
		String8 &defaultUrl, DrmPlugin::KeyRequestType *keyRequestType) {
		Mutex::Autolock autoLock(mLock);
		INIT_CHECK();
		EventTimer<status_t> keyRequestTimer(&mMetrics.mGetKeyRequestTiming);

		DrmSessionManager::Instance()->useSession(sessionId);

		@@ -562,6 +563,7 @@ status_t DrmHal::getKeyRequest(Vector<uint8_t> const &sessionId,
		} else if (keyType == DrmPlugin::kKeyType_Release) {
		hKeyType = KeyType::RELEASE;
		} else {
		keyRequestTimer.SetAttribute(BAD_VALUE);
		return BAD_VALUE;
		}

		@@ -636,7 +638,9 @@ status_t DrmHal::getKeyRequest(Vector<uint8_t> const &sessionId,
		}
		});

		return hResult.isOk() ? err : DEAD_OBJECT;
		err = hResult.isOk() ? err : DEAD_OBJECT;
		keyRequestTimer.SetAttribute(err);
		return err;
		}

		status_t DrmHal::provideKeyResponse(Vector<uint8_t> const &sessionId,
		@@ -987,26 +991,12 @@ status_t DrmHal::setPropertyByteArray(String8 const &name,
		return toStatusT(status);
		}

		status_t DrmHal::getMetrics(MediaAnalyticsItem* metrics) {
		// TODO: Move mOpenSessionCounter and suffixes to a separate class
		// that manages the collection of metrics and exporting them.
		std::string success_count_name =
		mOpenSessionCounter.metric_name() + "/ok/count";
		std::string error_count_name =
		mOpenSessionCounter.metric_name() + "/error/count";
		mOpenSessionCounter.ExportValues(
		[&] (status_t status, int64_t value) {
		if (status == OK) {
		metrics->setInt64(success_count_name.c_str(), value);
		} else {
		int64_t total_errors(0);
		metrics->getInt64(error_count_name.c_str(), &total_errors);
		metrics->setInt64(error_count_name.c_str(),
		total_errors + value);
		// TODO: Add support for exporting the list of error values.
		// This probably needs to be added to MediaAnalyticsItem.
		status_t DrmHal::getMetrics(MediaAnalyticsItem* item) {
		if (item == nullptr) {
		return UNEXPECTED_NULL;
		}
		});

		mMetrics.Export(item);
		return OK;
		}

drm/libmediadrm/DrmMetrics.cpp

0 → 100644

+77 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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 <media/DrmMetrics.h>

		namespace {

		template<typename T>
		void ExportCounterMetric(const android::CounterMetric<T>& counter,
		android::MediaAnalyticsItem* item) {
		std::string success_count_name = counter.metric_name() + "/ok/count";
		std::string error_count_name = counter.metric_name() + "/error/count";
		counter.ExportValues(
		[&] (const android::status_t status, const int64_t value) {
		if (status == android::OK) {
		item->setInt64(success_count_name.c_str(), value);
		} else {
		int64_t total_errors(0);
		item->getInt64(error_count_name.c_str(), &total_errors);
		item->setInt64(error_count_name.c_str(), total_errors + value);
		// TODO: Add support for exporting the list of error values.
		// This probably needs to be added to MediaAnalyticsItem.
		}
		});
		}

		template<typename T>
		void ExportEventMetric(const android::EventMetric<T>& event,
		android::MediaAnalyticsItem* item) {
		std::string success_count_name = event.metric_name() + "/ok/count";
		std::string error_count_name = event.metric_name() + "/error/count";
		std::string timing_name = event.metric_name() + "/average_time_micros";
		event.ExportValues(
		[&] (const android::status_t& status,
		const android::EventStatistics& value) {
		if (status == android::OK) {
		item->setInt64(success_count_name.c_str(), value.count);
		item->setInt64(timing_name.c_str(), value.mean);
		} else {
		int64_t total_errors(0);
		item->getInt64(error_count_name.c_str(), &total_errors);
		item->setInt64(error_count_name.c_str(),
		total_errors + value.count);
		// TODO: Add support for exporting the list of error values.
		// This probably needs to be added to MediaAnalyticsItem.
		}
		});
		}

		} // namespace anonymous

		namespace android {

		MediaDrmMetrics::MediaDrmMetrics()
		: mOpenSessionCounter("/drm/mediadrm/open_session", "status"),
		mGetKeyRequestTiming("/drm/mediadrm/get_key_request", "status") {
		}

		void MediaDrmMetrics::Export(MediaAnalyticsItem* item) {
		ExportCounterMetric(mOpenSessionCounter, item);
		ExportEventMetric(mGetKeyRequestTiming, item);
		}

		} // namespace android

drm/libmediadrm/tests/Android.bp

+15 −0

Original line number	Diff line number	Diff line
		@@ -10,3 +10,18 @@ cc_test {
		"-Wall",
		],
		}

		cc_test {
		name: "EventMetric_test",
		srcs: ["EventMetric_test.cpp"],
		shared_libs: [
		"liblog",
		"libmediadrm",
		"libutils",
		],
		include_dirs: ["frameworks/av/include/media"],
		cflags: [
		"-Werror",
		"-Wall",
		],
		}

drm/libmediadrm/tests/EventMetric_test.cpp

0 → 100644

+142 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2018 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 <gtest/gtest.h>

		#include "EventMetric.h"

		namespace android {

		/**
		* Unit tests for the EventMetric class.
		*/

		TEST(EventMetricTest, IntDataTypeEmpty) {
		EventMetric<int> metric("MyMetricName", "MetricAttributeName");

		std::map<int, EventStatistics> values;

		metric.ExportValues(
		[&] (int attribute_value, const EventStatistics& value) {
		values[attribute_value] = value;
		});

		EXPECT_TRUE(values.empty());
		}

		TEST(EventMetricTest, IntDataType) {
		EventMetric<int> metric("MyMetricName", "MetricAttributeName");

		std::map<int, EventStatistics> values;

		metric.Record(4, 7);
		metric.Record(5, 8);
		metric.Record(5, 8);
		metric.Record(5, 8);
		metric.Record(6, 8);
		metric.Record(6, 8);
		metric.Record(6, 8);

		metric.ExportValues(
		[&] (int attribute_value, const EventStatistics& value) {
		values[attribute_value] = value;
		});

		ASSERT_EQ(2u, values.size());
		EXPECT_EQ(4, values[7].min);
		EXPECT_EQ(4, values[7].max);
		EXPECT_EQ(4, values[7].mean);
		EXPECT_EQ(1, values[7].count);

		EXPECT_EQ(5, values[8].min);
		EXPECT_EQ(6, values[8].max);
		// This is an approximate value because of the technique we're using.
		EXPECT_NEAR(5.5, values[8].mean, 0.2);
		EXPECT_EQ(6, values[8].count);
		}

		TEST(EventMetricTest, StringDataType) {
		EventMetric<std::string> metric("MyMetricName", "MetricAttributeName");

		std::map<std::string, EventStatistics> values;

		metric.Record(1, "a");
		metric.Record(2, "b");
		metric.Record(2, "b");
		metric.Record(3, "b");
		metric.Record(3, "b");

		metric.ExportValues(
		[&] (std::string attribute_value, const EventStatistics& value) {
		values[attribute_value] = value;
		});

		ASSERT_EQ(2u, values.size());
		EXPECT_EQ(1, values["a"].min);
		EXPECT_EQ(1, values["a"].max);
		EXPECT_EQ(1, values["a"].mean);
		EXPECT_EQ(1, values["a"].count);

		EXPECT_EQ(2, values["b"].min);
		EXPECT_EQ(3, values["b"].max);
		EXPECT_NEAR(2.5, values["b"].mean, 0.2);
		EXPECT_EQ(4, values["b"].count);
		}

		// Helper class that allows us to mock the clock.
		template<typename AttributeType>
		class MockEventTimer : public EventTimer<AttributeType> {
		public:
		explicit MockEventTimer(nsecs_t time_delta_ns,
		EventMetric<AttributeType>* metric)
		: EventTimer<AttributeType>(metric) {
		// Pretend the event started earlier.
		this->start_time_ = systemTime() - time_delta_ns;
		}
		};

		TEST(EventTimerTest, IntDataType) {
		EventMetric<int> metric("MyMetricName", "MetricAttributeName");

		for (int i = 0; i < 5; i++) {
		{
		// Add a mock time delta.
		MockEventTimer<int> metric_timer(i * 1000000, &metric);
		metric_timer.SetAttribute(i % 2);
		}
		}

		std::map<int, EventStatistics> values;
		metric.ExportValues(
		[&] (int attribute_value, const EventStatistics& value) {
		values[attribute_value] = value;
		});

		ASSERT_EQ(2u, values.size());
		EXPECT_LT(values[0].min, values[0].max);
		EXPECT_GE(4000, values[0].max);
		EXPECT_GT(values[0].mean, values[0].min);
		EXPECT_LE(values[0].mean, values[0].max);
		EXPECT_EQ(3, values[0].count);

		EXPECT_LT(values[1].min, values[1].max);
		EXPECT_GE(3000, values[1].max);
		EXPECT_GT(values[1].mean, values[1].min);
		EXPECT_LE(values[1].mean, values[1].max);
		EXPECT_EQ(2, values[1].count);
		}

		} // namespace android