blob: 3d003a7f06e2012ae00849072d8ab2070d6b506d [file] [log] [blame]
/*
* Copyright (C) 2017 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 <memory>
#include <set>
#include "boot_image_profile.h"
#include "dex/dex_file-inl.h"
#include "jit/profile_compilation_info.h"
#include "method_reference.h"
#include "type_reference.h"
namespace art {
using Hotness = ProfileCompilationInfo::MethodHotness;
void GenerateBootImageProfile(
const std::vector<std::unique_ptr<const DexFile>>& dex_files,
const std::vector<std::unique_ptr<const ProfileCompilationInfo>>& profiles,
const BootImageOptions& options,
bool verbose,
ProfileCompilationInfo* out_profile) {
for (const std::unique_ptr<const ProfileCompilationInfo>& profile : profiles) {
// Avoid merging classes since we may want to only add classes that fit a certain criteria.
// If we merged the classes, every single class in each profile would be in the out_profile,
// but we want to only included classes that are in at least a few profiles.
out_profile->MergeWith(*profile, /*merge_classes*/ false);
}
// Image classes that were added because they are commonly used.
size_t class_count = 0;
// Image classes that were only added because they were clean.
size_t clean_class_count = 0;
// Total clean classes.
size_t clean_count = 0;
// Total dirty classes.
size_t dirty_count = 0;
for (const std::unique_ptr<const DexFile>& dex_file : dex_files) {
// Inferred classes are classes inferred from method samples.
std::set<std::pair<const ProfileCompilationInfo*, dex::TypeIndex>> inferred_classes;
for (size_t i = 0; i < dex_file->NumMethodIds(); ++i) {
MethodReference ref(dex_file.get(), i);
// This counter is how many profiles contain the method as sampled or hot.
size_t counter = 0;
for (const std::unique_ptr<const ProfileCompilationInfo>& profile : profiles) {
Hotness hotness = profile->GetMethodHotness(ref);
if (hotness.IsInProfile()) {
++counter;
out_profile->AddMethodHotness(ref, hotness);
inferred_classes.emplace(profile.get(), ref.GetMethodId().class_idx_);
}
}
// If the counter is greater or equal to the compile threshold, mark the method as hot.
// Note that all hot methods are also marked as hot in the out profile during the merging
// process.
if (counter >= options.compiled_method_threshold) {
Hotness hotness;
hotness.AddFlag(Hotness::kFlagHot);
out_profile->AddMethodHotness(ref, hotness);
}
}
// Walk all of the classes and add them to the profile if they meet the requirements.
for (size_t i = 0; i < dex_file->NumClassDefs(); ++i) {
const DexFile::ClassDef& class_def = dex_file->GetClassDef(i);
TypeReference ref(dex_file.get(), class_def.class_idx_);
bool is_clean = true;
const uint8_t* class_data = dex_file->GetClassData(class_def);
if (class_data != nullptr) {
ClassDataItemIterator it(*dex_file, class_data);
while (it.HasNextStaticField()) {
const uint32_t flags = it.GetFieldAccessFlags();
if ((flags & kAccFinal) == 0) {
// Not final static field will probably dirty the class.
is_clean = false;
break;
}
it.Next();
}
it.SkipInstanceFields();
while (it.HasNextMethod()) {
const uint32_t flags = it.GetMethodAccessFlags();
if ((flags & kAccNative) != 0) {
// Native method will get dirtied.
is_clean = false;
break;
}
if ((flags & kAccConstructor) != 0 && (flags & kAccStatic) != 0) {
// Class initializer, may get dirtied (not sure).
is_clean = false;
break;
}
it.Next();
}
}
++(is_clean ? clean_count : dirty_count);
// This counter is how many profiles contain the class.
size_t counter = 0;
for (const std::unique_ptr<const ProfileCompilationInfo>& profile : profiles) {
auto it = inferred_classes.find(std::make_pair(profile.get(), ref.TypeIndex()));
if (it != inferred_classes.end() ||
profile->ContainsClass(*ref.dex_file, ref.TypeIndex())) {
++counter;
}
}
if (counter == 0) {
continue;
}
if (counter >= options.image_class_theshold) {
++class_count;
out_profile->AddClassForDex(ref);
} else if (is_clean && counter >= options.image_class_clean_theshold) {
++clean_class_count;
out_profile->AddClassForDex(ref);
}
}
}
if (verbose) {
LOG(INFO) << "Image classes " << class_count + clean_class_count
<< " added because clean " << clean_class_count
<< " total clean " << clean_count << " total dirty " << dirty_count;
}
}
} // namespace art