blob: 510bc7be34c95ea56dc07ff63b639d30d4225e28 [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.
*/
#include <stdlib.h>
#include <sys/system_properties.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <random>
#include "perfetto/base/logging.h"
#include "perfetto/tracing/core/data_source_config.h"
#include "src/base/test/test_task_runner.h"
#include "test/android_test_utils.h"
#include "test/gtest_and_gmock.h"
#include "test/test_helper.h"
#include "protos/perfetto/config/profiling/heapprofd_config.gen.h"
#include "protos/perfetto/trace/profiling/profile_common.gen.h"
#include "protos/perfetto/trace/profiling/profile_packet.gen.h"
#include "protos/perfetto/trace/trace_packet.gen.h"
namespace perfetto {
namespace {
// Size of individual (repeated) allocations done by the test apps (must be kept
// in sync with their sources).
constexpr uint64_t kTestSamplingInterval = 4096;
constexpr uint64_t kExpectedIndividualAllocSz = 4153;
// Tests rely on the sampling behaviour where allocations larger than the
// sampling interval are recorded at their actual size.
static_assert(kExpectedIndividualAllocSz > kTestSamplingInterval,
"kTestSamplingInterval invalid");
// Activity that runs a JNI thread that repeatedly calls
// malloc(kExpectedIndividualAllocSz).
static char kMallocActivity[] = "MainActivity";
// Activity that runs a java thread that repeatedly constructs small java
// objects.
static char kJavaAllocActivity[] = "JavaAllocActivity";
std::string RandomSessionName() {
std::random_device rd;
std::default_random_engine generator(rd());
std::uniform_int_distribution<> distribution('a', 'z');
constexpr size_t kSessionNameLen = 20;
std::string result(kSessionNameLen, '\0');
for (size_t i = 0; i < kSessionNameLen; ++i)
result[i] = static_cast<char>(distribution(generator));
return result;
}
// Starts the activity `activity` of the app `app_name` and later starts
// recording a trace with the allocations in `heap_names`.
//
// `heap_names` is a list of the heap names whose allocations will be recorded.
// An empty list means that only the allocations in the default malloc heap
// ("libc.malloc") are recorded.
//
// Returns the recorded trace.
std::vector<protos::gen::TracePacket> ProfileRuntime(
const std::string& app_name,
const std::string& activity,
const std::vector<std::string>& heap_names) {
base::TestTaskRunner task_runner;
// (re)start the target app's main activity
if (IsAppRunning(app_name)) {
StopApp(app_name, "old.app.stopped", &task_runner);
task_runner.RunUntilCheckpoint("old.app.stopped", 10000 /*ms*/);
}
StartAppActivity(app_name, activity, "target.app.running", &task_runner,
/*delay_ms=*/100);
task_runner.RunUntilCheckpoint("target.app.running", 10000 /*ms*/);
// set up tracing
TestHelper helper(&task_runner);
helper.ConnectConsumer();
helper.WaitForConsumerConnect();
TraceConfig trace_config;
trace_config.add_buffers()->set_size_kb(10 * 1024);
trace_config.set_duration_ms(4000);
trace_config.set_unique_session_name(RandomSessionName().c_str());
auto* ds_config = trace_config.add_data_sources()->mutable_config();
ds_config->set_name("android.heapprofd");
ds_config->set_target_buffer(0);
protos::gen::HeapprofdConfig heapprofd_config;
heapprofd_config.set_sampling_interval_bytes(kTestSamplingInterval);
heapprofd_config.add_process_cmdline(app_name.c_str());
heapprofd_config.set_block_client(true);
heapprofd_config.set_all(false);
for (const std::string& heap_name : heap_names) {
heapprofd_config.add_heaps(heap_name);
}
ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
// start tracing
helper.StartTracing(trace_config);
helper.WaitForTracingDisabled();
helper.ReadData();
helper.WaitForReadData();
return helper.trace();
}
// Starts recording a trace with the allocations in `heap_names` and later
// starts the activity `activity` of the app `app_name`
//
// `heap_names` is a list of the heap names whose allocations will be recorded.
// An empty list means that only the allocation in the default malloc heap
// ("libc.malloc") are recorded.
//
// Returns the recorded trace.
std::vector<protos::gen::TracePacket> ProfileStartup(
const std::string& app_name,
const std::string& activity,
const std::vector<std::string>& heap_names,
const bool enable_extra_guardrails = false) {
base::TestTaskRunner task_runner;
if (IsAppRunning(app_name)) {
StopApp(app_name, "old.app.stopped", &task_runner);
task_runner.RunUntilCheckpoint("old.app.stopped", 10000 /*ms*/);
}
// set up tracing
TestHelper helper(&task_runner);
helper.ConnectConsumer();
helper.WaitForConsumerConnect();
TraceConfig trace_config;
trace_config.add_buffers()->set_size_kb(10 * 1024);
trace_config.set_duration_ms(4000);
trace_config.set_enable_extra_guardrails(enable_extra_guardrails);
trace_config.set_unique_session_name(RandomSessionName().c_str());
auto* ds_config = trace_config.add_data_sources()->mutable_config();
ds_config->set_name("android.heapprofd");
ds_config->set_target_buffer(0);
protos::gen::HeapprofdConfig heapprofd_config;
heapprofd_config.set_sampling_interval_bytes(kTestSamplingInterval);
heapprofd_config.add_process_cmdline(app_name.c_str());
heapprofd_config.set_block_client(true);
heapprofd_config.set_all(false);
for (const std::string& heap_name : heap_names) {
heapprofd_config.add_heaps(heap_name);
}
ds_config->set_heapprofd_config_raw(heapprofd_config.SerializeAsString());
// start tracing
helper.StartTracing(trace_config);
// start app
StartAppActivity(app_name, activity, "target.app.running", &task_runner,
/*delay_ms=*/100);
task_runner.RunUntilCheckpoint("target.app.running", 10000 /*ms*/);
helper.WaitForTracingDisabled();
helper.ReadData();
helper.WaitForReadData();
return helper.trace();
}
// Check that `packets` contain some allocations performed by kMallocActivity.
void AssertExpectedMallocsPresent(
const std::vector<protos::gen::TracePacket>& packets) {
ASSERT_GT(packets.size(), 0u);
// TODO(rsavitski): assert particular stack frames once we clarify the
// expected behaviour of unwinding native libs within an apk.
// Until then, look for an allocation that is a multiple of the expected
// allocation size.
bool found_alloc = false;
bool found_proc_dump = false;
for (const auto& packet : packets) {
for (const auto& proc_dump : packet.profile_packet().process_dumps()) {
found_proc_dump = true;
for (const auto& sample : proc_dump.samples()) {
if (sample.self_allocated() > 0 &&
sample.self_allocated() % kExpectedIndividualAllocSz == 0) {
found_alloc = true;
EXPECT_TRUE(sample.self_freed() > 0 &&
sample.self_freed() % kExpectedIndividualAllocSz == 0)
<< "self_freed: " << sample.self_freed();
}
}
}
}
ASSERT_TRUE(found_proc_dump);
ASSERT_TRUE(found_alloc);
}
// Check that `packets` contain some allocations performed by
// kJavaAllocActivity.
void AssertExpectedArtAllocsPresent(
const std::vector<protos::gen::TracePacket>& packets) {
ASSERT_GT(packets.size(), 0u);
bool found_alloc = false;
bool found_proc_dump = false;
for (const auto& packet : packets) {
for (const auto& proc_dump : packet.profile_packet().process_dumps()) {
found_proc_dump = true;
for (const auto& sample : proc_dump.samples()) {
if (sample.self_allocated() > 0) {
found_alloc = true;
}
}
}
}
ASSERT_TRUE(found_proc_dump);
ASSERT_TRUE(found_alloc);
}
void AssertNoProfileContents(
const std::vector<protos::gen::TracePacket>& packets) {
// If profile packets are present, they must be empty.
for (const auto& packet : packets) {
ASSERT_EQ(packet.profile_packet().process_dumps_size(), 0);
}
}
TEST(HeapprofdCtsTest, DebuggableAppRuntime) {
std::string app_name = "android.perfetto.cts.app.debuggable";
const auto& packets =
ProfileRuntime(app_name, kMallocActivity, /*heap_names=*/{});
AssertExpectedMallocsPresent(packets);
StopApp(app_name);
}
TEST(HeapprofdCtsTest, DebuggableAppStartup) {
std::string app_name = "android.perfetto.cts.app.debuggable";
const auto& packets =
ProfileStartup(app_name, kMallocActivity, /*heap_names=*/{});
AssertExpectedMallocsPresent(packets);
StopApp(app_name);
}
TEST(HeapprofdCtsTest, ProfileableAppRuntime) {
std::string app_name = "android.perfetto.cts.app.profileable";
const auto& packets =
ProfileRuntime(app_name, kMallocActivity, /*heap_names=*/{});
AssertExpectedMallocsPresent(packets);
StopApp(app_name);
}
TEST(HeapprofdCtsTest, ProfileableAppStartup) {
std::string app_name = "android.perfetto.cts.app.profileable";
const auto& packets =
ProfileStartup(app_name, kMallocActivity, /*heap_names=*/{});
AssertExpectedMallocsPresent(packets);
StopApp(app_name);
}
TEST(HeapprofdCtsTest, ReleaseAppRuntime) {
std::string app_name = "android.perfetto.cts.app.release";
const auto& packets =
ProfileRuntime(app_name, kMallocActivity, /*heap_names=*/{});
if (IsUserBuild())
AssertNoProfileContents(packets);
else
AssertExpectedMallocsPresent(packets);
StopApp(app_name);
}
TEST(HeapprofdCtsTest, ReleaseAppStartup) {
std::string app_name = "android.perfetto.cts.app.release";
const auto& packets =
ProfileStartup(app_name, kMallocActivity, /*heap_names=*/{});
if (IsUserBuild())
AssertNoProfileContents(packets);
else
AssertExpectedMallocsPresent(packets);
StopApp(app_name);
}
TEST(HeapprofdCtsTest, NonProfileableAppRuntime) {
std::string app_name = "android.perfetto.cts.app.nonprofileable";
const auto& packets =
ProfileRuntime(app_name, kMallocActivity, /*heap_names=*/{});
if (IsUserBuild())
AssertNoProfileContents(packets);
else
AssertExpectedMallocsPresent(packets);
StopApp(app_name);
}
TEST(HeapprofdCtsTest, NonProfileableAppStartup) {
std::string app_name = "android.perfetto.cts.app.nonprofileable";
const auto& packets =
ProfileStartup(app_name, kMallocActivity, /*heap_names=*/{});
if (IsUserBuild())
AssertNoProfileContents(packets);
else
AssertExpectedMallocsPresent(packets);
StopApp(app_name);
}
TEST(HeapprofdCtsTest, JavaHeapRuntime) {
std::string app_name = "android.perfetto.cts.app.debuggable";
const auto& packets = ProfileRuntime(app_name, kJavaAllocActivity,
/*heap_names=*/{"com.android.art"});
AssertExpectedArtAllocsPresent(packets);
StopApp(app_name);
}
TEST(HeapprofdCtsTest, JavaHeapStartup) {
std::string app_name = "android.perfetto.cts.app.debuggable";
const auto& packets = ProfileStartup(app_name, kJavaAllocActivity,
/*heap_names=*/{"com.android.art"});
AssertExpectedArtAllocsPresent(packets);
StopApp(app_name);
}
} // namespace
} // namespace perfetto