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 "base/mutex.h"
21#include "base/safe_map.h"
22#include "dex/method_reference.h"
23#include "jit_code_cache.h"
24#include "profile_compilation_info.h"
25#include "profile_saver_options.h"
26
27namespace art {
28
29class ProfileSaver {
30 public:
31  // Starts the profile saver thread if not already started.
32  // If the saver is already running it adds (output_filename, code_paths) to its tracked locations.
33  static void Start(const ProfileSaverOptions& options,
34                    const std::string& output_filename,
35                    jit::JitCodeCache* jit_code_cache,
36                    const std::vector<std::string>& code_paths)
37      REQUIRES(!Locks::profiler_lock_, !wait_lock_);
38
39  // Stops the profile saver thread.
40  // NO_THREAD_SAFETY_ANALYSIS for static function calling into member function with excludes lock.
41  static void Stop(bool dump_info_)
42      REQUIRES(!Locks::profiler_lock_, !wait_lock_)
43      NO_THREAD_SAFETY_ANALYSIS;
44
45  // Returns true if the profile saver is started.
46  static bool IsStarted() REQUIRES(!Locks::profiler_lock_);
47
48  // If the profile saver is running, dumps statistics to the `os`. Otherwise it does nothing.
49  static void DumpInstanceInfo(std::ostream& os);
50
51  // NO_THREAD_SAFETY_ANALYSIS for static function calling into member function with excludes lock.
52  static void NotifyJitActivity()
53      REQUIRES(!Locks::profiler_lock_, !wait_lock_)
54      NO_THREAD_SAFETY_ANALYSIS;
55
56  // For testing or manual purposes (SIGUSR1).
57  static void ForceProcessProfiles();
58
59  // Just for testing purposes.
60  static bool HasSeenMethod(const std::string& profile, bool hot, MethodReference ref);
61
62 private:
63  ProfileSaver(const ProfileSaverOptions& options,
64               const std::string& output_filename,
65               jit::JitCodeCache* jit_code_cache,
66               const std::vector<std::string>& code_paths);
67  ~ProfileSaver();
68
69  // NO_THREAD_SAFETY_ANALYSIS for static function calling into member function with excludes lock.
70  static void* RunProfileSaverThread(void* arg)
71      REQUIRES(!Locks::profiler_lock_, !wait_lock_)
72      NO_THREAD_SAFETY_ANALYSIS;
73
74  // The run loop for the saver.
75  void Run() REQUIRES(!Locks::profiler_lock_, !wait_lock_);
76
77  // Processes the existing profiling info from the jit code cache and returns
78  // true if it needed to be saved to disk.
79  // If number_of_new_methods is not null, after the call it will contain the number of new methods
80  // written to disk.
81  // If force_save is true, the saver will ignore any constraints which limit IO (e.g. will write
82  // the profile to disk even if it's just one new method).
83  bool ProcessProfilingInfo(bool force_save, /*out*/uint16_t* number_of_new_methods)
84    REQUIRES(!Locks::profiler_lock_)
85    REQUIRES(!Locks::mutator_lock_);
86
87  void NotifyJitActivityInternal() REQUIRES(!wait_lock_);
88  void WakeUpSaver() REQUIRES(wait_lock_);
89
90  // Returns true if the saver is shutting down (ProfileSaver::Stop() has been called).
91  bool ShuttingDown(Thread* self) REQUIRES(!Locks::profiler_lock_);
92
93  void AddTrackedLocations(const std::string& output_filename,
94                           const std::vector<std::string>& code_paths)
95      REQUIRES(Locks::profiler_lock_);
96
97  // Fetches the current resolved classes and methods from the ClassLinker and stores them in the
98  // profile_cache_ for later save.
99  void FetchAndCacheResolvedClassesAndMethods(bool startup);
100
101  void DumpInfo(std::ostream& os);
102
103  // Resolve the realpath of the locations stored in tracked_dex_base_locations_to_be_resolved_
104  // and put the result in tracked_dex_base_locations_.
105  void ResolveTrackedLocations() REQUIRES(!Locks::profiler_lock_);
106
107  // The only instance of the saver.
108  static ProfileSaver* instance_ GUARDED_BY(Locks::profiler_lock_);
109  // Profile saver thread.
110  static pthread_t profiler_pthread_ GUARDED_BY(Locks::profiler_lock_);
111
112  jit::JitCodeCache* jit_code_cache_;
113
114  // Collection of code paths that the profiler tracks.
115  // It maps profile locations to code paths (dex base locations).
116  SafeMap<std::string, std::set<std::string>> tracked_dex_base_locations_
117      GUARDED_BY(Locks::profiler_lock_);
118
119  // Collection of code paths that the profiler tracks but may note have been resolved
120  // to their realpath. The resolution is done async to minimize the time it takes for
121  // someone to register a path.
122  SafeMap<std::string, std::set<std::string>> tracked_dex_base_locations_to_be_resolved_
123      GUARDED_BY(Locks::profiler_lock_);
124
125  bool shutting_down_ GUARDED_BY(Locks::profiler_lock_);
126  uint64_t last_time_ns_saver_woke_up_ GUARDED_BY(wait_lock_);
127  uint32_t jit_activity_notifications_;
128
129  // A local cache for the profile information. Maps each tracked file to its
130  // profile information. This is used to cache the startup classes so that
131  // we don't hammer the disk to save them right away.
132  // The size of this cache is usually very small and tops
133  // to just a few hundreds entries in the ProfileCompilationInfo objects.
134  SafeMap<std::string, ProfileCompilationInfo*> profile_cache_;
135
136  // Save period condition support.
137  Mutex wait_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
138  ConditionVariable period_condition_ GUARDED_BY(wait_lock_);
139
140  uint64_t total_bytes_written_;
141  uint64_t total_number_of_writes_;
142  uint64_t total_number_of_code_cache_queries_;
143  uint64_t total_number_of_skipped_writes_;
144  uint64_t total_number_of_failed_writes_;
145  uint64_t total_ms_of_sleep_;
146  uint64_t total_ns_of_work_;
147  // TODO(calin): replace with an actual size.
148  uint64_t max_number_of_profile_entries_cached_;
149  uint64_t total_number_of_hot_spikes_;
150  uint64_t total_number_of_wake_ups_;
151
152  const ProfileSaverOptions options_;
153  DISALLOW_COPY_AND_ASSIGN(ProfileSaver);
154};
155
156}  // namespace art
157
158#endif  // ART_RUNTIME_JIT_PROFILE_SAVER_H_
159