/*
|
* 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 "dexanalyze_experiments.h"
|
|
#include <algorithm>
|
#include <stdint.h>
|
#include <inttypes.h>
|
#include <iostream>
|
#include <map>
|
#include <vector>
|
|
#include "android-base/stringprintf.h"
|
#include "dex/class_accessor-inl.h"
|
#include "dex/class_iterator.h"
|
#include "dex/code_item_accessors-inl.h"
|
#include "dex/dex_instruction-inl.h"
|
#include "dex/standard_dex_file.h"
|
#include "dex/utf-inl.h"
|
|
namespace art {
|
namespace dexanalyze {
|
|
bool IsRange(Instruction::Code code) {
|
return code == Instruction::INVOKE_VIRTUAL_RANGE ||
|
code == Instruction::INVOKE_DIRECT_RANGE ||
|
code == Instruction::INVOKE_SUPER_RANGE ||
|
code == Instruction::INVOKE_STATIC_RANGE ||
|
code == Instruction::INVOKE_INTERFACE_RANGE;
|
}
|
|
uint16_t NumberOfArgs(const Instruction& inst) {
|
return IsRange(inst.Opcode()) ? inst.VRegA_3rc() : inst.VRegA_35c();
|
}
|
|
uint16_t DexMethodIndex(const Instruction& inst) {
|
return IsRange(inst.Opcode()) ? inst.VRegB_3rc() : inst.VRegB_35c();
|
}
|
|
std::string Percent(uint64_t value, uint64_t max) {
|
if (max == 0) {
|
return "0";
|
}
|
return android::base::StringPrintf(
|
"%" PRId64 "(%.2f%%)",
|
value,
|
static_cast<double>(value * 100) / static_cast<double>(max));
|
}
|
|
std::string PercentDivide(uint64_t value, uint64_t max) {
|
if (max == 0) {
|
return "0";
|
}
|
return android::base::StringPrintf(
|
"%" PRId64 "/%" PRId64 "(%.2f%%)",
|
value,
|
max,
|
static_cast<double>(value * 100) / static_cast<double>(max));
|
}
|
|
size_t PrefixLen(const std::string& a, const std::string& b) {
|
size_t len = 0;
|
for (; len < a.length() && len < b.length() && a[len] == b[len]; ++len) {}
|
return len;
|
}
|
|
void Experiment::ProcessDexFiles(const std::vector<std::unique_ptr<const DexFile>>& dex_files) {
|
for (const std::unique_ptr<const DexFile>& dex_file : dex_files) {
|
ProcessDexFile(*dex_file);
|
}
|
}
|
|
void AnalyzeDebugInfo::ProcessDexFiles(
|
const std::vector<std::unique_ptr<const DexFile>>& dex_files) {
|
std::set<const uint8_t*> seen;
|
std::vector<size_t> counts(256, 0u);
|
std::vector<size_t> opcode_counts(256, 0u);
|
std::set<std::vector<uint8_t>> unique_non_header;
|
for (const std::unique_ptr<const DexFile>& dex_file : dex_files) {
|
for (ClassAccessor accessor : dex_file->GetClasses()) {
|
for (const ClassAccessor::Method& method : accessor.GetMethods()) {
|
CodeItemDebugInfoAccessor code_item(*dex_file, method.GetCodeItem(), method.GetIndex());
|
const uint8_t* debug_info = dex_file->GetDebugInfoStream(code_item.DebugInfoOffset());
|
if (debug_info != nullptr && seen.insert(debug_info).second) {
|
const uint8_t* stream = debug_info;
|
DecodeUnsignedLeb128(&stream); // line_start
|
uint32_t parameters_size = DecodeUnsignedLeb128(&stream);
|
for (uint32_t i = 0; i < parameters_size; ++i) {
|
DecodeUnsignedLeb128P1(&stream); // Parameter name.
|
}
|
bool done = false;
|
const uint8_t* after_header_start = stream;
|
while (!done) {
|
const uint8_t* const op_start = stream;
|
uint8_t opcode = *stream++;
|
++opcode_counts[opcode];
|
++total_opcode_bytes_;
|
switch (opcode) {
|
case DexFile::DBG_END_SEQUENCE:
|
++total_end_seq_bytes_;
|
done = true;
|
break;
|
case DexFile::DBG_ADVANCE_PC:
|
DecodeUnsignedLeb128(&stream); // addr_diff
|
total_advance_pc_bytes_ += stream - op_start;
|
break;
|
case DexFile::DBG_ADVANCE_LINE:
|
DecodeSignedLeb128(&stream); // line_diff
|
total_advance_line_bytes_ += stream - op_start;
|
break;
|
case DexFile::DBG_START_LOCAL:
|
DecodeUnsignedLeb128(&stream); // register_num
|
DecodeUnsignedLeb128P1(&stream); // name_idx
|
DecodeUnsignedLeb128P1(&stream); // type_idx
|
total_start_local_bytes_ += stream - op_start;
|
break;
|
case DexFile::DBG_START_LOCAL_EXTENDED:
|
DecodeUnsignedLeb128(&stream); // register_num
|
DecodeUnsignedLeb128P1(&stream); // name_idx
|
DecodeUnsignedLeb128P1(&stream); // type_idx
|
DecodeUnsignedLeb128P1(&stream); // sig_idx
|
total_start_local_extended_bytes_ += stream - op_start;
|
break;
|
case DexFile::DBG_END_LOCAL:
|
DecodeUnsignedLeb128(&stream); // register_num
|
total_end_local_bytes_ += stream - op_start;
|
break;
|
case DexFile::DBG_RESTART_LOCAL:
|
DecodeUnsignedLeb128(&stream); // register_num
|
total_restart_local_bytes_ += stream - op_start;
|
break;
|
case DexFile::DBG_SET_PROLOGUE_END:
|
case DexFile::DBG_SET_EPILOGUE_BEGIN:
|
total_epilogue_bytes_ += stream - op_start;
|
break;
|
case DexFile::DBG_SET_FILE: {
|
DecodeUnsignedLeb128P1(&stream); // name_idx
|
total_set_file_bytes_ += stream - op_start;
|
break;
|
}
|
default: {
|
total_other_bytes_ += stream - op_start;
|
break;
|
}
|
}
|
}
|
const size_t bytes = stream - debug_info;
|
total_bytes_ += bytes;
|
total_non_header_bytes_ += stream - after_header_start;
|
if (unique_non_header.insert(std::vector<uint8_t>(after_header_start, stream)).second) {
|
total_unique_non_header_bytes_ += stream - after_header_start;
|
}
|
for (size_t i = 0; i < bytes; ++i) {
|
++counts[debug_info[i]];
|
}
|
}
|
}
|
}
|
}
|
auto calc_entropy = [](std::vector<size_t> data) {
|
size_t total = std::accumulate(data.begin(), data.end(), 0u);
|
double avg_entropy = 0.0;
|
for (size_t c : data) {
|
if (c > 0) {
|
double ratio = static_cast<double>(c) / static_cast<double>(total);
|
avg_entropy -= ratio * log(ratio) / log(256.0);
|
}
|
}
|
return avg_entropy * total;
|
};
|
total_entropy_ += calc_entropy(counts);
|
total_opcode_entropy_ += calc_entropy(opcode_counts);
|
}
|
|
void AnalyzeDebugInfo::Dump(std::ostream& os, uint64_t total_size) const {
|
os << "Debug info bytes " << Percent(total_bytes_, total_size) << "\n";
|
|
os << " DBG_END_SEQUENCE: " << Percent(total_end_seq_bytes_, total_size) << "\n";
|
os << " DBG_ADVANCE_PC: " << Percent(total_advance_pc_bytes_, total_size) << "\n";
|
os << " DBG_ADVANCE_LINE: " << Percent(total_advance_line_bytes_, total_size) << "\n";
|
os << " DBG_START_LOCAL: " << Percent(total_start_local_bytes_, total_size) << "\n";
|
os << " DBG_START_LOCAL_EXTENDED: "
|
<< Percent(total_start_local_extended_bytes_, total_size) << "\n";
|
os << " DBG_END_LOCAL: " << Percent(total_end_local_bytes_, total_size) << "\n";
|
os << " DBG_RESTART_LOCAL: " << Percent(total_restart_local_bytes_, total_size) << "\n";
|
os << " DBG_SET_PROLOGUE bytes " << Percent(total_epilogue_bytes_, total_size) << "\n";
|
os << " DBG_SET_FILE bytes " << Percent(total_set_file_bytes_, total_size) << "\n";
|
os << " special: "
|
<< Percent(total_other_bytes_, total_size) << "\n";
|
os << "Debug info entropy " << Percent(total_entropy_, total_size) << "\n";
|
os << "Debug info opcode bytes " << Percent(total_opcode_bytes_, total_size) << "\n";
|
os << "Debug info opcode entropy " << Percent(total_opcode_entropy_, total_size) << "\n";
|
os << "Debug info non header bytes " << Percent(total_non_header_bytes_, total_size) << "\n";
|
os << "Debug info deduped non header bytes "
|
<< Percent(total_unique_non_header_bytes_, total_size) << "\n";
|
}
|
|
void CountDexIndices::ProcessDexFiles(
|
const std::vector<std::unique_ptr<const DexFile>>& dex_files) {
|
std::set<std::string> unique_field_names;
|
std::set<std::string> unique_method_names;
|
std::set<std::string> unique_type_names;
|
std::set<std::string> unique_mf_names;
|
for (const std::unique_ptr<const DexFile>& dex_file : dex_files) {
|
for (size_t i = 0; i < dex_file->NumTypeIds(); ++i) {
|
unique_type_names.insert(
|
dex_file->StringDataByIdx(dex_file->GetTypeId(dex::TypeIndex(i)).descriptor_idx_));
|
}
|
for (size_t i = 0; i < dex_file->NumFieldIds(); ++i) {
|
unique_field_names.insert(dex_file->StringDataByIdx(dex_file->GetFieldId(i).name_idx_));
|
}
|
for (size_t i = 0; i < dex_file->NumMethodIds(); ++i) {
|
unique_method_names.insert(dex_file->StringDataByIdx(dex_file->GetMethodId(i).name_idx_));
|
}
|
ProcessDexFile(*dex_file);
|
}
|
total_unique_method_names_ += unique_method_names.size();
|
total_unique_field_names_ += unique_field_names.size();
|
total_unique_type_names_ += unique_type_names.size();
|
unique_mf_names = unique_field_names;
|
unique_mf_names.insert(unique_method_names.begin(), unique_method_names.end());
|
total_unique_mf_names_ += unique_mf_names.size();
|
}
|
|
void CountDexIndices::ProcessDexFile(const DexFile& dex_file) {
|
num_string_ids_ += dex_file.NumStringIds();
|
num_method_ids_ += dex_file.NumMethodIds();
|
num_field_ids_ += dex_file.NumFieldIds();
|
num_type_ids_ += dex_file.NumTypeIds();
|
num_class_defs_ += dex_file.NumClassDefs();
|
std::set<size_t> unique_code_items;
|
|
for (ClassAccessor accessor : dex_file.GetClasses()) {
|
std::set<size_t> unique_method_ids;
|
std::set<size_t> unique_string_ids;
|
// Types accessed and count.
|
std::map<size_t, size_t> types_accessed;
|
|
// Maps from dex field index -> class field index (static or instance).
|
std::map<uint32_t, uint32_t> static_field_index_map_;
|
size_t current_idx = 0u;
|
for (const ClassAccessor::Field& field : accessor.GetStaticFields()) {
|
static_field_index_map_[field.GetIndex()] = current_idx++;
|
}
|
std::map<uint32_t, uint32_t> instance_field_index_map_;
|
current_idx = 0u;
|
for (const ClassAccessor::Field& field : accessor.GetInstanceFields()) {
|
instance_field_index_map_[field.GetIndex()] = current_idx++;
|
}
|
auto ProcessFieldIndex = [&](uint32_t dex_field_idx,
|
uint32_t inout,
|
const std::map<uint32_t, uint32_t>& index_map,
|
/*inout*/ FieldAccessStats* stats) {
|
auto it = index_map.find(dex_field_idx);
|
if (it != index_map.end()) {
|
if (it->second < FieldAccessStats::kMaxFieldIndex) {
|
++stats->field_index_[it->second];
|
} else {
|
++stats->field_index_other_;
|
}
|
} else {
|
++stats->field_index_other_class_;
|
}
|
if (it != index_map.end() &&
|
it->second < FieldAccessStats::kShortBytecodeFieldIndexOutCutOff &&
|
inout < FieldAccessStats::kShortBytecodeInOutCutOff) {
|
++stats->short_bytecode_;
|
}
|
};
|
auto ProcessInstanceField = [&](const Instruction& inst,
|
uint32_t first_arg_reg,
|
const std::map<uint32_t, uint32_t>& index_map,
|
/*inout*/ InstanceFieldAccessStats* stats) {
|
const uint32_t dex_field_idx = inst.VRegC_22c();
|
++types_accessed[dex_file.GetFieldId(dex_field_idx).class_idx_.index_];
|
uint32_t input = inst.VRegA_22c();
|
++stats->inout_[input];
|
const uint32_t receiver = inst.VRegB_22c();
|
// FIXME: This is weird if receiver < first_arg_reg.
|
++stats->receiver_[(receiver - first_arg_reg) & 0xF];
|
if (first_arg_reg == receiver) {
|
ProcessFieldIndex(dex_field_idx, input, index_map, stats);
|
}
|
};
|
auto ProcessStaticField = [&](const Instruction& inst,
|
const std::map<uint32_t, uint32_t>& index_map,
|
/*inout*/ StaticFieldAccessStats* stats) {
|
const uint32_t dex_field_idx = inst.VRegB_21c();
|
++types_accessed[dex_file.GetFieldId(dex_field_idx).class_idx_.index_];
|
uint8_t output = inst.VRegA_21c();
|
if (output < 16u) {
|
++stats->inout_[output];
|
} else {
|
++stats->inout_other_;
|
}
|
ProcessFieldIndex(dex_field_idx, output, index_map, stats);
|
};
|
|
for (const ClassAccessor::Method& method : accessor.GetMethods()) {
|
CodeItemDataAccessor code_item(dex_file, method.GetCodeItem());
|
const uint32_t first_arg_reg =
|
((method.GetAccessFlags() & kAccStatic) == 0)
|
? code_item.RegistersSize() - code_item.InsSize()
|
: static_cast<uint32_t>(-1);
|
|
dex_code_bytes_ += code_item.InsnsSizeInBytes();
|
unique_code_items.insert(method.GetCodeItemOffset());
|
for (const DexInstructionPcPair& inst : code_item) {
|
switch (inst->Opcode()) {
|
case Instruction::CONST_STRING: {
|
const dex::StringIndex string_index(inst->VRegB_21c());
|
unique_string_ids.insert(string_index.index_);
|
++num_string_ids_from_code_;
|
break;
|
}
|
case Instruction::IGET:
|
case Instruction::IGET_WIDE:
|
case Instruction::IGET_OBJECT:
|
case Instruction::IGET_BOOLEAN:
|
case Instruction::IGET_BYTE:
|
case Instruction::IGET_CHAR:
|
case Instruction::IGET_SHORT: {
|
ProcessInstanceField(
|
inst.Inst(), first_arg_reg, instance_field_index_map_, &iget_stats_);
|
break;
|
}
|
case Instruction::IPUT:
|
case Instruction::IPUT_WIDE:
|
case Instruction::IPUT_OBJECT:
|
case Instruction::IPUT_BOOLEAN:
|
case Instruction::IPUT_BYTE:
|
case Instruction::IPUT_CHAR:
|
case Instruction::IPUT_SHORT: {
|
ProcessInstanceField(
|
inst.Inst(), first_arg_reg, instance_field_index_map_, &iput_stats_);
|
break;
|
}
|
case Instruction::SGET:
|
case Instruction::SGET_WIDE:
|
case Instruction::SGET_OBJECT:
|
case Instruction::SGET_BOOLEAN:
|
case Instruction::SGET_BYTE:
|
case Instruction::SGET_CHAR:
|
case Instruction::SGET_SHORT: {
|
ProcessStaticField(inst.Inst(), static_field_index_map_, &sget_stats_);
|
break;
|
}
|
case Instruction::SPUT:
|
case Instruction::SPUT_WIDE:
|
case Instruction::SPUT_OBJECT:
|
case Instruction::SPUT_BOOLEAN:
|
case Instruction::SPUT_BYTE:
|
case Instruction::SPUT_CHAR:
|
case Instruction::SPUT_SHORT: {
|
ProcessStaticField(inst.Inst(), static_field_index_map_, &sput_stats_);
|
break;
|
}
|
case Instruction::CONST_STRING_JUMBO: {
|
const dex::StringIndex string_index(inst->VRegB_31c());
|
unique_string_ids.insert(string_index.index_);
|
++num_string_ids_from_code_;
|
break;
|
}
|
// Invoke cases.
|
case Instruction::INVOKE_VIRTUAL:
|
case Instruction::INVOKE_VIRTUAL_RANGE: {
|
uint32_t method_idx = DexMethodIndex(inst.Inst());
|
++types_accessed[dex_file.GetMethodId(method_idx).class_idx_.index_];
|
if (dex_file.GetMethodId(method_idx).class_idx_ == accessor.GetClassIdx()) {
|
++same_class_virtual_;
|
}
|
++total_virtual_;
|
unique_method_ids.insert(method_idx);
|
break;
|
}
|
case Instruction::INVOKE_DIRECT:
|
case Instruction::INVOKE_DIRECT_RANGE: {
|
uint32_t method_idx = DexMethodIndex(inst.Inst());
|
++types_accessed[dex_file.GetMethodId(method_idx).class_idx_.index_];
|
if (dex_file.GetMethodId(method_idx).class_idx_ == accessor.GetClassIdx()) {
|
++same_class_direct_;
|
}
|
++total_direct_;
|
unique_method_ids.insert(method_idx);
|
break;
|
}
|
case Instruction::INVOKE_STATIC:
|
case Instruction::INVOKE_STATIC_RANGE: {
|
uint32_t method_idx = DexMethodIndex(inst.Inst());
|
++types_accessed[dex_file.GetMethodId(method_idx).class_idx_.index_];
|
if (dex_file.GetMethodId(method_idx).class_idx_ == accessor.GetClassIdx()) {
|
++same_class_static_;
|
}
|
++total_static_;
|
unique_method_ids.insert(method_idx);
|
break;
|
}
|
case Instruction::INVOKE_INTERFACE:
|
case Instruction::INVOKE_INTERFACE_RANGE: {
|
uint32_t method_idx = DexMethodIndex(inst.Inst());
|
++types_accessed[dex_file.GetMethodId(method_idx).class_idx_.index_];
|
if (dex_file.GetMethodId(method_idx).class_idx_ == accessor.GetClassIdx()) {
|
++same_class_interface_;
|
}
|
++total_interface_;
|
unique_method_ids.insert(method_idx);
|
break;
|
}
|
case Instruction::INVOKE_SUPER:
|
case Instruction::INVOKE_SUPER_RANGE: {
|
uint32_t method_idx = DexMethodIndex(inst.Inst());
|
++types_accessed[dex_file.GetMethodId(method_idx).class_idx_.index_];
|
if (dex_file.GetMethodId(method_idx).class_idx_ == accessor.GetClassIdx()) {
|
++same_class_super_;
|
}
|
++total_super_;
|
unique_method_ids.insert(method_idx);
|
break;
|
}
|
case Instruction::NEW_ARRAY: {
|
++types_accessed[inst->VRegC_22c()];
|
break;
|
}
|
case Instruction::FILLED_NEW_ARRAY: {
|
++types_accessed[inst->VRegB_35c()];
|
break;
|
}
|
case Instruction::FILLED_NEW_ARRAY_RANGE: {
|
++types_accessed[inst->VRegB_3rc()];
|
break;
|
}
|
case Instruction::CONST_CLASS:
|
case Instruction::CHECK_CAST:
|
case Instruction::NEW_INSTANCE: {
|
++types_accessed[inst->VRegB_21c()];
|
break;
|
}
|
case Instruction::INSTANCE_OF: {
|
++types_accessed[inst->VRegB_21c()];
|
break;
|
}
|
default:
|
break;
|
}
|
}
|
}
|
// Count uses of top 16n.
|
std::vector<size_t> uses;
|
for (auto&& p : types_accessed) {
|
uses.push_back(p.second);
|
}
|
std::sort(uses.rbegin(), uses.rend());
|
for (size_t i = 0; i < uses.size(); ++i) {
|
if (i < 16) {
|
uses_top_types_ += uses[i];
|
}
|
uses_all_types_ += uses[i];
|
}
|
total_unique_types_ += types_accessed.size();
|
total_unique_method_ids_ += unique_method_ids.size();
|
total_unique_string_ids_ += unique_string_ids.size();
|
}
|
total_unique_code_items_ += unique_code_items.size();
|
}
|
|
void CountDexIndices::Dump(std::ostream& os, uint64_t total_size) const {
|
auto DumpFieldIndexes = [&](const FieldAccessStats& stats) {
|
const uint64_t fields_idx_total = std::accumulate(
|
stats.field_index_,
|
stats.field_index_ + FieldAccessStats::kMaxFieldIndex,
|
stats.field_index_other_ + stats.field_index_other_class_);
|
for (size_t i = 0; i < FieldAccessStats::kMaxFieldIndex; ++i) {
|
os << " field_idx=" << i << ": " << Percent(stats.field_index_[i], fields_idx_total) << "\n";
|
}
|
os << " field_idx=other: " << Percent(stats.field_index_other_, fields_idx_total) << "\n";
|
os << " field_idx=other_class: " << Percent(stats.field_index_other_class_, fields_idx_total)
|
<< "\n";
|
};
|
auto DumpInstanceFieldStats = [&](const char* tag, const InstanceFieldAccessStats& stats) {
|
const uint64_t fields_total = std::accumulate(stats.inout_, stats.inout_ + 16u, 0u);
|
os << tag << "\n";
|
for (size_t i = 0; i < 16; ++i) {
|
os << " receiver_reg=" << i << ": " << Percent(stats.receiver_[i], fields_total) << "\n";
|
}
|
DCHECK(tag[1] == 'G' || tag[1] == 'P');
|
const char* inout_tag = (tag[1] == 'G') ? "output_reg" : "input_reg";
|
for (size_t i = 0; i < 16; ++i) {
|
os << " " << inout_tag << "=" << i << ": " << Percent(stats.inout_[i], fields_total) << "\n";
|
}
|
DumpFieldIndexes(stats);
|
os << " short_bytecode: " << Percent(stats.short_bytecode_, fields_total) << "\n";
|
os << " short_bytecode_savings=" << Percent(stats.short_bytecode_ * 2, total_size) << "\n";
|
};
|
DumpInstanceFieldStats("IGET", iget_stats_);
|
DumpInstanceFieldStats("IPUT", iput_stats_);
|
|
auto DumpStaticFieldStats = [&](const char* tag, const StaticFieldAccessStats& stats) {
|
const uint64_t fields_total =
|
std::accumulate(stats.inout_, stats.inout_ + 16u, stats.inout_other_);
|
os << tag << "\n";
|
DCHECK(tag[1] == 'G' || tag[1] == 'P');
|
const char* inout_tag = (tag[1] == 'G') ? "output_reg" : "input_reg";
|
for (size_t i = 0; i < 16; ++i) {
|
os << " " << inout_tag << "=" << i << ": " << Percent(stats.inout_[i], fields_total) << "\n";
|
}
|
os << " " << inout_tag << "=other: " << Percent(stats.inout_other_, fields_total) << "\n";
|
DumpFieldIndexes(stats);
|
os << " short_bytecode: " << Percent(stats.short_bytecode_, fields_total) << "\n";
|
os << " short_bytecode_savings=" << Percent(stats.short_bytecode_ * 2, total_size) << "\n";
|
};
|
DumpStaticFieldStats("SGET", sget_stats_);
|
DumpStaticFieldStats("SPUT", sput_stats_);
|
|
os << "Num string ids: " << num_string_ids_ << "\n";
|
os << "Num method ids: " << num_method_ids_ << "\n";
|
os << "Num field ids: " << num_field_ids_ << "\n";
|
os << "Num type ids: " << num_type_ids_ << "\n";
|
os << "Num class defs: " << num_class_defs_ << "\n";
|
os << "Direct same class: " << PercentDivide(same_class_direct_, total_direct_) << "\n";
|
os << "Virtual same class: " << PercentDivide(same_class_virtual_, total_virtual_) << "\n";
|
os << "Static same class: " << PercentDivide(same_class_static_, total_static_) << "\n";
|
os << "Interface same class: " << PercentDivide(same_class_interface_, total_interface_) << "\n";
|
os << "Super same class: " << PercentDivide(same_class_super_, total_super_) << "\n";
|
os << "Num strings accessed from code: " << num_string_ids_from_code_ << "\n";
|
os << "Avg unique methods accessed per class: "
|
<< static_cast<double>(total_unique_method_ids_) / static_cast<double>(num_class_defs_) << "\n";
|
os << "Avg unique strings accessed per class: "
|
<< static_cast<double>(total_unique_string_ids_) / static_cast<double>(num_class_defs_) << "\n";
|
os << "Avg unique types accessed per class " <<
|
static_cast<double>(total_unique_types_) / static_cast<double>(num_class_defs_) << "\n";
|
os << "Total unique methods accessed per class: "
|
<< Percent(total_unique_method_ids_, total_size) << "\n";
|
os << "Total unique strings accessed per class: "
|
<< Percent(total_unique_string_ids_, total_size) << "\n";
|
os << "Total unique types accessed per class: "
|
<< Percent(total_unique_types_, total_size) << "\n";
|
const size_t same_class_total =
|
same_class_direct_ +
|
same_class_virtual_ +
|
same_class_static_ +
|
same_class_interface_ +
|
same_class_super_;
|
const size_t other_class_total =
|
total_direct_ +
|
total_virtual_ +
|
total_static_ +
|
total_interface_ +
|
total_super_;
|
os << "Unique method names: " << Percent(total_unique_method_names_, num_field_ids_) << "\n";
|
os << "Unique field names: " << Percent(total_unique_field_names_, num_method_ids_) << "\n";
|
os << "Unique type names: " << Percent(total_unique_type_names_, num_type_ids_) << "\n";
|
os << "Unique method/field names: "
|
<< Percent(total_unique_mf_names_, num_field_ids_ + num_method_ids_) << "\n";
|
os << "Same class invokes: " << PercentDivide(same_class_total, other_class_total) << "\n";
|
os << "Invokes from code: " << (same_class_total + other_class_total) << "\n";
|
os << "Type uses on top types: " << PercentDivide(uses_top_types_, uses_all_types_) << "\n";
|
os << "Type uses 1b savings: " << PercentDivide(uses_top_types_, total_size) << "\n";
|
os << "Total Dex code bytes: " << Percent(dex_code_bytes_, total_size) << "\n";
|
os << "Total unique code items: " << total_unique_code_items_ << "\n";
|
os << "Total Dex size: " << total_size << "\n";
|
}
|
|
void CodeMetrics::ProcessDexFile(const DexFile& dex_file) {
|
for (ClassAccessor accessor : dex_file.GetClasses()) {
|
for (const ClassAccessor::Method& method : accessor.GetMethods()) {
|
bool space_for_out_arg = false;
|
for (const DexInstructionPcPair& inst : method.GetInstructions()) {
|
switch (inst->Opcode()) {
|
case Instruction::INVOKE_VIRTUAL:
|
case Instruction::INVOKE_DIRECT:
|
case Instruction::INVOKE_SUPER:
|
case Instruction::INVOKE_INTERFACE:
|
case Instruction::INVOKE_STATIC: {
|
const uint32_t args = NumberOfArgs(inst.Inst());
|
CHECK_LT(args, kMaxArgCount);
|
++arg_counts_[args];
|
space_for_out_arg = args < kMaxArgCount - 1;
|
break;
|
}
|
case Instruction::MOVE_RESULT:
|
case Instruction::MOVE_RESULT_OBJECT: {
|
if (space_for_out_arg && inst->VRegA_11x() < 16) {
|
move_result_savings_ += inst->SizeInCodeUnits() * 2;
|
}
|
break;
|
}
|
default:
|
space_for_out_arg = false;
|
break;
|
}
|
}
|
}
|
}
|
}
|
|
void CodeMetrics::Dump(std::ostream& os, uint64_t total_size) const {
|
const uint64_t total = std::accumulate(arg_counts_, arg_counts_ + kMaxArgCount, 0u);
|
for (size_t i = 0; i < kMaxArgCount; ++i) {
|
os << "args=" << i << ": " << Percent(arg_counts_[i], total) << "\n";
|
}
|
os << "Move result savings: " << Percent(move_result_savings_, total_size) << "\n";
|
os << "One byte invoke savings: " << Percent(total, total_size) << "\n";
|
const uint64_t low_arg_total = std::accumulate(arg_counts_, arg_counts_ + 2, 0u);
|
os << "Low arg savings: " << Percent(low_arg_total * 2, total_size) << "\n";
|
}
|
|
} // namespace dexanalyze
|
} // namespace art
|
