1 /* 2 * Copyright (C) 2015 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 #ifndef ART_RUNTIME_JIT_PROFILE_SAVER_H_ 18 #define ART_RUNTIME_JIT_PROFILE_SAVER_H_ 19 20 #include <utility> 21 22 #include "app_info.h" 23 #include "base/mutex.h" 24 #include "base/safe_map.h" 25 #include "dex/method_reference.h" 26 #include "jit_code_cache.h" 27 #include "profile/profile_compilation_info.h" 28 #include "profile_saver_options.h" 29 30 namespace art HIDDEN { 31 32 class ProfileSaver { 33 public: 34 // Starts the profile saver thread if not already started. 35 // If the saver is already running it adds (output_filename, code_paths) to its tracked locations. 36 // 37 // The `ref_profile_filename` denotes the path to the reference profile which 38 // might be queried to determine if an initial save should be done earlier. 39 // It can be empty indicating there is no reference profile. 40 static void Start(const ProfileSaverOptions& options, 41 const std::string& output_filename, 42 jit::JitCodeCache* jit_code_cache, 43 const std::vector<std::string>& code_paths, 44 const std::string& ref_profile_filename, 45 AppInfo::CodeType code_type) 46 REQUIRES(!Locks::profiler_lock_, !instance_->wait_lock_); 47 48 // Stops the profile saver thread. 49 static void Stop(bool dump_info_) REQUIRES(!Locks::profiler_lock_, !instance_->wait_lock_); 50 51 // Returns true if the profile saver is started. 52 static bool IsStarted() REQUIRES(!Locks::profiler_lock_); 53 54 // If the profile saver is running, dumps statistics to the `os`. Otherwise it does nothing. 55 static void DumpInstanceInfo(std::ostream& os); 56 57 static void NotifyJitActivity() REQUIRES(!Locks::profiler_lock_, !instance_->wait_lock_); 58 59 // For testing or manual purposes (SIGUSR1). 60 EXPORT static void ForceProcessProfiles() REQUIRES(!Locks::profiler_lock_, !Locks::mutator_lock_); 61 62 // Notify that startup has completed. 63 static void NotifyStartupCompleted() REQUIRES(!Locks::profiler_lock_, !instance_->wait_lock_); 64 65 private: 66 // Helper classes for collecting classes and methods. 67 class GetClassesAndMethodsHelper; 68 class ScopedDefaultPriority; 69 70 ProfileSaver(const ProfileSaverOptions& options, jit::JitCodeCache* jit_code_cache); 71 ~ProfileSaver(); 72 73 static void* RunProfileSaverThread(void* arg) 74 REQUIRES(!Locks::profiler_lock_, !instance_->wait_lock_); 75 76 // The run loop for the saver. 77 void Run() 78 REQUIRES(Locks::profiler_lock_, !wait_lock_) 79 RELEASE(Locks::profiler_lock_); 80 81 // Processes the existing profiling info from the jit code cache and returns 82 // true if it needed to be saved to disk. 83 // If number_of_new_methods is not null, after the call it will contain the number of new methods 84 // written to disk. 85 // If force_save is true, the saver will ignore any constraints which limit IO (e.g. will write 86 // the profile to disk even if it's just one new method). 87 bool ProcessProfilingInfo(bool force_save, /*out*/uint16_t* number_of_new_methods) 88 REQUIRES(!Locks::profiler_lock_) 89 REQUIRES(!Locks::mutator_lock_); 90 91 void NotifyJitActivityInternal() REQUIRES(!wait_lock_); 92 void WakeUpSaver() REQUIRES(wait_lock_); 93 94 // Returns true if the saver is shutting down (ProfileSaver::Stop() has been called). 95 bool ShuttingDown(Thread* self) REQUIRES(!Locks::profiler_lock_); 96 97 void AddTrackedLocations(const std::string& output_filename, 98 const std::vector<std::string>& code_paths, 99 const std::string& ref_profile_filename, 100 AppInfo::CodeType code_type) REQUIRES(Locks::profiler_lock_); 101 102 // Fetches the current resolved classes and methods from the ClassLinker and stores them in the 103 // profile_cache_ for later save. 104 void FetchAndCacheResolvedClassesAndMethods(bool startup) REQUIRES(!Locks::profiler_lock_); 105 106 void DumpInfo(std::ostream& os); 107 108 // Resolve the realpath of the locations stored in tracked_dex_base_locations_to_be_resolved_ 109 // and put the result in tracked_dex_base_locations_. 110 void ResolveTrackedLocations() REQUIRES(!Locks::profiler_lock_); 111 112 // Get the profile metadata that should be associated with the profile session during the current 113 // profile saver session. 114 ProfileCompilationInfo::ProfileSampleAnnotation GetProfileSampleAnnotation(); 115 116 // Get extra global flags if necessary (e.g. the running architecture), otherwise 0. 117 static uint32_t GetExtraMethodHotnessFlags(const ProfileSaverOptions& options); 118 119 // Extends the given set of flags with global flags if necessary (e.g. the running architecture). 120 ProfileCompilationInfo::MethodHotness::Flag AnnotateSampleFlags(uint32_t flags); 121 122 // The only instance of the saver. 123 static ProfileSaver* instance_ GUARDED_BY(Locks::profiler_lock_); 124 // Profile saver thread. 125 static pthread_t profiler_pthread_ GUARDED_BY(Locks::profiler_lock_); 126 127 jit::JitCodeCache* jit_code_cache_; 128 129 // Collection of code paths that the profiler tracks. 130 // It maps profile locations to code paths (dex base locations). 131 SafeMap<std::string, std::set<std::string>> tracked_dex_base_locations_ 132 GUARDED_BY(Locks::profiler_lock_); 133 134 // Collection of code paths that the profiler tracks but may note have been resolved 135 // to their realpath. The resolution is done async to minimize the time it takes for 136 // someone to register a path. 137 SafeMap<std::string, std::set<std::string>> tracked_dex_base_locations_to_be_resolved_ 138 GUARDED_BY(Locks::profiler_lock_); 139 140 // Collection of output profiles that the profile tracks. 141 // It maps output profile locations to reference profiles and code types. 142 // This is used to determine if any profile is non-empty at the start of the ProfileSaver, which 143 // influences the time of the first ever save. 144 // It's also used to determine the save order. 145 SafeMap<std::string, std::pair<std::string, AppInfo::CodeType>> tracked_profiles_ 146 GUARDED_BY(Locks::profiler_lock_); 147 148 bool shutting_down_ GUARDED_BY(Locks::profiler_lock_); 149 uint64_t last_time_ns_saver_woke_up_ GUARDED_BY(wait_lock_); 150 uint32_t jit_activity_notifications_; 151 152 // A local cache for the profile information. Maps each tracked file to its 153 // profile information. This is used to cache the startup classes so that 154 // we don't hammer the disk to save them right away. 155 // The size of this cache is usually very small and tops 156 // to just a few hundreds entries in the ProfileCompilationInfo objects. 157 SafeMap<std::string, ProfileCompilationInfo*> profile_cache_ GUARDED_BY(Locks::profiler_lock_); 158 159 // Whether or not this is the first ever profile save. 160 // Note this is an approximation and is not 100% precise. It relies on checking 161 // whether or not the profiles are empty which is not a precise indication 162 // of being the first save (they could have been cleared in the meantime). 163 bool IsFirstSave() REQUIRES(!Locks::profiler_lock_); 164 165 // Save period condition support. 166 Mutex wait_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 167 ConditionVariable period_condition_ GUARDED_BY(wait_lock_); 168 169 uint64_t total_bytes_written_; 170 uint64_t total_number_of_writes_; 171 uint64_t total_number_of_code_cache_queries_; 172 uint64_t total_number_of_skipped_writes_; 173 uint64_t total_number_of_failed_writes_; 174 uint64_t total_ms_of_sleep_; 175 uint64_t total_ns_of_work_; 176 // TODO(calin): replace with an actual size. 177 uint64_t total_number_of_hot_spikes_; 178 uint64_t total_number_of_wake_ups_; 179 180 const ProfileSaverOptions options_; 181 182 friend class ProfileSaverTest; 183 friend class ProfileSaverForBootTest; 184 185 DISALLOW_COPY_AND_ASSIGN(ProfileSaver); 186 }; 187 188 } // namespace art 189 190 #endif // ART_RUNTIME_JIT_PROFILE_SAVER_H_ 191