/*
* Copyright (C) 2011 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 "profiler.h"
#include <fstream>
#include <sys/uio.h>
#include <sys/file.h>
#include "base/stl_util.h"
#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "common_throws.h"
#include "debugger.h"
#include "dex_file-inl.h"
#include "instrumentation.h"
#include "mirror/art_method-inl.h"
#include "mirror/class-inl.h"
#include "mirror/dex_cache.h"
#include "mirror/object_array-inl.h"
#include "mirror/object-inl.h"
#include "os.h"
#include "scoped_thread_state_change.h"
#include "ScopedLocalRef.h"
#include "thread.h"
#include "thread_list.h"
#ifdef HAVE_ANDROID_OS
#include "cutils/properties.h"
#endif
#if !defined(ART_USE_PORTABLE_COMPILER)
#include "entrypoints/quick/quick_entrypoints.h"
#endif
namespace art {
BackgroundMethodSamplingProfiler* BackgroundMethodSamplingProfiler::profiler_ = nullptr;
pthread_t BackgroundMethodSamplingProfiler::profiler_pthread_ = 0U;
volatile bool BackgroundMethodSamplingProfiler::shutting_down_ = false;
// TODO: this profiler runs regardless of the state of the machine. Maybe we should use the
// wakelock or something to modify the run characteristics. This can be done when we
// have some performance data after it's been used for a while.
// Walk through the method within depth of max_depth_ on the Java stack
class BoundedStackVisitor : public StackVisitor {
public:
BoundedStackVisitor(std::vector<std::pair<mirror::ArtMethod*, uint32_t>>* stack,
Thread* thread, uint32_t max_depth)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: StackVisitor(thread, NULL), stack_(stack), max_depth_(max_depth), depth_(0) {
}
bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
mirror::ArtMethod* m = GetMethod();
if (m->IsRuntimeMethod()) {
return true;
}
uint32_t dex_pc_ = GetDexPc();
stack_->push_back(std::make_pair(m, dex_pc_));
++depth_;
if (depth_ < max_depth_) {
return true;
} else {
return false;
}
}
private:
std::vector<std::pair<mirror::ArtMethod*, uint32_t>>* stack_;
const uint32_t max_depth_;
uint32_t depth_;
};
// This is called from either a thread list traversal or from a checkpoint. Regardless
// of which caller, the mutator lock must be held.
static void GetSample(Thread* thread, void* arg) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
BackgroundMethodSamplingProfiler* profiler =
reinterpret_cast<BackgroundMethodSamplingProfiler*>(arg);
const ProfilerOptions profile_options = profiler->GetProfilerOptions();
switch (profile_options.GetProfileType()) {
case kProfilerMethod: {
mirror::ArtMethod* method = thread->GetCurrentMethod(nullptr);
if (false && method == nullptr) {
LOG(INFO) << "No current method available";
std::ostringstream os;
thread->Dump(os);
std::string data(os.str());
LOG(INFO) << data;
}
profiler->RecordMethod(method);
break;
}
case kProfilerBoundedStack: {
std::vector<InstructionLocation> stack;
uint32_t max_depth = profile_options.GetMaxStackDepth();
BoundedStackVisitor bounded_stack_visitor(&stack, thread, max_depth);
bounded_stack_visitor.WalkStack();
profiler->RecordStack(stack);
break;
}
default:
LOG(INFO) << "This profile type is not implemented.";
}
}
// A closure that is called by the thread checkpoint code.
class SampleCheckpoint : public Closure {
public:
explicit SampleCheckpoint(BackgroundMethodSamplingProfiler* const profiler) :
profiler_(profiler) {}
virtual void Run(Thread* thread) NO_THREAD_SAFETY_ANALYSIS {
Thread* self = Thread::Current();
if (thread == nullptr) {
LOG(ERROR) << "Checkpoint with nullptr thread";
return;
}
// Grab the mutator lock (shared access).
ScopedObjectAccess soa(self);
// Grab a sample.
GetSample(thread, this->profiler_);
// And finally tell the barrier that we're done.
this->profiler_->GetBarrier().Pass(self);
}
private:
BackgroundMethodSamplingProfiler* const profiler_;
};
bool BackgroundMethodSamplingProfiler::ShuttingDown(Thread* self) {
MutexLock mu(self, *Locks::profiler_lock_);
return shutting_down_;
}
void* BackgroundMethodSamplingProfiler::RunProfilerThread(void* arg) {
Runtime* runtime = Runtime::Current();
BackgroundMethodSamplingProfiler* profiler =
reinterpret_cast<BackgroundMethodSamplingProfiler*>(arg);
// Add a random delay for the first time run so that we don't hammer the CPU
// with all profiles running at the same time.
const int kRandomDelayMaxSecs = 30;
const double kMaxBackoffSecs = 24*60*60; // Max backoff time.
srand(MicroTime() * getpid());
int startup_delay = rand() % kRandomDelayMaxSecs; // random delay for startup.
CHECK(runtime->AttachCurrentThread("Profiler", true, runtime->GetSystemThreadGroup(),
!runtime->IsCompiler()));
Thread* self = Thread::Current();
double backoff = 1.0;
while (true) {
if (ShuttingDown(self)) {
break;
}
{
// wait until we need to run another profile
uint64_t delay_secs = profiler->options_.GetPeriodS() * backoff;
// Add a startup delay to prevent all the profiles running at once.
delay_secs += startup_delay;
// Immediate startup for benchmarking?
if (profiler->options_.GetStartImmediately() && startup_delay > 0) {
delay_secs = 0;
}
startup_delay = 0;
VLOG(profiler) << "Delaying profile start for " << delay_secs << " secs";
MutexLock mu(self, profiler->wait_lock_);
profiler->period_condition_.TimedWait(self, delay_secs * 1000, 0);
// Expand the backoff by its coefficient, but don't go beyond the max.
backoff = std::min(backoff * profiler->options_.GetBackoffCoefficient(), kMaxBackoffSecs);
}
if (ShuttingDown(self)) {
break;
}
uint64_t start_us = MicroTime();
uint64_t end_us = start_us + profiler->options_.GetDurationS() * UINT64_C(1000000);
uint64_t now_us = start_us;
VLOG(profiler) << "Starting profiling run now for "
<< PrettyDuration((end_us - start_us) * 1000);
SampleCheckpoint check_point(profiler);
size_t valid_samples = 0;
while (now_us < end_us) {
if (ShuttingDown(self)) {
break;
}
usleep(profiler->options_.GetIntervalUs()); // Non-interruptible sleep.
ThreadList* thread_list = runtime->GetThreadList();
profiler->profiler_barrier_->Init(self, 0);
size_t barrier_count = thread_list->RunCheckpointOnRunnableThreads(&check_point);
// All threads are suspended, nothing to do.
if (barrier_count == 0) {
now_us = MicroTime();
continue;
}
valid_samples += barrier_count;
ScopedThreadStateChange tsc(self, kWaitingForCheckPointsToRun);
// Wait for the barrier to be crossed by all runnable threads. This wait
// is done with a timeout so that we can detect problems with the checkpoint
// running code. We should never see this.
const uint32_t kWaitTimeoutMs = 10000;
const uint32_t kWaitTimeoutUs = kWaitTimeoutMs * 1000;
uint64_t waitstart_us = MicroTime();
// Wait for all threads to pass the barrier.
profiler->profiler_barrier_->Increment(self, barrier_count, kWaitTimeoutMs);
uint64_t waitend_us = MicroTime();
uint64_t waitdiff_us = waitend_us - waitstart_us;
// We should never get a timeout. If we do, it suggests a problem with the checkpoint
// code. Crash the process in this case.
CHECK_LT(waitdiff_us, kWaitTimeoutUs);
// Update the current time.
now_us = MicroTime();
}
if (valid_samples > 0) {
// After the profile has been taken, write it out.
ScopedObjectAccess soa(self); // Acquire the mutator lock.
uint32_t size = profiler->WriteProfile();
VLOG(profiler) << "Profile size: " << size;
}
}
LOG(INFO) << "Profiler shutdown";
runtime->DetachCurrentThread();
return nullptr;
}
// Write out the profile file if we are generating a profile.
uint32_t BackgroundMethodSamplingProfiler::WriteProfile() {
std::string full_name = output_filename_;
VLOG(profiler) << "Saving profile to " << full_name;
int fd = open(full_name.c_str(), O_RDWR);
if (fd < 0) {
// Open failed.
LOG(ERROR) << "Failed to open profile file " << full_name;
return 0;
}
// Lock the file for exclusive access. This will block if another process is using
// the file.
int err = flock(fd, LOCK_EX);
if (err < 0) {
LOG(ERROR) << "Failed to lock profile file " << full_name;
return 0;
}
// Read the previous profile.
profile_table_.ReadPrevious(fd, options_.GetProfileType());
// Move back to the start of the file.
lseek(fd, 0, SEEK_SET);
// Format the profile output and write to the file.
std::ostringstream os;
uint32_t num_methods = DumpProfile(os);
std::string data(os.str());
const char *p = data.c_str();
size_t length = data.length();
size_t full_length = length;
do {
int n = ::write(fd, p, length);
p += n;
length -= n;
} while (length > 0);
// Truncate the file to the new length.
ftruncate(fd, full_length);
// Now unlock the file, allowing another process in.
err = flock(fd, LOCK_UN);
if (err < 0) {
LOG(ERROR) << "Failed to unlock profile file " << full_name;
}
// Done, close the file.
::close(fd);
// Clean the profile for the next time.
CleanProfile();
return num_methods;
}
bool BackgroundMethodSamplingProfiler::Start(
const std::string& output_filename, const ProfilerOptions& options) {
if (!options.IsEnabled()) {
return false;
}
CHECK(!output_filename.empty());
Thread* self = Thread::Current();
{
MutexLock mu(self, *Locks::profiler_lock_);
// Don't start two profiler threads.
if (profiler_ != nullptr) {
return true;
}
}
LOG(INFO) << "Starting profiler using output file: " << output_filename
<< " and options: " << options;
{
MutexLock mu(self, *Locks::profiler_lock_);
profiler_ = new BackgroundMethodSamplingProfiler(output_filename, options);
CHECK_PTHREAD_CALL(pthread_create, (&profiler_pthread_, nullptr, &RunProfilerThread,
reinterpret_cast<void*>(profiler_)),
"Profiler thread");
}
return true;
}
void BackgroundMethodSamplingProfiler::Stop() {
BackgroundMethodSamplingProfiler* profiler = nullptr;
pthread_t profiler_pthread = 0U;
{
MutexLock trace_mu(Thread::Current(), *Locks::profiler_lock_);
CHECK(!shutting_down_);
profiler = profiler_;
shutting_down_ = true;
profiler_pthread = profiler_pthread_;
}
// Now wake up the sampler thread if it sleeping.
{
MutexLock profile_mu(Thread::Current(), profiler->wait_lock_);
profiler->period_condition_.Signal(Thread::Current());
}
// Wait for the sample thread to stop.
CHECK_PTHREAD_CALL(pthread_join, (profiler_pthread, nullptr), "profiler thread shutdown");
{
MutexLock mu(Thread::Current(), *Locks::profiler_lock_);
profiler_ = nullptr;
}
delete profiler;
}
void BackgroundMethodSamplingProfiler::Shutdown() {
Stop();
}
BackgroundMethodSamplingProfiler::BackgroundMethodSamplingProfiler(
const std::string& output_filename, const ProfilerOptions& options)
: output_filename_(output_filename),
options_(options),
wait_lock_("Profile wait lock"),
period_condition_("Profile condition", wait_lock_),
profile_table_(wait_lock_),
profiler_barrier_(new Barrier(0)) {
// Populate the filtered_methods set.
// This is empty right now, but to add a method, do this:
//
// filtered_methods_.insert("void java.lang.Object.wait(long, int)");
}
// Filter out methods the profiler doesn't want to record.
// We require mutator lock since some statistics will be updated here.
bool BackgroundMethodSamplingProfiler::ProcessMethod(mirror::ArtMethod* method) {
if (method == nullptr) {
profile_table_.NullMethod();
// Don't record a nullptr method.
return false;
}
mirror::Class* cls = method->GetDeclaringClass();
if (cls != nullptr) {
if (cls->GetClassLoader() == nullptr) {
// Don't include things in the boot
profile_table_.BootMethod();
return false;
}
}
bool is_filtered = false;
if (strcmp(method->GetName(), "<clinit>") == 0) {
// always filter out class init
is_filtered = true;
}
// Filter out methods by name if there are any.
if (!is_filtered && filtered_methods_.size() > 0) {
std::string method_full_name = PrettyMethod(method);
// Don't include specific filtered methods.
is_filtered = filtered_methods_.count(method_full_name) != 0;
}
return !is_filtered;
}
// A method has been hit, record its invocation in the method map.
// The mutator_lock must be held (shared) when this is called.
void BackgroundMethodSamplingProfiler::RecordMethod(mirror::ArtMethod* method) {
// Add to the profile table unless it is filtered out.
if (ProcessMethod(method)) {
profile_table_.Put(method);
}
}
// Record the current bounded stack into sampling results.
void BackgroundMethodSamplingProfiler::RecordStack(const std::vector<InstructionLocation>& stack) {
if (stack.size() == 0) {
return;
}
// Get the method on top of the stack. We use this method to perform filtering.
mirror::ArtMethod* method = stack.front().first;
if (ProcessMethod(method)) {
profile_table_.PutStack(stack);
}
}
// Clean out any recordings for the method traces.
void BackgroundMethodSamplingProfiler::CleanProfile() {
profile_table_.Clear();
}
uint32_t BackgroundMethodSamplingProfiler::DumpProfile(std::ostream& os) {
return profile_table_.Write(os, options_.GetProfileType());
}
// Profile Table.
// This holds a mapping of mirror::ArtMethod* to a count of how many times a sample
// hit it at the top of the stack.
ProfileSampleResults::ProfileSampleResults(Mutex& lock) : lock_(lock), num_samples_(0),
num_null_methods_(0),
num_boot_methods_(0) {
for (int i = 0; i < kHashSize; i++) {
table[i] = nullptr;
}
method_context_table = nullptr;
stack_trie_root_ = nullptr;
}
ProfileSampleResults::~ProfileSampleResults() {
Clear();
}
// Add a method to the profile table. If it's the first time the method
// has been seen, add it with count=1, otherwise increment the count.
void ProfileSampleResults::Put(mirror::ArtMethod* method) {
MutexLock mu(Thread::Current(), lock_);
uint32_t index = Hash(method);
if (table[index] == nullptr) {
table[index] = new Map();
}
Map::iterator i = table[index]->find(method);
if (i == table[index]->end()) {
(*table[index])[method] = 1;
} else {
i->second++;
}
num_samples_++;
}
// Add a bounded stack to the profile table. Only the count of the method on
// top of the frame will be increased.
void ProfileSampleResults::PutStack(const std::vector<InstructionLocation>& stack) {
MutexLock mu(Thread::Current(), lock_);
ScopedObjectAccess soa(Thread::Current());
if (stack_trie_root_ == nullptr) {
// The root of the stack trie is a dummy node so that we don't have to maintain
// a collection of tries.
stack_trie_root_ = new StackTrieNode();
}
StackTrieNode* current = stack_trie_root_;
if (stack.size() == 0) {
current->IncreaseCount();
return;
}
for (std::vector<InstructionLocation>::const_reverse_iterator iter = stack.rbegin();
iter != stack.rend(); ++iter) {
InstructionLocation inst_loc = *iter;
mirror::ArtMethod* method = inst_loc.first;
if (method == nullptr) {
// skip null method
continue;
}
uint32_t dex_pc = inst_loc.second;
uint32_t method_idx = method->GetDexMethodIndex();
const DexFile* dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile();
MethodReference method_ref(dex_file, method_idx);
StackTrieNode* child = current->FindChild(method_ref, dex_pc);
if (child != nullptr) {
current = child;
} else {
uint32_t method_size = 0;
const DexFile::CodeItem* codeitem = method->GetCodeItem();
if (codeitem != nullptr) {
method_size = codeitem->insns_size_in_code_units_;
}
StackTrieNode* new_node = new StackTrieNode(method_ref, dex_pc, method_size, current);
current->AppendChild(new_node);
current = new_node;
}
}
if (current != stack_trie_root_ && current->GetCount() == 0) {
// Insert into method_context table;
if (method_context_table == nullptr) {
method_context_table = new MethodContextMap();
}
MethodReference method = current->GetMethod();
MethodContextMap::iterator i = method_context_table->find(method);
if (i == method_context_table->end()) {
TrieNodeSet* node_set = new TrieNodeSet();
node_set->insert(current);
(*method_context_table)[method] = node_set;
} else {
TrieNodeSet* node_set = i->second;
node_set->insert(current);
}
}
current->IncreaseCount();
num_samples_++;
}
// Write the profile table to the output stream. Also merge with the previous profile.
uint32_t ProfileSampleResults::Write(std::ostream& os, ProfileDataType type) {
ScopedObjectAccess soa(Thread::Current());
num_samples_ += previous_num_samples_;
num_null_methods_ += previous_num_null_methods_;
num_boot_methods_ += previous_num_boot_methods_;
VLOG(profiler) << "Profile: "
<< num_samples_ << "/" << num_null_methods_ << "/" << num_boot_methods_;
os << num_samples_ << "/" << num_null_methods_ << "/" << num_boot_methods_ << "\n";
uint32_t num_methods = 0;
if (type == kProfilerMethod) {
for (int i = 0 ; i < kHashSize; i++) {
Map *map = table[i];
if (map != nullptr) {
for (const auto &meth_iter : *map) {
mirror::ArtMethod *method = meth_iter.first;
std::string method_name = PrettyMethod(method);
const DexFile::CodeItem* codeitem = method->GetCodeItem();
uint32_t method_size = 0;
if (codeitem != nullptr) {
method_size = codeitem->insns_size_in_code_units_;
}
uint32_t count = meth_iter.second;
// Merge this profile entry with one from a previous run (if present). Also
// remove the previous entry.
PreviousProfile::iterator pi = previous_.find(method_name);
if (pi != previous_.end()) {
count += pi->second.count_;
previous_.erase(pi);
}
os << StringPrintf("%s/%u/%u\n", method_name.c_str(), count, method_size);
++num_methods;
}
}
}
} else if (type == kProfilerBoundedStack) {
if (method_context_table != nullptr) {
for (const auto &method_iter : *method_context_table) {
MethodReference method = method_iter.first;
TrieNodeSet* node_set = method_iter.second;
std::string method_name = PrettyMethod(method.dex_method_index, *(method.dex_file));
uint32_t method_size = 0;
uint32_t total_count = 0;
PreviousContextMap new_context_map;
for (const auto &trie_node_i : *node_set) {
StackTrieNode* node = trie_node_i;
method_size = node->GetMethodSize();
uint32_t count = node->GetCount();
uint32_t dexpc = node->GetDexPC();
total_count += count;
StackTrieNode* current = node->GetParent();
// We go backward on the trie to retrieve context and dex_pc until the dummy root.
// The format of the context is "method_1@pc_1@method_2@pc_2@..."
std::vector<std::string> context_vector;
while (current != nullptr && current->GetParent() != nullptr) {
context_vector.push_back(StringPrintf("%s@%u",
PrettyMethod(current->GetMethod().dex_method_index, *(current->GetMethod().dex_file)).c_str(),
current->GetDexPC()));
current = current->GetParent();
}
std::string context_sig = Join(context_vector, '@');
new_context_map[std::make_pair(dexpc, context_sig)] = count;
}
PreviousProfile::iterator pi = previous_.find(method_name);
if (pi != previous_.end()) {
total_count += pi->second.count_;
PreviousContextMap* previous_context_map = pi->second.context_map_;
if (previous_context_map != nullptr) {
for (const auto &context_i : *previous_context_map) {
uint32_t count = context_i.second;
PreviousContextMap::iterator ci = new_context_map.find(context_i.first);
if (ci == new_context_map.end()) {
new_context_map[context_i.first] = count;
} else {
ci->second += count;
}
}
}
delete previous_context_map;
previous_.erase(pi);
}
// We write out profile data with dex pc and context information in the following format:
// "method/total_count/size/[pc_1:count_1:context_1#pc_2:count_2:context_2#...]".
std::vector<std::string> context_count_vector;
for (const auto &context_i : new_context_map) {
context_count_vector.push_back(StringPrintf("%u:%u:%s", context_i.first.first,
context_i.second, context_i.first.second.c_str()));
}
os << StringPrintf("%s/%u/%u/[%s]\n", method_name.c_str(), total_count,
method_size, Join(context_count_vector, '#').c_str());
++num_methods;
}
}
}
// Now we write out the remaining previous methods.
for (const auto &pi : previous_) {
if (type == kProfilerMethod) {
os << StringPrintf("%s/%u/%u\n", pi.first.c_str(), pi.second.count_, pi.second.method_size_);
} else if (type == kProfilerBoundedStack) {
os << StringPrintf("%s/%u/%u/[", pi.first.c_str(), pi.second.count_, pi.second.method_size_);
PreviousContextMap* previous_context_map = pi.second.context_map_;
if (previous_context_map != nullptr) {
std::vector<std::string> context_count_vector;
for (const auto &context_i : *previous_context_map) {
context_count_vector.push_back(StringPrintf("%u:%u:%s", context_i.first.first,
context_i.second, context_i.first.second.c_str()));
}
os << Join(context_count_vector, '#');
}
os << "]\n";
}
++num_methods;
}
return num_methods;
}
void ProfileSampleResults::Clear() {
num_samples_ = 0;
num_null_methods_ = 0;
num_boot_methods_ = 0;
for (int i = 0; i < kHashSize; i++) {
delete table[i];
table[i] = nullptr;
}
if (stack_trie_root_ != nullptr) {
stack_trie_root_->DeleteChildren();
delete stack_trie_root_;
stack_trie_root_ = nullptr;
if (method_context_table != nullptr) {
delete method_context_table;
method_context_table = nullptr;
}
}
for (auto &pi : previous_) {
if (pi.second.context_map_ != nullptr) {
delete pi.second.context_map_;
pi.second.context_map_ = nullptr;
}
}
previous_.clear();
}
uint32_t ProfileSampleResults::Hash(mirror::ArtMethod* method) {
return (PointerToLowMemUInt32(method) >> 3) % kHashSize;
}
// Read a single line into the given string. Returns true if everything OK, false
// on EOF or error.
static bool ReadProfileLine(int fd, std::string& line) {
char buf[4];
line.clear();
while (true) {
int n = read(fd, buf, 1); // TODO: could speed this up but is it worth it?
if (n != 1) {
return false;
}
if (buf[0] == '\n') {
break;
}
line += buf[0];
}
return true;
}
void ProfileSampleResults::ReadPrevious(int fd, ProfileDataType type) {
// Reset counters.
previous_num_samples_ = previous_num_null_methods_ = previous_num_boot_methods_ = 0;
std::string line;
// The first line contains summary information.
if (!ReadProfileLine(fd, line)) {
return;
}
std::vector<std::string> summary_info;
Split(line, '/', summary_info);
if (summary_info.size() != 3) {
// Bad summary info. It should be count/nullcount/bootcount
return;
}
previous_num_samples_ = strtoul(summary_info[0].c_str(), nullptr, 10);
previous_num_null_methods_ = strtoul(summary_info[1].c_str(), nullptr, 10);
previous_num_boot_methods_ = strtoul(summary_info[2].c_str(), nullptr, 10);
// Now read each line until the end of file. Each line consists of 3 or 4 fields separated by /
while (true) {
if (!ReadProfileLine(fd, line)) {
break;
}
std::vector<std::string> info;
Split(line, '/', info);
if (info.size() != 3 && info.size() != 4) {
// Malformed.
break;
}
std::string methodname = info[0];
uint32_t total_count = strtoul(info[1].c_str(), nullptr, 10);
uint32_t size = strtoul(info[2].c_str(), nullptr, 10);
PreviousContextMap* context_map = nullptr;
if (type == kProfilerBoundedStack && info.size() == 4) {
context_map = new PreviousContextMap();
std::string context_counts_str = info[3].substr(1, info[3].size() - 2);
std::vector<std::string> context_count_pairs;
Split(context_counts_str, '#', context_count_pairs);
for (uint32_t i = 0; i < context_count_pairs.size(); ++i) {
std::vector<std::string> context_count;
Split(context_count_pairs[i], ':', context_count);
if (context_count.size() == 2) {
// Handles the situtation when the profile file doesn't contain context information.
uint32_t dexpc = strtoul(context_count[0].c_str(), nullptr, 10);
uint32_t count = strtoul(context_count[1].c_str(), nullptr, 10);
(*context_map)[std::make_pair(dexpc, "")] = count;
} else {
// Handles the situtation when the profile file contains context information.
uint32_t dexpc = strtoul(context_count[0].c_str(), nullptr, 10);
uint32_t count = strtoul(context_count[1].c_str(), nullptr, 10);
std::string context = context_count[2];
(*context_map)[std::make_pair(dexpc, context)] = count;
}
}
}
previous_[methodname] = PreviousValue(total_count, size, context_map);
}
}
bool ProfileFile::LoadFile(const std::string& fileName) {
LOG(VERBOSE) << "reading profile file " << fileName;
struct stat st;
int err = stat(fileName.c_str(), &st);
if (err == -1) {
LOG(VERBOSE) << "not found";
return false;
}
if (st.st_size == 0) {
return false; // Empty profiles are invalid.
}
std::ifstream in(fileName.c_str());
if (!in) {
LOG(VERBOSE) << "profile file " << fileName << " exists but can't be opened";
LOG(VERBOSE) << "file owner: " << st.st_uid << ":" << st.st_gid;
LOG(VERBOSE) << "me: " << getuid() << ":" << getgid();
LOG(VERBOSE) << "file permissions: " << std::oct << st.st_mode;
LOG(VERBOSE) << "errno: " << errno;
return false;
}
// The first line contains summary information.
std::string line;
std::getline(in, line);
if (in.eof()) {
return false;
}
std::vector<std::string> summary_info;
Split(line, '/', summary_info);
if (summary_info.size() != 3) {
// Bad summary info. It should be total/null/boot.
return false;
}
// This is the number of hits in all profiled methods (without nullptr or boot methods)
uint32_t total_count = strtoul(summary_info[0].c_str(), nullptr, 10);
// Now read each line until the end of file. Each line consists of 3 fields separated by '/'.
// Store the info in descending order given by the most used methods.
typedef std::set<std::pair<int, std::vector<std::string>>> ProfileSet;
ProfileSet countSet;
while (!in.eof()) {
std::getline(in, line);
if (in.eof()) {
break;
}
std::vector<std::string> info;
Split(line, '/', info);
if (info.size() != 3 && info.size() != 4) {
// Malformed.
return false;
}
int count = atoi(info[1].c_str());
countSet.insert(std::make_pair(-count, info));
}
uint32_t curTotalCount = 0;
ProfileSet::iterator end = countSet.end();
const ProfileData* prevData = nullptr;
for (ProfileSet::iterator it = countSet.begin(); it != end ; it++) {
const std::string& methodname = it->second[0];
uint32_t count = -it->first;
uint32_t size = strtoul(it->second[2].c_str(), nullptr, 10);
double usedPercent = (count * 100.0) / total_count;
curTotalCount += count;
// Methods with the same count should be part of the same top K percentage bucket.
double topKPercentage = (prevData != nullptr) && (prevData->GetCount() == count)
? prevData->GetTopKUsedPercentage()
: 100 * static_cast<double>(curTotalCount) / static_cast<double>(total_count);
// Add it to the profile map.
ProfileData curData = ProfileData(methodname, count, size, usedPercent, topKPercentage);
profile_map_[methodname] = curData;
prevData = &curData;
}
return true;
}
bool ProfileFile::GetProfileData(ProfileFile::ProfileData* data, const std::string& method_name) {
ProfileMap::iterator i = profile_map_.find(method_name);
if (i == profile_map_.end()) {
return false;
}
*data = i->second;
return true;
}
bool ProfileFile::GetTopKSamples(std::set<std::string>& topKSamples, double topKPercentage) {
ProfileMap::iterator end = profile_map_.end();
for (ProfileMap::iterator it = profile_map_.begin(); it != end; it++) {
if (it->second.GetTopKUsedPercentage() < topKPercentage) {
topKSamples.insert(it->first);
}
}
return true;
}
StackTrieNode* StackTrieNode::FindChild(MethodReference method, uint32_t dex_pc) {
if (children_.size() == 0) {
return nullptr;
}
// Create a dummy node for searching.
StackTrieNode* node = new StackTrieNode(method, dex_pc, 0, nullptr);
std::set<StackTrieNode*, StackTrieNodeComparator>::iterator i = children_.find(node);
delete node;
return (i == children_.end()) ? nullptr : *i;
}
void StackTrieNode::DeleteChildren() {
for (auto &child : children_) {
if (child != nullptr) {
child->DeleteChildren();
delete child;
}
}
}
} // namespace art