Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Update the cc_benchmark to use the new socket schema" into rvc-dev am: be88f7df21 am: 819aa0f9f0

Browse Source 
Change-Id: I1bc44318bbf2ad11a29d1964b91ab1de01650667
This commit is contained in:
Christine Tsai
2020-03-25 16:49:28 +00:00
committed by Automerger Merge Worker
parent 63c45b2c9b 819aa0f9f0
commit 7563df3f4d
7 changed files with 327 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
cmds/statsd/Android.bp
View File

@@ -378,55 +378,55 @@ cc_test {
// statsd micro benchmark
//#############################
//cc_benchmark {
// name: "statsd_benchmark",
// defaults: ["statsd_defaults"],
//
// srcs: [
// // atom_field_options.proto needs field_options.proto, but that is
// // not included in libprotobuf-cpp-lite, so compile it here.
// ":libprotobuf-internal-protos",
//
// "benchmark/duration_metric_benchmark.cpp",
// "benchmark/filter_value_benchmark.cpp",
// "benchmark/get_dimensions_for_condition_benchmark.cpp",
// "benchmark/hello_world_benchmark.cpp",
// "benchmark/log_event_benchmark.cpp",
// "benchmark/main.cpp",
// "benchmark/metric_util.cpp",
// "benchmark/stats_write_benchmark.cpp",
// "src/atom_field_options.proto",
// "src/atoms.proto",
// "src/stats_log.proto",
// ],
//
// proto: {
// type: "lite",
// include_dirs: ["external/protobuf/src"],
// },
//
// cflags: [
// "-Wall",
// "-Werror",
// "-Wno-unused-parameter",
// "-Wno-unused-variable",
// "-Wno-unused-function",
//
// // Bug: http://b/29823425 Disable -Wvarargs for Clang update to r271374
// "-Wno-varargs",
// ],
//
// static_libs: [
// "libplatformprotos",
// ],
//
// shared_libs: [
// "libgtest_prod",
// "libprotobuf-cpp-lite",
// "libstatslog",
// "libstatssocket",
// ],
//}
cc_benchmark {
name: "statsd_benchmark",
defaults: ["statsd_defaults"],
srcs: [
// atom_field_options.proto needs field_options.proto, but that is
// not included in libprotobuf-cpp-lite, so compile it here.
":libprotobuf-internal-protos",
"benchmark/duration_metric_benchmark.cpp",
"benchmark/filter_value_benchmark.cpp",
"benchmark/get_dimensions_for_condition_benchmark.cpp",
"benchmark/hello_world_benchmark.cpp",
"benchmark/log_event_benchmark.cpp",
"benchmark/main.cpp",
"benchmark/metric_util.cpp",
"benchmark/stats_write_benchmark.cpp",
"src/atom_field_options.proto",
"src/atoms.proto",
"src/stats_log.proto",
],
proto: {
type: "lite",
include_dirs: ["external/protobuf/src"],
},
cflags: [
"-Wall",
"-Werror",
"-Wno-unused-parameter",
"-Wno-unused-variable",
"-Wno-unused-function",
// Bug: http://b/29823425 Disable -Wvarargs for Clang update to r271374
"-Wno-varargs",
],
static_libs: [
"libplatformprotos",
"libstatssocket_private",
],
shared_libs: [
"libgtest_prod",
"libprotobuf-cpp-lite",
"libstatslog",
],
}
// ==== java proto device library (for test only) ==============================
java_library {

236
cmds/statsd/benchmark/duration_metric_benchmark.cpp
View File

@@ -137,77 +137,74 @@ static void BM_DurationMetricNoLink(benchmark::State& state) {
int64_t bucketSizeNs =
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
std::vector<AttributionNodeInternal> attributions1 = {
CreateAttribution(111, "App1"), CreateAttribution(222, "GMSCoreModule1"),
CreateAttribution(222, "GMSCoreModule2")};
std::vector<AttributionNodeInternal> attributions2 = {
CreateAttribution(333, "App2"), CreateAttribution(222, "GMSCoreModule1"),
CreateAttribution(555, "GMSCoreModule2")};
std::vector<std::unique_ptr<LogEvent>> events;
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
bucketStartTimeNs + 11));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
bucketStartTimeNs + 40));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + 11,
android::view::DISPLAY_STATE_OFF));
events.push_back(
CreateScreenStateChangedEvent(bucketStartTimeNs + 40, android::view::DISPLAY_STATE_ON));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
bucketStartTimeNs + 102));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
bucketStartTimeNs + 450));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + 102,
android::view::DISPLAY_STATE_OFF));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + 450,
android::view::DISPLAY_STATE_ON));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
bucketStartTimeNs + 650));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
bucketStartTimeNs + bucketSizeNs + 100));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + 650,
android::view::DISPLAY_STATE_OFF));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + bucketSizeNs + 100,
android::view::DISPLAY_STATE_ON));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
bucketStartTimeNs + bucketSizeNs + 640));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
bucketStartTimeNs + bucketSizeNs + 650));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + bucketSizeNs + 640,
android::view::DISPLAY_STATE_OFF));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + bucketSizeNs + 650,
android::view::DISPLAY_STATE_ON));
events.push_back(CreateStartScheduledJobEvent(
{CreateAttribution(9999, "")}, "job0", bucketStartTimeNs + 2));
events.push_back(CreateFinishScheduledJobEvent(
{CreateAttribution(9999, "")}, "job0",bucketStartTimeNs + 101));
vector<int> attributionUids1 = {9999};
vector<string> attributionTags1 = {""};
events.push_back(CreateStartScheduledJobEvent(bucketStartTimeNs + 2, attributionUids1,
attributionTags1, "job0"));
events.push_back(CreateFinishScheduledJobEvent(bucketStartTimeNs + 101, attributionUids1,
attributionTags1, "job0"));
events.push_back(CreateStartScheduledJobEvent(
{CreateAttribution(9999, "")}, "job2", bucketStartTimeNs + 201));
events.push_back(CreateFinishScheduledJobEvent(
{CreateAttribution(9999, "")}, "job2",bucketStartTimeNs + 500));
events.push_back(CreateStartScheduledJobEvent(bucketStartTimeNs + 201, attributionUids1,
attributionTags1, "job2"));
events.push_back(CreateFinishScheduledJobEvent(bucketStartTimeNs + 500, attributionUids1,
attributionTags1, "job2"));
events.push_back(CreateStartScheduledJobEvent(
{CreateAttribution(8888, "")}, "job2", bucketStartTimeNs + 600));
events.push_back(CreateFinishScheduledJobEvent(
{CreateAttribution(8888, "")}, "job2",bucketStartTimeNs + bucketSizeNs + 850));
vector<int> attributionUids2 = {8888};
events.push_back(CreateStartScheduledJobEvent(bucketStartTimeNs + 600, attributionUids2,
attributionTags1, "job2"));
events.push_back(CreateFinishScheduledJobEvent(bucketStartTimeNs + bucketSizeNs + 850,
attributionUids2, attributionTags1, "job2"));
events.push_back(CreateStartScheduledJobEvent(
{CreateAttribution(8888, "")}, "job1", bucketStartTimeNs + bucketSizeNs + 600));
events.push_back(CreateFinishScheduledJobEvent(
{CreateAttribution(8888, "")}, "job1", bucketStartTimeNs + bucketSizeNs + 900));
events.push_back(CreateStartScheduledJobEvent(bucketStartTimeNs + bucketSizeNs + 600,
attributionUids2, attributionTags1, "job1"));
events.push_back(CreateFinishScheduledJobEvent(bucketStartTimeNs + bucketSizeNs + 900,
attributionUids2, attributionTags1, "job1"));
events.push_back(CreateSyncStartEvent(attributions1, "ReadEmail",
bucketStartTimeNs + 10));
events.push_back(CreateSyncEndEvent(attributions1, "ReadEmail",
bucketStartTimeNs + 50));
vector<int> attributionUids3 = {111, 222, 222};
vector<string> attributionTags3 = {"App1", "GMSCoreModule1", "GMSCoreModule2"};
events.push_back(CreateSyncStartEvent(bucketStartTimeNs + 10, attributionUids3,
attributionTags3, "ReadEmail"));
events.push_back(CreateSyncEndEvent(bucketStartTimeNs + 50, attributionUids3, attributionTags3,
"ReadEmail"));
events.push_back(CreateSyncStartEvent(attributions1, "ReadEmail",
bucketStartTimeNs + 200));
events.push_back(CreateSyncEndEvent(attributions1, "ReadEmail",
bucketStartTimeNs + bucketSizeNs + 300));
events.push_back(CreateSyncStartEvent(bucketStartTimeNs + 200, attributionUids3,
attributionTags3, "ReadEmail"));
events.push_back(CreateSyncEndEvent(bucketStartTimeNs + bucketSizeNs + 300, attributionUids3,
attributionTags3, "ReadEmail"));
events.push_back(CreateSyncStartEvent(attributions1, "ReadDoc",
bucketStartTimeNs + 400));
events.push_back(CreateSyncEndEvent(attributions1, "ReadDoc",
bucketStartTimeNs + bucketSizeNs - 1));
events.push_back(CreateSyncStartEvent(attributions2, "ReadEmail",
bucketStartTimeNs + 401));
events.push_back(CreateSyncEndEvent(attributions2, "ReadEmail",
bucketStartTimeNs + bucketSizeNs + 700));
events.push_back(CreateSyncStartEvent(bucketStartTimeNs + 400, attributionUids3,
attributionTags3, "ReadDoc"));
events.push_back(CreateSyncEndEvent(bucketStartTimeNs + bucketSizeNs - 1, attributionUids3,
attributionTags3, "ReadDoc"));
vector<int> attributionUids4 = {333, 222, 555};
vector<string> attributionTags4 = {"App2", "GMSCoreModule1", "GMSCoreModule2"};
events.push_back(CreateSyncStartEvent(bucketStartTimeNs + 401, attributionUids4,
attributionTags4, "ReadEmail"));
events.push_back(CreateSyncEndEvent(bucketStartTimeNs + bucketSizeNs + 700, attributionUids4,
attributionTags4, "ReadEmail"));
sortLogEventsByTimestamp(&events);
while (state.KeepRunning()) {
@@ -230,78 +227,75 @@ static void BM_DurationMetricLink(benchmark::State& state) {
int64_t bucketSizeNs =
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
std::vector<AttributionNodeInternal> attributions1 = {
CreateAttribution(111, "App1"), CreateAttribution(222, "GMSCoreModule1"),
CreateAttribution(222, "GMSCoreModule2")};
std::vector<AttributionNodeInternal> attributions2 = {
CreateAttribution(333, "App2"), CreateAttribution(222, "GMSCoreModule1"),
CreateAttribution(555, "GMSCoreModule2")};
std::vector<AttributionNodeInternal> attributions3 = {
CreateAttribution(444, "App3"), CreateAttribution(222, "GMSCoreModule1"),
CreateAttribution(555, "GMSCoreModule2")};
std::vector<std::unique_ptr<LogEvent>> events;
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
bucketStartTimeNs + 55));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
bucketStartTimeNs + 120));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
bucketStartTimeNs + 121));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
bucketStartTimeNs + 450));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + 55,
android::view::DISPLAY_STATE_OFF));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + 120,
android::view::DISPLAY_STATE_ON));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + 121,
android::view::DISPLAY_STATE_OFF));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + 450,
android::view::DISPLAY_STATE_ON));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
bucketStartTimeNs + 501));
events.push_back(CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
bucketStartTimeNs + bucketSizeNs + 100));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + 501,
android::view::DISPLAY_STATE_OFF));
events.push_back(CreateScreenStateChangedEvent(bucketStartTimeNs + bucketSizeNs + 100,
android::view::DISPLAY_STATE_ON));
events.push_back(CreateStartScheduledJobEvent(
{CreateAttribution(111, "App1")}, "job1", bucketStartTimeNs + 1));
events.push_back(CreateFinishScheduledJobEvent(
{CreateAttribution(111, "App1")}, "job1",bucketStartTimeNs + 101));
vector<int> attributionUids1 = {111};
vector<string> attributionTags1 = {"App1"};
events.push_back(CreateStartScheduledJobEvent(bucketStartTimeNs + 1, attributionUids1,
attributionTags1, "job1"));
events.push_back(CreateFinishScheduledJobEvent(bucketStartTimeNs + 101, attributionUids1,
attributionTags1, "job1"));
events.push_back(CreateStartScheduledJobEvent(
{CreateAttribution(333, "App2")}, "job2", bucketStartTimeNs + 201));
events.push_back(CreateFinishScheduledJobEvent(
{CreateAttribution(333, "App2")}, "job2",bucketStartTimeNs + 500));
events.push_back(CreateStartScheduledJobEvent(
{CreateAttribution(333, "App2")}, "job2", bucketStartTimeNs + 600));
events.push_back(CreateFinishScheduledJobEvent(
{CreateAttribution(333, "App2")}, "job2",
bucketStartTimeNs + bucketSizeNs + 850));
vector<int> attributionUids2 = {333};
vector<string> attributionTags2 = {"App2"};
events.push_back(CreateStartScheduledJobEvent(bucketStartTimeNs + 201, attributionUids2,
attributionTags2, "job2"));
events.push_back(CreateFinishScheduledJobEvent(bucketStartTimeNs + 500, attributionUids2,
attributionTags2, "job2"));
events.push_back(CreateStartScheduledJobEvent(bucketStartTimeNs + 600, attributionUids2,
attributionTags2, "job2"));
events.push_back(CreateFinishScheduledJobEvent(bucketStartTimeNs + bucketSizeNs + 850,
attributionUids2, attributionTags2, "job2"));
events.push_back(
CreateStartScheduledJobEvent({CreateAttribution(444, "App3")}, "job3",
bucketStartTimeNs + bucketSizeNs - 2));
events.push_back(
CreateFinishScheduledJobEvent({CreateAttribution(444, "App3")}, "job3",
bucketStartTimeNs + bucketSizeNs + 900));
vector<int> attributionUids3 = {444};
vector<string> attributionTags3 = {"App3"};
events.push_back(CreateStartScheduledJobEvent(bucketStartTimeNs + bucketSizeNs - 2,
attributionUids3, attributionTags3, "job3"));
events.push_back(CreateFinishScheduledJobEvent(bucketStartTimeNs + bucketSizeNs + 900,
attributionUids3, attributionTags3, "job3"));
events.push_back(CreateSyncStartEvent(attributions1, "ReadEmail",
bucketStartTimeNs + 50));
events.push_back(CreateSyncEndEvent(attributions1, "ReadEmail",
bucketStartTimeNs + 110));
vector<int> attributionUids4 = {111, 222, 222};
vector<string> attributionTags4 = {"App1", "GMSCoreModule1", "GMSCoreModule2"};
events.push_back(CreateSyncStartEvent(bucketStartTimeNs + 50, attributionUids4,
attributionTags4, "ReadEmail"));
events.push_back(CreateSyncEndEvent(bucketStartTimeNs + 110, attributionUids4, attributionTags4,
"ReadEmail"));
events.push_back(CreateSyncStartEvent(attributions2, "ReadEmail",
bucketStartTimeNs + 300));
events.push_back(CreateSyncEndEvent(attributions2, "ReadEmail",
bucketStartTimeNs + bucketSizeNs + 700));
events.push_back(CreateSyncStartEvent(attributions2, "ReadDoc",
bucketStartTimeNs + 400));
events.push_back(CreateSyncEndEvent(attributions2, "ReadDoc",
bucketStartTimeNs + bucketSizeNs - 1));
vector<int> attributionUids5 = {333, 222, 555};
vector<string> attributionTags5 = {"App2", "GMSCoreModule1", "GMSCoreModule2"};
events.push_back(CreateSyncStartEvent(bucketStartTimeNs + 300, attributionUids5,
attributionTags5, "ReadEmail"));
events.push_back(CreateSyncEndEvent(bucketStartTimeNs + bucketSizeNs + 700, attributionUids5,
attributionTags5, "ReadEmail"));
events.push_back(CreateSyncStartEvent(bucketStartTimeNs + 400, attributionUids5,
attributionTags5, "ReadDoc"));
events.push_back(CreateSyncEndEvent(bucketStartTimeNs + bucketSizeNs - 1, attributionUids5,
attributionTags5, "ReadDoc"));
events.push_back(CreateSyncStartEvent(attributions3, "ReadDoc",
bucketStartTimeNs + 550));
events.push_back(CreateSyncEndEvent(attributions3, "ReadDoc",
bucketStartTimeNs + 800));
events.push_back(CreateSyncStartEvent(attributions3, "ReadDoc",
bucketStartTimeNs + bucketSizeNs - 1));
events.push_back(CreateSyncEndEvent(attributions3, "ReadDoc",
bucketStartTimeNs + bucketSizeNs + 700));
vector<int> attributionUids6 = {444, 222, 555};
vector<string> attributionTags6 = {"App3", "GMSCoreModule1", "GMSCoreModule2"};
events.push_back(CreateSyncStartEvent(bucketStartTimeNs + 550, attributionUids6,
attributionTags6, "ReadDoc"));
events.push_back(CreateSyncEndEvent(bucketStartTimeNs + 800, attributionUids6, attributionTags6,
"ReadDoc"));
events.push_back(CreateSyncStartEvent(bucketStartTimeNs + bucketSizeNs - 1, attributionUids6,
attributionTags6, "ReadDoc"));
events.push_back(CreateSyncEndEvent(bucketStartTimeNs + bucketSizeNs + 700, attributionUids6,
attributionTags6, "ReadDoc"));
sortLogEventsByTimestamp(&events);
while (state.KeepRunning()) {

37
cmds/statsd/benchmark/filter_value_benchmark.cpp
View File

@@ -19,6 +19,7 @@
#include "HashableDimensionKey.h"
#include "logd/LogEvent.h"
#include "stats_log_util.h"
#include "stats_event.h"
namespace android {
namespace os {
@@ -26,17 +27,31 @@ namespace statsd {
using std::vector;
static void createLogEventAndMatcher(LogEvent* event, FieldMatcher *field_matcher) {
AttributionNodeInternal node;
node.set_uid(100);
node.set_tag("LOCATION");
static void createLogEventAndMatcher(LogEvent* event, FieldMatcher* field_matcher) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, 1);
AStatsEvent_overwriteTimestamp(statsEvent, 100000);
std::vector<AttributionNodeInternal> nodes = {node, node};
event->write(nodes);
event->write(3.2f);
event->write("LOCATION");
event->write((int64_t)990);
event->init();
std::vector<int> attributionUids = {100, 100};
std::vector<string> attributionTags = {"LOCATION", "LOCATION"};
vector<const char*> cTags(attributionTags.size());
for (int i = 0; i < cTags.size(); i++) {
cTags[i] = attributionTags[i].c_str();
}
AStatsEvent_writeAttributionChain(statsEvent,
reinterpret_cast<const uint32_t*>(attributionUids.data()),
cTags.data(), attributionUids.size());
AStatsEvent_writeFloat(statsEvent, 3.2f);
AStatsEvent_writeString(statsEvent, "LOCATION");
AStatsEvent_writeInt64(statsEvent, 990);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
event->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
field_matcher->set_field(1);
auto child = field_matcher->add_child();
@@ -46,7 +61,7 @@ static void createLogEventAndMatcher(LogEvent* event, FieldMatcher *field_matche
}
static void BM_FilterValue(benchmark::State& state) {
LogEvent event(1, 100000);
LogEvent event(/*uid=*/0, /*pid=*/0);
FieldMatcher field_matcher;
createLogEventAndMatcher(&event, &field_matcher);

35
cmds/statsd/benchmark/get_dimensions_for_condition_benchmark.cpp
View File

@@ -19,6 +19,7 @@
#include "HashableDimensionKey.h"
#include "logd/LogEvent.h"
#include "stats_log_util.h"
#include "stats_event.h"
namespace android {
namespace os {
@@ -27,16 +28,30 @@ namespace statsd {
using std::vector;
static void createLogEventAndLink(LogEvent* event, Metric2Condition *link) {
AttributionNodeInternal node;
node.set_uid(100);
node.set_tag("LOCATION");
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, 1);
AStatsEvent_overwriteTimestamp(statsEvent, 100000);
std::vector<AttributionNodeInternal> nodes = {node, node};
event->write(nodes);
event->write(3.2f);
event->write("LOCATION");
event->write((int64_t)990);
event->init();
std::vector<int> attributionUids = {100, 100};
std::vector<string> attributionTags = {"LOCATION", "LOCATION"};
vector<const char*> cTags(attributionTags.size());
for (int i = 0; i < cTags.size(); i++) {
cTags[i] = attributionTags[i].c_str();
}
AStatsEvent_writeAttributionChain(statsEvent,
reinterpret_cast<const uint32_t*>(attributionUids.data()),
cTags.data(), attributionUids.size());
AStatsEvent_writeFloat(statsEvent, 3.2f);
AStatsEvent_writeString(statsEvent, "LOCATION");
AStatsEvent_writeInt64(statsEvent, 990);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
event->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
link->conditionId = 1;
@@ -54,7 +69,7 @@ static void createLogEventAndLink(LogEvent* event, Metric2Condition *link) {
static void BM_GetDimensionInCondition(benchmark::State& state) {
Metric2Condition link;
LogEvent event(1, 100000);
LogEvent event(/*uid=*/0, /*pid=*/0);
createLogEventAndLink(&event, &link);
while (state.KeepRunning()) {

3
cmds/statsd/benchmark/log_event_benchmark.cpp
View File

@@ -39,7 +39,8 @@ static void BM_LogEventCreation(benchmark::State& state) {
uint8_t msg[LOGGER_ENTRY_MAX_PAYLOAD];
size_t size = createAndParseStatsEvent(msg);
while (state.KeepRunning()) {
benchmark::DoNotOptimize(LogEvent(msg, size, /*uid=*/ 1000, /*pid=*/ 1001));
LogEvent event(/*uid=*/ 1000, /*pid=*/ 1001);
benchmark::DoNotOptimize(event.parseBuffer(msg, size));
}
}
BENCHMARK(BM_LogEventCreation);

187
cmds/statsd/benchmark/metric_util.cpp
View File

@@ -14,6 +14,8 @@
#include "metric_util.h"
#include "stats_event.h"
namespace android {
namespace os {
namespace statsd {
@@ -246,117 +248,112 @@ FieldMatcher CreateDimensions(const int atomId, const std::vector<int>& fields)
}
std::unique_ptr<LogEvent> CreateScreenStateChangedEvent(
const android::view::DisplayStateEnum state, uint64_t timestampNs) {
auto event = std::make_unique<LogEvent>(android::util::SCREEN_STATE_CHANGED, timestampNs);
event->write(state);
event->init();
return event;
}
uint64_t timestampNs, const android::view::DisplayStateEnum state) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, util::SCREEN_STATE_CHANGED);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
std::unique_ptr<LogEvent> CreateScreenBrightnessChangedEvent(
int level, uint64_t timestampNs) {
auto event = std::make_unique<LogEvent>(android::util::SCREEN_BRIGHTNESS_CHANGED, timestampNs);
(event->write(level));
event->init();
return event;
AStatsEvent_writeInt32(statsEvent, state);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
std::unique_ptr<LogEvent> CreateScheduledJobStateChangedEvent(
const std::vector<AttributionNodeInternal>& attributions, const string& jobName,
const ScheduledJobStateChanged::State state, uint64_t timestampNs) {
auto event = std::make_unique<LogEvent>(android::util::SCHEDULED_JOB_STATE_CHANGED, timestampNs);
event->write(attributions);
event->write(jobName);
event->write(state);
event->init();
return event;
const vector<int>& attributionUids, const vector<string>& attributionTags,
const string& jobName, const ScheduledJobStateChanged::State state, uint64_t timestampNs) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, util::SCHEDULED_JOB_STATE_CHANGED);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
vector<const char*> cTags(attributionTags.size());
for (int i = 0; i < cTags.size(); i++) {
cTags[i] = attributionTags[i].c_str();
}
AStatsEvent_writeAttributionChain(statsEvent,
reinterpret_cast<const uint32_t*>(attributionUids.data()),
cTags.data(), attributionUids.size());
AStatsEvent_writeString(statsEvent, jobName.c_str());
AStatsEvent_writeInt32(statsEvent, state);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
std::unique_ptr<LogEvent> CreateStartScheduledJobEvent(
const std::vector<AttributionNodeInternal>& attributions,
const string& name, uint64_t timestampNs) {
return CreateScheduledJobStateChangedEvent(
attributions, name, ScheduledJobStateChanged::STARTED, timestampNs);
std::unique_ptr<LogEvent> CreateStartScheduledJobEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& jobName) {
return CreateScheduledJobStateChangedEvent(attributionUids, attributionTags, jobName,
ScheduledJobStateChanged::STARTED, timestampNs);
}
// Create log event when scheduled job finishes.
std::unique_ptr<LogEvent> CreateFinishScheduledJobEvent(
const std::vector<AttributionNodeInternal>& attributions,
const string& name, uint64_t timestampNs) {
return CreateScheduledJobStateChangedEvent(
attributions, name, ScheduledJobStateChanged::FINISHED, timestampNs);
std::unique_ptr<LogEvent> CreateFinishScheduledJobEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& jobName) {
return CreateScheduledJobStateChangedEvent(attributionUids, attributionTags, jobName,
ScheduledJobStateChanged::FINISHED, timestampNs);
}
std::unique_ptr<LogEvent> CreateWakelockStateChangedEvent(
const std::vector<AttributionNodeInternal>& attributions, const string& wakelockName,
const WakelockStateChanged::State state, uint64_t timestampNs) {
auto event = std::make_unique<LogEvent>(android::util::WAKELOCK_STATE_CHANGED, timestampNs);
event->write(attributions);
event->write(android::os::WakeLockLevelEnum::PARTIAL_WAKE_LOCK);
event->write(wakelockName);
event->write(state);
event->init();
return event;
std::unique_ptr<LogEvent> CreateSyncStateChangedEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& name,
const SyncStateChanged::State state) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, util::SYNC_STATE_CHANGED);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
vector<const char*> cTags(attributionTags.size());
for (int i = 0; i < cTags.size(); i++) {
cTags[i] = attributionTags[i].c_str();
}
AStatsEvent_writeAttributionChain(statsEvent,
reinterpret_cast<const uint32_t*>(attributionUids.data()),
cTags.data(), attributionUids.size());
AStatsEvent_writeString(statsEvent, name.c_str());
AStatsEvent_writeInt32(statsEvent, state);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
std::unique_ptr<LogEvent> CreateAcquireWakelockEvent(
const std::vector<AttributionNodeInternal>& attributions, const string& wakelockName,
uint64_t timestampNs) {
return CreateWakelockStateChangedEvent(
attributions, wakelockName, WakelockStateChanged::ACQUIRE, timestampNs);
std::unique_ptr<LogEvent> CreateSyncStartEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& name) {
return CreateSyncStateChangedEvent(timestampNs, attributionUids, attributionTags, name,
SyncStateChanged::ON);
}
std::unique_ptr<LogEvent> CreateReleaseWakelockEvent(
const std::vector<AttributionNodeInternal>& attributions, const string& wakelockName,
uint64_t timestampNs) {
return CreateWakelockStateChangedEvent(
attributions, wakelockName, WakelockStateChanged::RELEASE, timestampNs);
}
std::unique_ptr<LogEvent> CreateActivityForegroundStateChangedEvent(
const int uid, const ActivityForegroundStateChanged::State state, uint64_t timestampNs) {
auto event = std::make_unique<LogEvent>(
android::util::ACTIVITY_FOREGROUND_STATE_CHANGED, timestampNs);
event->write(uid);
event->write("pkg_name");
event->write("class_name");
event->write(state);
event->init();
return event;
}
std::unique_ptr<LogEvent> CreateMoveToBackgroundEvent(const int uid, uint64_t timestampNs) {
return CreateActivityForegroundStateChangedEvent(
uid, ActivityForegroundStateChanged::BACKGROUND, timestampNs);
}
std::unique_ptr<LogEvent> CreateMoveToForegroundEvent(const int uid, uint64_t timestampNs) {
return CreateActivityForegroundStateChangedEvent(
uid, ActivityForegroundStateChanged::FOREGROUND, timestampNs);
}
std::unique_ptr<LogEvent> CreateSyncStateChangedEvent(
const std::vector<AttributionNodeInternal>& attributions, const string& name,
const SyncStateChanged::State state, uint64_t timestampNs) {
auto event = std::make_unique<LogEvent>(android::util::SYNC_STATE_CHANGED, timestampNs);
event->write(attributions);
event->write(name);
event->write(state);
event->init();
return event;
}
std::unique_ptr<LogEvent> CreateSyncStartEvent(
const std::vector<AttributionNodeInternal>& attributions, const string& name,
uint64_t timestampNs) {
return CreateSyncStateChangedEvent(attributions, name, SyncStateChanged::ON, timestampNs);
}
std::unique_ptr<LogEvent> CreateSyncEndEvent(
const std::vector<AttributionNodeInternal>& attributions, const string& name,
uint64_t timestampNs) {
return CreateSyncStateChangedEvent(attributions, name, SyncStateChanged::OFF, timestampNs);
std::unique_ptr<LogEvent> CreateSyncEndEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& name) {
return CreateSyncStateChangedEvent(timestampNs, attributionUids, attributionTags, name,
SyncStateChanged::OFF);
}
sp<StatsLogProcessor> CreateStatsLogProcessor(const long timeBaseSec, const StatsdConfig& config,

60
cmds/statsd/benchmark/metric_util.h
View File

@@ -94,55 +94,31 @@ FieldMatcher CreateAttributionUidDimensions(const int atomId,
// Create log event for screen state changed.
std::unique_ptr<LogEvent> CreateScreenStateChangedEvent(
const android::view::DisplayStateEnum state, uint64_t timestampNs);
// Create log event for screen brightness state changed.
std::unique_ptr<LogEvent> CreateScreenBrightnessChangedEvent(
int level, uint64_t timestampNs);
uint64_t timestampNs, const android::view::DisplayStateEnum state);
// Create log event when scheduled job starts.
std::unique_ptr<LogEvent> CreateStartScheduledJobEvent(
const std::vector<AttributionNodeInternal>& attributions,
const string& name, uint64_t timestampNs);
std::unique_ptr<LogEvent> CreateStartScheduledJobEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& jobName);
// Create log event when scheduled job finishes.
std::unique_ptr<LogEvent> CreateFinishScheduledJobEvent(
const std::vector<AttributionNodeInternal>& attributions,
const string& name, uint64_t timestampNs);
// Create log event for app moving to background.
std::unique_ptr<LogEvent> CreateMoveToBackgroundEvent(const int uid, uint64_t timestampNs);
// Create log event for app moving to foreground.
std::unique_ptr<LogEvent> CreateMoveToForegroundEvent(const int uid, uint64_t timestampNs);
std::unique_ptr<LogEvent> CreateFinishScheduledJobEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& jobName);
// Create log event when the app sync starts.
std::unique_ptr<LogEvent> CreateSyncStartEvent(
const std::vector<AttributionNodeInternal>& attributions, const string& name,
uint64_t timestampNs);
std::unique_ptr<LogEvent> CreateSyncStartEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& name);
// Create log event when the app sync ends.
std::unique_ptr<LogEvent> CreateSyncEndEvent(
const std::vector<AttributionNodeInternal>& attributions, const string& name,
uint64_t timestampNs);
// Create log event when the app sync ends.
std::unique_ptr<LogEvent> CreateAppCrashEvent(
const int uid, uint64_t timestampNs);
// Create log event for acquiring wakelock.
std::unique_ptr<LogEvent> CreateAcquireWakelockEvent(
const std::vector<AttributionNodeInternal>& attributions, const string& wakelockName,
uint64_t timestampNs);
// Create log event for releasing wakelock.
std::unique_ptr<LogEvent> CreateReleaseWakelockEvent(
const std::vector<AttributionNodeInternal>& attributions, const string& wakelockName,
uint64_t timestampNs);
// Create log event for releasing wakelock.
std::unique_ptr<LogEvent> CreateIsolatedUidChangedEvent(
int isolatedUid, int hostUid, bool is_create, uint64_t timestampNs);
std::unique_ptr<LogEvent> CreateSyncEndEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& name);
// Helper function to create an AttributionNodeInternal proto.
AttributionNodeInternal CreateAttribution(const int& uid, const string& tag);
@@ -158,4 +134,4 @@ int64_t StringToId(const string& str);
} // namespace statsd
} // namespace os
} // namespace android
} // namespace android