1 /* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <memory> 18 #include <set> 19 20 #include "boot_image_profile.h" 21 #include "dex_file-inl.h" 22 #include "method_reference.h" 23 #include "type_reference.h" 24 25 namespace art { 26 27 using Hotness = ProfileCompilationInfo::MethodHotness; 28 29 void GenerateBootImageProfile( 30 const std::vector<std::unique_ptr<const DexFile>>& dex_files, 31 const std::vector<std::unique_ptr<const ProfileCompilationInfo>>& profiles, 32 const BootImageOptions& options, 33 bool verbose, 34 ProfileCompilationInfo* out_profile) { 35 for (const std::unique_ptr<const ProfileCompilationInfo>& profile : profiles) { 36 // Avoid merging classes since we may want to only add classes that fit a certain criteria. 37 // If we merged the classes, every single class in each profile would be in the out_profile, 38 // but we want to only included classes that are in at least a few profiles. 39 out_profile->MergeWith(*profile, /*merge_classes*/ false); 40 } 41 42 // Image classes that were added because they are commonly used. 43 size_t class_count = 0; 44 // Image classes that were only added because they were clean. 45 size_t clean_class_count = 0; 46 // Total clean classes. 47 size_t clean_count = 0; 48 // Total dirty classes. 49 size_t dirty_count = 0; 50 51 for (const std::unique_ptr<const DexFile>& dex_file : dex_files) { 52 // Inferred classes are classes inferred from method samples. 53 std::set<std::pair<const ProfileCompilationInfo*, dex::TypeIndex>> inferred_classes; 54 for (size_t i = 0; i < dex_file->NumMethodIds(); ++i) { 55 MethodReference ref(dex_file.get(), i); 56 // This counter is how many profiles contain the method as sampled or hot. 57 size_t counter = 0; 58 for (const std::unique_ptr<const ProfileCompilationInfo>& profile : profiles) { 59 Hotness hotness = profile->GetMethodHotness(ref); 60 if (hotness.IsInProfile()) { 61 ++counter; 62 out_profile->AddMethodHotness(ref, hotness); 63 inferred_classes.emplace(profile.get(), 64 dex_file->GetMethodId(ref.dex_method_index).class_idx_); 65 } 66 } 67 // If the counter is greater or equal to the compile threshold, mark the method as hot. 68 // Note that all hot methods are also marked as hot in the out profile during the merging 69 // process. 70 if (counter >= options.compiled_method_threshold) { 71 Hotness hotness; 72 hotness.AddFlag(Hotness::kFlagHot); 73 out_profile->AddMethodHotness(ref, hotness); 74 } 75 } 76 // Walk all of the classes and add them to the profile if they meet the requirements. 77 for (size_t i = 0; i < dex_file->NumClassDefs(); ++i) { 78 const DexFile::ClassDef& class_def = dex_file->GetClassDef(i); 79 TypeReference ref(dex_file.get(), class_def.class_idx_); 80 bool is_clean = true; 81 const uint8_t* class_data = dex_file->GetClassData(class_def); 82 if (class_data != nullptr) { 83 ClassDataItemIterator it(*dex_file, class_data); 84 while (it.HasNextStaticField()) { 85 const uint32_t flags = it.GetFieldAccessFlags(); 86 if ((flags & kAccFinal) == 0) { 87 // Not final static field will probably dirty the class. 88 is_clean = false; 89 break; 90 } 91 it.Next(); 92 } 93 it.SkipInstanceFields(); 94 while (it.HasNextDirectMethod() || it.HasNextVirtualMethod()) { 95 const uint32_t flags = it.GetMethodAccessFlags(); 96 if ((flags & kAccNative) != 0 || (flags & kAccFastNative) != 0) { 97 // Native method will get dirtied. 98 is_clean = false; 99 break; 100 } 101 if ((flags & kAccConstructor) != 0 && (flags & kAccStatic) != 0) { 102 // Class initializer, may get dirtied (not sure). 103 is_clean = false; 104 break; 105 } 106 it.Next(); 107 } 108 } 109 ++(is_clean ? clean_count : dirty_count); 110 // This counter is how many profiles contain the class. 111 size_t counter = 0; 112 for (const std::unique_ptr<const ProfileCompilationInfo>& profile : profiles) { 113 auto it = inferred_classes.find(std::make_pair(profile.get(), ref.type_index)); 114 if (it != inferred_classes.end() || 115 profile->ContainsClass(*ref.dex_file, ref.type_index)) { 116 ++counter; 117 } 118 } 119 if (counter == 0) { 120 continue; 121 } 122 if (counter >= options.image_class_theshold) { 123 ++class_count; 124 out_profile->AddClassesForDex(ref.dex_file, &ref.type_index, &ref.type_index + 1); 125 } else if (is_clean && counter >= options.image_class_clean_theshold) { 126 ++clean_class_count; 127 out_profile->AddClassesForDex(ref.dex_file, &ref.type_index, &ref.type_index + 1); 128 } 129 } 130 } 131 if (verbose) { 132 LOG(INFO) << "Image classes " << class_count + clean_class_count 133 << " added because clean " << clean_class_count 134 << " total clean " << clean_count << " total dirty " << dirty_count; 135 } 136 } 137 138 } // namespace art 139
